feat: reasoning, web search, and thinking event support (#62)

## Summary

Adds support for reasoning and web search events in fixture responses
across multiple providers:

- **OpenAI Responses API**: Optional `reasoning` field on `TextResponse`
emits `response.reasoning_summary_text.delta` events before text
content. Optional `webSearches` field emits `response.web_search_call`
events.
- **Anthropic Claude**: `reasoning` field emits `thinking` content
blocks before text in `/v1/messages`.
- Both HTTP SSE and WebSocket transports supported.
- Backward compatible — existing fixtures work unchanged.

Closes #60

## Changes

- **`src/types.ts`**: `TextResponse` extended with optional `reasoning?:
string` and `webSearches?: string[]`
- **`src/responses.ts`**: `buildTextStreamEvents` accepts optional
reasoning/webSearches and prepends the appropriate events with correct
`output_index` adjustment. Private helpers `buildReasoningStreamEvents`
and `buildWebSearchStreamEvents` handle individual event sequences.
Non-streaming `buildTextResponse` includes reasoning and web search
output items.
- **`src/messages.ts`**: Emits `thinking` content blocks when
`reasoning` is present (both streaming and non-streaming). Warns when
`webSearches` is used (not supported by Claude API).
- **`src/ws-responses.ts`**: Passes reasoning/webSearches through to
`buildTextStreamEvents` (no duplicated logic)
- **`src/fixture-loader.ts`**: Validates `reasoning` (string) and
`webSearches` (array of strings). Warns on empty reasoning.
- **`src/stream-collapse.ts`**: Extracts reasoning from
`response.reasoning_summary_text.delta`, text from
`response.output_text.delta`, and web searches from
`response.output_item.done` web_search_call events. Claude collapse
extracts reasoning from `thinking_delta` events.

## Example

```typescript
mock.addFixture({
  match: { userMessage: "hello" },
  response: {
    content: "Based on my research, here's what I found.",
    reasoning: "Let me think about what the user is asking...",
    webSearches: ["latest greeting conventions 2025"],
  },
});
```

## Test plan

- [x] Reasoning events emitted correctly in Responses API SSE
- [x] Reasoning deltas reconstruct full text
- [x] Web search events emitted before text events
- [x] Web search items contain query strings
- [x] Combined reasoning + web search + text streaming
- [x] Non-streaming responses include reasoning and web search output
items
- [x] Anthropic thinking blocks (streaming and non-streaming)
- [x] Backward compatibility — plain text fixtures unchanged
- [x] WebSocket reasoning passthrough
- [x] Fixture-loader validation (reasoning type, empty string,
webSearches type/elements)
- [x] Stream-collapse extraction (OpenAI reasoning/text/web search,
Anthropic thinking)
- [x] All 1333 tests pass
- [x] Prettier, ESLint clean

Author: jpr5

src/__tests__/fixture-loader.test.ts

@@ -844,4 +844,75 @@ describe("validateFixtures", () => {
       true,
     );
   });
+
+  it("error: reasoning is not a string", () => {
+    const fixtures = [makeFixture({ response: { content: "hi", reasoning: 123 } as never })];
+    const results = validateFixtures(fixtures);
+    expect(
+      results.some(
+        (r) => r.severity === "error" && r.message.includes("reasoning must be a string"),
+      ),
+    ).toBe(true);
+  });
+
+  it("warning: reasoning is empty string", () => {
+    const fixtures = [makeFixture({ response: { content: "hi", reasoning: "" } })];
+    const results = validateFixtures(fixtures);
+    expect(
+      results.some((r) => r.severity === "warning" && r.message.includes("reasoning is empty")),
+    ).toBe(true);
+  });
+
+  it("error: webSearches is not an array", () => {
+    const fixtures = [
+      makeFixture({ response: { content: "hi", webSearches: "not-array" } as never }),
+    ];
+    const results = validateFixtures(fixtures);
+    expect(
+      results.some(
+        (r) => r.severity === "error" && r.message.includes("webSearches must be an array"),
+      ),
+    ).toBe(true);
+  });
+
+  it("error: webSearches element is not a string", () => {
+    const fixtures = [
+      makeFixture({ response: { content: "hi", webSearches: ["valid", 42] } as never }),
+    ];
+    const results = validateFixtures(fixtures);
+    expect(
+      results.some(
+        (r) => r.severity === "error" && r.message.includes("webSearches[1] is not a string"),
+      ),
+    ).toBe(true);
+  });
+
+  it("accepts valid reasoning and webSearches", () => {
+    const fixtures = [
+      makeFixture({
+        response: { content: "hi", reasoning: "thinking...", webSearches: ["query1", "query2"] },
+      }),
+    ];
+    expect(validateFixtures(fixtures)).toEqual([]);
+  });
+
+  it("warning: webSearches is empty array", () => {
+    const fixtures = [makeFixture({ response: { content: "hi", webSearches: [] } })];
+    const results = validateFixtures(fixtures);
+    expect(
+      results.some(
+        (r) => r.severity === "warning" && r.message.includes("webSearches is empty array"),
+      ),
+    ).toBe(true);
+  });
+
+  it("warning: webSearches element is empty string", () => {
+    const fixtures = [makeFixture({ response: { content: "hi", webSearches: ["valid", ""] } })];
+    const results = validateFixtures(fixtures);
+    expect(
+      results.some(
+        (r) => r.severity === "warning" && r.message.includes("webSearches[1] is empty string"),
+      ),
+    ).toBe(true);
+  });
 });