fix: return reasoning content with generateText() (#116)

fry69 · louisgv · web-flow · commit 10af3a4b0a81 · 2025-07-22T22:06:38.000-07:00
* fix: (WIP) return reasoning content with generateText()

* fix: downgrade to Zod v3

* chore: fix formatting

* fix: relax peer depdencies for Zod v4

* Use types derived from schema

* Remove unnecessary types

* chore: update beta version

---------

Co-authored-by: lab &lt;6723574+louisgv@users.noreply.github.com&gt;
diff --git a/package.json b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@openrouter/ai-sdk-provider",
-  "version": "1.0.0-beta.4",
+  "version": "1.0.0-beta.5",
   "license": "Apache-2.0",
   "sideEffects": false,
   "main": "./dist/index.js",
@@ -49,11 +49,11 @@
     "typescript": "5.8.3",
     "vite-tsconfig-paths": "5.1.4",
     "vitest": "3.2.4",
-    "zod": "^4.0.5"
+    "zod": "3.25.76"
   },
   "peerDependencies": {
     "ai": "^5.0.0-beta.12",
-    "zod": "^4.0.5"
+    "zod": "^3.24.1 || ^v4"
   },
   "engines": {
     "node": ">=18"
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
diff --git a/src/chat/index.test.ts b/src/chat/index.test.ts
@@ -1,10 +1,12 @@
 import type { LanguageModelV2Prompt } from '@ai-sdk/provider';
+import type { ReasoningDetailUnion } from '../schemas/reasoning-details';
 
 import {
   convertReadableStreamToArray,
   createTestServer,
 } from '@ai-sdk/provider-utils/test';
 import { createOpenRouter } from '../provider';
+import { ReasoningDetailType } from '../schemas/reasoning-details';
 
 const TEST_PROMPT: LanguageModelV2Prompt = [
   { role: 'user', content: [{ type: 'text', text: 'Hello' }] },
@@ -121,6 +123,8 @@ describe('doGenerate', () => {
 
   function prepareJsonResponse({
     content = '',
+    reasoning,
+    reasoning_details,
     usage = {
       prompt_tokens: 4,
       total_tokens: 34,
@@ -130,6 +134,8 @@ describe('doGenerate', () => {
     finish_reason = 'stop',
   }: {
     content?: string;
+    reasoning?: string;
+    reasoning_details?: Array<ReasoningDetailUnion>;
     usage?: {
       prompt_tokens: number;
       total_tokens: number;
@@ -159,6 +165,8 @@ describe('doGenerate', () => {
             message: {
               role: 'assistant',
               content,
+              reasoning,
+              reasoning_details,
             },
             logprobs,
             finish_reason,
@@ -238,6 +246,91 @@ describe('doGenerate', () => {
     expect(response.finishReason).toStrictEqual('unknown');
   });
 
+  it('should extract reasoning content from reasoning field', async () => {
+    prepareJsonResponse({
+      content: 'Hello!',
+      reasoning:
+        'I need to think about this... The user said hello, so I should respond with a greeting.',
+    });
+
+    const result = await model.doGenerate({
+      prompt: TEST_PROMPT,
+    });
+
+    expect(result.content).toStrictEqual([
+      {
+        type: 'reasoning',
+        text: 'I need to think about this... The user said hello, so I should respond with a greeting.',
+      },
+      {
+        type: 'text',
+        text: 'Hello!',
+      },
+    ]);
+  });
+
+  it('should extract reasoning content from reasoning_details', async () => {
+    prepareJsonResponse({
+      content: 'Hello!',
+      reasoning_details: [
+        {
+          type: ReasoningDetailType.Text,
+          text: 'Let me analyze this request...',
+        },
+        {
+          type: ReasoningDetailType.Summary,
+          summary: 'The user wants a greeting response.',
+        },
+      ],
+    });
+
+    const result = await model.doGenerate({
+      prompt: TEST_PROMPT,
+    });
+
+    expect(result.content).toStrictEqual([
+      {
+        type: 'reasoning',
+        text: 'Let me analyze this request...',
+      },
+      {
+        type: 'reasoning',
+        text: 'The user wants a greeting response.',
+      },
+      {
+        type: 'text',
+        text: 'Hello!',
+      },
+    ]);
+  });
+
+  it('should handle encrypted reasoning details', async () => {
+    prepareJsonResponse({
+      content: 'Hello!',
+      reasoning_details: [
+        {
+          type: ReasoningDetailType.Encrypted,
+          data: 'encrypted_reasoning_data_here',
+        },
+      ],
+    });
+
+    const result = await model.doGenerate({
+      prompt: TEST_PROMPT,
+    });
+
+    expect(result.content).toStrictEqual([
+      {
+        type: 'reasoning',
+        text: '[REDACTED]',
+      },
+      {
+        type: 'text',
+        text: 'Hello!',
+      },
+    ]);
+  });
+
   it('should pass the model and the messages', async () => {
     prepareJsonResponse({ content: '' });
 
diff --git a/src/chat/index.ts b/src/chat/index.ts
@@ -1,5 +1,3 @@
-import type { ReasoningDetailUnion } from '@/src/schemas/reasoning-details';
-import type { OpenRouterUsageAccounting } from '@/src/types/index';
 import type {
   LanguageModelV2,
   LanguageModelV2CallOptions,
@@ -14,12 +12,12 @@ import type {
 import type { ParseResult } from '@ai-sdk/provider-utils';
 import type { FinishReason } from 'ai';
 import type { z } from 'zod/v4';
+import type { OpenRouterUsageAccounting } from '@/src/types/index';
 import type {
   OpenRouterChatModelId,
   OpenRouterChatSettings,
 } from '../types/openrouter-chat-settings';
 
-import { ReasoningDetailType } from '@/src/schemas/reasoning-details';
 import { InvalidResponseDataError } from '@ai-sdk/provider';
 import {
   combineHeaders,
@@ -29,6 +27,7 @@ import {
   isParsableJson,
   postJsonToApi,
 } from '@ai-sdk/provider-utils';
+import { ReasoningDetailType } from '@/src/schemas/reasoning-details';
 import { openrouterFailedResponseHandler } from '../schemas/error-response';
 import { mapOpenRouterFinishReason } from '../utils/map-finish-reason';
 import { convertToOpenRouterChatMessages } from './convert-to-openrouter-chat-messages';
@@ -235,60 +234,62 @@ export class OpenRouterChatLanguageModel implements LanguageModelV2 {
           cachedInputTokens: 0,
         };
 
-    const reasoningDetails = (choice.message.reasoning_details ??
-      []) as ReasoningDetailUnion[];
-
-    // const reasoning: any[] =
-    reasoningDetails.length > 0
-      ? reasoningDetails
-          .map((detail) => {
-            switch (detail.type) {
-              case ReasoningDetailType.Text: {
-                if (detail.text) {
-                  return {
-                    type: 'text' as const,
-                    text: detail.text,
-                    signature: detail.signature ?? undefined,
-                  };
+    const reasoningDetails = choice.message.reasoning_details ?? [];
+
+    const reasoning: Array<LanguageModelV2Content> =
+      reasoningDetails.length > 0
+        ? reasoningDetails
+            .map((detail) => {
+              switch (detail.type) {
+                case ReasoningDetailType.Text: {
+                  if (detail.text) {
+                    return {
+                      type: 'reasoning' as const,
+                      text: detail.text,
+                    };
+                  }
+                  break;
                 }
-                break;
-              }
-              case ReasoningDetailType.Summary: {
-                if (detail.summary) {
-                  return {
-                    type: 'text' as const,
-                    text: detail.summary,
-                  };
+                case ReasoningDetailType.Summary: {
+                  if (detail.summary) {
+                    return {
+                      type: 'reasoning' as const,
+                      text: detail.summary,
+                    };
+                  }
+                  break;
                 }
-                break;
-              }
-              case ReasoningDetailType.Encrypted: {
-                if (detail.data) {
-                  return {
-                    type: 'redacted' as const,
-                    data: detail.data,
-                  };
+                case ReasoningDetailType.Encrypted: {
+                  // For encrypted reasoning, we include a redacted placeholder
+                  if (detail.data) {
+                    return {
+                      type: 'reasoning' as const,
+                      text: '[REDACTED]',
+                    };
+                  }
+                  break;
+                }
+                default: {
+                  detail satisfies never;
                 }
-                break;
-              }
-              default: {
-                detail satisfies never;
               }
-            }
-            return null;
-          })
-          .filter((p) => p !== null)
-      : choice.message.reasoning
-        ? [
-            {
-              type: 'text' as const,
-              text: choice.message.reasoning,
-            },
-          ]
-        : [];
+              return null;
+            })
+            .filter((p) => p !== null)
+        : choice.message.reasoning
+          ? [
+              {
+                type: 'reasoning' as const,
+                text: choice.message.reasoning,
+              },
+            ]
+          : [];
 
     const content: Array<LanguageModelV2Content> = [];
 
+    // Add reasoning content first
+    content.push(...reasoning);
+
     if (choice.message.content) {
       content.push({
         type: 'text' as const,
