@ai-sdk/open-responses 2.0.27 → 2.0.28

package/src/responses/convert-to-open-responses-input.ts

@@ -9,7 +9,6 @@ import {
   resolveFullMediaType,
 } from '@ai-sdk/provider-utils';
 import type {
-  FunctionCallItemParam,
   FunctionCallOutputItemParam,
   InputFileContentParam,
   InputImageContentParam,
@@ -22,8 +21,10 @@ import type {
 
 export async function convertToOpenResponsesInput({
   prompt,
+  providerOptionsName = 'open-responses',
 }: {
   prompt: LanguageModelV4Prompt;
+  providerOptionsName?: string;
 }): Promise<{
   input: OpenResponsesRequestBody['input'];
   instructions: string | undefined;
@@ -103,33 +104,128 @@ export async function convertToOpenResponsesInput({
       }
 
       case 'assistant': {
-        const assistantContent: Array<
+        let assistantContent: Array<
           OutputTextContentParam | RefusalContentParam
         > = [];
-        const reasoningItems: Array<ReasoningItemParam> = [];
-        const toolCalls: Array<FunctionCallItemParam> = [];
+        let assistantMessageId: string | undefined;
+
+        const flushAssistantContent = () => {
+          if (assistantContent.length === 0) {
+            return;
+          }
+
+          input.push({
+            type: 'message',
+            role: 'assistant',
+            content: assistantContent,
+            ...(assistantMessageId != null && { id: assistantMessageId }),
+          });
+          assistantContent = [];
+          assistantMessageId = undefined;
+        };
 
         for (const part of content) {
           switch (part.type) {
             case 'reasoning': {
-              reasoningItems.push({
+              flushAssistantContent();
+
+              const providerData = getProviderData(part, providerOptionsName);
+              const itemId =
+                typeof providerData?.itemId === 'string'
+                  ? providerData.itemId
+                  : undefined;
+              const summary = parseReasoningSummary(
+                providerData?.reasoningSummary,
+              );
+              const reasoningContent = parseReasoningContent(
+                providerData?.reasoningContent,
+              );
+              const hasReasoningContent =
+                providerData != null && 'reasoningContent' in providerData;
+              const encryptedContent =
+                typeof providerData?.reasoningEncryptedContent === 'string'
+                  ? providerData.reasoningEncryptedContent
+                  : undefined;
+
+              const reasoningItem: ReasoningItemParam = {
                 type: 'reasoning',
-                summary: [],
-                content: [{ type: 'reasoning_text', text: part.text }],
-              });
+                summary: summary ?? [],
+                ...(itemId != null && { id: itemId }),
+                ...(reasoningContent != null
+                  ? { content: reasoningContent }
+                  : !hasReasoningContent && part.text.length > 0
+                    ? {
+                        content: [
+                          {
+                            type: 'reasoning_text' as const,
+                            text: part.text,
+                          },
+                        ],
+                      }
+                    : {}),
+                ...(encryptedContent != null && {
+                  encrypted_content: encryptedContent,
+                }),
+              };
+              const previousItem = input[input.length - 1];
+
+              if (
+                reasoningItem.id != null &&
+                previousItem?.type === 'reasoning' &&
+                previousItem.id === reasoningItem.id
+              ) {
+                if (reasoningItem.content != null) {
+                  previousItem.content = [
+                    ...(previousItem.content ?? []),
+                    ...reasoningItem.content,
+                  ];
+                }
+              } else {
+                input.push(reasoningItem);
+              }
               break;
             }
             case 'text': {
-              assistantContent.push({ type: 'output_text', text: part.text });
+              const providerData = getProviderData(part, providerOptionsName);
+              const itemId =
+                typeof providerData?.itemId === 'string'
+                  ? providerData.itemId
+                  : undefined;
+              const annotations = parseOutputTextAnnotations(
+                providerData?.annotations,
+              );
+
+              if (
+                assistantContent.length > 0 &&
+                assistantMessageId !== itemId
+              ) {
+                flushAssistantContent();
+              }
+
+              assistantMessageId = itemId;
+              assistantContent.push({
+                type: 'output_text',
+                text: part.text,
+                ...(annotations != null && { annotations }),
+              });
               break;
             }
             case 'tool-call': {
+              flushAssistantContent();
+
               const argumentsValue =
                 typeof part.input === 'string'
                   ? part.input
                   : JSON.stringify(part.input);
-              toolCalls.push({
+              const providerData = getProviderData(part, providerOptionsName);
+              const itemId =
+                typeof providerData?.itemId === 'string'
+                  ? providerData.itemId
+                  : undefined;
+
+              input.push({
                 type: 'function_call',
+                ...(itemId != null && { id: itemId }),
                 call_id: part.toolCallId,
                 name: part.toolName,
                 arguments: argumentsValue,
@@ -139,24 +235,7 @@ export async function convertToOpenResponsesInput({
           }
         }
 
-        // Push reasoning as separate items
-        for (const reasoningItem of reasoningItems) {
-          input.push(reasoningItem);
-        }
-
-        // Push assistant message with text content if any
-        if (assistantContent.length > 0) {
-          input.push({
-            type: 'message',
-            role: 'assistant',
-            content: assistantContent,
-          });
-        }
-
-        // Push function calls as separate items
-        for (const toolCall of toolCalls) {
-          input.push(toolCall);
-        }
+        flushAssistantContent();
 
         break;
       }
@@ -266,3 +345,97 @@ export async function convertToOpenResponsesInput({
     warnings,
   };
 }
+
+function getProviderData(
+  part: {
+    providerOptions?: Record<string, unknown>;
+  },
+  providerOptionsName: string,
+): Record<string, unknown> | undefined {
+  const providerData =
+    part.providerOptions?.[providerOptionsName] ??
+    (
+      part as {
+        providerMetadata?: Record<string, unknown>;
+      }
+    ).providerMetadata?.[providerOptionsName];
+
+  return providerData != null &&
+    typeof providerData === 'object' &&
+    !Array.isArray(providerData)
+    ? (providerData as Record<string, unknown>)
+    : undefined;
+}
+
+function parseReasoningSummary(
+  value: unknown,
+): ReasoningItemParam['summary'] | undefined {
+  if (
+    !Array.isArray(value) ||
+    !value.every(
+      part =>
+        part != null &&
+        typeof part === 'object' &&
+        (part as { type?: unknown }).type === 'summary_text' &&
+        typeof (part as { text?: unknown }).text === 'string',
+    )
+  ) {
+    return undefined;
+  }
+
+  return value.map(part => ({
+    type: 'summary_text',
+    text: (part as { text: string }).text,
+  }));
+}
+
+function parseReasoningContent(
+  value: unknown,
+): ReasoningItemParam['content'] | undefined {
+  if (
+    !Array.isArray(value) ||
+    !value.every(
+      part =>
+        part != null &&
+        typeof part === 'object' &&
+        (part as { type?: unknown }).type === 'reasoning_text' &&
+        typeof (part as { text?: unknown }).text === 'string',
+    )
+  ) {
+    return undefined;
+  }
+
+  return value.map(part => ({
+    type: 'reasoning_text',
+    text: (part as { text: string }).text,
+  }));
+}
+
+function parseOutputTextAnnotations(
+  value: unknown,
+): OutputTextContentParam['annotations'] | undefined {
+  if (
+    !Array.isArray(value) ||
+    !value.every(
+      annotation =>
+        annotation != null &&
+        typeof annotation === 'object' &&
+        (annotation as { type?: unknown }).type === 'url_citation' &&
+        typeof (annotation as { start_index?: unknown }).start_index ===
+          'number' &&
+        typeof (annotation as { end_index?: unknown }).end_index === 'number' &&
+        typeof (annotation as { url?: unknown }).url === 'string' &&
+        typeof (annotation as { title?: unknown }).title === 'string',
+    )
+  ) {
+    return undefined;
+  }
+
+  return value.map(annotation => ({
+    type: 'url_citation',
+    start_index: (annotation as { start_index: number }).start_index,
+    end_index: (annotation as { end_index: number }).end_index,
+    url: (annotation as { url: string }).url,
+    title: (annotation as { title: string }).title,
+  }));
+}

package/src/responses/open-responses-api.ts

@@ -311,7 +311,7 @@ export type StreamOptionsParam = {
  * Configuration options for reasoning behavior.
  */
 export type ReasoningParam = {
-  effort?: ReasoningEffortEnum;
+  effort?: string;
   summary?: ReasoningSummaryEnum;
 };
 

package/src/responses/open-responses-language-model-options.ts

@@ -8,6 +8,12 @@ import { z } from 'zod/v4';
 export const openResponsesLanguageModelOptions = lazySchema(() =>
   zodSchema(
     z.object({
+      /**
+       * Provider-native reasoning effort. The value is passed through to the
+       * endpoint and takes precedence over the top-level `reasoning` setting.
+       */
+      reasoningEffort: z.string().nullish(),
+
       /**
        * Controls reasoning summary output from the model.
        * Valid values: 'concise', 'detailed', 'auto'.

package/src/responses/open-responses-language-model.ts

@@ -8,6 +8,7 @@ import {
   type LanguageModelV4StreamPart,
   type LanguageModelV4StreamResult,
   type LanguageModelV4Usage,
+  type SharedV4ProviderMetadata,
   type SharedV4Warning,
 } from '@ai-sdk/provider';
 import {
@@ -29,10 +30,12 @@ import { z } from 'zod/v4';
 import { convertToOpenResponsesInput } from './convert-to-open-responses-input';
 import {
   openResponsesErrorSchema,
+  type Annotation,
   type FunctionToolParam,
   type OpenResponsesRequestBody,
   type OpenResponsesResponseBody,
   type OpenResponsesChunk,
+  type ReasoningBody,
   type ToolChoiceParam,
 } from './open-responses-api';
 import { mapOpenResponsesFinishReason } from './map-open-responses-finish-reason';
@@ -112,20 +115,30 @@ export class OpenResponsesLanguageModel implements LanguageModelV4 {
       warnings: inputWarnings,
     } = await convertToOpenResponsesInput({
       prompt,
+      providerOptionsName: this.config.providerOptionsName,
     });
 
     warnings.push(...inputWarnings);
 
     // Convert function tools to the Open Responses format
-    const functionTools: FunctionToolParam[] | undefined = tools
-      ?.filter(tool => tool.type === 'function')
-      .map(tool => ({
-        type: 'function' as const,
-        name: tool.name,
-        description: tool.description,
-        parameters: tool.inputSchema,
-        ...(tool.strict != null ? { strict: tool.strict } : {}),
-      }));
+    const functionTools: FunctionToolParam[] = [];
+
+    for (const tool of tools ?? []) {
+      if (tool.type === 'provider') {
+        warnings.push({
+          type: 'unsupported',
+          feature: `provider-defined tool ${tool.id}`,
+        });
+      } else {
+        functionTools.push({
+          type: 'function',
+          name: tool.name,
+          description: tool.description,
+          parameters: tool.inputSchema,
+          ...(tool.strict != null ? { strict: tool.strict } : {}),
+        });
+      }
+    }
 
     // Convert tool choice to the Open Responses format
     const convertedToolChoice: ToolChoiceParam | undefined =
@@ -156,21 +169,23 @@ export class OpenResponsesLanguageModel implements LanguageModelV4 {
       schema: openResponsesLanguageModelOptions,
     });
 
-    const resolvedReasoningEffort = isCustomReasoning(reasoning)
-      ? reasoning === 'none'
-        ? 'none'
-        : mapReasoningToProviderEffort({
-            reasoning,
-            effortMap: {
-              minimal: 'low',
-              low: 'low',
-              medium: 'medium',
-              high: 'high',
-              xhigh: 'xhigh',
-            },
-            warnings,
-          })
-      : undefined;
+    const resolvedReasoningEffort =
+      openResponsesOptions?.reasoningEffort ??
+      (isCustomReasoning(reasoning)
+        ? reasoning === 'none'
+          ? 'none'
+          : mapReasoningToProviderEffort({
+              reasoning,
+              effortMap: {
+                minimal: 'low',
+                low: 'low',
+                medium: 'medium',
+                high: 'high',
+                xhigh: 'xhigh',
+              },
+              warnings,
+            })
+        : undefined);
 
     return {
       body: {
@@ -194,7 +209,7 @@ export class OpenResponsesLanguageModel implements LanguageModelV4 {
                 }),
               }
             : undefined,
-        tools: functionTools?.length ? functionTools : undefined,
+        tools: functionTools.length ? functionTools : undefined,
         tool_choice: convertedToolChoice,
         ...(textFormat != null && { text: { format: textFormat } }),
       },
@@ -263,10 +278,26 @@ export class OpenResponsesLanguageModel implements LanguageModelV4 {
       switch (part.type) {
         // TODO AI SDK 7 adjust reasoning in the specification to better support the reasoning structure from open responses.
         case 'reasoning': {
-          for (const contentPart of part.content ?? []) {
+          if ((part.content?.length ?? 0) > 0) {
+            for (const contentPart of part.content!) {
+              content.push({
+                type: 'reasoning',
+                text: contentPart.text,
+                providerMetadata: createReasoningProviderMetadata({
+                  part,
+                  providerOptionsName: this.config.providerOptionsName,
+                  reasoningContent: [contentPart],
+                }),
+              });
+            }
+          } else {
             content.push({
               type: 'reasoning',
-              text: contentPart.text,
+              text: part.summary.map(summaryPart => summaryPart.text).join(''),
+              providerMetadata: createReasoningProviderMetadata({
+                part,
+                providerOptionsName: this.config.providerOptionsName,
+              }),
             });
           }
           break;
@@ -274,9 +305,17 @@ export class OpenResponsesLanguageModel implements LanguageModelV4 {
 
         case 'message': {
           for (const contentPart of part.content) {
+            const annotations = getOutputTextAnnotations(contentPart);
+
             content.push({
               type: 'text',
               text: contentPart.text,
+              providerMetadata: {
+                [this.config.providerOptionsName]: {
+                  itemId: part.id,
+                  ...(annotations.length > 0 && { annotations }),
+                },
+              },
             });
           }
 
@@ -290,6 +329,9 @@ export class OpenResponsesLanguageModel implements LanguageModelV4 {
             toolCallId: part.call_id,
             toolName: part.name,
             input: part.arguments,
+            providerMetadata: {
+              [this.config.providerOptionsName]: { itemId: part.id },
+            },
           });
           break;
         }
@@ -401,7 +443,7 @@ export class OpenResponsesLanguageModel implements LanguageModelV4 {
       usage.raw = responseUsage;
     };
 
-    let isActiveReasoning = false;
+    let activeReasoningId: string | undefined;
     let hasToolCalls = false;
     let finishReason: LanguageModelV4FinishReason = {
       unified: 'other',
@@ -411,6 +453,7 @@ export class OpenResponsesLanguageModel implements LanguageModelV4 {
       string,
       { toolName?: string; toolCallId?: string; arguments?: string }
     >();
+    const providerOptionsName = this.config.providerOptionsName;
 
     return {
       stream: response.pipeThrough(
@@ -488,6 +531,11 @@ export class OpenResponsesLanguageModel implements LanguageModelV4 {
                 toolCallId,
                 toolName,
                 input,
+                providerMetadata: {
+                  [providerOptionsName]: {
+                    itemId: chunk.item.id,
+                  },
+                },
               });
               hasToolCalls = true;
 
@@ -503,7 +551,7 @@ export class OpenResponsesLanguageModel implements LanguageModelV4 {
                 type: 'reasoning-start',
                 id: chunk.item.id,
               });
-              isActiveReasoning = true;
+              activeReasoningId = chunk.item.id;
             } else if (
               (chunk as { type: string }).type ===
               'response.reasoning_text.delta'
@@ -521,8 +569,17 @@ export class OpenResponsesLanguageModel implements LanguageModelV4 {
               chunk.type === 'response.output_item.done' &&
               chunk.item.type === 'reasoning'
             ) {
-              controller.enqueue({ type: 'reasoning-end', id: chunk.item.id });
-              isActiveReasoning = false;
+              controller.enqueue({
+                type: 'reasoning-end',
+                id: chunk.item.id,
+                providerMetadata: createReasoningProviderMetadata({
+                  part: chunk.item,
+                  providerOptionsName,
+                }),
+              });
+              if (activeReasoningId === chunk.item.id) {
+                activeReasoningId = undefined;
+              }
             }
 
             // Text events
@@ -541,7 +598,20 @@ export class OpenResponsesLanguageModel implements LanguageModelV4 {
               chunk.type === 'response.output_item.done' &&
               chunk.item.type === 'message'
             ) {
-              controller.enqueue({ type: 'text-end', id: chunk.item.id });
+              const annotations = chunk.item.content.flatMap(
+                getOutputTextAnnotations,
+              );
+
+              controller.enqueue({
+                type: 'text-end',
+                id: chunk.item.id,
+                providerMetadata: {
+                  [providerOptionsName]: {
+                    itemId: chunk.item.id,
+                    ...(annotations.length > 0 && { annotations }),
+                  },
+                },
+              });
             } else if (
               chunk.type === 'response.completed' ||
               chunk.type === 'response.incomplete'
@@ -565,8 +635,11 @@ export class OpenResponsesLanguageModel implements LanguageModelV4 {
           },
 
           flush(controller) {
-            if (isActiveReasoning) {
-              controller.enqueue({ type: 'reasoning-end', id: 'reasoning-0' });
+            if (activeReasoningId != null) {
+              controller.enqueue({
+                type: 'reasoning-end',
+                id: activeReasoningId,
+              });
             }
 
             controller.enqueue({
@@ -583,3 +656,63 @@ export class OpenResponsesLanguageModel implements LanguageModelV4 {
     };
   }
 }
+
+function createReasoningProviderMetadata({
+  part,
+  providerOptionsName,
+  reasoningContent = part.content,
+}: {
+  part: ReasoningBody;
+  providerOptionsName: string;
+  reasoningContent?: ReasoningBody['content'];
+}): SharedV4ProviderMetadata {
+  return {
+    [providerOptionsName]: {
+      itemId: part.id,
+      reasoningSummary: part.summary.map(summaryPart => ({
+        type: 'summary_text',
+        text: summaryPart.text,
+      })),
+      reasoningContent:
+        reasoningContent == null
+          ? null
+          : reasoningContent.map(contentPart => ({
+              type: 'reasoning_text',
+              text: contentPart.text,
+            })),
+      ...(part.encrypted_content != null && {
+        reasoningEncryptedContent: part.encrypted_content,
+      }),
+    },
+  };
+}
+
+function getOutputTextAnnotations(value: unknown): Annotation[] {
+  if (
+    value == null ||
+    typeof value !== 'object' ||
+    !('annotations' in value) ||
+    !Array.isArray(value.annotations) ||
+    !value.annotations.every(
+      annotation =>
+        annotation != null &&
+        typeof annotation === 'object' &&
+        (annotation as { type?: unknown }).type === 'url_citation' &&
+        typeof (annotation as { start_index?: unknown }).start_index ===
+          'number' &&
+        typeof (annotation as { end_index?: unknown }).end_index === 'number' &&
+        typeof (annotation as { url?: unknown }).url === 'string' &&
+        typeof (annotation as { title?: unknown }).title === 'string',
+    )
+  ) {
+    return [];
+  }
+
+  return value.annotations.map(annotation => ({
+    type: 'url_citation',
+    start_index: (annotation as { start_index: number }).start_index,
+    end_index: (annotation as { end_index: number }).end_index,
+    url: (annotation as { url: string }).url,
+    title: (annotation as { title: string }).title,
+  }));
+}