feat(agents-extensions): #628 Add support for Anthropic extended thinking

Implements support for Anthropic's reasoning and interleaved thinking
capabilities, achieving parity with the Python SDK.

- Modifies `aiSdk.ts` to handle both streaming and non-streaming cases.
- `getResponse` (non-streaming) passes the `reasoning` field from the
  provider result.
- `getStreamedResponse` (streaming) captures `reasoning-delta` chunks
  and accumulates them into the `reasoning` field of the final
`response_done` event.
- Updates the core `protocol.ts` Zod schema.
- Adds new unit tests to `aiSdk.test.ts`

Closes #[Issue 628]

Author: subPTcon

.changeset/happy-shrimps-sell.md

@@ -0,0 +1,6 @@
+---
+'@openai/agents-extensions': patch
+'@openai/agents-core': patch
+---
+
+feat: Add support for Anthropic extended thinking

package.json

@@ -71,5 +71,9 @@
     "verdaccio": "^6.2.1",
     "vitest": "^3.2.4"
   },
-  "packageManager": "pnpm@10.20.0"
+  "packageManager": "pnpm@10.20.0",
+  "dependencies": {
+    "@ai-sdk/openai": "^2.0.62",
+    "@openai/agents-extensions": "^0.2.1"
+  }
 }

packages/agents-core/src/types/protocol.ts

@@ -694,6 +694,11 @@ export const StreamEventResponseCompleted = SharedBase.extend({
      * The output from the model.
      */
     output: z.array(OutputModelItem),
+
+    /**
+     * The reasoning/thinking text from the model.
+     */
+    reasoning: z.string().optional(),
   }),
 });
 

packages/agents-extensions/src/aiSdk.ts

@@ -741,6 +741,7 @@ export class AiSdkModel implements Model {
                   : ((result as any).usage?.outputTokens ?? 0)) || 0,
           }),
           output,
+          reasoning: (result as any).reasoning ?? undefined,
           providerData: result,
         } as const;
 
@@ -874,6 +875,7 @@ export class AiSdkModel implements Model {
       let usageCompletionTokens = 0;
       const functionCalls: Record<string, protocol.FunctionCallItem> = {};
       let textOutput: protocol.OutputText | undefined;
+      let reasoningText: string | undefined;
 
       for await (const part of stream) {
         if (!started) {
@@ -922,6 +924,16 @@ export class AiSdkModel implements Model {
               : ((part as any).usage?.outputTokens ?? 0);
             break;
           }
+          case 'reasoning-delta': {
+            const reasoningDelta = (part as any).reasoningDelta;
+            if (reasoningDelta) {
+              if (!reasoningText) {
+                reasoningText = '';
+              }
+              reasoningText += reasoningDelta;
+            }
+            break;
+          }
           case 'error': {
             throw part.error;
           }
@@ -953,6 +965,7 @@ export class AiSdkModel implements Model {
             totalTokens: usagePromptTokens + usageCompletionTokens,
           },
           output: outputs,
+          reasoning: reasoningText,
         },
       };
 

packages/agents-extensions/test/aiSdk.test.ts

@@ -820,6 +820,115 @@ describe('AiSdkModel.getResponse', () => {
       outputTokensDetails: [],
     });
   });
+
+  test('should store reasoning in response for non-streaming text output', async () => {
+    const mockProviderResult = {
+      content: [{ type: 'text', text: 'This is the final answer.' }],
+      usage: { inputTokens: 10, outputTokens: 20, totalTokens: 30 },
+      providerMetadata: { p: 1 },
+      response: { id: 'fake-id-123' },
+      finishReason: 'stop',
+      warnings: [],
+      reasoning: '<thinking>I am thinking about the answer.</thinking>',
+    };
+
+    const model = new AiSdkModel(
+      stubModel({
+        async doGenerate() {
+          return mockProviderResult as any;
+        },
+      }),
+    );
+
+    const res = await withTrace('t', () =>
+      model.getResponse({
+        input: 'hi',
+        tools: [],
+        handoffs: [],
+        modelSettings: {},
+        outputType: 'text',
+        tracing: false,
+      } as any),
+    );
+
+    expect(res.reasoning).toBeDefined();
+    expect(res.reasoning).toBe(
+      '<thinking>I am thinking about the answer.</thinking>',
+    );
+    expect(res.responseId).toBe('fake-id-123');
+  });
+
+  test('should store reasoning in final response_done event for streaming', async () => {
+    async function* mockProviderStream() {
+      yield {
+        type: 'response-metadata',
+        id: 'fake-stream-id-456',
+      };
+
+      yield {
+        type: 'reasoning-delta',
+        reasoningDelta: '<thinking>Step 1: I am thinking.',
+      };
+
+      yield {
+        type: 'text-delta',
+        delta: 'Here is the answer.',
+      };
+
+      yield {
+        type: 'reasoning-delta',
+        reasoningDelta: ' Step 2: More thinking.</thinking>',
+      };
+
+      yield {
+        type: 'finish',
+        usage: { inputTokens: 5, outputTokens: 10, totalTokens: 15 },
+      };
+    }
+
+    const model = new AiSdkModel(
+      stubModel({
+        async doStream() {
+          return {
+            stream: mockProviderStream(),
+          } as any;
+        },
+      }),
+    );
+
+    const stream = model.getStreamedResponse({
+      input: 'hi',
+      tools: [],
+      handoffs: [],
+      modelSettings: {},
+      outputType: 'text',
+      tracing: false,
+    } as any);
+
+    const events = [];
+    for await (const event of stream) {
+      events.push(event);
+    }
+
+    const finalEvent = events.find((e) => e.type === 'response_done') as
+      | protocol.StreamEventResponseCompleted
+      | undefined;
+
+    expect(finalEvent).toBeDefined();
+
+    expect(finalEvent!.response.reasoning).toBeDefined();
+    expect(finalEvent!.response.reasoning).toBe(
+      '<thinking>Step 1: I am thinking. Step 2: More thinking.</thinking>',
+    );
+
+    expect(finalEvent!.response.id).toBe('fake-stream-id-456');
+    expect(finalEvent!.response.usage.totalTokens).toBe(15);
+
+    const textOutput = finalEvent!.response.output.find(
+      (o) => o.type === 'message' && o.content[0].type === 'output_text',
+    ) as any;
+    expect(textOutput.content[0].text).toBe('Here is the answer.');
+  });
 });
 
 describe('AiSdkModel.getStreamedResponse', () => {