@ai-sdk/open-responses 2.0.34 → 2.0.36

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

@@ -1,5 +1,6 @@
 import {
   UnsupportedFunctionalityError,
+  type LanguageModelV4ProviderTool,
   type LanguageModelV4Prompt,
   type SharedV4Warning,
 } from '@ai-sdk/provider';
@@ -8,6 +9,12 @@ import {
   getTopLevelMediaType,
   resolveFullMediaType,
 } from '@ai-sdk/provider-utils';
+import {
+  isOpenResponsesExtensionItem,
+  type OpenResponsesExtensionInputPart,
+  type OpenResponsesExtensionItem,
+  type OpenResponsesExtensionRegistry,
+} from '../open-responses-extension';
 import type {
   FunctionCallOutputItemParam,
   InputFileContentParam,
@@ -22,9 +29,13 @@ import type {
 export async function convertToOpenResponsesInput({
   prompt,
   providerOptionsName = 'open-responses',
+  extensionRegistry,
+  providerToolsByName = new Map(),
 }: {
   prompt: LanguageModelV4Prompt;
   providerOptionsName?: string;
+  extensionRegistry?: OpenResponsesExtensionRegistry;
+  providerToolsByName?: Map<string, LanguageModelV4ProviderTool>;
 }): Promise<{
   input: OpenResponsesRequestBody['input'];
   instructions: string | undefined;
@@ -33,6 +44,7 @@ export async function convertToOpenResponsesInput({
   const input: OpenResponsesRequestBody['input'] = [];
   const warnings: Array<SharedV4Warning> = [];
   const systemMessages: string[] = [];
+  const replayedExtensionItems = new Set<string>();
 
   for (const { role, content } of prompt) {
     switch (role) {
@@ -125,6 +137,52 @@ export async function convertToOpenResponsesInput({
         };
 
         for (const part of content) {
+          const extensionReplay = getExtensionReplay({
+            part,
+            providerOptionsName,
+            extensionRegistry,
+          });
+
+          if (extensionReplay != null) {
+            flushAssistantContent();
+            const replayItem = extensionReplay.item;
+            if (replayItem != null) {
+              const replayKey = `${replayItem.type}:${replayItem.id}`;
+              if (!replayedExtensionItems.has(replayKey)) {
+                input.push(replayItem);
+                replayedExtensionItems.add(replayKey);
+              }
+            }
+            continue;
+          }
+
+          if (part.type === 'tool-call' || part.type === 'tool-result') {
+            const providerTool = providerToolsByName.get(part.toolName);
+            const extension =
+              providerTool == null
+                ? undefined
+                : extensionRegistry?.byProviderToolId.get(providerTool.id);
+
+            if (providerTool != null && extension != null) {
+              flushAssistantContent();
+              const encoded = await encodeExtensionInputPart({
+                extensionRegistry,
+                part,
+                providerTool,
+              });
+
+              if (encoded == null) {
+                warnings.push({
+                  type: 'unsupported',
+                  feature: `provider-defined tool ${providerTool.id} ${part.type} history`,
+                });
+              } else {
+                input.push(...encoded);
+              }
+              continue;
+            }
+          }
+
           switch (part.type) {
             case 'reasoning': {
               flushAssistantContent();
@@ -243,6 +301,48 @@ export async function convertToOpenResponsesInput({
       case 'tool': {
         for (const part of content) {
           if (part.type === 'tool-result') {
+            const extensionReplay = getExtensionReplay({
+              part,
+              providerOptionsName,
+              extensionRegistry,
+            });
+
+            if (extensionReplay != null) {
+              const replayItem = extensionReplay.item;
+              if (replayItem != null) {
+                const replayKey = `${replayItem.type}:${replayItem.id}`;
+                if (!replayedExtensionItems.has(replayKey)) {
+                  input.push(replayItem);
+                  replayedExtensionItems.add(replayKey);
+                }
+              }
+              continue;
+            }
+
+            const providerTool = providerToolsByName.get(part.toolName);
+            const extension =
+              providerTool == null
+                ? undefined
+                : extensionRegistry?.byProviderToolId.get(providerTool.id);
+
+            if (providerTool != null && extension != null) {
+              const encoded = await encodeExtensionInputPart({
+                extensionRegistry,
+                part,
+                providerTool,
+              });
+
+              if (encoded == null) {
+                warnings.push({
+                  type: 'unsupported',
+                  feature: `provider-defined tool ${providerTool.id} tool-result history`,
+                });
+              } else {
+                input.push(...encoded);
+              }
+              continue;
+            }
+
             const output = part.output;
             let contentValue: FunctionCallOutputItemParam['output'];
 
@@ -346,6 +446,99 @@ export async function convertToOpenResponsesInput({
   };
 }
 
+async function encodeExtensionInputPart({
+  extensionRegistry,
+  part,
+  providerTool,
+}: {
+  extensionRegistry: OpenResponsesExtensionRegistry | undefined;
+  part: OpenResponsesExtensionInputPart;
+  providerTool: LanguageModelV4ProviderTool;
+}): Promise<OpenResponsesExtensionItem[] | undefined> {
+  const extension = extensionRegistry?.byProviderToolId.get(providerTool.id);
+  const encodeInputItem = extension?.encodeInputItem;
+  const itemTypes = extension?.itemTypes;
+  if (encodeInputItem == null || itemTypes == null) {
+    return undefined;
+  }
+
+  try {
+    const value = await encodeInputItem({
+      part,
+      tool: providerTool,
+    });
+    const items =
+      value == null ? undefined : Array.isArray(value) ? value : [value];
+
+    if (
+      items == null ||
+      items.length === 0 ||
+      !items.every(
+        item =>
+          isOpenResponsesExtensionItem(item) && itemTypes.includes(item.type),
+      )
+    ) {
+      return undefined;
+    }
+
+    return items;
+  } catch {
+    return undefined;
+  }
+}
+
+function getExtensionReplay({
+  part,
+  providerOptionsName,
+  extensionRegistry,
+}: {
+  part: {
+    providerOptions?: Record<string, unknown>;
+  };
+  providerOptionsName: string;
+  extensionRegistry: OpenResponsesExtensionRegistry | undefined;
+}): { item?: OpenResponsesExtensionItem } | undefined {
+  const extensionData = getProviderData(
+    part,
+    providerOptionsName,
+  )?.openResponsesExtension;
+
+  if (
+    extensionData == null ||
+    typeof extensionData !== 'object' ||
+    Array.isArray(extensionData)
+  ) {
+    return undefined;
+  }
+
+  const { id, item, itemId } = extensionData as {
+    id?: unknown;
+    item?: unknown;
+    itemId?: unknown;
+  };
+
+  if (typeof id !== 'string') {
+    return undefined;
+  }
+
+  const extension = extensionRegistry?.byExtensionId.get(
+    id as LanguageModelV4ProviderTool['id'],
+  );
+
+  if (extension == null) {
+    return undefined;
+  }
+
+  if (
+    isOpenResponsesExtensionItem(item) &&
+    extension.itemTypes?.includes(item.type)
+  ) {
+    return { item };
+  }
+
+  return typeof itemId === 'string' ? {} : undefined;
+}
+
 function getProviderData(
   part: {
     providerOptions?: Record<string, unknown>;

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

@@ -1,6 +1,11 @@
 import type { JSONSchema7 } from '@ai-sdk/provider';
 import { lazySchema, zodSchema } from '@ai-sdk/provider-utils';
 import { z } from 'zod/v4';
+import type {
+  OpenResponsesExtensionEvent,
+  OpenResponsesExtensionItem,
+  OpenResponsesExtensionRecord,
+} from '../open-responses-extension';
 
 export const openResponsesErrorSchema = lazySchema(() =>
   zodSchema(
@@ -263,7 +268,8 @@ export type AllowedToolsParam = {
 export type ToolChoiceParam =
   | ToolChoiceValueEnum
   | SpecificFunctionParam
-  | AllowedToolsParam;
+  | AllowedToolsParam
+  | OpenResponsesExtensionRecord;
 
 // ============================================================================
 // Configuration Types
@@ -483,7 +489,8 @@ export type OutputItem =
   | FunctionCall
   | FunctionCallOutput
   | Message
-  | ReasoningBody;
+  | ReasoningBody
+  | OpenResponsesExtensionItem;
 
 /**
  * Details about why the response was incomplete.
@@ -626,6 +633,7 @@ export type OpenResponsesRequestBody = {
         | AssistantMessageItemParam
         | FunctionCallItemParam
         | FunctionCallOutputItemParam
+        | OpenResponsesExtensionRecord
       >;
 
   /**
@@ -643,7 +651,7 @@ export type OpenResponsesRequestBody = {
   /**
    * A list of tools that the model may call while generating the response.
    */
-  tools?: FunctionToolParam[];
+  tools?: Array<FunctionToolParam | OpenResponsesExtensionRecord>;
 
   /**
    * Controls which tool the model should use, if any.
@@ -1235,4 +1243,6 @@ export type OpenResponsesChunk =
   | ResponseReasoningSummaryPartAddedEvent
   | ResponseReasoningSummaryPartDoneEvent
   // Error Event
-  | ResponseErrorEvent;
+  | ResponseErrorEvent
+  // Registered extension event
+  | OpenResponsesExtensionEvent;

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

@@ -1,4 +1,5 @@
 import type { FetchFunction } from '@ai-sdk/provider-utils';
+import type { OpenResponsesExtensionRegistry } from '../open-responses-extension';
 
 export type OpenResponsesConfig = {
   provider: string;
@@ -7,4 +8,5 @@ export type OpenResponsesConfig = {
   headers?: () => Record<string, string | undefined>;
   fetch?: FetchFunction;
   generateId: () => string;
+  extensionRegistry?: OpenResponsesExtensionRegistry;
 };

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

@@ -22,17 +22,28 @@ import {
   mapReasoningToProviderEffort,
   parseProviderOptions,
   postJsonToApi,
+  SerializationError,
   serializeModelOptions,
   WORKFLOW_SERIALIZE,
   WORKFLOW_DESERIALIZE,
   type ParseResult,
 } from '@ai-sdk/provider-utils';
 import { z } from 'zod/v4';
+import {
+  createOpenResponsesExtensionRegistry,
+  isOpenResponsesExtensionEvent,
+  isOpenResponsesExtensionItem,
+  isOpenResponsesJSONObject,
+  type OpenResponsesExtension,
+  type OpenResponsesExtensionContentPart,
+  type OpenResponsesExtensionItem,
+  type OpenResponsesExtensionRecord,
+  type OpenResponsesExtensionRegistry,
+} from '../open-responses-extension';
 import { convertToOpenResponsesInput } from './convert-to-open-responses-input';
 import {
   openResponsesErrorSchema,
   type Annotation,
-  type FunctionToolParam,
   type OpenResponsesRequestBody,
   type OpenResponsesResponseBody,
   type OpenResponsesChunk,
@@ -49,8 +60,16 @@ export class OpenResponsesLanguageModel implements LanguageModelV4 {
   readonly modelId: string;
 
   private readonly config: OpenResponsesConfig;
+  private readonly extensionRegistry: OpenResponsesExtensionRegistry;
 
   static [WORKFLOW_SERIALIZE](model: OpenResponsesLanguageModel) {
+    if (model.extensionRegistry.byExtensionId.size > 0) {
+      throw new SerializationError({
+        message:
+          'Open Responses models with registered extensions cannot be serialized across workflow boundaries. Recreate the provider with its extension codecs inside the workflow step.',
+      });
+    }
+
     return serializeModelOptions({
       modelId: model.modelId,
       config: model.config,
@@ -67,6 +86,8 @@ export class OpenResponsesLanguageModel implements LanguageModelV4 {
   constructor(modelId: string, config: OpenResponsesConfig) {
     this.modelId = modelId;
     this.config = config;
+    this.extensionRegistry =
+      config.extensionRegistry ?? createOpenResponsesExtensionRegistry();
   }
 
   readonly supportedUrls: Record<string, RegExp[]> = {
@@ -110,6 +131,12 @@ export class OpenResponsesLanguageModel implements LanguageModelV4 {
       warnings.push({ type: 'unsupported', feature: 'seed' });
     }
 
+    const providerToolsByName = new Map(
+      (tools ?? [])
+        .filter(tool => tool.type === 'provider')
+        .map(tool => [tool.name, tool]),
+    );
+
     const {
       input,
       instructions,
@@ -117,21 +144,63 @@ export class OpenResponsesLanguageModel implements LanguageModelV4 {
     } = await convertToOpenResponsesInput({
       prompt,
       providerOptionsName: this.config.providerOptionsName,
+      extensionRegistry: this.extensionRegistry,
+      providerToolsByName,
     });
 
     warnings.push(...inputWarnings);
 
-    // Convert function tools to the Open Responses format
-    const functionTools: FunctionToolParam[] = [];
+    const convertedTools: NonNullable<OpenResponsesRequestBody['tools']> = [];
+    const encodedProviderToolsByName = new Map<
+      string,
+      {
+        toolType: OpenResponsesExtensionRecord['type'];
+        encodeToolChoice: OpenResponsesExtension['encodeToolChoice'];
+        tool: Extract<
+          NonNullable<LanguageModelV4CallOptions['tools']>[number],
+          { type: 'provider' }
+        >;
+      }
+    >();
 
     for (const tool of tools ?? []) {
       if (tool.type === 'provider') {
-        warnings.push({
-          type: 'unsupported',
-          feature: `provider-defined tool ${tool.id}`,
-        });
+        const extension = this.extensionRegistry.byProviderToolId.get(tool.id);
+        let encoded: OpenResponsesExtensionRecord | undefined;
+
+        if (extension != null) {
+          try {
+            const fields = await extension.encodeTool({
+              name: tool.name,
+              args: tool.args,
+            });
+
+            if (isOpenResponsesJSONObject(fields)) {
+              encoded = {
+                ...fields,
+                type: extension.toolType,
+              };
+            }
+          } catch {
+            // Encoding failures are reported as unsupported below.
+          }
+        }
+
+        if (encoded == null) {
+          warnings.push({
+            type: 'unsupported',
+            feature: `provider-defined tool ${tool.id}`,
+          });
+        } else if (extension != null) {
+          convertedTools.push(encoded);
+          encodedProviderToolsByName.set(tool.name, {
+            toolType: extension.toolType,
+            encodeToolChoice: extension.encodeToolChoice,
+            tool,
+          });
+        }
       } else {
-        functionTools.push({
+        convertedTools.push({
           type: 'function',
           name: tool.name,
           description: tool.description,
@@ -142,12 +211,47 @@ export class OpenResponsesLanguageModel implements LanguageModelV4 {
     }
 
     // Convert tool choice to the Open Responses format
-    const convertedToolChoice: ToolChoiceParam | undefined =
-      toolChoice == null
-        ? undefined
-        : toolChoice.type === 'tool'
-          ? { type: 'function', name: toolChoice.toolName }
-          : toolChoice.type; // 'auto' | 'none' | 'required'
+    let convertedToolChoice: ToolChoiceParam | undefined;
+    if (toolChoice?.type === 'tool') {
+      const registeredTool = encodedProviderToolsByName.get(
+        toolChoice.toolName,
+      );
+
+      if (registeredTool == null) {
+        if (!providerToolsByName.has(toolChoice.toolName)) {
+          convertedToolChoice = {
+            type: 'function',
+            name: toolChoice.toolName,
+          };
+        }
+      } else {
+        const { encodeToolChoice, tool, toolType } = registeredTool;
+        let fields: unknown = {};
+
+        try {
+          fields = await encodeToolChoice?.({
+            name: tool.name,
+            args: tool.args,
+          });
+        } catch {
+          fields = undefined;
+        }
+
+        if (encodeToolChoice != null && !isOpenResponsesJSONObject(fields)) {
+          warnings.push({
+            type: 'unsupported',
+            feature: `tool choice for provider-defined tool ${tool.id}`,
+          });
+        } else {
+          convertedToolChoice = {
+            ...(isOpenResponsesJSONObject(fields) ? fields : {}),
+            type: toolType,
+          };
+        }
+      }
+    } else {
+      convertedToolChoice = toolChoice?.type;
+    }
 
     const textFormat =
       responseFormat?.type === 'json'
@@ -210,7 +314,7 @@ export class OpenResponsesLanguageModel implements LanguageModelV4 {
                 }),
               }
             : undefined,
-        tools: functionTools.length ? functionTools : undefined,
+        tools: convertedTools.length ? convertedTools : undefined,
         tool_choice: convertedToolChoice,
         ...(textFormat != null && { text: { format: textFormat } }),
       },
@@ -336,6 +440,25 @@ export class OpenResponsesLanguageModel implements LanguageModelV4 {
           });
           break;
         }
+
+        default: {
+          if (!isOpenResponsesExtensionItem(part)) {
+            break;
+          }
+
+          const decoded = await decodeExtensionItem({
+            extensionRegistry: this.extensionRegistry,
+            item: part,
+            mode: 'generate',
+            providerOptionsName: this.config.providerOptionsName,
+          });
+
+          if (decoded != null) {
+            content.push(...decoded);
+            hasToolCalls ||= decoded.some(part => part.type === 'tool-call');
+          }
+          break;
+        }
       }
     }
 
@@ -455,6 +578,8 @@ export class OpenResponsesLanguageModel implements LanguageModelV4 {
       { toolName?: string; toolCallId?: string; arguments?: string }
     >();
     const providerOptionsName = this.config.providerOptionsName;
+    const extensionRegistry = this.extensionRegistry;
+    const extensionStreamState = new Map<string, unknown>();
 
     return {
       stream: response.pipeThrough(
@@ -466,7 +591,7 @@ export class OpenResponsesLanguageModel implements LanguageModelV4 {
             controller.enqueue({ type: 'stream-start', warnings });
           },
 
-          transform(parseResult, controller) {
+          async transform(parseResult, controller) {
             if (options.includeRawChunks) {
               controller.enqueue({
                 type: 'raw',
@@ -481,6 +606,27 @@ export class OpenResponsesLanguageModel implements LanguageModelV4 {
 
             const chunk = parseResult.value;
 
+            if (isOpenResponsesExtensionEvent(chunk)) {
+              const extension = extensionRegistry.byEventType.get(chunk.type);
+              if (extension?.decodeEvent != null) {
+                try {
+                  const decoded = await extension.decodeEvent({
+                    event: chunk,
+                    state: extensionStreamState,
+                  });
+                  for (const part of decoded ?? []) {
+                    controller.enqueue(part);
+                    hasToolCalls ||=
+                      part.type === 'tool-call' ||
+                      part.type === 'tool-input-start';
+                  }
+                } catch (error) {
+                  controller.enqueue({ type: 'error', error });
+                }
+              }
+              return;
+            }
+
             // Tool call events (single-shot tool-call when complete)
             if (
               chunk.type === 'response.output_item.added' &&
@@ -541,6 +687,25 @@ export class OpenResponsesLanguageModel implements LanguageModelV4 {
               hasToolCalls = true;
 
               toolCallsByItemId.delete(chunk.item.id);
+            } else if (
+              chunk.type === 'response.output_item.done' &&
+              isOpenResponsesExtensionItem(chunk.item)
+            ) {
+              try {
+                const decoded = await decodeExtensionItem({
+                  extensionRegistry,
+                  item: chunk.item,
+                  mode: 'stream',
+                  providerOptionsName,
+                });
+
+                for (const part of decoded ?? []) {
+                  controller.enqueue(part);
+                  hasToolCalls ||= part.type === 'tool-call';
+                }
+              } catch (error) {
+                controller.enqueue({ type: 'error', error });
+              }
             }
 
             // Reasoning events (note: response.reasoning_text.delta is an LM Studio extension, not in official spec)
@@ -729,6 +894,95 @@ function createReasoningProviderMetadata({
   };
 }
 
+async function decodeExtensionItem({
+  extensionRegistry,
+  item,
+  mode,
+  providerOptionsName,
+}: {
+  extensionRegistry: OpenResponsesExtensionRegistry;
+  item: OpenResponsesExtensionItem;
+  mode: 'generate' | 'stream';
+  providerOptionsName: string;
+}): Promise<OpenResponsesExtensionContentPart[] | undefined> {
+  const extension = extensionRegistry.byItemType.get(item.type);
+  if (extension == null) {
+    return undefined;
+  }
+
+  const decoded = await extension.decodeItem({ item, mode });
+  if (decoded == null) {
+    return undefined;
+  }
+
+  return [
+    createExtensionReplayCarrier({
+      extension,
+      item,
+      providerOptionsName,
+    }),
+    ...decoded.map(part =>
+      addExtensionItemReferenceMetadata({
+        extension,
+        item,
+        part,
+        providerOptionsName,
+      }),
+    ),
+  ];
+}
+
+function createExtensionReplayCarrier({
+  extension,
+  item,
+  providerOptionsName,
+}: {
+  extension: OpenResponsesExtension;
+  item: OpenResponsesExtensionItem;
+  providerOptionsName: string;
+}): OpenResponsesExtensionContentPart {
+  return {
+    type: 'custom',
+    kind: 'open-responses.extension-replay',
+    providerMetadata: {
+      [providerOptionsName]: {
+        openResponsesExtension: {
+          id: extension.id,
+          item,
+        },
+      },
+    },
+  };
+}
+
+function addExtensionItemReferenceMetadata({
+  extension,
+  item,
+  part,
+  providerOptionsName,
+}: {
+  extension: OpenResponsesExtension;
+  item: OpenResponsesExtensionItem;
+  part: OpenResponsesExtensionContentPart;
+  providerOptionsName: string;
+}): OpenResponsesExtensionContentPart {
+  const providerMetadata = part.providerMetadata ?? {};
+
+  return {
+    ...part,
+    providerMetadata: {
+      ...providerMetadata,
+      [providerOptionsName]: {
+        ...providerMetadata[providerOptionsName],
+        openResponsesExtension: {
+          id: extension.id,
+          itemId: item.id,
+        },
+      },
+    },
+  };
+}
+
 function getOutputTextAnnotations(value: unknown): Annotation[] {
   if (
     value == null ||