feat: add reasoning_content support for OpenRouter chat completions (#88)

## Summary

- Adds `reasoning_content` field to chat completions streaming
(`delta.reasoning_content`) and non-streaming
(`message.reasoning_content`) responses
- Updates `collapseOpenAISSE` to extract `reasoning_content` from chat
completions delta chunks for record-and-replay
- OpenRouter models that support reasoning (DeepSeek, Claude via
OpenRouter, etc.) return thinking tokens via this field — aimock
previously only supported reasoning for the Responses API and Anthropic
Messages API

## What's included

This PR covers the **aimock mock server** side — emitting
`reasoning_content` in `/v1/chat/completions` responses when a fixture
has `reasoning` set. It does NOT cover any additional
OpenRouter-specific behavior (e.g. `reasoning_details`, model routing,
provider preferences). Those may need separate work.

## Files changed

- `src/types.ts` — added `reasoning_content` to `SSEDelta` and
`ChatCompletionMessage`
- `src/helpers.ts` — `buildTextChunks` and `buildTextCompletion` now
accept and emit reasoning
- `src/server.ts` — passes `response.reasoning` through to chat
completions builders
- `src/stream-collapse.ts` — extracts `reasoning_content` from chat
completions deltas
- Tests — 5 new tests covering streaming, non-streaming, absence, delta
reconstruction, and stream-collapse

## Test plan

- [x] Streaming: reasoning_content deltas emitted before content deltas
- [x] Streaming: reasoning_content deltas reconstruct full reasoning
text
- [x] Streaming: content deltas still reconstruct full text
- [x] Streaming: no reasoning_content when fixture has no reasoning
- [x] Non-streaming: reasoning_content present in message
- [x] Non-streaming: reasoning_content absent when no reasoning
- [x] Stream-collapse: extracts reasoning_content from chat completions
deltas
- [x] All 2034 existing tests still pass

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Author: jpr5

src/__tests__/reasoning-web-search.test.ts

@@ -549,3 +549,125 @@ describe("POST /v1/messages (thinking blocks non-streaming)", () => {
     expect(body.content[0].type).toBe("text");
   });
 });
+
+// ─── Chat Completions: reasoning_content (OpenRouter format) ────────────────
+
+interface ChatCompletionChunk {
+  id: string;
+  object: string;
+  created: number;
+  model: string;
+  choices: {
+    index: number;
+    delta: { role?: string; content?: string | null; reasoning_content?: string };
+    finish_reason: string | null;
+  }[];
+}
+
+function parseChatCompletionSSEChunks(body: string): ChatCompletionChunk[] {
+  const chunks: ChatCompletionChunk[] = [];
+  for (const line of body.split("\n")) {
+    if (line.startsWith("data: ") && line.slice(6).trim() !== "[DONE]") {
+      chunks.push(JSON.parse(line.slice(6)) as ChatCompletionChunk);
+    }
+  }
+  return chunks;
+}
+
+describe("POST /v1/chat/completions (reasoning_content streaming)", () => {
+  it("emits reasoning_content deltas before content deltas", async () => {
+    instance = await createServer(allFixtures);
+    const res = await post(`${instance.url}/v1/chat/completions`, {
+      model: "gpt-4",
+      messages: [{ role: "user", content: "think" }],
+      stream: true,
+    });
+
+    expect(res.status).toBe(200);
+    const chunks = parseChatCompletionSSEChunks(res.body);
+
+    const reasoningChunks = chunks.filter((c) => c.choices[0]?.delta.reasoning_content);
+    const contentChunks = chunks.filter(
+      (c) => c.choices[0]?.delta.content && c.choices[0].delta.content.length > 0,
+    );
+
+    expect(reasoningChunks.length).toBeGreaterThan(0);
+    expect(contentChunks.length).toBeGreaterThan(0);
+
+    // All reasoning chunks appear before all content chunks
+    const lastReasoningIdx = chunks.lastIndexOf(reasoningChunks[reasoningChunks.length - 1]);
+    const firstContentIdx = chunks.indexOf(contentChunks[0]);
+    expect(lastReasoningIdx).toBeLessThan(firstContentIdx);
+  });
+
+  it("reasoning_content deltas reconstruct full reasoning text", async () => {
+    instance = await createServer(allFixtures);
+    const res = await post(`${instance.url}/v1/chat/completions`, {
+      model: "gpt-4",
+      messages: [{ role: "user", content: "think" }],
+      stream: true,
+    });
+
+    const chunks = parseChatCompletionSSEChunks(res.body);
+    const reasoning = chunks.map((c) => c.choices[0]?.delta.reasoning_content ?? "").join("");
+    expect(reasoning).toBe("Let me think step by step about this problem.");
+  });
+
+  it("content deltas still reconstruct full text", async () => {
+    instance = await createServer(allFixtures);
+    const res = await post(`${instance.url}/v1/chat/completions`, {
+      model: "gpt-4",
+      messages: [{ role: "user", content: "think" }],
+      stream: true,
+    });
+
+    const chunks = parseChatCompletionSSEChunks(res.body);
+    const content = chunks.map((c) => c.choices[0]?.delta.content ?? "").join("");
+    expect(content).toBe("The answer is 42.");
+  });
+
+  it("no reasoning_content when reasoning is absent", async () => {
+    instance = await createServer(allFixtures);
+    const res = await post(`${instance.url}/v1/chat/completions`, {
+      model: "gpt-4",
+      messages: [{ role: "user", content: "plain" }],
+      stream: true,
+    });
+
+    const chunks = parseChatCompletionSSEChunks(res.body);
+    const reasoningChunks = chunks.filter((c) => c.choices[0]?.delta.reasoning_content);
+    expect(reasoningChunks).toHaveLength(0);
+  });
+});
+
+describe("POST /v1/chat/completions (reasoning_content non-streaming)", () => {
+  it("includes reasoning_content in non-streaming response", async () => {
+    instance = await createServer(allFixtures);
+    const res = await post(`${instance.url}/v1/chat/completions`, {
+      model: "gpt-4",
+      messages: [{ role: "user", content: "think" }],
+      stream: false,
+    });
+
+    expect(res.status).toBe(200);
+    const body = JSON.parse(res.body);
+    expect(body.object).toBe("chat.completion");
+    expect(body.choices[0].message.content).toBe("The answer is 42.");
+    expect(body.choices[0].message.reasoning_content).toBe(
+      "Let me think step by step about this problem.",
+    );
+  });
+
+  it("no reasoning_content when reasoning is absent", async () => {
+    instance = await createServer(allFixtures);
+    const res = await post(`${instance.url}/v1/chat/completions`, {
+      model: "gpt-4",
+      messages: [{ role: "user", content: "plain" }],
+      stream: false,
+    });
+
+    const body = JSON.parse(res.body);
+    expect(body.choices[0].message.content).toBe("Just plain text.");
+    expect(body.choices[0].message.reasoning_content).toBeUndefined();
+  });
+});

