@ai-sdk/open-responses 2.0.34 → 2.0.36

package/dist/index.js

@@ -1,5 +1,5 @@
 // src/version.ts
-var VERSION = true ? "2.0.34" : "0.0.0-test";
+var VERSION = true ? "2.0.36" : "0.0.0-test";
 
 // src/open-responses-provider.ts
 import {
@@ -10,6 +10,184 @@ import {
   withUserAgentSuffix
 } from "@ai-sdk/provider-utils";
 
+// src/open-responses-extension.ts
+function createOpenResponsesExtensionRegistry(extensions) {
+  const registry = {
+    byEventType: /* @__PURE__ */ new Map(),
+    byExtensionId: /* @__PURE__ */ new Map(),
+    byItemType: /* @__PURE__ */ new Map(),
+    byProviderToolId: /* @__PURE__ */ new Map(),
+    byToolType: /* @__PURE__ */ new Map()
+  };
+  for (const extension of extensions != null ? extensions : []) {
+    const namespaceSeparatorIndex = extension.id.indexOf(".");
+    if (namespaceSeparatorIndex <= 0) {
+      throw new Error(
+        `Open Responses extension ID ${extension.id} must use <implementor>.<extension> format.`
+      );
+    }
+    const namespace = extension.id.slice(0, namespaceSeparatorIndex);
+    registerUnique({
+      map: registry.byExtensionId,
+      key: extension.id,
+      extension,
+      field: "id"
+    });
+    const hasToolType = extension.toolType != null;
+    const hasToolEncoder = extension.encodeTool != null;
+    if (hasToolType !== hasToolEncoder) {
+      throw new Error(
+        `Open Responses extension ${extension.id} must provide toolType and encodeTool together.`
+      );
+    }
+    if (extension.encodeToolChoice != null && !hasToolEncoder) {
+      throw new Error(
+        `Open Responses extension ${extension.id} cannot provide encodeToolChoice without toolType and encodeTool.`
+      );
+    }
+    if (hasToolType && hasToolEncoder) {
+      const toolExtension = extension;
+      assertNamespacedType({
+        extensionId: extension.id,
+        namespace,
+        type: toolExtension.toolType,
+        field: "toolType"
+      });
+      registerUnique({
+        map: registry.byProviderToolId,
+        key: extension.id,
+        extension: toolExtension,
+        field: "provider-tool id"
+      });
+      registerUnique({
+        map: registry.byToolType,
+        key: toolExtension.toolType,
+        extension: toolExtension,
+        field: "toolType"
+      });
+    }
+    const hasItemTypes = extension.itemTypes != null;
+    const hasItemDecoder = extension.decodeItem != null;
+    if (hasItemTypes !== hasItemDecoder) {
+      throw new Error(
+        `Open Responses extension ${extension.id} must provide itemTypes and decodeItem together.`
+      );
+    }
+    if (extension.encodeInputItem != null && !hasItemDecoder) {
+      throw new Error(
+        `Open Responses extension ${extension.id} cannot provide encodeInputItem without itemTypes and decodeItem.`
+      );
+    }
+    if (hasItemTypes && hasItemDecoder) {
+      const itemExtension = extension;
+      if (itemExtension.itemTypes.length === 0) {
+        throw new Error(
+          `Open Responses extension ${extension.id} must register at least one item type.`
+        );
+      }
+      for (const itemType of itemExtension.itemTypes) {
+        assertNamespacedType({
+          extensionId: extension.id,
+          namespace,
+          type: itemType,
+          field: "itemTypes"
+        });
+        registerUnique({
+          map: registry.byItemType,
+          key: itemType,
+          extension: itemExtension,
+          field: "item type"
+        });
+      }
+    }
+    const hasEventTypes = extension.eventTypes != null;
+    const hasEventDecoder = extension.decodeEvent != null;
+    if (hasEventTypes !== hasEventDecoder) {
+      throw new Error(
+        `Open Responses extension ${extension.id} must provide eventTypes and decodeEvent together.`
+      );
+    }
+    if (hasEventTypes && hasEventDecoder) {
+      const eventExtension = extension;
+      if (eventExtension.eventTypes.length === 0) {
+        throw new Error(
+          `Open Responses extension ${extension.id} must register at least one event type.`
+        );
+      }
+      for (const eventType of eventExtension.eventTypes) {
+        assertNamespacedType({
+          extensionId: extension.id,
+          namespace,
+          type: eventType,
+          field: "eventTypes"
+        });
+        registerUnique({
+          map: registry.byEventType,
+          key: eventType,
+          extension: eventExtension,
+          field: "event type"
+        });
+      }
+    }
+    if (!hasToolEncoder && !hasItemDecoder && !hasEventDecoder) {
+      throw new Error(
+        `Open Responses extension ${extension.id} must register a tool, item, or event capability.`
+      );
+    }
+  }
+  return registry;
+}
+function assertNamespacedType({
+  extensionId,
+  namespace,
+  type,
+  field
+}) {
+  if (!type.includes(":") || type.slice(0, type.indexOf(":")) !== namespace) {
+    throw new Error(
+      `Open Responses extension ${extensionId} has invalid ${field} value ${type}. Extension wire types must use the ${namespace}: namespace.`
+    );
+  }
+}
+function registerUnique({
+  map,
+  key,
+  extension,
+  field
+}) {
+  const existing = map.get(key);
+  if (existing != null) {
+    throw new Error(
+      `Open Responses extension ${extension.id} cannot register ${field} ${String(key)} because it is already registered by ${existing.id}.`
+    );
+  }
+  map.set(key, extension);
+}
+function isOpenResponsesNamespacedType(value) {
+  return typeof value === "string" && value.includes(":");
+}
+function isOpenResponsesExtensionRecord(value) {
+  return isOpenResponsesJSONObject(value) && isOpenResponsesNamespacedType(value.type);
+}
+function isOpenResponsesJSONObject(value) {
+  return value != null && typeof value === "object" && !Array.isArray(value) && Object.getPrototypeOf(value) === Object.prototype && Object.values(value).every(isOpenResponsesJSONValue);
+}
+function isOpenResponsesExtensionItem(value) {
+  return isOpenResponsesExtensionRecord(value) && typeof value.id === "string" && typeof value.status === "string";
+}
+function isOpenResponsesExtensionEvent(value) {
+  return isOpenResponsesExtensionRecord(value) && typeof value.sequence_number === "number";
+}
+function isOpenResponsesJSONValue(value) {
+  if (value == null || typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+    return true;
+  }
+  if (Array.isArray(value)) {
+    return value.every(isOpenResponsesJSONValue);
+  }
+  return isOpenResponsesJSONObject(value);
+}
+
 // src/responses/open-responses-language-model.ts
 import {
   APICallError
@@ -25,6 +203,7 @@ import {
   mapReasoningToProviderEffort,
   parseProviderOptions,
   postJsonToApi,
+  SerializationError,
   serializeModelOptions,
   WORKFLOW_SERIALIZE,
   WORKFLOW_DESERIALIZE
@@ -42,12 +221,15 @@ import {
 } from "@ai-sdk/provider-utils";
 async function convertToOpenResponsesInput({
   prompt,
-  providerOptionsName = "open-responses"
+  providerOptionsName = "open-responses",
+  extensionRegistry,
+  providerToolsByName = /* @__PURE__ */ new Map()
 }) {
   var _a, _b, _c, _d;
   const input = [];
   const warnings = [];
   const systemMessages = [];
+  const replayedExtensionItems = /* @__PURE__ */ new Set();
   for (const { role, content } of prompt) {
     switch (role) {
       case "system": {
@@ -124,6 +306,44 @@ async function convertToOpenResponsesInput({
           assistantMessageId = void 0;
         };
         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 ? void 0 : extensionRegistry == null ? void 0 : 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();
@@ -205,6 +425,40 @@ 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 ? void 0 : extensionRegistry == null ? void 0 : 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;
             switch (output.type) {
@@ -298,6 +552,61 @@ async function convertToOpenResponsesInput({
     warnings
   };
 }
+async function encodeExtensionInputPart({
+  extensionRegistry,
+  part,
+  providerTool
+}) {
+  const extension = extensionRegistry == null ? void 0 : extensionRegistry.byProviderToolId.get(providerTool.id);
+  const encodeInputItem = extension == null ? void 0 : extension.encodeInputItem;
+  const itemTypes = extension == null ? void 0 : extension.itemTypes;
+  if (encodeInputItem == null || itemTypes == null) {
+    return void 0;
+  }
+  try {
+    const value = await encodeInputItem({
+      part,
+      tool: providerTool
+    });
+    const items = value == null ? void 0 : Array.isArray(value) ? value : [value];
+    if (items == null || items.length === 0 || !items.every(
+      (item) => isOpenResponsesExtensionItem(item) && itemTypes.includes(item.type)
+    )) {
+      return void 0;
+    }
+    return items;
+  } catch (e) {
+    return void 0;
+  }
+}
+function getExtensionReplay({
+  part,
+  providerOptionsName,
+  extensionRegistry
+}) {
+  var _a, _b;
+  const extensionData = (_a = getProviderData(
+    part,
+    providerOptionsName
+  )) == null ? void 0 : _a.openResponsesExtension;
+  if (extensionData == null || typeof extensionData !== "object" || Array.isArray(extensionData)) {
+    return void 0;
+  }
+  const { id, item, itemId } = extensionData;
+  if (typeof id !== "string") {
+    return void 0;
+  }
+  const extension = extensionRegistry == null ? void 0 : extensionRegistry.byExtensionId.get(
+    id
+  );
+  if (extension == null) {
+    return void 0;
+  }
+  if (isOpenResponsesExtensionItem(item) && ((_b = extension.itemTypes) == null ? void 0 : _b.includes(item.type))) {
+    return { item };
+  }
+  return typeof itemId === "string" ? {} : void 0;
+}
 function getProviderData(part, providerOptionsName) {
   var _a, _b, _c;
   const providerData = (_c = (_a = part.providerOptions) == null ? void 0 : _a[providerOptionsName]) != null ? _c : (_b = part.providerMetadata) == null ? void 0 : _b[providerOptionsName];
@@ -404,10 +713,17 @@ var OpenResponsesLanguageModel = class _OpenResponsesLanguageModel {
     this.supportedUrls = {
       "image/*": [/^https?:\/\/.*$/]
     };
+    var _a;
     this.modelId = modelId;
     this.config = config;
+    this.extensionRegistry = (_a = config.extensionRegistry) != null ? _a : createOpenResponsesExtensionRegistry();
   }
   static [WORKFLOW_SERIALIZE](model) {
+    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
@@ -446,24 +762,56 @@ var OpenResponsesLanguageModel = class _OpenResponsesLanguageModel {
     if (seed != null) {
       warnings.push({ type: "unsupported", feature: "seed" });
     }
+    const providerToolsByName = new Map(
+      (tools != null ? tools : []).filter((tool) => tool.type === "provider").map((tool) => [tool.name, tool])
+    );
     const {
       input,
       instructions,
       warnings: inputWarnings
     } = await convertToOpenResponsesInput({
       prompt,
-      providerOptionsName: this.config.providerOptionsName
+      providerOptionsName: this.config.providerOptionsName,
+      extensionRegistry: this.extensionRegistry,
+      providerToolsByName
     });
     warnings.push(...inputWarnings);
-    const functionTools = [];
+    const convertedTools = [];
+    const encodedProviderToolsByName = /* @__PURE__ */ new Map();
     for (const tool of tools != null ? 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;
+        if (extension != null) {
+          try {
+            const fields = await extension.encodeTool({
+              name: tool.name,
+              args: tool.args
+            });
+            if (isOpenResponsesJSONObject(fields)) {
+              encoded = {
+                ...fields,
+                type: extension.toolType
+              };
+            }
+          } catch (e) {
+          }
+        }
+        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,
@@ -472,7 +820,44 @@ var OpenResponsesLanguageModel = class _OpenResponsesLanguageModel {
         });
       }
     }
-    const convertedToolChoice = toolChoice == null ? void 0 : toolChoice.type === "tool" ? { type: "function", name: toolChoice.toolName } : toolChoice.type;
+    let convertedToolChoice;
+    if ((toolChoice == null ? void 0 : 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 = {};
+        try {
+          fields = await (encodeToolChoice == null ? void 0 : encodeToolChoice({
+            name: tool.name,
+            args: tool.args
+          }));
+        } catch (e) {
+          fields = void 0;
+        }
+        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 == null ? void 0 : toolChoice.type;
+    }
     const textFormat = (responseFormat == null ? void 0 : responseFormat.type) === "json" ? {
       type: "json_schema",
       ...responseFormat.schema != null ? {
@@ -516,7 +901,7 @@ var OpenResponsesLanguageModel = class _OpenResponsesLanguageModel {
             summary: openResponsesOptions.reasoningSummary
           }
         } : void 0,
-        tools: functionTools.length ? functionTools : void 0,
+        tools: convertedTools.length ? convertedTools : void 0,
         tool_choice: convertedToolChoice,
         ...textFormat != null && { text: { format: textFormat } }
       },
@@ -629,6 +1014,22 @@ var OpenResponsesLanguageModel = class _OpenResponsesLanguageModel {
           });
           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 || (hasToolCalls = decoded.some((part2) => part2.type === "tool-call"));
+          }
+          break;
+        }
       }
     }
     const usage = response.usage;
@@ -732,13 +1133,15 @@ var OpenResponsesLanguageModel = class _OpenResponsesLanguageModel {
     };
     const toolCallsByItemId = /* @__PURE__ */ new Map();
     const providerOptionsName = this.config.providerOptionsName;
+    const extensionRegistry = this.extensionRegistry;
+    const extensionStreamState = /* @__PURE__ */ new Map();
     return {
       stream: response.pipeThrough(
         new TransformStream({
           start(controller) {
             controller.enqueue({ type: "stream-start", warnings });
           },
-          transform(parseResult, controller) {
+          async transform(parseResult, controller) {
             var _a2, _b2, _c, _d, _e, _f, _g, _h;
             if (options.includeRawChunks) {
               controller.enqueue({
@@ -751,6 +1154,24 @@ var OpenResponsesLanguageModel = class _OpenResponsesLanguageModel {
               return;
             }
             const chunk = parseResult.value;
+            if (isOpenResponsesExtensionEvent(chunk)) {
+              const extension = extensionRegistry.byEventType.get(chunk.type);
+              if ((extension == null ? void 0 : extension.decodeEvent) != null) {
+                try {
+                  const decoded = await extension.decodeEvent({
+                    event: chunk,
+                    state: extensionStreamState
+                  });
+                  for (const part of decoded != null ? decoded : []) {
+                    controller.enqueue(part);
+                    hasToolCalls || (hasToolCalls = part.type === "tool-call" || part.type === "tool-input-start");
+                  }
+                } catch (error) {
+                  controller.enqueue({ type: "error", error });
+                }
+              }
+              return;
+            }
             if (chunk.type === "response.output_item.added" && chunk.item.type === "function_call") {
               toolCallsByItemId.set(chunk.item.id, {
                 toolName: chunk.item.name,
@@ -795,6 +1216,21 @@ var OpenResponsesLanguageModel = class _OpenResponsesLanguageModel {
               });
               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 != null ? decoded : []) {
+                  controller.enqueue(part);
+                  hasToolCalls || (hasToolCalls = part.type === "tool-call");
+                }
+              } catch (error) {
+                controller.enqueue({ type: "error", error });
+              }
             } else if (chunk.type === "response.output_item.added" && chunk.item.type === "reasoning") {
               controller.enqueue({
                 type: "reasoning-start",
@@ -938,6 +1374,76 @@ function createReasoningProviderMetadata({
     }
   };
 }
+async function decodeExtensionItem({
+  extensionRegistry,
+  item,
+  mode,
+  providerOptionsName
+}) {
+  const extension = extensionRegistry.byItemType.get(item.type);
+  if (extension == null) {
+    return void 0;
+  }
+  const decoded = await extension.decodeItem({ item, mode });
+  if (decoded == null) {
+    return void 0;
+  }
+  return [
+    createExtensionReplayCarrier({
+      extension,
+      item,
+      providerOptionsName
+    }),
+    ...decoded.map(
+      (part) => addExtensionItemReferenceMetadata({
+        extension,
+        item,
+        part,
+        providerOptionsName
+      })
+    )
+  ];
+}
+function createExtensionReplayCarrier({
+  extension,
+  item,
+  providerOptionsName
+}) {
+  return {
+    type: "custom",
+    kind: "open-responses.extension-replay",
+    providerMetadata: {
+      [providerOptionsName]: {
+        openResponsesExtension: {
+          id: extension.id,
+          item
+        }
+      }
+    }
+  };
+}
+function addExtensionItemReferenceMetadata({
+  extension,
+  item,
+  part,
+  providerOptionsName
+}) {
+  var _a;
+  const providerMetadata = (_a = part.providerMetadata) != null ? _a : {};
+  return {
+    ...part,
+    providerMetadata: {
+      ...providerMetadata,
+      [providerOptionsName]: {
+        ...providerMetadata[providerOptionsName],
+        openResponsesExtension: {
+          id: extension.id,
+          itemId: item.id
+        }
+      }
+    }
+  };
+}
 function getOutputTextAnnotations(value) {
   if (value == null || typeof value !== "object" || !("annotations" in value) || !Array.isArray(value.annotations) || !value.annotations.every(
     (annotation) => annotation != null && typeof annotation === "object" && annotation.type === "url_citation" && typeof annotation.start_index === "number" && typeof annotation.end_index === "number" && typeof annotation.url === "string" && typeof annotation.title === "string"
@@ -956,6 +1462,9 @@ function getOutputTextAnnotations(value) {
 // src/open-responses-provider.ts
 function createOpenResponses(options) {
   const providerName = options.name;
+  const extensionRegistry = createOpenResponsesExtensionRegistry(
+    options.experimental_extensions
+  );
   const getHeaders = () => withUserAgentSuffix(
     {
       ...options.apiKey ? {
@@ -972,7 +1481,8 @@ function createOpenResponses(options) {
       headers: getHeaders,
       url: options.url,
       fetch: options.fetch,
-      generateId: () => generateId()
+      generateId: () => generateId(),
+      extensionRegistry
     });
   };
   const createLanguageModel = (modelId) => {