@ai-sdk/open-responses 2.0.54 → 2.0.55

package/docs/06-open-responses.mdx

@@ -386,6 +386,57 @@ const result = await generateText({
 });
 ```
 
+Some Responses-compatible implementations document non-namespaced extension
+discriminators, such as `web_search`, `web_search_call`, or
+`response.custom_tool_call_input.delta`. These are not portable Open Responses
+types. Register each exact value through the dedicated bare fields to opt in:
+
+```ts
+import type { Experimental_OpenResponsesBareExtension } from '@ai-sdk/open-responses';
+
+const webSearchExtension: Experimental_OpenResponsesBareExtension = {
+  id: 'acme.web_search',
+  allowBareTypes: true,
+  bareToolType: 'web_search',
+  bareItemTypes: ['web_search_call'],
+  bareEventTypes: ['response.web_search_call.completed'],
+  encodeTool: ({ name, args }) => ({
+    name,
+    search_context_size: args.searchContextSize,
+  }),
+  decodeItem: ({ item }) => {
+    if (
+      typeof item.call_id !== 'string' ||
+      typeof item.name !== 'string' ||
+      typeof item.query !== 'string'
+    ) {
+      return undefined;
+    }
+
+    return [
+      {
+        type: 'tool-call',
+        toolCallId: item.call_id,
+        toolName: item.name,
+        input: JSON.stringify({ query: item.query }),
+        providerExecuted: true,
+      },
+    ];
+  },
+  decodeEvent: () => undefined,
+};
+```
+
+Set `allowBareTypes: true` when using `bareToolType`, `bareItemTypes`, or
+`bareEventTypes`. These fields accept only non-namespaced values. They do not
+enable unknown JSON passthrough: a bare discriminator is handled only when it
+exactly matches a registered value. Core Open Responses discriminators and
+duplicate registrations are rejected.
+Use the normal namespaced fields whenever the implementation supports them.
+`Experimental_OpenResponsesExtension` remains the namespaced interface;
+use `Experimental_OpenResponsesBareExtension` only for this compatibility
+mode.
+
 Set `providerExecuted` on each decoded `tool-call` or `tool-input-start` part.
 It can vary by item or event.
 
@@ -395,18 +446,18 @@ An extension codec can define:
   with an `unsupported` warning. A `toolChoice` that selects the omitted tool is
   also omitted.
 - `encodeToolChoice`: Encodes a specific `toolChoice`. The default is
-  `{ type: toolType }`.
+  an object containing the registered `toolType` or `bareToolType`.
 - `decodeItem`: Maps a completed item to AI SDK content parts. `mode` is either
   `'generate'` or `'stream'`.
 - `encodeInputItem`: Encodes tool-call or tool-result history when the original
   wire item is unavailable. Returned items must include `id`, `status`, and a
-  registered namespaced `type`.
+  `type` registered through `itemTypes` or `bareItemTypes`.
 - `decodeEvent`: Maps a streaming event to AI SDK stream parts. Its `state` map
   lasts for one response stream.
 
 Tool, item, and event capabilities are independent. An item-only extension, for
-example, defines `itemTypes` and `decodeItem` without `toolType` or `encodeTool`.
-Capability fields must be provided in pairs.
+example, defines `itemTypes` (or `bareItemTypes`) and `decodeItem` without a
+tool type or `encodeTool`. Capability fields must be provided in pairs.
 
 Each decoded item adds an `open-responses.extension-replay` custom part that
 stores the original JSON in provider metadata. Other decoded parts reference

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-sdk/open-responses",
-  "version": "2.0.54",
+  "version": "2.0.55",
   "type": "module",
   "license": "Apache-2.0",
   "sideEffects": false,
@@ -29,8 +29,8 @@
     }
   },
   "dependencies": {
-    "@ai-sdk/provider": "4.0.18",
-    "@ai-sdk/provider-utils": "5.0.49"
+    "@ai-sdk/provider": "4.0.19",
+    "@ai-sdk/provider-utils": "5.0.50"
   },
   "devDependencies": {
     "@ai-sdk/test-server": "2.0.2",

package/src/index.ts

@@ -6,6 +6,7 @@ export type {
 } from './open-responses-provider';
 export type { OpenResponsesCustomToolOptions } from './open-responses-tools';
 export type {
+  OpenResponsesBareExtension as Experimental_OpenResponsesBareExtension,
   OpenResponsesExtension as Experimental_OpenResponsesExtension,
   OpenResponsesExtensionContentPart as Experimental_OpenResponsesExtensionContentPart,
   OpenResponsesExtensionEvent as Experimental_OpenResponsesExtensionEvent,

package/src/open-responses-extension.ts

@@ -10,16 +10,22 @@ import type { MaybePromiseLike } from '@ai-sdk/provider-utils';
 
 export type OpenResponsesNamespacedType = `${string}:${string}`;
 
-export type OpenResponsesExtensionRecord = JSONObject & {
-  type: OpenResponsesNamespacedType;
+export type OpenResponsesExtensionRecord<
+  Type extends string = OpenResponsesNamespacedType,
+> = JSONObject & {
+  type: Type;
 };
 
-export type OpenResponsesExtensionItem = OpenResponsesExtensionRecord & {
+export type OpenResponsesExtensionItem<
+  Type extends string = OpenResponsesNamespacedType,
+> = OpenResponsesExtensionRecord<Type> & {
   id: string;
   status: string;
 };
 
-export type OpenResponsesExtensionEvent = OpenResponsesExtensionRecord & {
+export type OpenResponsesExtensionEvent<
+  Type extends string = OpenResponsesNamespacedType,
+> = OpenResponsesExtensionRecord<Type> & {
   sequence_number: number;
 };
 
@@ -44,7 +50,7 @@ export type OpenResponsesExtensionStreamPart = Exclude<
  *
  * Tool, item, and event codecs can be registered independently.
  */
-export 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.
@@ -57,22 +63,10 @@ export interface OpenResponsesExtension {
    */
   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;
@@ -80,74 +74,196 @@ export interface OpenResponsesExtension {
   }): 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
+    | OpenResponsesExtensionItem<Type>
+    | OpenResponsesExtensionItem<Type>[]
+    | undefined
   >;
+};
 
+type OpenResponsesExtensionEventCodec<Type extends string> = {
   /**
-   * Decodes a namespaced streaming event.
+   * Namespaced streaming event types decoded by this extension. Must be
+   * provided together with `decodeEvent`.
+   */
+  eventTypes?: readonly OpenResponsesNamespacedType[];
+
+  /**
+   * 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.
+ */
+export 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.
+ */
+export 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[] }
+  );
+
+export type OpenResponsesExtensionRegistration =
+  | OpenResponsesExtension
+  | OpenResponsesBareExtension;
+
 export 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>;
 };
 
+const coreToolTypes = new Set(['allowed_tools', 'function']);
+const coreItemTypes = new Set([
+  'function_call',
+  'function_call_output',
+  'item_reference',
+  'message',
+  'reasoning',
+]);
+const coreEventTypes = 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',
+]);
+
 export function createOpenResponsesExtensionRegistry(
-  extensions?: readonly OpenResponsesExtension[],
+  extensions?: readonly OpenResponsesExtensionRegistration[],
 ): OpenResponsesExtensionRegistry {
   const registry: OpenResponsesExtensionRegistry = {
     byEventType: new Map(),
@@ -173,28 +289,56 @@ export function createOpenResponsesExtensionRegistry(
       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 as OpenResponsesToolExtension;
-      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,
@@ -203,34 +347,39 @@ export function createOpenResponsesExtensionRegistry(
       });
       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 as OpenResponsesItemExtension;
-      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,
@@ -244,24 +393,43 @@ export function createOpenResponsesExtensionRegistry(
           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 as OpenResponsesEventExtension;
-      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,
@@ -275,6 +443,20 @@ export function createOpenResponsesExtensionRegistry(
           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) {
@@ -298,14 +480,64 @@ function assertNamespacedType({
   type: string;
   field: string;
 }) {
-  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 registerUnique<K, Extension extends OpenResponsesExtension>({
+function assertBareType({
+  coreTypes,
+  extensionId,
+  type,
+  field,
+}: {
+  coreTypes: Set<string>;
+  extensionId: string;
+  type: string;
+  field: string;
+}) {
+  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}.`,
+    );
+  }
+}
+
+export function getOpenResponsesExtensionItemTypes(
+  extension: OpenResponsesExtensionRegistration,
+): readonly string[] {
+  return [...(extension.itemTypes ?? []), ...(extension.bareItemTypes ?? [])];
+}
+
+export function getOpenResponsesExtensionToolType(
+  extension: OpenResponsesExtensionRegistration,
+): string | undefined {
+  return extension.toolType ?? extension.bareToolType;
+}
+
+/**
+ * Keeps the internal API unions narrow enough to discriminate core wire types.
+ * Bare records only reach this boundary after registry validation.
+ */
+export function asOpenResponsesExtensionRecord(
+  value: OpenResponsesExtensionRecord<string>,
+): OpenResponsesExtensionRecord {
+  return value as OpenResponsesExtensionRecord;
+}
+
+function registerUnique<
+  K,
+  Extension extends OpenResponsesExtensionRegistration,
+>({
   map,
   key,
   extension,
@@ -333,10 +565,10 @@ export function isOpenResponsesNamespacedType(
 
 export function isOpenResponsesExtensionRecord(
   value: unknown,
-): value is OpenResponsesExtensionRecord {
+): value is OpenResponsesExtensionRecord<string> {
   return (
     isOpenResponsesJSONObject(value) &&
-    isOpenResponsesNamespacedType((value as { type?: unknown }).type)
+    typeof (value as { type?: unknown }).type === 'string'
   );
 }
 
@@ -352,7 +584,7 @@ export function isOpenResponsesJSONObject(value: unknown): value is JSONObject {
 
 export function isOpenResponsesExtensionItem(
   value: unknown,
-): value is OpenResponsesExtensionItem {
+): value is OpenResponsesExtensionItem<string> {
   return (
     isOpenResponsesExtensionRecord(value) &&
     typeof value.id === 'string' &&
@@ -362,7 +594,7 @@ export function isOpenResponsesExtensionItem(
 
 export function isOpenResponsesExtensionEvent(
   value: unknown,
-): value is OpenResponsesExtensionEvent {
+): value is OpenResponsesExtensionEvent<string> {
   return (
     isOpenResponsesExtensionRecord(value) &&
     typeof value.sequence_number === 'number'

package/src/open-responses-provider.ts

@@ -12,7 +12,7 @@ import {
 } from '@ai-sdk/provider-utils';
 import {
   createOpenResponsesExtensionRegistry,
-  type OpenResponsesExtension,
+  type OpenResponsesExtensionRegistration,
 } from './open-responses-extension';
 import { createOpenResponsesTools } from './open-responses-tools';
 import { OpenResponsesLanguageModel } from './responses/open-responses-language-model';
@@ -99,7 +99,7 @@ export interface OpenResponsesProviderSettings {
    *
    * @experimental This API may change in a future release.
    */
-  experimental_extensions?: readonly OpenResponsesExtension[];
+  experimental_extensions?: readonly OpenResponsesExtensionRegistration[];
 }
 
 export function createOpenResponses(