feat: add reasoning_content support for OpenRouter chat completions

OpenRouter returns reasoning via reasoning_content in the chat completions
message/delta format. This adds support for emitting and collapsing
reasoning_content in both streaming and non-streaming responses.

Author: AlemTuzlak

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

@@ -62,11 +62,30 @@ export function isEmbeddingResponse(r: FixtureResponse): r is EmbeddingResponse
   return "embedding" in r && Array.isArray((r as EmbeddingResponse).embedding);
 }
 
-export function buildTextChunks(content: string, model: string, chunkSize: number): SSEChunk[] {
+export function buildTextChunks(
+  content: string,
+  model: string,
+  chunkSize: number,
+  reasoning?: string,
+): SSEChunk[] {
   const id = generateId();
   const created = Math.floor(Date.now() / 1000);
   const chunks: SSEChunk[] = [];
 
+  // 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);
+      chunks.push({
+        id,
+        object: "chat.completion.chunk",
+        created,
+        model,
+        choices: [{ index: 0, delta: { reasoning_content: slice }, finish_reason: null }],
+      });
+    }
+  }
+
   // Role chunk
   chunks.push({
     id,
@@ -183,7 +202,11 @@ export function buildToolCallChunks(
 
 // Non-streaming response builders
 
-export function buildTextCompletion(content: string, model: string): ChatCompletion {
+export function buildTextCompletion(
+  content: string,
+  model: string,
+  reasoning?: string,
+): ChatCompletion {
   return {
     id: generateId(),
     object: "chat.completion",
@@ -192,7 +215,12 @@ export function buildTextCompletion(content: string, model: string): ChatComplet
     choices: [
       {
         index: 0,
-        message: { role: "assistant", content, refusal: null },
+        message: {
+          role: "assistant",
+          content,
+          refusal: null,
+          ...(reasoning ? { reasoning_content: reasoning } : {}),
+        },
         finish_reason: "stop",
       },
     ],

src/server.ts

@@ -454,11 +454,11 @@ async function handleCompletions(
       response: { status: 200, fixture },
     });
     if (body.stream !== true) {
-      const completion = buildTextCompletion(response.content, body.model);
+      const completion = buildTextCompletion(response.content, body.model, response.reasoning);
       res.writeHead(200, { "Content-Type": "application/json" });
       res.end(JSON.stringify(completion));
     } else {
-      const chunks = buildTextChunks(response.content, body.model, chunkSize);
+      const chunks = buildTextChunks(response.content, body.model, chunkSize, response.reasoning);
       const interruption = createInterruptionSignal(fixture);
       const completed = await writeSSEStream(res, chunks, {
         latency,

src/stream-collapse.ts

@@ -95,6 +95,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;

src/types.ts

@@ -200,6 +200,7 @@ export interface SSEChoice {
 export interface SSEDelta {
   role?: string;
   content?: string | null;
+  reasoning_content?: string;
   tool_calls?: SSEToolCallDelta[];
 }
 
@@ -231,6 +232,7 @@ export interface ChatCompletionMessage {
   role: "assistant";
   content: string | null;
   refusal: string | null;
+  reasoning_content?: string;
   tool_calls?: ToolCallMessage[];
 }