src/__tests__/stream-collapse.test.ts

@@ -1792,3 +1792,35 @@ describe("collapseAnthropicSSE with thinking", () => {
     expect(result.reasoning).toBeUndefined();
   });
 });
+
+describe("collapseOpenAISSE with chat completions reasoning_content", () => {
+  it("extracts reasoning from reasoning_content delta fields", () => {
+    const body = [
+      `data: ${JSON.stringify({ id: "chatcmpl-1", choices: [{ delta: { reasoning_content: "Let me " } }] })}`,
+      "",
+      `data: ${JSON.stringify({ id: "chatcmpl-1", choices: [{ delta: { reasoning_content: "think." } }] })}`,
+      "",
+      `data: ${JSON.stringify({ id: "chatcmpl-1", choices: [{ delta: { content: "Answer" } }] })}`,
+      "",
+      "data: [DONE]",
+      "",
+    ].join("\n");
+
+    const result = collapseOpenAISSE(body);
+    expect(result.content).toBe("Answer");
+    expect(result.reasoning).toBe("Let me think.");
+  });
+
+  it("handles reasoning_content without regular content", () => {
+    const body = [
+      `data: ${JSON.stringify({ id: "chatcmpl-2", choices: [{ delta: { reasoning_content: "Thinking only" } }] })}`,
+      "",
+      "data: [DONE]",
+      "",
+    ].join("\n");
+
+    const result = collapseOpenAISSE(body);
+    expect(result.reasoning).toBe("Thinking only");
+    expect(result.content).toBe("");
+  });
+});

src/helpers.ts

@@ -72,16 +72,7 @@ export function buildTextChunks(
   const created = Math.floor(Date.now() / 1000);
   const chunks: SSEChunk[] = [];
 
-  // Role chunk
-  chunks.push({
-    id,
-    object: "chat.completion.chunk",
-    created,
-    model,
-    choices: [{ index: 0, delta: { role: "assistant", content: "" }, finish_reason: null }],
-  });
-
-  // Reasoning chunks (emitted before content chunks)
+  // Reasoning chunks (emitted before content, OpenRouter format)
   if (reasoning) {
     for (let i = 0; i < reasoning.length; i += chunkSize) {
       const slice = reasoning.slice(i, i + chunkSize);
@@ -95,6 +86,15 @@ export function buildTextChunks(
     }
   }
 
+  // Role chunk
+  chunks.push({
+    id,
+    object: "chat.completion.chunk",
+    created,
+    model,
+    choices: [{ index: 0, delta: { role: "assistant", content: "" }, finish_reason: null }],
+  });
+
   // Content chunks
   for (let i = 0; i < content.length; i += chunkSize) {
     const slice = content.slice(i, i + chunkSize);

src/stream-collapse.ts

@@ -98,6 +98,11 @@ export function collapseOpenAISSE(body: string): CollapseResult {
     const delta = choices[0].delta as Record<string, unknown> | undefined;
     if (!delta) continue;
 
+    // Reasoning content (OpenRouter / chat completions format)
+    if (typeof delta.reasoning_content === "string") {
+      reasoning += delta.reasoning_content;
+    }
+
     // Text content
     if (typeof delta.content === "string") {
       content += delta.content;