@ai-sdk/open-responses 2.0.31 → 2.0.35

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;
 };