@ai-sdk/open-responses 2.0.54 → 2.0.55

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # @ai-sdk/open-responses
 
+## 2.0.55
+
+### Patch Changes
+
+- 8cf3f5b: Allow extension codecs to explicitly opt in to exact bare tool, item, and event discriminator registration.
+- Updated dependencies [e3605f6]
+- Updated dependencies [525efc5]
+  - @ai-sdk/provider-utils@5.0.50
+  - @ai-sdk/provider@4.0.19
+
 ## 2.0.54
 
 ### Patch Changes

package/dist/index.d.ts

@@ -5,14 +5,14 @@ import { MaybePromiseLike, FetchFunction, ResponseHandler, InferSchema } from '@
 declare const VERSION: string;
 
 type OpenResponsesNamespacedType = `${string}:${string}`;
-type OpenResponsesExtensionRecord = JSONObject & {
-    type: OpenResponsesNamespacedType;
+type OpenResponsesExtensionRecord<Type extends string = OpenResponsesNamespacedType> = JSONObject & {
+    type: Type;
 };
-type OpenResponsesExtensionItem = OpenResponsesExtensionRecord & {
+type OpenResponsesExtensionItem<Type extends string = OpenResponsesNamespacedType> = OpenResponsesExtensionRecord<Type> & {
     id: string;
     status: string;
 };
-type OpenResponsesExtensionEvent = OpenResponsesExtensionRecord & {
+type OpenResponsesExtensionEvent<Type extends string = OpenResponsesNamespacedType> = OpenResponsesExtensionRecord<Type> & {
     sequence_number: number;
 };
 type OpenResponsesExtensionInputPart = LanguageModelV4ToolCallPart | LanguageModelV4ToolResultPart;
@@ -25,7 +25,7 @@ type OpenResponsesExtensionStreamPart = Exclude<LanguageModelV4StreamPart, {
  *
  * Tool, item, and event codecs can be registered independently.
  */
-interface OpenResponsesExtension {
+interface OpenResponsesExtensionBase {
     /**
      * Extension ID in `<implementor>.<extension>` format. For extensions that
      * encode a provider tool, this is also the AI SDK provider-tool ID.
@@ -36,78 +36,135 @@ interface OpenResponsesExtension {
      * Must be provided together with `encodeTool`.
      */
     toolType?: OpenResponsesNamespacedType;
-    /**
-     * Namespaced item types decoded by this extension. Must be provided together
-     * with `decodeItem`.
-     */
-    itemTypes?: readonly OpenResponsesNamespacedType[];
-    /**
-     * Namespaced streaming event types decoded by this extension. Must be
-     * provided together with `decodeEvent`.
-     */
-    eventTypes?: readonly OpenResponsesNamespacedType[];
     /**
      * Encodes an AI SDK provider tool. Return `undefined` when its arguments
-     * cannot be encoded. The adapter adds `toolType` and omits a specific tool
-     * choice that selects the omitted tool.
+     * cannot be encoded. The adapter adds the registered tool type and omits a
+     * specific tool choice that selects the omitted tool.
      */
     encodeTool?(options: {
         name: string;
         args: Record<string, unknown>;
     }): MaybePromiseLike<JSONObject | undefined>;
     /**
-     * Encodes a specific `toolChoice`. The adapter adds `toolType`. The default
-     * is an object containing only `toolType`.
+     * Encodes a specific `toolChoice`. The adapter adds the registered tool type.
+     * The default is an object containing only that type.
      */
     encodeToolChoice?(options: {
         name: string;
         args: Record<string, unknown>;
     }): MaybePromiseLike<JSONObject | undefined>;
+}
+type OpenResponsesExtensionItemCodec<Type extends string> = {
     /**
-     * Decodes a completed namespaced item into AI SDK content parts. The adapter
+     * Namespaced item types decoded by this extension. Must be provided together
+     * with `decodeItem`.
+     */
+    itemTypes?: readonly OpenResponsesNamespacedType[];
+    /**
+     * Decodes a completed registered item into AI SDK content parts. The adapter
      * adds a custom replay part containing the original item and reference
      * metadata to the returned parts.
      */
     decodeItem?(options: {
-        item: OpenResponsesExtensionItem;
+        item: OpenResponsesExtensionItem<Type>;
         mode: 'generate' | 'stream';
     }): MaybePromiseLike<OpenResponsesExtensionContentPart[] | undefined>;
     /**
      * Encodes an AI SDK history part when no original wire item is available.
-     * Every returned item must use one of `itemTypes`.
+     * Every returned item must use one of the registered item types.
      */
     encodeInputItem?(options: {
         part: OpenResponsesExtensionInputPart;
         tool: LanguageModelV4ProviderTool;
-    }): MaybePromiseLike<OpenResponsesExtensionItem | OpenResponsesExtensionItem[] | undefined>;
+    }): MaybePromiseLike<OpenResponsesExtensionItem<Type> | OpenResponsesExtensionItem<Type>[] | undefined>;
+};
+type OpenResponsesExtensionEventCodec<Type extends string> = {
+    /**
+     * Namespaced streaming event types decoded by this extension. Must be
+     * provided together with `decodeEvent`.
+     */
+    eventTypes?: readonly OpenResponsesNamespacedType[];
     /**
-     * Decodes a namespaced streaming event.
+     * Decodes a registered streaming event.
      *
      * `state` persists for the lifetime of one response stream.
      */
     decodeEvent?(options: {
-        event: OpenResponsesExtensionEvent;
+        event: OpenResponsesExtensionEvent<Type>;
         state: Map<string, unknown>;
     }): MaybePromiseLike<OpenResponsesExtensionStreamPart[] | undefined>;
+};
+/**
+ * Defines a portable Open Responses extension using namespaced wire types.
+ *
+ * This remains an interface so existing consumers can extend it from their own
+ * interfaces and implement it in classes.
+ */
+interface OpenResponsesExtension extends OpenResponsesExtensionBase, OpenResponsesExtensionItemCodec<OpenResponsesNamespacedType>, OpenResponsesExtensionEventCodec<OpenResponsesNamespacedType> {
+    allowBareTypes?: false;
+    bareToolType?: undefined;
+    bareItemTypes?: undefined;
+    bareEventTypes?: undefined;
 }
+/**
+ * Defines a non-portable Open Responses extension that explicitly registers
+ * exact bare wire types.
+ */
+type OpenResponsesBareExtension = OpenResponsesExtensionBase & OpenResponsesExtensionItemCodec<string> & OpenResponsesExtensionEventCodec<string> & {
+    /**
+     * Explicitly enables non-portable bare discriminator registration for this
+     * extension.
+     */
+    allowBareTypes: true;
+    /**
+     * Exact non-namespaced tool type used by a documented implementation
+     * extension. Must be provided together with `encodeTool` and cannot be used
+     * together with `toolType`.
+     */
+    bareToolType?: string;
+    /**
+     * Exact non-namespaced item types decoded by a documented implementation
+     * extension. Must be provided together with `decodeItem`.
+     */
+    bareItemTypes?: readonly string[];
+    /**
+     * Exact non-namespaced streaming event types decoded by this extension.
+     * Must be provided together with `decodeEvent`.
+     */
+    bareEventTypes?: readonly string[];
+} & ({
+    bareToolType: string;
+} | {
+    bareItemTypes: readonly string[];
+} | {
+    bareEventTypes: readonly string[];
+});
+type OpenResponsesExtensionRegistration = OpenResponsesExtension | OpenResponsesBareExtension;
 type OpenResponsesExtensionRegistry = {
-    byEventType: Map<OpenResponsesNamespacedType, OpenResponsesEventExtension>;
-    byExtensionId: Map<LanguageModelV4ProviderTool['id'], OpenResponsesExtension>;
-    byItemType: Map<OpenResponsesNamespacedType, OpenResponsesItemExtension>;
+    byEventType: Map<string, OpenResponsesEventExtension>;
+    byExtensionId: Map<LanguageModelV4ProviderTool['id'], OpenResponsesExtensionRegistration>;
+    byItemType: Map<string, OpenResponsesItemExtension>;
     byProviderToolId: Map<LanguageModelV4ProviderTool['id'], OpenResponsesToolExtension>;
-    byToolType: Map<OpenResponsesNamespacedType, OpenResponsesToolExtension>;
+    byToolType: Map<string, OpenResponsesToolExtension>;
 };
-type OpenResponsesToolExtension = OpenResponsesExtension & {
-    toolType: OpenResponsesNamespacedType;
-    encodeTool: NonNullable<OpenResponsesExtension['encodeTool']>;
+type OpenResponsesToolExtension = OpenResponsesExtensionRegistration & {
+    encodeTool: NonNullable<OpenResponsesExtensionRegistration['encodeTool']>;
+    encodeInputItem?: (options: {
+        part: OpenResponsesExtensionInputPart;
+        tool: LanguageModelV4ProviderTool;
+    }) => MaybePromiseLike<OpenResponsesExtensionItem<string> | OpenResponsesExtensionItem<string>[] | undefined>;
 };
-type OpenResponsesItemExtension = OpenResponsesExtension & {
-    itemTypes: readonly OpenResponsesNamespacedType[];
-    decodeItem: NonNullable<OpenResponsesExtension['decodeItem']>;
+type OpenResponsesItemExtension = OpenResponsesExtensionRegistration & {
+    decodeItem(options: {
+        item: OpenResponsesExtensionItem<string>;
+        mode: 'generate' | 'stream';
+    }): MaybePromiseLike<OpenResponsesExtensionContentPart[] | undefined>;
 };
-type OpenResponsesEventExtension = OpenResponsesExtension & {
-    eventTypes: readonly OpenResponsesNamespacedType[];
-    decodeEvent: NonNullable<OpenResponsesExtension['decodeEvent']>;
+type OpenResponsesEventExtension = OpenResponsesExtensionRegistration & {
+    decodeEvent(options: {
+        event: OpenResponsesExtensionEvent<string>;
+        state: Map<string, unknown>;
+    }): MaybePromiseLike<OpenResponsesExtensionStreamPart[] | undefined>;
 };
 
 type OpenResponsesCustomToolOptions = {
@@ -230,7 +287,7 @@ interface OpenResponsesProviderSettings {
      *
      * @experimental This API may change in a future release.
      */
-    experimental_extensions?: readonly OpenResponsesExtension[];
+    experimental_extensions?: readonly OpenResponsesExtensionRegistration[];
 }
 declare function createOpenResponses(options: OpenResponsesProviderSettings): OpenResponsesProvider;
 
@@ -240,4 +297,4 @@ declare const openResponsesLanguageModelOptions: _ai_sdk_provider_utils.LazySche
 }>;
 type OpenResponsesLanguageModelOptions = InferSchema<typeof openResponsesLanguageModelOptions>;
 
-export { type OpenResponsesExtension as Experimental_OpenResponsesExtension, type OpenResponsesExtensionContentPart as Experimental_OpenResponsesExtensionContentPart, type OpenResponsesExtensionEvent as Experimental_OpenResponsesExtensionEvent, type OpenResponsesExtensionInputPart as Experimental_OpenResponsesExtensionInputPart, type OpenResponsesExtensionItem as Experimental_OpenResponsesExtensionItem, type OpenResponsesExtensionRecord as Experimental_OpenResponsesExtensionRecord, type OpenResponsesExtensionStreamPart as Experimental_OpenResponsesExtensionStreamPart, type OpenResponsesNamespacedType as Experimental_OpenResponsesNamespacedType, type OpenResponsesCustomToolOptions, type OpenResponsesLanguageModelOptions, type OpenResponsesLanguageModelOptions as OpenResponsesOptions, type OpenResponsesProvider, type OpenResponsesProviderSettings, VERSION, createOpenResponses };
+export { type OpenResponsesBareExtension as Experimental_OpenResponsesBareExtension, type OpenResponsesExtension as Experimental_OpenResponsesExtension, type OpenResponsesExtensionContentPart as Experimental_OpenResponsesExtensionContentPart, type OpenResponsesExtensionEvent as Experimental_OpenResponsesExtensionEvent, type OpenResponsesExtensionInputPart as Experimental_OpenResponsesExtensionInputPart, type OpenResponsesExtensionItem as Experimental_OpenResponsesExtensionItem, type OpenResponsesExtensionRecord as Experimental_OpenResponsesExtensionRecord, type OpenResponsesExtensionStreamPart as Experimental_OpenResponsesExtensionStreamPart, type OpenResponsesNamespacedType as Experimental_OpenResponsesNamespacedType, type OpenResponsesCustomToolOptions, type OpenResponsesLanguageModelOptions, type OpenResponsesLanguageModelOptions as OpenResponsesOptions, type OpenResponsesProvider, type OpenResponsesProviderSettings, VERSION, createOpenResponses };

package/dist/index.js

@@ -1,5 +1,5 @@
 // src/version.ts
-var VERSION = true ? "2.0.54" : "0.0.0-test";
+var VERSION = true ? "2.0.55" : "0.0.0-test";
 
 // src/open-responses-provider.ts
 import {
@@ -11,6 +11,37 @@ import {
 } from "@ai-sdk/provider-utils";
 
 // src/open-responses-extension.ts
+var coreToolTypes = /* @__PURE__ */ new Set(["allowed_tools", "function"]);
+var coreItemTypes = /* @__PURE__ */ new Set([
+  "function_call",
+  "function_call_output",
+  "item_reference",
+  "message",
+  "reasoning"
+]);
+var coreEventTypes = /* @__PURE__ */ new Set([
+  "error",
+  "response.completed",
+  "response.content_part.added",
+  "response.content_part.done",
+  "response.created",
+  "response.failed",
+  "response.function_call_arguments.delta",
+  "response.function_call_arguments.done",
+  "response.in_progress",
+  "response.incomplete",
+  "response.output_item.added",
+  "response.output_item.done",
+  "response.output_text.delta",
+  "response.output_text.done",
+  "response.reasoning_summary_part.added",
+  "response.reasoning_summary_part.done",
+  "response.reasoning_summary_text.delta",
+  "response.reasoning_summary_text.done",
+  "response.reasoning_text.delta",
+  "response.refusal.delta",
+  "response.refusal.done"
+]);
 function createOpenResponsesExtensionRegistry(extensions) {
   const registry = {
     byEventType: /* @__PURE__ */ new Map(),
@@ -33,26 +64,48 @@ function createOpenResponsesExtensionRegistry(extensions) {
       extension,
       field: "id"
     });
-    const hasToolType = extension.toolType != null;
+    const hasBareTypes = extension.bareToolType != null || extension.bareItemTypes != null || extension.bareEventTypes != null;
+    if (hasBareTypes !== (extension.allowBareTypes === true)) {
+      throw new Error(
+        `Open Responses extension ${extension.id} must set allowBareTypes to true exactly when registering bare types.`
+      );
+    }
+    if (extension.toolType != null && extension.bareToolType != null) {
+      throw new Error(
+        `Open Responses extension ${extension.id} cannot provide toolType and bareToolType together.`
+      );
+    }
+    const toolType = extension.toolType ?? extension.bareToolType;
+    const hasToolType = toolType != null;
     const hasToolEncoder = extension.encodeTool != null;
     if (hasToolType !== hasToolEncoder) {
+      const typeField = extension.bareToolType != null ? "bareToolType" : "toolType";
       throw new Error(
-        `Open Responses extension ${extension.id} must provide toolType and encodeTool together.`
+        `Open Responses extension ${extension.id} must provide ${typeField} and encodeTool together.`
       );
     }
     if (extension.encodeToolChoice != null && !hasToolEncoder) {
       throw new Error(
-        `Open Responses extension ${extension.id} cannot provide encodeToolChoice without toolType and encodeTool.`
+        `Open Responses extension ${extension.id} cannot provide encodeToolChoice without a tool type and encodeTool.`
       );
     }
     if (hasToolType && hasToolEncoder) {
       const toolExtension = extension;
-      assertNamespacedType({
-        extensionId: extension.id,
-        namespace,
-        type: toolExtension.toolType,
-        field: "toolType"
-      });
+      if (extension.toolType != null) {
+        assertNamespacedType({
+          extensionId: extension.id,
+          namespace,
+          type: extension.toolType,
+          field: "toolType"
+        });
+      } else {
+        assertBareType({
+          coreTypes: coreToolTypes,
+          extensionId: extension.id,
+          type: extension.bareToolType,
+          field: "bareToolType"
+        });
+      }
       registerUnique({
         map: registry.byProviderToolId,
         key: extension.id,
@@ -61,31 +114,35 @@ function createOpenResponsesExtensionRegistry(extensions) {
       });
       registerUnique({
         map: registry.byToolType,
-        key: toolExtension.toolType,
+        key: toolType,
         extension: toolExtension,
-        field: "toolType"
+        field: "tool type"
       });
     }
-    const hasItemTypes = extension.itemTypes != null;
+    const itemTypes = [
+      ...extension.itemTypes ?? [],
+      ...extension.bareItemTypes ?? []
+    ];
+    const hasItemTypes = extension.itemTypes != null || extension.bareItemTypes != null;
     const hasItemDecoder = extension.decodeItem != null;
     if (hasItemTypes !== hasItemDecoder) {
       throw new Error(
-        `Open Responses extension ${extension.id} must provide itemTypes and decodeItem together.`
+        `Open Responses extension ${extension.id} must provide itemTypes or bareItemTypes together with decodeItem.`
       );
     }
     if (extension.encodeInputItem != null && !hasItemDecoder) {
       throw new Error(
-        `Open Responses extension ${extension.id} cannot provide encodeInputItem without itemTypes and decodeItem.`
+        `Open Responses extension ${extension.id} cannot provide encodeInputItem without itemTypes or bareItemTypes and decodeItem.`
       );
     }
     if (hasItemTypes && hasItemDecoder) {
       const itemExtension = extension;
-      if (itemExtension.itemTypes.length === 0) {
+      if (itemTypes.length === 0) {
         throw new Error(
           `Open Responses extension ${extension.id} must register at least one item type.`
         );
       }
-      for (const itemType of itemExtension.itemTypes) {
+      for (const itemType of extension.itemTypes ?? []) {
         assertNamespacedType({
           extensionId: extension.id,
           namespace,
@@ -99,22 +156,40 @@ function createOpenResponsesExtensionRegistry(extensions) {
           field: "item type"
         });
       }
+      for (const itemType of extension.bareItemTypes ?? []) {
+        assertBareType({
+          coreTypes: coreItemTypes,
+          extensionId: extension.id,
+          type: itemType,
+          field: "bareItemTypes"
+        });
+        registerUnique({
+          map: registry.byItemType,
+          key: itemType,
+          extension: itemExtension,
+          field: "item type"
+        });
+      }
     }
-    const hasEventTypes = extension.eventTypes != null;
+    const eventTypes = [
+      ...extension.eventTypes ?? [],
+      ...extension.bareEventTypes ?? []
+    ];
+    const hasEventTypes = extension.eventTypes != null || extension.bareEventTypes != null;
     const hasEventDecoder = extension.decodeEvent != null;
     if (hasEventTypes !== hasEventDecoder) {
       throw new Error(
-        `Open Responses extension ${extension.id} must provide eventTypes and decodeEvent together.`
+        `Open Responses extension ${extension.id} must provide eventTypes or bareEventTypes together with decodeEvent.`
       );
     }
     if (hasEventTypes && hasEventDecoder) {
       const eventExtension = extension;
-      if (eventExtension.eventTypes.length === 0) {
+      if (eventTypes.length === 0) {
         throw new Error(
           `Open Responses extension ${extension.id} must register at least one event type.`
         );
       }
-      for (const eventType of eventExtension.eventTypes) {
+      for (const eventType of extension.eventTypes ?? []) {
         assertNamespacedType({
           extensionId: extension.id,
           namespace,
@@ -128,6 +203,20 @@ function createOpenResponsesExtensionRegistry(extensions) {
           field: "event type"
         });
       }
+      for (const eventType of extension.bareEventTypes ?? []) {
+        assertBareType({
+          coreTypes: coreEventTypes,
+          extensionId: extension.id,
+          type: eventType,
+          field: "bareEventTypes"
+        });
+        registerUnique({
+          map: registry.byEventType,
+          key: eventType,
+          extension: eventExtension,
+          field: "event type"
+        });
+      }
     }
     if (!hasToolEncoder && !hasItemDecoder && !hasEventDecoder) {
       throw new Error(
@@ -143,12 +232,39 @@ function assertNamespacedType({
   type,
   field
 }) {
-  if (!type.includes(":") || type.slice(0, type.indexOf(":")) !== namespace) {
+  const separatorIndex = type.indexOf(":");
+  if (separatorIndex <= 0 || type.slice(0, separatorIndex) !== namespace) {
     throw new Error(
       `Open Responses extension ${extensionId} has invalid ${field} value ${type}. Extension wire types must use the ${namespace}: namespace.`
     );
   }
 }
+function assertBareType({
+  coreTypes,
+  extensionId,
+  type,
+  field
+}) {
+  if (type.length === 0 || type.includes(":")) {
+    throw new Error(
+      `Open Responses extension ${extensionId} has invalid ${field} value ${type}. Bare extension wire types must be non-empty and must not contain a colon.`
+    );
+  }
+  if (coreTypes.has(type)) {
+    throw new Error(
+      `Open Responses extension ${extensionId} cannot register core ${field} value ${type}.`
+    );
+  }
+}
+function getOpenResponsesExtensionItemTypes(extension) {
+  return [...extension.itemTypes ?? [], ...extension.bareItemTypes ?? []];
+}
+function getOpenResponsesExtensionToolType(extension) {
+  return extension.toolType ?? extension.bareToolType;
+}
+function asOpenResponsesExtensionRecord(value) {
+  return value;
+}
 function registerUnique({
   map,
   key,
@@ -163,11 +279,8 @@ function registerUnique({
   }
   map.set(key, extension);
 }
-function isOpenResponsesNamespacedType(value) {
-  return typeof value === "string" && value.includes(":");
-}
 function isOpenResponsesExtensionRecord(value) {
-  return isOpenResponsesJSONObject(value) && isOpenResponsesNamespacedType(value.type);
+  return isOpenResponsesJSONObject(value) && typeof value.type === "string";
 }
 function isOpenResponsesJSONObject(value) {
   return value != null && typeof value === "object" && !Array.isArray(value) && Object.getPrototypeOf(value) === Object.prototype && Object.values(value).every(isOpenResponsesJSONValue);
@@ -367,7 +480,7 @@ async function convertToOpenResponsesInput({
             if (replayItem != null) {
               const replayKey = `${replayItem.type}:${replayItem.id}`;
               if (!replayedExtensionItems.has(replayKey)) {
-                input.push(replayItem);
+                input.push(asOpenResponsesExtensionRecord(replayItem));
                 replayedExtensionItems.add(replayKey);
               }
             }
@@ -389,7 +502,7 @@ async function convertToOpenResponsesInput({
                   feature: `provider-defined tool ${providerTool.id} ${part.type} history`
                 });
               } else {
-                input.push(...encoded);
+                input.push(...encoded.map(asOpenResponsesExtensionRecord));
               }
               continue;
             }
@@ -496,7 +609,7 @@ async function convertToOpenResponsesInput({
               if (replayItem != null) {
                 const replayKey = `${replayItem.type}:${replayItem.id}`;
                 if (!replayedExtensionItems.has(replayKey)) {
-                  input.push(replayItem);
+                  input.push(asOpenResponsesExtensionRecord(replayItem));
                   replayedExtensionItems.add(replayKey);
                 }
               }
@@ -516,7 +629,7 @@ async function convertToOpenResponsesInput({
                   feature: `provider-defined tool ${providerTool.id} tool-result history`
                 });
               } else {
-                input.push(...encoded);
+                input.push(...encoded.map(asOpenResponsesExtensionRecord));
               }
               continue;
             }
@@ -622,8 +735,8 @@ async function encodeExtensionInputPart({
 }) {
   const extension = extensionRegistry?.byProviderToolId.get(providerTool.id);
   const encodeInputItem = extension?.encodeInputItem;
-  const itemTypes = extension?.itemTypes;
-  if (encodeInputItem == null || itemTypes == null) {
+  const itemTypes = extension == null ? [] : getOpenResponsesExtensionItemTypes(extension);
+  if (encodeInputItem == null || itemTypes.length === 0) {
     return void 0;
   }
   try {
@@ -664,7 +777,7 @@ function getExtensionReplay({
   if (extension == null) {
     return void 0;
   }
-  if (isOpenResponsesExtensionItem(item) && extension.itemTypes?.includes(item.type)) {
+  if (isOpenResponsesExtensionItem(item) && getOpenResponsesExtensionItemTypes(extension).includes(item.type)) {
     return { item };
   }
   return typeof itemId === "string" ? {} : void 0;
@@ -866,6 +979,7 @@ var OpenResponsesLanguageModel = class _OpenResponsesLanguageModel {
         const extension = this.extensionRegistry.byProviderToolId.get(tool.id);
         let encoded;
         if (extension != null) {
+          const toolType = getOpenResponsesExtensionToolType(extension);
           try {
             const fields = await extension.encodeTool({
               name: tool.name,
@@ -874,7 +988,7 @@ var OpenResponsesLanguageModel = class _OpenResponsesLanguageModel {
             if (isOpenResponsesJSONObject(fields)) {
               encoded = {
                 ...fields,
-                type: extension.toolType
+                type: toolType
               };
             }
           } catch {
@@ -886,9 +1000,9 @@ var OpenResponsesLanguageModel = class _OpenResponsesLanguageModel {
             feature: `provider-defined tool ${tool.id}`
           });
         } else if (extension != null) {
-          convertedTools.push(encoded);
+          convertedTools.push(asOpenResponsesExtensionRecord(encoded));
           encodedProviderToolsByName.set(tool.name, {
-            toolType: extension.toolType,
+            toolType: getOpenResponsesExtensionToolType(extension),
             encodeToolChoice: extension.encodeToolChoice,
             tool
           });
@@ -937,10 +1051,10 @@ var OpenResponsesLanguageModel = class _OpenResponsesLanguageModel {
             feature: `tool choice for provider-defined tool ${tool.id}`
           });
         } else {
-          convertedToolChoice = {
+          convertedToolChoice = asOpenResponsesExtensionRecord({
             ...isOpenResponsesJSONObject(fields) ? fields : {},
             type: toolType
-          };
+          });
         }
       }
     } else {
@@ -1269,8 +1383,8 @@ var OpenResponsesLanguageModel = class _OpenResponsesLanguageModel {
                 } catch (error) {
                   controller.enqueue({ type: "error", error });
                 }
+                return;
               }
-              return;
             }
             if (chunk.type === "response.output_item.added" && chunk.item.type === "function_call") {
               toolCallsByItemId.set(chunk.item.id, {
@@ -1366,7 +1480,7 @@ var OpenResponsesLanguageModel = class _OpenResponsesLanguageModel {
               });
               hasToolCalls = true;
               customToolCallsByItemId.delete(chunk.item.id);
-            } else if (chunk.type === "response.output_item.done" && isOpenResponsesExtensionItem(chunk.item)) {
+            } else if (chunk.type === "response.output_item.done" && isOpenResponsesExtensionItem(chunk.item) && extensionRegistry.byItemType.has(chunk.item.type)) {
               try {
                 const decoded = await decodeExtensionItem({
                   extensionRegistry,