@ai-sdk/open-responses 2.0.56 → 2.0.58

package/dist/index.js

@@ -1,1787 +1,1371 @@
-// src/version.ts
-var VERSION = true ? "2.0.56" : "0.0.0-test";
-
-// src/open-responses-provider.ts
-import {
-  NoSuchModelError
-} from "@ai-sdk/provider";
-import {
-  generateId,
-  withUserAgentSuffix
-} 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"
+import { APICallError, NoSuchModelError, UnsupportedFunctionalityError } from "@ai-sdk/provider";
+import { SerializationError, WORKFLOW_DESERIALIZE, WORKFLOW_SERIALIZE, combineHeaders, convertToBase64, createEventSourceResponseHandler, createJsonErrorResponseHandler, createJsonResponseHandler, createProviderDefinedToolFactory, createProviderStreamError, generateId, getTopLevelMediaType, isCustomReasoning, jsonSchema, lazySchema, mapReasoningToProviderEffort, parseProviderOptions, postJsonToApi, resolveFullMediaType, serializeModelOptions, withUserAgentSuffix, zodSchema } from "@ai-sdk/provider-utils";
+import { z } from "zod/v4";
+//#region src/version.ts
+const VERSION = "2.0.58";
+//#endregion
+//#region src/open-responses-extension.ts
+const coreToolTypes = /* @__PURE__ */ new Set(["allowed_tools", "function"]);
+const 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"
+const 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(),
-    byExtensionId: /* @__PURE__ */ new Map(),
-    byItemType: /* @__PURE__ */ new Map(),
-    byProviderToolId: /* @__PURE__ */ new Map(),
-    byToolType: /* @__PURE__ */ new Map()
-  };
-  for (const extension of 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 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 ${typeField} and encodeTool together.`
-      );
-    }
-    if (extension.encodeToolChoice != null && !hasToolEncoder) {
-      throw new Error(
-        `Open Responses extension ${extension.id} cannot provide encodeToolChoice without a tool type and encodeTool.`
-      );
-    }
-    if (hasToolType && hasToolEncoder) {
-      const toolExtension = extension;
-      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,
-        extension: toolExtension,
-        field: "provider-tool id"
-      });
-      registerUnique({
-        map: registry.byToolType,
-        key: toolType,
-        extension: toolExtension,
-        field: "tool type"
-      });
-    }
-    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 or bareItemTypes together with decodeItem.`
-      );
-    }
-    if (extension.encodeInputItem != null && !hasItemDecoder) {
-      throw new Error(
-        `Open Responses extension ${extension.id} cannot provide encodeInputItem without itemTypes or bareItemTypes and decodeItem.`
-      );
-    }
-    if (hasItemTypes && hasItemDecoder) {
-      const itemExtension = extension;
-      if (itemTypes.length === 0) {
-        throw new Error(
-          `Open Responses extension ${extension.id} must register at least one item type.`
-        );
-      }
-      for (const itemType of extension.itemTypes ?? []) {
-        assertNamespacedType({
-          extensionId: extension.id,
-          namespace,
-          type: itemType,
-          field: "itemTypes"
-        });
-        registerUnique({
-          map: registry.byItemType,
-          key: itemType,
-          extension: itemExtension,
-          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 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 or bareEventTypes together with decodeEvent.`
-      );
-    }
-    if (hasEventTypes && hasEventDecoder) {
-      const eventExtension = extension;
-      if (eventTypes.length === 0) {
-        throw new Error(
-          `Open Responses extension ${extension.id} must register at least one event type.`
-        );
-      }
-      for (const eventType of extension.eventTypes ?? []) {
-        assertNamespacedType({
-          extensionId: extension.id,
-          namespace,
-          type: eventType,
-          field: "eventTypes"
-        });
-        registerUnique({
-          map: registry.byEventType,
-          key: eventType,
-          extension: eventExtension,
-          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(
-        `Open Responses extension ${extension.id} must register a tool, item, or event capability.`
-      );
-    }
-  }
-  return registry;
+	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 ?? []) {
+		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"
+		});
+		if ((extension.bareToolType != null || extension.bareItemTypes != null || extension.bareEventTypes != null) !== (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 ${typeField} and encodeTool together.`);
+		}
+		if (extension.encodeToolChoice != null && !hasToolEncoder) throw new Error(`Open Responses extension ${extension.id} cannot provide encodeToolChoice without a tool type and encodeTool.`);
+		if (hasToolType && hasToolEncoder) {
+			const toolExtension = extension;
+			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,
+				extension: toolExtension,
+				field: "provider-tool id"
+			});
+			registerUnique({
+				map: registry.byToolType,
+				key: toolType,
+				extension: toolExtension,
+				field: "tool type"
+			});
+		}
+		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 or bareItemTypes together with decodeItem.`);
+		if (extension.encodeInputItem != null && !hasItemDecoder) throw new Error(`Open Responses extension ${extension.id} cannot provide encodeInputItem without itemTypes or bareItemTypes and decodeItem.`);
+		if (hasItemTypes && hasItemDecoder) {
+			const itemExtension = extension;
+			if (itemTypes.length === 0) throw new Error(`Open Responses extension ${extension.id} must register at least one item type.`);
+			for (const itemType of extension.itemTypes ?? []) {
+				assertNamespacedType({
+					extensionId: extension.id,
+					namespace,
+					type: itemType,
+					field: "itemTypes"
+				});
+				registerUnique({
+					map: registry.byItemType,
+					key: itemType,
+					extension: itemExtension,
+					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 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 or bareEventTypes together with decodeEvent.`);
+		if (hasEventTypes && hasEventDecoder) {
+			const eventExtension = extension;
+			if (eventTypes.length === 0) throw new Error(`Open Responses extension ${extension.id} must register at least one event type.`);
+			for (const eventType of extension.eventTypes ?? []) {
+				assertNamespacedType({
+					extensionId: extension.id,
+					namespace,
+					type: eventType,
+					field: "eventTypes"
+				});
+				registerUnique({
+					map: registry.byEventType,
+					key: eventType,
+					extension: eventExtension,
+					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(`Open Responses extension ${extension.id} must register a tool, item, or event capability.`);
+	}
+	return registry;
 }
-function assertNamespacedType({
-  extensionId,
-  namespace,
-  type,
-  field
-}) {
-  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 assertNamespacedType({ extensionId, namespace, type, field }) {
+	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 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 ?? []];
+	return [...extension.itemTypes ?? [], ...extension.bareItemTypes ?? []];
 }
 function getOpenResponsesExtensionToolType(extension) {
-  return extension.toolType ?? extension.bareToolType;
+	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.
+*/
 function asOpenResponsesExtensionRecord(value) {
-  return value;
+	return value;
 }
-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 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 isOpenResponsesExtensionRecord(value) {
-  return isOpenResponsesJSONObject(value) && typeof value.type === "string";
+	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);
+	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";
+	return isOpenResponsesExtensionRecord(value) && typeof value.id === "string" && typeof value.status === "string";
 }
 function isOpenResponsesExtensionEvent(value) {
-  return isOpenResponsesExtensionRecord(value) && typeof value.sequence_number === "number";
+	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);
+	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/open-responses-tools.ts
-import {
-  createProviderDefinedToolFactory,
-  lazySchema,
-  zodSchema
-} from "@ai-sdk/provider-utils";
-import { z } from "zod/v4";
-var customInputSchema = lazySchema(() => zodSchema(z.string()));
-function createOpenResponsesTools({
-  customToolId
-}) {
-  const customToolFactory = createProviderDefinedToolFactory({
-    id: customToolId,
-    inputSchema: customInputSchema
-  });
-  return {
-    /**
-     * Creates a caller-executed OpenAI-compatible custom tool. Custom tools accept
-     * a raw string, optionally constrained by a grammar. Requires endpoint support.
-     */
-    customTool: (options) => customToolFactory(options)
-  };
+//#endregion
+//#region src/open-responses-tools.ts
+const customInputSchema = lazySchema(() => zodSchema(z.string()));
+function createOpenResponsesTools({ customToolId }) {
+	const customToolFactory = createProviderDefinedToolFactory({
+		id: customToolId,
+		inputSchema: customInputSchema
+	});
+	return { 
+	/**
+	* Creates a caller-executed OpenAI-compatible custom tool. Custom tools accept
+	* a raw string, optionally constrained by a grammar. Requires endpoint support.
+	*/
+customTool: (options) => customToolFactory(options) };
 }
-
-// src/responses/open-responses-language-model.ts
-import {
-  APICallError
-} from "@ai-sdk/provider";
-import {
-  combineHeaders,
-  createEventSourceResponseHandler,
-  createJsonErrorResponseHandler,
-  createJsonResponseHandler,
-  createProviderStreamError,
-  isCustomReasoning,
-  jsonSchema,
-  mapReasoningToProviderEffort,
-  parseProviderOptions,
-  postJsonToApi,
-  SerializationError,
-  serializeModelOptions,
-  WORKFLOW_SERIALIZE,
-  WORKFLOW_DESERIALIZE
-} from "@ai-sdk/provider-utils";
-import { z as z4 } from "zod/v4";
-
-// src/responses/convert-to-open-responses-input.ts
-import {
-  UnsupportedFunctionalityError
-} from "@ai-sdk/provider";
-import {
-  convertToBase64,
-  getTopLevelMediaType,
-  resolveFullMediaType
-} from "@ai-sdk/provider-utils";
-async function convertToOpenResponsesInput({
-  prompt,
-  providerOptionsName = "open-responses",
-  extensionRegistry,
-  providerToolsByName = /* @__PURE__ */ new Map(),
-  strictResponseInput = false,
-  customToolId
-}) {
-  const input = [];
-  const warnings = [];
-  const systemMessages = [];
-  const replayedExtensionItems = /* @__PURE__ */ new Set();
-  for (const { role, content } of prompt) {
-    switch (role) {
-      case "system": {
-        systemMessages.push(content);
-        break;
-      }
-      case "user": {
-        const userContent = [];
-        for (const part of content) {
-          switch (part.type) {
-            case "text": {
-              userContent.push({ type: "input_text", text: part.text });
-              break;
-            }
-            case "file": {
-              switch (part.data.type) {
-                case "reference": {
-                  throw new UnsupportedFunctionalityError({
-                    functionality: "file parts with provider references"
-                  });
-                }
-                case "text": {
-                  throw new UnsupportedFunctionalityError({
-                    functionality: "text file parts"
-                  });
-                }
-                case "url":
-                case "data": {
-                  const topLevel = getTopLevelMediaType(part.mediaType);
-                  if (topLevel === "image") {
-                    userContent.push({
-                      type: "input_image",
-                      ...part.data.type === "url" ? { image_url: part.data.url.toString() } : {
-                        image_url: `data:${resolveFullMediaType({ part })};base64,${convertToBase64(part.data.data)}`
-                      },
-                      detail: getImageDetail(part, providerOptionsName)
-                    });
-                  } else if (part.data.type === "url") {
-                    userContent.push({
-                      type: "input_file",
-                      file_url: part.data.url.toString()
-                    });
-                  } else {
-                    const fullMediaType = resolveFullMediaType({ part });
-                    userContent.push({
-                      type: "input_file",
-                      filename: part.filename ?? "data",
-                      file_data: `data:${fullMediaType};base64,${convertToBase64(part.data.data)}`
-                    });
-                  }
-                  break;
-                }
-              }
-              break;
-            }
-          }
-        }
-        input.push({ type: "message", role: "user", content: userContent });
-        break;
-      }
-      case "assistant": {
-        let assistantContent = [];
-        let assistantMessageId;
-        const flushAssistantContent = () => {
-          if (assistantContent.length === 0) {
-            return;
-          }
-          if (strictResponseInput && assistantMessageId == null) {
-            input.push({
-              type: "message",
-              role: "assistant",
-              content: assistantContent.map(
-                (part) => part.type === "output_text" ? part.text : part.refusal
-              ).join("")
-            });
-          } else if (strictResponseInput) {
-            input.push({
-              id: assistantMessageId,
-              type: "message",
-              status: "completed",
-              role: "assistant",
-              content: assistantContent.map(
-                (part) => part.type === "output_text" ? {
-                  ...part,
-                  annotations: part.annotations ?? [],
-                  logprobs: part.logprobs ?? []
-                } : part
-              )
-            });
-          } else {
-            input.push({
-              type: "message",
-              role: "assistant",
-              content: assistantContent,
-              ...assistantMessageId != null && { id: assistantMessageId }
-            });
-          }
-          assistantContent = [];
-          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(asOpenResponsesExtensionRecord(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?.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.map(asOpenResponsesExtensionRecord));
-              }
-              continue;
-            }
-          }
-          switch (part.type) {
-            case "reasoning": {
-              flushAssistantContent();
-              const providerData = getProviderData(part, providerOptionsName);
-              const itemId = typeof providerData?.itemId === "string" ? providerData.itemId : void 0;
-              const summary = parseReasoningSummary(
-                providerData?.reasoningSummary
-              );
-              const reasoningContent = parseReasoningContent(
-                providerData?.reasoningContent
-              );
-              const hasReasoningContent = providerData != null && "reasoningContent" in providerData;
-              const encryptedContent = typeof providerData?.reasoningEncryptedContent === "string" ? providerData.reasoningEncryptedContent : void 0;
-              const reasoningItem = {
-                type: "reasoning",
-                summary: summary ?? [],
-                ...itemId != null && { id: itemId },
-                ...reasoningContent != null ? { content: reasoningContent } : !hasReasoningContent && part.text.length > 0 ? {
-                  content: [
-                    {
-                      type: "reasoning_text",
-                      text: part.text
-                    }
-                  ]
-                } : {},
-                ...encryptedContent != null && {
-                  encrypted_content: encryptedContent
-                }
-              };
-              const previousItem = input[input.length - 1];
-              if (reasoningItem.id != null && previousItem?.type === "reasoning" && previousItem.id === reasoningItem.id) {
-                if (reasoningItem.content != null) {
-                  previousItem.content = [
-                    ...previousItem.content ?? [],
-                    ...reasoningItem.content
-                  ];
-                }
-              } else {
-                input.push(reasoningItem);
-              }
-              break;
-            }
-            case "text": {
-              const providerData = getProviderData(part, providerOptionsName);
-              const itemId = typeof providerData?.itemId === "string" ? providerData.itemId : void 0;
-              const annotations = parseOutputTextAnnotations(
-                providerData?.annotations
-              );
-              if (assistantContent.length > 0 && assistantMessageId !== itemId) {
-                flushAssistantContent();
-              }
-              assistantMessageId = itemId;
-              assistantContent.push({
-                type: "output_text",
-                text: part.text,
-                ...annotations != null && { annotations }
-              });
-              break;
-            }
-            case "tool-call": {
-              flushAssistantContent();
-              const argumentsValue = typeof part.input === "string" ? part.input : JSON.stringify(part.input);
-              const providerData = getProviderData(part, providerOptionsName);
-              const itemId = typeof providerData?.itemId === "string" ? providerData.itemId : void 0;
-              const providerTool = providerToolsByName.get(part.toolName);
-              if (customToolId != null && providerTool?.id === customToolId) {
-                input.push({
-                  type: "custom_tool_call",
-                  ...itemId != null && { id: itemId },
-                  call_id: part.toolCallId,
-                  name: part.toolName,
-                  input: argumentsValue
-                });
-              } else {
-                input.push({
-                  type: "function_call",
-                  ...itemId != null && { id: itemId },
-                  call_id: part.toolCallId,
-                  name: part.toolName,
-                  arguments: argumentsValue
-                });
-              }
-              break;
-            }
-          }
-        }
-        flushAssistantContent();
-        break;
-      }
-      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(asOpenResponsesExtensionRecord(replayItem));
-                  replayedExtensionItems.add(replayKey);
-                }
-              }
-              continue;
-            }
-            const providerTool = providerToolsByName.get(part.toolName);
-            const extension = providerTool == 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.map(asOpenResponsesExtensionRecord));
-              }
-              continue;
-            }
-            const output = part.output;
-            let contentValue;
-            switch (output.type) {
-              case "text":
-              case "error-text":
-                contentValue = output.value;
-                break;
-              case "execution-denied":
-                contentValue = output.reason ?? "Tool call execution denied.";
-                break;
-              case "json":
-              case "error-json":
-                contentValue = JSON.stringify(output.value);
-                break;
-              case "content": {
-                const contentParts = [];
-                for (const item of output.value) {
-                  switch (item.type) {
-                    case "text": {
-                      contentParts.push({
-                        type: "input_text",
-                        text: item.text
-                      });
-                      break;
-                    }
-                    case "file": {
-                      const topLevel = getTopLevelMediaType(item.mediaType);
-                      if (item.data.type === "data") {
-                        const fullMediaType = resolveFullMediaType({
-                          part: item
-                        });
-                        if (topLevel === "image") {
-                          contentParts.push({
-                            type: "input_image",
-                            image_url: `data:${fullMediaType};base64,${convertToBase64(item.data.data)}`,
-                            detail: getImageDetail(item, providerOptionsName)
-                          });
-                        } else {
-                          contentParts.push({
-                            type: "input_file",
-                            filename: item.filename ?? "data",
-                            file_data: `data:${fullMediaType};base64,${convertToBase64(item.data.data)}`
-                          });
-                        }
-                      } else if (item.data.type === "url") {
-                        if (topLevel === "image") {
-                          contentParts.push({
-                            type: "input_image",
-                            image_url: item.data.url.toString(),
-                            detail: getImageDetail(item, providerOptionsName)
-                          });
-                        } else {
-                          contentParts.push({
-                            type: "input_file",
-                            file_url: item.data.url.toString()
-                          });
-                        }
-                      } else {
-                        warnings.push({
-                          type: "other",
-                          message: `unsupported tool content part type: ${item.type} with data type: ${item.data.type}`
-                        });
-                      }
-                      break;
-                    }
-                    default: {
-                      warnings.push({
-                        type: "other",
-                        message: `unsupported tool content part type: ${item.type}`
-                      });
-                      break;
-                    }
-                  }
-                }
-                contentValue = contentParts;
-                break;
-              }
-            }
-            input.push({
-              type: customToolId != null && providerTool?.id === customToolId ? "custom_tool_call_output" : "function_call_output",
-              call_id: part.toolCallId,
-              output: contentValue
-            });
-          }
-        }
-        break;
-      }
-    }
-  }
-  return {
-    input,
-    instructions: systemMessages.length > 0 ? systemMessages.join("\n") : void 0,
-    warnings
-  };
+//#endregion
+//#region src/responses/convert-to-open-responses-input.ts
+async function convertToOpenResponsesInput({ prompt, providerOptionsName = "open-responses", extensionRegistry, providerToolsByName = /* @__PURE__ */ new Map(), strictResponseInput = false, customToolId }) {
+	const input = [];
+	const warnings = [];
+	const systemMessages = [];
+	const replayedExtensionItems = /* @__PURE__ */ new Set();
+	for (const { role, content } of prompt) switch (role) {
+		case "system":
+			systemMessages.push(content);
+			break;
+		case "user": {
+			const userContent = [];
+			for (const part of content) switch (part.type) {
+				case "text":
+					userContent.push({
+						type: "input_text",
+						text: part.text
+					});
+					break;
+				case "file": switch (part.data.type) {
+					case "reference": throw new UnsupportedFunctionalityError({ functionality: "file parts with provider references" });
+					case "text": throw new UnsupportedFunctionalityError({ functionality: "text file parts" });
+					case "url":
+					case "data": if (getTopLevelMediaType(part.mediaType) === "image") userContent.push({
+						type: "input_image",
+						...part.data.type === "url" ? { image_url: part.data.url.toString() } : { image_url: `data:${resolveFullMediaType({ part })};base64,${convertToBase64(part.data.data)}` },
+						detail: getImageDetail(part, providerOptionsName)
+					});
+					else if (part.data.type === "url") userContent.push({
+						type: "input_file",
+						file_url: part.data.url.toString()
+					});
+					else {
+						const fullMediaType = resolveFullMediaType({ part });
+						userContent.push({
+							type: "input_file",
+							filename: part.filename ?? "data",
+							file_data: `data:${fullMediaType};base64,${convertToBase64(part.data.data)}`
+						});
+					}
+				}
+			}
+			input.push({
+				type: "message",
+				role: "user",
+				content: userContent
+			});
+			break;
+		}
+		case "assistant": {
+			let assistantContent = [];
+			let assistantMessageId;
+			const flushAssistantContent = () => {
+				if (assistantContent.length === 0) return;
+				if (strictResponseInput && assistantMessageId == null) input.push({
+					type: "message",
+					role: "assistant",
+					content: assistantContent.map((part) => part.type === "output_text" ? part.text : part.refusal).join("")
+				});
+				else if (strictResponseInput) input.push({
+					id: assistantMessageId,
+					type: "message",
+					status: "completed",
+					role: "assistant",
+					content: assistantContent.map((part) => part.type === "output_text" ? {
+						...part,
+						annotations: part.annotations ?? [],
+						logprobs: part.logprobs ?? []
+					} : part)
+				});
+				else input.push({
+					type: "message",
+					role: "assistant",
+					content: assistantContent,
+					...assistantMessageId != null && { id: assistantMessageId }
+				});
+				assistantContent = [];
+				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(asOpenResponsesExtensionRecord(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?.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.map(asOpenResponsesExtensionRecord));
+						continue;
+					}
+				}
+				switch (part.type) {
+					case "reasoning": {
+						flushAssistantContent();
+						const providerData = getProviderData(part, providerOptionsName);
+						const itemId = typeof providerData?.itemId === "string" ? providerData.itemId : void 0;
+						const summary = parseReasoningSummary(providerData?.reasoningSummary);
+						const reasoningContent = parseReasoningContent(providerData?.reasoningContent);
+						const hasReasoningContent = providerData != null && "reasoningContent" in providerData;
+						const encryptedContent = typeof providerData?.reasoningEncryptedContent === "string" ? providerData.reasoningEncryptedContent : void 0;
+						const reasoningItem = {
+							type: "reasoning",
+							summary: summary ?? [],
+							...itemId != null && { id: itemId },
+							...reasoningContent != null ? { content: reasoningContent } : !hasReasoningContent && part.text.length > 0 ? { content: [{
+								type: "reasoning_text",
+								text: part.text
+							}] } : {},
+							...encryptedContent != null && { encrypted_content: encryptedContent }
+						};
+						const previousItem = input[input.length - 1];
+						if (reasoningItem.id != null && previousItem?.type === "reasoning" && previousItem.id === reasoningItem.id) {
+							if (reasoningItem.content != null) previousItem.content = [...previousItem.content ?? [], ...reasoningItem.content];
+						} else input.push(reasoningItem);
+						break;
+					}
+					case "text": {
+						const providerData = getProviderData(part, providerOptionsName);
+						const itemId = typeof providerData?.itemId === "string" ? providerData.itemId : void 0;
+						const annotations = parseOutputTextAnnotations(providerData?.annotations);
+						if (assistantContent.length > 0 && assistantMessageId !== itemId) flushAssistantContent();
+						assistantMessageId = itemId;
+						assistantContent.push({
+							type: "output_text",
+							text: part.text,
+							...annotations != null && { annotations }
+						});
+						break;
+					}
+					case "tool-call": {
+						flushAssistantContent();
+						const argumentsValue = typeof part.input === "string" ? part.input : JSON.stringify(part.input);
+						const providerData = getProviderData(part, providerOptionsName);
+						const itemId = typeof providerData?.itemId === "string" ? providerData.itemId : void 0;
+						const providerTool = providerToolsByName.get(part.toolName);
+						if (customToolId != null && providerTool?.id === customToolId) input.push({
+							type: "custom_tool_call",
+							...itemId != null && { id: itemId },
+							call_id: part.toolCallId,
+							name: part.toolName,
+							input: argumentsValue
+						});
+						else input.push({
+							type: "function_call",
+							...itemId != null && { id: itemId },
+							call_id: part.toolCallId,
+							name: part.toolName,
+							arguments: argumentsValue
+						});
+						break;
+					}
+				}
+			}
+			flushAssistantContent();
+			break;
+		}
+		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(asOpenResponsesExtensionRecord(replayItem));
+						replayedExtensionItems.add(replayKey);
+					}
+				}
+				continue;
+			}
+			const providerTool = providerToolsByName.get(part.toolName);
+			const extension = providerTool == 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.map(asOpenResponsesExtensionRecord));
+				continue;
+			}
+			const output = part.output;
+			let contentValue;
+			switch (output.type) {
+				case "text":
+				case "error-text":
+					contentValue = output.value;
+					break;
+				case "execution-denied":
+					contentValue = output.reason ?? "Tool call execution denied.";
+					break;
+				case "json":
+				case "error-json":
+					contentValue = JSON.stringify(output.value);
+					break;
+				case "content": {
+					const contentParts = [];
+					for (const item of output.value) switch (item.type) {
+						case "text":
+							contentParts.push({
+								type: "input_text",
+								text: item.text
+							});
+							break;
+						case "file": {
+							const topLevel = getTopLevelMediaType(item.mediaType);
+							if (item.data.type === "data") {
+								const fullMediaType = resolveFullMediaType({ part: item });
+								if (topLevel === "image") contentParts.push({
+									type: "input_image",
+									image_url: `data:${fullMediaType};base64,${convertToBase64(item.data.data)}`,
+									detail: getImageDetail(item, providerOptionsName)
+								});
+								else contentParts.push({
+									type: "input_file",
+									filename: item.filename ?? "data",
+									file_data: `data:${fullMediaType};base64,${convertToBase64(item.data.data)}`
+								});
+							} else if (item.data.type === "url") {
+								if (topLevel === "image") contentParts.push({
+									type: "input_image",
+									image_url: item.data.url.toString(),
+									detail: getImageDetail(item, providerOptionsName)
+								});
+								else contentParts.push({
+									type: "input_file",
+									file_url: item.data.url.toString()
+								});
+							} else warnings.push({
+								type: "other",
+								message: `unsupported tool content part type: ${item.type} with data type: ${item.data.type}`
+							});
+							break;
+						}
+						default: warnings.push({
+							type: "other",
+							message: `unsupported tool content part type: ${item.type}`
+						});
+					}
+					contentValue = contentParts;
+					break;
+				}
+			}
+			input.push({
+				type: customToolId != null && providerTool?.id === customToolId ? "custom_tool_call_output" : "function_call_output",
+				call_id: part.toolCallId,
+				output: contentValue
+			});
+		}
+	}
+	return {
+		input,
+		instructions: systemMessages.length > 0 ? systemMessages.join("\n") : void 0,
+		warnings
+	};
 }
-async function encodeExtensionInputPart({
-  extensionRegistry,
-  part,
-  providerTool
-}) {
-  const extension = extensionRegistry?.byProviderToolId.get(providerTool.id);
-  const encodeInputItem = extension?.encodeInputItem;
-  const itemTypes = extension == null ? [] : getOpenResponsesExtensionItemTypes(extension);
-  if (encodeInputItem == null || itemTypes.length === 0) {
-    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 {
-    return void 0;
-  }
+async function encodeExtensionInputPart({ extensionRegistry, part, providerTool }) {
+	const extension = extensionRegistry?.byProviderToolId.get(providerTool.id);
+	const encodeInputItem = extension?.encodeInputItem;
+	const itemTypes = extension == null ? [] : getOpenResponsesExtensionItemTypes(extension);
+	if (encodeInputItem == null || itemTypes.length === 0) return;
+	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;
+		return items;
+	} catch {
+		return;
+	}
 }
-function getExtensionReplay({
-  part,
-  providerOptionsName,
-  extensionRegistry
-}) {
-  const extensionData = getProviderData(
-    part,
-    providerOptionsName
-  )?.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?.byExtensionId.get(
-    id
-  );
-  if (extension == null) {
-    return void 0;
-  }
-  if (isOpenResponsesExtensionItem(item) && getOpenResponsesExtensionItemTypes(extension).includes(item.type)) {
-    return { item };
-  }
-  return typeof itemId === "string" ? {} : void 0;
+function getExtensionReplay({ part, providerOptionsName, extensionRegistry }) {
+	const extensionData = getProviderData(part, providerOptionsName)?.openResponsesExtension;
+	if (extensionData == null || typeof extensionData !== "object" || Array.isArray(extensionData)) return;
+	const { id, item, itemId } = extensionData;
+	if (typeof id !== "string") return;
+	const extension = extensionRegistry?.byExtensionId.get(id);
+	if (extension == null) return;
+	if (isOpenResponsesExtensionItem(item) && getOpenResponsesExtensionItemTypes(extension).includes(item.type)) return { item };
+	return typeof itemId === "string" ? {} : void 0;
 }
 function getProviderData(part, providerOptionsName) {
-  const providerData = part.providerOptions?.[providerOptionsName] ?? part.providerMetadata?.[providerOptionsName];
-  return providerData != null && typeof providerData === "object" && !Array.isArray(providerData) ? providerData : void 0;
+	const providerData = part.providerOptions?.[providerOptionsName] ?? part.providerMetadata?.[providerOptionsName];
+	return providerData != null && typeof providerData === "object" && !Array.isArray(providerData) ? providerData : void 0;
 }
 function getImageDetail(part, providerOptionsName) {
-  const imageDetail = getProviderData(part, providerOptionsName)?.imageDetail;
-  return imageDetail === "low" || imageDetail === "high" || imageDetail === "auto" ? imageDetail : "auto";
+	const imageDetail = getProviderData(part, providerOptionsName)?.imageDetail;
+	return imageDetail === "low" || imageDetail === "high" || imageDetail === "auto" ? imageDetail : "auto";
 }
 function parseReasoningSummary(value) {
-  if (!Array.isArray(value) || !value.every(
-    (part) => part != null && typeof part === "object" && part.type === "summary_text" && typeof part.text === "string"
-  )) {
-    return void 0;
-  }
-  return value.map((part) => ({
-    type: "summary_text",
-    text: part.text
-  }));
+	if (!Array.isArray(value) || !value.every((part) => part != null && typeof part === "object" && part.type === "summary_text" && typeof part.text === "string")) return;
+	return value.map((part) => ({
+		type: "summary_text",
+		text: part.text
+	}));
 }
 function parseReasoningContent(value) {
-  if (!Array.isArray(value) || !value.every(
-    (part) => part != null && typeof part === "object" && part.type === "reasoning_text" && typeof part.text === "string"
-  )) {
-    return void 0;
-  }
-  return value.map((part) => ({
-    type: "reasoning_text",
-    text: part.text
-  }));
+	if (!Array.isArray(value) || !value.every((part) => part != null && typeof part === "object" && part.type === "reasoning_text" && typeof part.text === "string")) return;
+	return value.map((part) => ({
+		type: "reasoning_text",
+		text: part.text
+	}));
 }
 function parseOutputTextAnnotations(value) {
-  if (!Array.isArray(value) || !value.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"
-  )) {
-    return void 0;
-  }
-  return value.map((annotation) => ({
-    type: "url_citation",
-    start_index: annotation.start_index,
-    end_index: annotation.end_index,
-    url: annotation.url,
-    title: annotation.title
-  }));
+	if (!Array.isArray(value) || !value.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")) return;
+	return value.map((annotation) => ({
+		type: "url_citation",
+		start_index: annotation.start_index,
+		end_index: annotation.end_index,
+		url: annotation.url,
+		title: annotation.title
+	}));
 }
-
-// src/responses/open-responses-api.ts
-import { lazySchema as lazySchema2, zodSchema as zodSchema2 } from "@ai-sdk/provider-utils";
-import { z as z2 } from "zod/v4";
-var openResponsesErrorSchema = lazySchema2(
-  () => zodSchema2(
-    z2.object({
-      error: z2.object({
-        message: z2.string(),
-        type: z2.string().nullish(),
-        param: z2.string().nullish(),
-        code: z2.string().nullish()
-      })
-    })
-  )
-);
-
-// src/responses/map-open-responses-finish-reason.ts
-function mapOpenResponsesFinishReason({
-  finishReason,
-  hasToolCalls
-}) {
-  switch (finishReason) {
-    case void 0:
-    case null:
-      return hasToolCalls ? "tool-calls" : "stop";
-    case "max_output_tokens":
-      return "length";
-    case "content_filter":
-      return "content-filter";
-    default:
-      return hasToolCalls ? "tool-calls" : "other";
-  }
+//#endregion
+//#region src/responses/open-responses-api.ts
+const openResponsesErrorSchema = lazySchema(() => zodSchema(z.object({ error: z.object({
+	message: z.string(),
+	type: z.string().nullish(),
+	param: z.string().nullish(),
+	code: z.string().nullish()
+}) })));
+//#endregion
+//#region src/responses/map-open-responses-finish-reason.ts
+function mapOpenResponsesFinishReason({ finishReason, hasToolCalls }) {
+	switch (finishReason) {
+		case void 0:
+		case null: return hasToolCalls ? "tool-calls" : "stop";
+		case "max_output_tokens": return "length";
+		case "content_filter": return "content-filter";
+		default: return hasToolCalls ? "tool-calls" : "other";
+	}
 }
-
-// src/responses/open-responses-language-model-options.ts
-import {
-  lazySchema as lazySchema3,
-  zodSchema as zodSchema3
-} from "@ai-sdk/provider-utils";
-import { z as z3 } from "zod/v4";
-var openResponsesLanguageModelOptions = lazySchema3(
-  () => zodSchema3(
-    z3.object({
-      /**
-       * Provider-native reasoning effort. The value is passed through to the
-       * endpoint and takes precedence over the top-level `reasoning` setting.
-       */
-      reasoningEffort: z3.string().nullish(),
-      /**
-       * Controls reasoning summary output from the model.
-       * Valid values: 'concise', 'detailed', 'auto'.
-       */
-      reasoningSummary: z3.enum(["concise", "detailed", "auto"]).nullish()
-    })
-  )
-);
-
-// src/responses/open-responses-language-model.ts
-var defaultFailedResponseHandler = createJsonErrorResponseHandler({
-  errorSchema: openResponsesErrorSchema,
-  errorToMessage: (error) => error.error.message
+//#endregion
+//#region src/responses/open-responses-language-model-options.ts
+const openResponsesLanguageModelOptions = lazySchema(() => zodSchema(z.object({
+	/**
+	* Provider-native reasoning effort. The value is passed through to the
+	* endpoint and takes precedence over the top-level `reasoning` setting.
+	*/
+	reasoningEffort: z.string().nullish(),
+	/**
+	* Controls reasoning summary output from the model.
+	* Valid values: 'concise', 'detailed', 'auto'.
+	*/
+	reasoningSummary: z.enum([
+		"concise",
+		"detailed",
+		"auto"
+	]).nullish()
+})));
+//#endregion
+//#region src/responses/open-responses-language-model.ts
+const defaultFailedResponseHandler = createJsonErrorResponseHandler({
+	errorSchema: openResponsesErrorSchema,
+	errorToMessage: (error) => error.error.message
 });
-var OpenResponsesLanguageModel = class _OpenResponsesLanguageModel {
-  constructor(modelId, config) {
-    this.specificationVersion = "v4";
-    this.supportedUrls = {
-      "image/*": [/^https?:\/\/.*$/]
-    };
-    this.modelId = modelId;
-    this.config = config;
-    this.extensionRegistry = config.extensionRegistry ?? 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
-    });
-  }
-  static [WORKFLOW_DESERIALIZE](options) {
-    return new _OpenResponsesLanguageModel(options.modelId, options.config);
-  }
-  get provider() {
-    return this.config.provider;
-  }
-  async getArgs({
-    maxOutputTokens,
-    temperature,
-    stopSequences,
-    topP,
-    topK,
-    presencePenalty,
-    frequencyPenalty,
-    seed,
-    reasoning,
-    prompt,
-    providerOptions,
-    tools,
-    toolChoice,
-    responseFormat
-  }) {
-    const warnings = [];
-    if (stopSequences != null) {
-      warnings.push({ type: "unsupported", feature: "stopSequences" });
-    }
-    if (topK != null) {
-      warnings.push({ type: "unsupported", feature: "topK" });
-    }
-    if (seed != null) {
-      warnings.push({ type: "unsupported", feature: "seed" });
-    }
-    const providerToolsByName = new Map(
-      (tools ?? []).filter((tool) => tool.type === "provider").map((tool) => [tool.name, tool])
-    );
-    const {
-      input,
-      instructions,
-      warnings: inputWarnings
-    } = await convertToOpenResponsesInput({
-      prompt,
-      providerOptionsName: this.config.providerOptionsName,
-      extensionRegistry: this.extensionRegistry,
-      providerToolsByName,
-      strictResponseInput: this.config.strictResponseInput,
-      customToolId: this.config.customToolId
-    });
-    warnings.push(...inputWarnings);
-    const convertedTools = [];
-    const encodedProviderToolsByName = /* @__PURE__ */ new Map();
-    for (const tool of tools ?? []) {
-      if (tool.type === "provider") {
-        if (this.config.customToolId != null && tool.id === this.config.customToolId) {
-          const format = tool.args.format != null && typeof tool.args.format === "object" && !Array.isArray(tool.args.format) ? tool.args.format : void 0;
-          convertedTools.push({
-            type: "custom",
-            name: tool.name,
-            description: typeof tool.args.description === "string" ? tool.args.description : void 0,
-            format: format != null && "type" in format && format.type === "grammar" && "syntax" in format && (format.syntax === "regex" || format.syntax === "lark") && "definition" in format && typeof format.definition === "string" ? {
-              type: "grammar",
-              syntax: format.syntax,
-              definition: format.definition
-            } : format != null && "type" in format && format.type === "text" ? { type: "text" } : void 0
-          });
-          continue;
-        }
-        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,
-              args: tool.args
-            });
-            if (isOpenResponsesJSONObject(fields)) {
-              encoded = {
-                ...fields,
-                type: toolType
-              };
-            }
-          } catch {
-          }
-        }
-        if (encoded == null) {
-          warnings.push({
-            type: "unsupported",
-            feature: `provider-defined tool ${tool.id}`
-          });
-        } else if (extension != null) {
-          convertedTools.push(asOpenResponsesExtensionRecord(encoded));
-          encodedProviderToolsByName.set(tool.name, {
-            toolType: getOpenResponsesExtensionToolType(extension),
-            encodeToolChoice: extension.encodeToolChoice,
-            tool
-          });
-        }
-      } else {
-        convertedTools.push({
-          type: "function",
-          name: tool.name,
-          description: tool.description,
-          parameters: tool.inputSchema,
-          ...tool.strict != null ? { strict: tool.strict } : {}
-        });
-      }
-    }
-    let convertedToolChoice;
-    if (toolChoice?.type === "tool") {
-      const registeredTool = encodedProviderToolsByName.get(
-        toolChoice.toolName
-      );
-      if (registeredTool == null) {
-        if (this.config.customToolId != null && providerToolsByName.get(toolChoice.toolName)?.id === this.config.customToolId) {
-          convertedToolChoice = {
-            type: "custom",
-            name: toolChoice.toolName
-          };
-        } else if (!providerToolsByName.has(toolChoice.toolName)) {
-          convertedToolChoice = {
-            type: "function",
-            name: toolChoice.toolName
-          };
-        }
-      } else {
-        const { encodeToolChoice, tool, toolType } = registeredTool;
-        let fields = {};
-        try {
-          fields = await encodeToolChoice?.({
-            name: tool.name,
-            args: tool.args
-          });
-        } catch {
-          fields = void 0;
-        }
-        if (encodeToolChoice != null && !isOpenResponsesJSONObject(fields)) {
-          warnings.push({
-            type: "unsupported",
-            feature: `tool choice for provider-defined tool ${tool.id}`
-          });
-        } else {
-          convertedToolChoice = asOpenResponsesExtensionRecord({
-            ...isOpenResponsesJSONObject(fields) ? fields : {},
-            type: toolType
-          });
-        }
-      }
-    } else {
-      convertedToolChoice = toolChoice?.type;
-    }
-    const textFormat = responseFormat?.type === "json" && this.config.structuredOutputs !== false ? responseFormat.schema != null ? {
-      type: "json_schema",
-      name: responseFormat.name ?? "response",
-      description: responseFormat.description,
-      schema: responseFormat.schema,
-      strict: true
-    } : { type: "json_object" } : void 0;
-    if (responseFormat?.type === "json" && this.config.structuredOutputs === false) {
-      warnings.push({ type: "unsupported", feature: "responseFormat" });
-    }
-    const openResponsesOptions = await parseProviderOptions({
-      provider: this.config.providerOptionsName,
-      providerOptions,
-      schema: openResponsesLanguageModelOptions
-    });
-    const resolvedReasoningEffort = openResponsesOptions?.reasoningEffort ?? (isCustomReasoning(reasoning) ? reasoning === "none" ? "none" : mapReasoningToProviderEffort({
-      reasoning,
-      effortMap: {
-        minimal: "low",
-        low: "low",
-        medium: "medium",
-        high: "high",
-        xhigh: "xhigh"
-      },
-      warnings
-    }) : void 0);
-    return {
-      body: {
-        model: this.modelId,
-        input,
-        instructions,
-        max_output_tokens: maxOutputTokens,
-        temperature,
-        top_p: topP,
-        presence_penalty: presencePenalty,
-        frequency_penalty: frequencyPenalty,
-        reasoning: resolvedReasoningEffort != null || openResponsesOptions?.reasoningSummary != null ? {
-          ...resolvedReasoningEffort != null && {
-            effort: resolvedReasoningEffort
-          },
-          ...openResponsesOptions?.reasoningSummary != null && {
-            summary: openResponsesOptions.reasoningSummary
-          }
-        } : void 0,
-        tools: convertedTools.length ? convertedTools : void 0,
-        tool_choice: convertedToolChoice,
-        ...textFormat != null && { text: { format: textFormat } }
-      },
-      warnings
-    };
-  }
-  async doGenerate(options) {
-    const { body, warnings } = await this.getArgs(options);
-    const {
-      responseHeaders,
-      value: response,
-      rawValue: rawResponse
-    } = await postJsonToApi({
-      url: this.config.url,
-      headers: combineHeaders(this.config.headers?.(), options.headers),
-      body,
-      failedResponseHandler: this.config.failedResponseHandler ?? defaultFailedResponseHandler,
-      successfulResponseHandler: createJsonResponseHandler(
-        // do not validate the response body, only apply types to the response body
-        jsonSchema(() => {
-          throw new Error("json schema not implemented");
-        })
-      ),
-      abortSignal: options.abortSignal,
-      fetch: this.config.fetch
-    });
-    if (response.error) {
-      const errorMetadata = this.config.getResponseErrorMetadata?.(
-        response.error
-      );
-      throw new APICallError({
-        message: response.error.message,
-        url: this.config.url,
-        requestBodyValues: body,
-        statusCode: errorMetadata?.statusCode ?? 400,
-        isRetryable: errorMetadata?.isRetryable,
-        responseHeaders,
-        responseBody: rawResponse,
-        data: response.error
-      });
-    }
-    if (response.output == null) {
-      const detail = response.incomplete_details?.reason ?? response.status;
-      throw new APICallError({
-        message: detail ? `Responses API returned no output (${detail})` : "Responses API returned no output",
-        url: this.config.url,
-        requestBodyValues: body,
-        statusCode: 500,
-        responseHeaders,
-        responseBody: rawResponse,
-        isRetryable: false
-      });
-    }
-    const content = [];
-    let hasToolCalls = false;
-    for (const part of response.output) {
-      switch (part.type) {
-        // TODO AI SDK 7 adjust reasoning in the specification to better support the reasoning structure from open responses.
-        case "reasoning": {
-          if ((part.content?.length ?? 0) > 0) {
-            for (const contentPart of part.content) {
-              content.push({
-                type: "reasoning",
-                text: contentPart.text,
-                providerMetadata: createReasoningProviderMetadata({
-                  part,
-                  providerOptionsName: this.config.providerOptionsName,
-                  reasoningContent: [contentPart]
-                })
-              });
-            }
-          } else {
-            content.push({
-              type: "reasoning",
-              text: part.summary.map((summaryPart) => summaryPart.text).join(""),
-              providerMetadata: createReasoningProviderMetadata({
-                part,
-                providerOptionsName: this.config.providerOptionsName
-              })
-            });
-          }
-          break;
-        }
-        case "message": {
-          for (const contentPart of part.content) {
-            const annotations = getOutputTextAnnotations(contentPart);
-            content.push({
-              type: "text",
-              text: contentPart.text,
-              providerMetadata: {
-                [this.config.providerOptionsName]: {
-                  itemId: part.id,
-                  ...annotations.length > 0 && { annotations }
-                }
-              }
-            });
-          }
-          break;
-        }
-        case "function_call": {
-          hasToolCalls = true;
-          content.push({
-            type: "tool-call",
-            toolCallId: part.call_id,
-            toolName: part.name,
-            input: part.arguments,
-            providerMetadata: {
-              [this.config.providerOptionsName]: { itemId: part.id }
-            }
-          });
-          break;
-        }
-        case "custom_tool_call": {
-          hasToolCalls = true;
-          content.push({
-            type: "tool-call",
-            toolCallId: part.call_id,
-            toolName: part.name,
-            input: JSON.stringify(part.input),
-            providerMetadata: {
-              [this.config.providerOptionsName]: { itemId: part.id }
-            }
-          });
-          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((part2) => part2.type === "tool-call");
-          }
-          break;
-        }
-      }
-    }
-    const usage = response.usage;
-    const inputTokens = usage?.input_tokens;
-    const cachedInputTokens = usage?.input_tokens_details?.cached_tokens;
-    const cacheWriteTokens = usage?.input_tokens_details?.cache_write_tokens;
-    const outputTokens = usage?.output_tokens;
-    const reasoningTokens = usage?.output_tokens_details?.reasoning_tokens;
-    return {
-      content,
-      finishReason: {
-        unified: mapOpenResponsesFinishReason({
-          finishReason: response.incomplete_details?.reason,
-          hasToolCalls
-        }),
-        raw: response.incomplete_details?.reason ?? void 0
-      },
-      usage: {
-        inputTokens: {
-          total: inputTokens,
-          noCache: (inputTokens ?? 0) - (cachedInputTokens ?? 0) - (cacheWriteTokens ?? 0),
-          cacheRead: cachedInputTokens,
-          cacheWrite: cacheWriteTokens
-        },
-        outputTokens: {
-          total: outputTokens,
-          text: (outputTokens ?? 0) - (reasoningTokens ?? 0),
-          reasoning: reasoningTokens
-        },
-        raw: response.usage
-      },
-      request: { body },
-      response: {
-        id: response.id,
-        timestamp: new Date(response.created_at * 1e3),
-        modelId: response.model,
-        headers: responseHeaders,
-        body: rawResponse
-      },
-      providerMetadata: void 0,
-      warnings
-    };
-  }
-  async doStream(options) {
-    const { body, warnings } = await this.getArgs(options);
-    const { responseHeaders, value: response } = await postJsonToApi({
-      url: this.config.url,
-      headers: combineHeaders(this.config.headers?.(), options.headers),
-      body: {
-        ...body,
-        stream: true
-      },
-      failedResponseHandler: this.config.failedResponseHandler ?? defaultFailedResponseHandler,
-      successfulResponseHandler: createEventSourceResponseHandler(z4.any()),
-      abortSignal: options.abortSignal,
-      fetch: this.config.fetch
-    });
-    const usage = {
-      inputTokens: {
-        total: void 0,
-        noCache: void 0,
-        cacheRead: void 0,
-        cacheWrite: void 0
-      },
-      outputTokens: {
-        total: void 0,
-        text: void 0,
-        reasoning: void 0
-      }
-    };
-    const updateUsage = (responseUsage) => {
-      if (!responseUsage) {
-        return;
-      }
-      const inputTokens = responseUsage.input_tokens;
-      const cachedInputTokens = responseUsage.input_tokens_details?.cached_tokens;
-      const cacheWriteTokens = responseUsage.input_tokens_details?.cache_write_tokens;
-      const outputTokens = responseUsage.output_tokens;
-      const reasoningTokens = responseUsage.output_tokens_details?.reasoning_tokens;
-      usage.inputTokens = {
-        total: inputTokens,
-        noCache: (inputTokens ?? 0) - (cachedInputTokens ?? 0) - (cacheWriteTokens ?? 0),
-        cacheRead: cachedInputTokens,
-        cacheWrite: cacheWriteTokens
-      };
-      usage.outputTokens = {
-        total: outputTokens,
-        text: (outputTokens ?? 0) - (reasoningTokens ?? 0),
-        reasoning: reasoningTokens
-      };
-      usage.raw = responseUsage;
-    };
-    let activeReasoningId;
-    let hasToolCalls = false;
-    let finishReason = {
-      unified: "other",
-      raw: void 0
-    };
-    const toolCallsByItemId = /* @__PURE__ */ new Map();
-    const customToolCallsByItemId = /* @__PURE__ */ new Map();
-    const providerOptionsName = this.config.providerOptionsName;
-    const extensionRegistry = this.extensionRegistry;
-    const extensionStreamState = /* @__PURE__ */ new Map();
-    const getResponseErrorMetadata = this.config.getResponseErrorMetadata;
-    return {
-      stream: response.pipeThrough(
-        new TransformStream({
-          start(controller) {
-            controller.enqueue({ type: "stream-start", warnings });
-          },
-          async transform(parseResult, controller) {
-            if (options.includeRawChunks) {
-              controller.enqueue({
-                type: "raw",
-                rawValue: parseResult.rawValue
-              });
-            }
-            if (!parseResult.success) {
-              controller.enqueue({ type: "error", error: parseResult.error });
-              return;
-            }
-            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;
-              }
-            }
-            if (chunk.type === "response.output_item.added" && chunk.item.type === "function_call") {
-              toolCallsByItemId.set(chunk.item.id, {
-                toolName: chunk.item.name,
-                toolCallId: chunk.item.call_id,
-                arguments: chunk.item.arguments
-              });
-            } else if (chunk.type === "response.function_call_arguments.delta") {
-              const functionCallChunk = chunk;
-              const toolCall = toolCallsByItemId.get(functionCallChunk.item_id);
-              if (toolCall == null) {
-                toolCallsByItemId.set(functionCallChunk.item_id, {
-                  arguments: functionCallChunk.delta
-                });
-                return;
-              }
-              toolCall.arguments = (toolCall.arguments ?? "") + functionCallChunk.delta;
-            } else if (chunk.type === "response.function_call_arguments.done") {
-              const functionCallChunk = chunk;
-              const toolCall = toolCallsByItemId.get(functionCallChunk.item_id);
-              if (toolCall == null) {
-                toolCallsByItemId.set(functionCallChunk.item_id, {
-                  arguments: functionCallChunk.arguments
-                });
-                return;
-              }
-              toolCall.arguments = functionCallChunk.arguments;
-            } else if (chunk.type === "response.output_item.done" && chunk.item.type === "function_call") {
-              const toolCall = toolCallsByItemId.get(chunk.item.id);
-              const toolName = toolCall?.toolName ?? chunk.item.name;
-              const toolCallId = toolCall?.toolCallId ?? chunk.item.call_id;
-              const input = chunk.item.arguments !== "" ? chunk.item.arguments : toolCall?.arguments ?? "";
-              controller.enqueue({
-                type: "tool-call",
-                toolCallId,
-                toolName,
-                input,
-                providerMetadata: {
-                  [providerOptionsName]: {
-                    itemId: chunk.item.id
-                  }
-                }
-              });
-              hasToolCalls = true;
-              toolCallsByItemId.delete(chunk.item.id);
-            } else if (chunk.type === "response.output_item.added" && chunk.item.type === "custom_tool_call") {
-              customToolCallsByItemId.set(chunk.item.id, {
-                toolName: chunk.item.name,
-                toolCallId: chunk.item.call_id,
-                input: chunk.item.input
-              });
-              controller.enqueue({
-                type: "tool-input-start",
-                id: chunk.item.call_id,
-                toolName: chunk.item.name
-              });
-            } else if (chunk.type === "response.custom_tool_call_input.delta") {
-              const toolCall = customToolCallsByItemId.get(chunk.item_id);
-              if (toolCall == null) {
-                customToolCallsByItemId.set(chunk.item_id, {
-                  input: chunk.delta
-                });
-              } else {
-                toolCall.input = (toolCall.input ?? "") + chunk.delta;
-              }
-              controller.enqueue({
-                type: "tool-input-delta",
-                id: customToolCallsByItemId.get(chunk.item_id)?.toolCallId ?? chunk.item_id,
-                delta: chunk.delta
-              });
-            } else if (chunk.type === "response.custom_tool_call_input.done") {
-              const toolCall = customToolCallsByItemId.get(chunk.item_id);
-              if (toolCall == null) {
-                customToolCallsByItemId.set(chunk.item_id, {
-                  input: chunk.input
-                });
-              } else {
-                toolCall.input = chunk.input;
-              }
-            } else if (chunk.type === "response.output_item.done" && chunk.item.type === "custom_tool_call") {
-              const toolCall = customToolCallsByItemId.get(chunk.item.id);
-              const toolCallId = toolCall?.toolCallId ?? chunk.item.call_id;
-              const input = chunk.item.input !== "" ? chunk.item.input : toolCall?.input ?? "";
-              controller.enqueue({ type: "tool-input-end", id: toolCallId });
-              controller.enqueue({
-                type: "tool-call",
-                toolCallId,
-                toolName: toolCall?.toolName ?? chunk.item.name,
-                input: JSON.stringify(input),
-                providerMetadata: {
-                  [providerOptionsName]: { itemId: chunk.item.id }
-                }
-              });
-              hasToolCalls = true;
-              customToolCallsByItemId.delete(chunk.item.id);
-            } else if (chunk.type === "response.output_item.done" && isOpenResponsesExtensionItem(chunk.item) && extensionRegistry.byItemType.has(chunk.item.type)) {
-              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 });
-              }
-            } else if (chunk.type === "response.output_item.added" && chunk.item.type === "reasoning") {
-              controller.enqueue({
-                type: "reasoning-start",
-                id: chunk.item.id
-              });
-              activeReasoningId = chunk.item.id;
-            } else if (chunk.type === "response.reasoning_summary_text.delta" || chunk.type === "response.reasoning_text.delta") {
-              const reasoningChunk = chunk;
-              controller.enqueue({
-                type: "reasoning-delta",
-                id: reasoningChunk.item_id,
-                delta: reasoningChunk.delta
-              });
-            } else if (chunk.type === "response.output_item.done" && chunk.item.type === "reasoning") {
-              controller.enqueue({
-                type: "reasoning-end",
-                id: chunk.item.id,
-                providerMetadata: createReasoningProviderMetadata({
-                  part: chunk.item,
-                  providerOptionsName
-                })
-              });
-              if (activeReasoningId === chunk.item.id) {
-                activeReasoningId = void 0;
-              }
-            } else if (chunk.type === "response.output_item.added" && chunk.item.type === "message") {
-              controller.enqueue({ type: "text-start", id: chunk.item.id });
-            } else if (chunk.type === "response.output_text.delta") {
-              controller.enqueue({
-                type: "text-delta",
-                id: chunk.item_id,
-                delta: chunk.delta
-              });
-            } else if (chunk.type === "response.output_item.done" && chunk.item.type === "message") {
-              const annotations = chunk.item.content.flatMap(
-                getOutputTextAnnotations
-              );
-              controller.enqueue({
-                type: "text-end",
-                id: chunk.item.id,
-                providerMetadata: {
-                  [providerOptionsName]: {
-                    itemId: chunk.item.id,
-                    ...annotations.length > 0 && { annotations }
-                  }
-                }
-              });
-            } else if (chunk.type === "response.completed" || chunk.type === "response.incomplete") {
-              const reason = chunk.response.incomplete_details?.reason;
-              finishReason = {
-                unified: mapOpenResponsesFinishReason({
-                  finishReason: reason,
-                  hasToolCalls
-                }),
-                raw: reason ?? void 0
-              };
-              updateUsage(chunk.response.usage);
-            } else if (chunk.type === "response.failed") {
-              finishReason = {
-                unified: "error",
-                raw: chunk.response.error?.code ?? chunk.response.status
-              };
-              updateUsage(chunk.response.usage);
-              if (chunk.response.error != null) {
-                controller.enqueue({
-                  type: "error",
-                  error: createOpenResponsesStreamError({
-                    type: chunk.type,
-                    error: chunk.response.error,
-                    data: chunk,
-                    getResponseErrorMetadata
-                  })
-                });
-              }
-            } else if (chunk.type === "error") {
-              finishReason = {
-                unified: "error",
-                raw: chunk.error.code
-              };
-              controller.enqueue({
-                type: "error",
-                error: createOpenResponsesStreamError({
-                  type: chunk.type,
-                  error: chunk.error,
-                  data: chunk,
-                  getResponseErrorMetadata
-                })
-              });
-            }
-          },
-          flush(controller) {
-            if (activeReasoningId != null) {
-              controller.enqueue({
-                type: "reasoning-end",
-                id: activeReasoningId
-              });
-            }
-            controller.enqueue({
-              type: "finish",
-              finishReason,
-              usage,
-              providerMetadata: void 0
-            });
-          }
-        })
-      ),
-      request: { body },
-      response: { headers: responseHeaders }
-    };
-  }
+var OpenResponsesLanguageModel = class OpenResponsesLanguageModel {
+	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
+		});
+	}
+	static [WORKFLOW_DESERIALIZE](options) {
+		return new OpenResponsesLanguageModel(options.modelId, options.config);
+	}
+	constructor(modelId, config) {
+		this.specificationVersion = "v4";
+		this.supportedUrls = { "image/*": [/^https?:\/\/.*$/] };
+		this.modelId = modelId;
+		this.config = config;
+		this.extensionRegistry = config.extensionRegistry ?? createOpenResponsesExtensionRegistry();
+	}
+	get provider() {
+		return this.config.provider;
+	}
+	async getArgs({ maxOutputTokens, temperature, stopSequences, topP, topK, presencePenalty, frequencyPenalty, seed, reasoning, prompt, providerOptions, tools, toolChoice, responseFormat }) {
+		const warnings = [];
+		if (stopSequences != null) warnings.push({
+			type: "unsupported",
+			feature: "stopSequences"
+		});
+		if (topK != null) warnings.push({
+			type: "unsupported",
+			feature: "topK"
+		});
+		if (seed != null) warnings.push({
+			type: "unsupported",
+			feature: "seed"
+		});
+		const providerToolsByName = new Map((tools ?? []).filter((tool) => tool.type === "provider").map((tool) => [tool.name, tool]));
+		const { input, instructions, warnings: inputWarnings } = await convertToOpenResponsesInput({
+			prompt,
+			providerOptionsName: this.config.providerOptionsName,
+			extensionRegistry: this.extensionRegistry,
+			providerToolsByName,
+			strictResponseInput: this.config.strictResponseInput,
+			customToolId: this.config.customToolId
+		});
+		warnings.push(...inputWarnings);
+		const convertedTools = [];
+		const encodedProviderToolsByName = /* @__PURE__ */ new Map();
+		for (const tool of tools ?? []) if (tool.type === "provider") {
+			if (this.config.customToolId != null && tool.id === this.config.customToolId) {
+				const format = tool.args.format != null && typeof tool.args.format === "object" && !Array.isArray(tool.args.format) ? tool.args.format : void 0;
+				convertedTools.push({
+					type: "custom",
+					name: tool.name,
+					description: typeof tool.args.description === "string" ? tool.args.description : void 0,
+					format: format != null && "type" in format && format.type === "grammar" && "syntax" in format && (format.syntax === "regex" || format.syntax === "lark") && "definition" in format && typeof format.definition === "string" ? {
+						type: "grammar",
+						syntax: format.syntax,
+						definition: format.definition
+					} : format != null && "type" in format && format.type === "text" ? { type: "text" } : void 0
+				});
+				continue;
+			}
+			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,
+						args: tool.args
+					});
+					if (isOpenResponsesJSONObject(fields)) encoded = {
+						...fields,
+						type: toolType
+					};
+				} catch {}
+			}
+			if (encoded == null) warnings.push({
+				type: "unsupported",
+				feature: `provider-defined tool ${tool.id}`
+			});
+			else if (extension != null) {
+				convertedTools.push(asOpenResponsesExtensionRecord(encoded));
+				encodedProviderToolsByName.set(tool.name, {
+					toolType: getOpenResponsesExtensionToolType(extension),
+					encodeToolChoice: extension.encodeToolChoice,
+					tool
+				});
+			}
+		} else convertedTools.push({
+			type: "function",
+			name: tool.name,
+			description: tool.description,
+			parameters: tool.inputSchema,
+			...tool.strict != null ? { strict: tool.strict } : {}
+		});
+		let convertedToolChoice;
+		if (toolChoice?.type === "tool") {
+			const registeredTool = encodedProviderToolsByName.get(toolChoice.toolName);
+			if (registeredTool == null) {
+				if (this.config.customToolId != null && providerToolsByName.get(toolChoice.toolName)?.id === this.config.customToolId) convertedToolChoice = {
+					type: "custom",
+					name: toolChoice.toolName
+				};
+				else if (!providerToolsByName.has(toolChoice.toolName)) convertedToolChoice = {
+					type: "function",
+					name: toolChoice.toolName
+				};
+			} else {
+				const { encodeToolChoice, tool, toolType } = registeredTool;
+				let fields = {};
+				try {
+					fields = await encodeToolChoice?.({
+						name: tool.name,
+						args: tool.args
+					});
+				} catch {
+					fields = void 0;
+				}
+				if (encodeToolChoice != null && !isOpenResponsesJSONObject(fields)) warnings.push({
+					type: "unsupported",
+					feature: `tool choice for provider-defined tool ${tool.id}`
+				});
+				else convertedToolChoice = asOpenResponsesExtensionRecord({
+					...isOpenResponsesJSONObject(fields) ? fields : {},
+					type: toolType
+				});
+			}
+		} else convertedToolChoice = toolChoice?.type;
+		const textFormat = responseFormat?.type === "json" && this.config.structuredOutputs !== false ? responseFormat.schema != null ? {
+			type: "json_schema",
+			name: responseFormat.name ?? "response",
+			description: responseFormat.description,
+			schema: responseFormat.schema,
+			strict: true
+		} : { type: "json_object" } : void 0;
+		if (responseFormat?.type === "json" && this.config.structuredOutputs === false) warnings.push({
+			type: "unsupported",
+			feature: "responseFormat"
+		});
+		const openResponsesOptions = await parseProviderOptions({
+			provider: this.config.providerOptionsName,
+			providerOptions,
+			schema: openResponsesLanguageModelOptions
+		});
+		const resolvedReasoningEffort = openResponsesOptions?.reasoningEffort ?? (isCustomReasoning(reasoning) ? reasoning === "none" ? "none" : mapReasoningToProviderEffort({
+			reasoning,
+			effortMap: {
+				minimal: "low",
+				low: "low",
+				medium: "medium",
+				high: "high",
+				xhigh: "xhigh"
+			},
+			warnings
+		}) : void 0);
+		return {
+			body: {
+				model: this.modelId,
+				input,
+				instructions,
+				max_output_tokens: maxOutputTokens,
+				temperature,
+				top_p: topP,
+				presence_penalty: presencePenalty,
+				frequency_penalty: frequencyPenalty,
+				reasoning: resolvedReasoningEffort != null || openResponsesOptions?.reasoningSummary != null ? {
+					...resolvedReasoningEffort != null && { effort: resolvedReasoningEffort },
+					...openResponsesOptions?.reasoningSummary != null && { summary: openResponsesOptions.reasoningSummary }
+				} : void 0,
+				tools: convertedTools.length ? convertedTools : void 0,
+				tool_choice: convertedToolChoice,
+				...textFormat != null && { text: { format: textFormat } }
+			},
+			warnings
+		};
+	}
+	async doGenerate(options) {
+		const { body, warnings } = await this.getArgs(options);
+		const { responseHeaders, value: response, rawValue: rawResponse } = await postJsonToApi({
+			url: this.config.url,
+			headers: combineHeaders(this.config.headers?.(), options.headers),
+			body,
+			failedResponseHandler: this.config.failedResponseHandler ?? defaultFailedResponseHandler,
+			successfulResponseHandler: createJsonResponseHandler(jsonSchema(() => {
+				throw new Error("json schema not implemented");
+			})),
+			abortSignal: options.abortSignal,
+			fetch: this.config.fetch
+		});
+		if (response.error) {
+			const errorMetadata = this.config.getResponseErrorMetadata?.(response.error);
+			throw new APICallError({
+				message: response.error.message,
+				url: this.config.url,
+				requestBodyValues: body,
+				statusCode: errorMetadata?.statusCode ?? 400,
+				isRetryable: errorMetadata?.isRetryable,
+				responseHeaders,
+				responseBody: rawResponse,
+				data: response.error
+			});
+		}
+		if (response.output == null) {
+			const detail = response.incomplete_details?.reason ?? response.status;
+			throw new APICallError({
+				message: detail ? `Responses API returned no output (${detail})` : "Responses API returned no output",
+				url: this.config.url,
+				requestBodyValues: body,
+				statusCode: 500,
+				responseHeaders,
+				responseBody: rawResponse,
+				isRetryable: false
+			});
+		}
+		const content = [];
+		let hasToolCalls = false;
+		for (const part of response.output) switch (part.type) {
+			case "reasoning":
+				if ((part.content?.length ?? 0) > 0) for (const contentPart of part.content) content.push({
+					type: "reasoning",
+					text: contentPart.text,
+					providerMetadata: createReasoningProviderMetadata({
+						part,
+						providerOptionsName: this.config.providerOptionsName,
+						reasoningContent: [contentPart]
+					})
+				});
+				else content.push({
+					type: "reasoning",
+					text: part.summary.map((summaryPart) => summaryPart.text).join(""),
+					providerMetadata: createReasoningProviderMetadata({
+						part,
+						providerOptionsName: this.config.providerOptionsName
+					})
+				});
+				break;
+			case "message":
+				for (const contentPart of part.content) {
+					const annotations = getOutputTextAnnotations(contentPart);
+					content.push({
+						type: "text",
+						text: contentPart.text,
+						providerMetadata: { [this.config.providerOptionsName]: {
+							itemId: part.id,
+							...annotations.length > 0 && { annotations }
+						} }
+					});
+				}
+				break;
+			case "function_call":
+				hasToolCalls = true;
+				content.push({
+					type: "tool-call",
+					toolCallId: part.call_id,
+					toolName: part.name,
+					input: part.arguments,
+					providerMetadata: { [this.config.providerOptionsName]: { itemId: part.id } }
+				});
+				break;
+			case "custom_tool_call":
+				hasToolCalls = true;
+				content.push({
+					type: "tool-call",
+					toolCallId: part.call_id,
+					toolName: part.name,
+					input: JSON.stringify(part.input),
+					providerMetadata: { [this.config.providerOptionsName]: { itemId: part.id } }
+				});
+				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;
+			}
+		}
+		const usage = response.usage;
+		const inputTokens = usage?.input_tokens;
+		const cachedInputTokens = usage?.input_tokens_details?.cached_tokens;
+		const cacheWriteTokens = usage?.input_tokens_details?.cache_write_tokens;
+		const outputTokens = usage?.output_tokens;
+		const reasoningTokens = usage?.output_tokens_details?.reasoning_tokens;
+		return {
+			content,
+			finishReason: {
+				unified: mapOpenResponsesFinishReason({
+					finishReason: response.incomplete_details?.reason,
+					hasToolCalls
+				}),
+				raw: response.incomplete_details?.reason ?? void 0
+			},
+			usage: {
+				inputTokens: {
+					total: inputTokens,
+					noCache: (inputTokens ?? 0) - (cachedInputTokens ?? 0) - (cacheWriteTokens ?? 0),
+					cacheRead: cachedInputTokens,
+					cacheWrite: cacheWriteTokens
+				},
+				outputTokens: {
+					total: outputTokens,
+					text: (outputTokens ?? 0) - (reasoningTokens ?? 0),
+					reasoning: reasoningTokens
+				},
+				raw: response.usage
+			},
+			request: { body },
+			response: {
+				id: response.id,
+				timestamp: /* @__PURE__ */ new Date(response.created_at * 1e3),
+				modelId: response.model,
+				headers: responseHeaders,
+				body: rawResponse
+			},
+			providerMetadata: void 0,
+			warnings
+		};
+	}
+	async doStream(options) {
+		const { body, warnings } = await this.getArgs(options);
+		const { responseHeaders, value: response } = await postJsonToApi({
+			url: this.config.url,
+			headers: combineHeaders(this.config.headers?.(), options.headers),
+			body: {
+				...body,
+				stream: true
+			},
+			failedResponseHandler: this.config.failedResponseHandler ?? defaultFailedResponseHandler,
+			successfulResponseHandler: createEventSourceResponseHandler(z.any()),
+			abortSignal: options.abortSignal,
+			fetch: this.config.fetch
+		});
+		const usage = {
+			inputTokens: {
+				total: void 0,
+				noCache: void 0,
+				cacheRead: void 0,
+				cacheWrite: void 0
+			},
+			outputTokens: {
+				total: void 0,
+				text: void 0,
+				reasoning: void 0
+			}
+		};
+		const updateUsage = (responseUsage) => {
+			if (!responseUsage) return;
+			const inputTokens = responseUsage.input_tokens;
+			const cachedInputTokens = responseUsage.input_tokens_details?.cached_tokens;
+			const cacheWriteTokens = responseUsage.input_tokens_details?.cache_write_tokens;
+			const outputTokens = responseUsage.output_tokens;
+			const reasoningTokens = responseUsage.output_tokens_details?.reasoning_tokens;
+			usage.inputTokens = {
+				total: inputTokens,
+				noCache: (inputTokens ?? 0) - (cachedInputTokens ?? 0) - (cacheWriteTokens ?? 0),
+				cacheRead: cachedInputTokens,
+				cacheWrite: cacheWriteTokens
+			};
+			usage.outputTokens = {
+				total: outputTokens,
+				text: (outputTokens ?? 0) - (reasoningTokens ?? 0),
+				reasoning: reasoningTokens
+			};
+			usage.raw = responseUsage;
+		};
+		let activeReasoningId;
+		let hasToolCalls = false;
+		let finishReason = {
+			unified: "other",
+			raw: void 0
+		};
+		const toolCallsByItemId = /* @__PURE__ */ new Map();
+		const customToolCallsByItemId = /* @__PURE__ */ new Map();
+		const providerOptionsName = this.config.providerOptionsName;
+		const extensionRegistry = this.extensionRegistry;
+		const extensionStreamState = /* @__PURE__ */ new Map();
+		const getResponseErrorMetadata = this.config.getResponseErrorMetadata;
+		return {
+			stream: response.pipeThrough(new TransformStream({
+				start(controller) {
+					controller.enqueue({
+						type: "stream-start",
+						warnings
+					});
+				},
+				async transform(parseResult, controller) {
+					if (options.includeRawChunks) controller.enqueue({
+						type: "raw",
+						rawValue: parseResult.rawValue
+					});
+					if (!parseResult.success) {
+						controller.enqueue({
+							type: "error",
+							error: parseResult.error
+						});
+						return;
+					}
+					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;
+						}
+					}
+					if (chunk.type === "response.output_item.added" && chunk.item.type === "function_call") toolCallsByItemId.set(chunk.item.id, {
+						toolName: chunk.item.name,
+						toolCallId: chunk.item.call_id,
+						arguments: chunk.item.arguments
+					});
+					else if (chunk.type === "response.function_call_arguments.delta") {
+						const functionCallChunk = chunk;
+						const toolCall = toolCallsByItemId.get(functionCallChunk.item_id);
+						if (toolCall == null) {
+							toolCallsByItemId.set(functionCallChunk.item_id, { arguments: functionCallChunk.delta });
+							return;
+						}
+						toolCall.arguments = (toolCall.arguments ?? "") + functionCallChunk.delta;
+					} else if (chunk.type === "response.function_call_arguments.done") {
+						const functionCallChunk = chunk;
+						const toolCall = toolCallsByItemId.get(functionCallChunk.item_id);
+						if (toolCall == null) {
+							toolCallsByItemId.set(functionCallChunk.item_id, { arguments: functionCallChunk.arguments });
+							return;
+						}
+						toolCall.arguments = functionCallChunk.arguments;
+					} else if (chunk.type === "response.output_item.done" && chunk.item.type === "function_call") {
+						const toolCall = toolCallsByItemId.get(chunk.item.id);
+						const toolName = toolCall?.toolName ?? chunk.item.name;
+						const toolCallId = toolCall?.toolCallId ?? chunk.item.call_id;
+						const input = chunk.item.arguments !== "" ? chunk.item.arguments : toolCall?.arguments ?? "";
+						controller.enqueue({
+							type: "tool-call",
+							toolCallId,
+							toolName,
+							input,
+							providerMetadata: { [providerOptionsName]: { itemId: chunk.item.id } }
+						});
+						hasToolCalls = true;
+						toolCallsByItemId.delete(chunk.item.id);
+					} else if (chunk.type === "response.output_item.added" && chunk.item.type === "custom_tool_call") {
+						customToolCallsByItemId.set(chunk.item.id, {
+							toolName: chunk.item.name,
+							toolCallId: chunk.item.call_id,
+							input: chunk.item.input
+						});
+						controller.enqueue({
+							type: "tool-input-start",
+							id: chunk.item.call_id,
+							toolName: chunk.item.name
+						});
+					} else if (chunk.type === "response.custom_tool_call_input.delta") {
+						const toolCall = customToolCallsByItemId.get(chunk.item_id);
+						if (toolCall == null) customToolCallsByItemId.set(chunk.item_id, { input: chunk.delta });
+						else toolCall.input = (toolCall.input ?? "") + chunk.delta;
+						controller.enqueue({
+							type: "tool-input-delta",
+							id: customToolCallsByItemId.get(chunk.item_id)?.toolCallId ?? chunk.item_id,
+							delta: chunk.delta
+						});
+					} else if (chunk.type === "response.custom_tool_call_input.done") {
+						const toolCall = customToolCallsByItemId.get(chunk.item_id);
+						if (toolCall == null) customToolCallsByItemId.set(chunk.item_id, { input: chunk.input });
+						else toolCall.input = chunk.input;
+					} else if (chunk.type === "response.output_item.done" && chunk.item.type === "custom_tool_call") {
+						const toolCall = customToolCallsByItemId.get(chunk.item.id);
+						const toolCallId = toolCall?.toolCallId ?? chunk.item.call_id;
+						const input = chunk.item.input !== "" ? chunk.item.input : toolCall?.input ?? "";
+						controller.enqueue({
+							type: "tool-input-end",
+							id: toolCallId
+						});
+						controller.enqueue({
+							type: "tool-call",
+							toolCallId,
+							toolName: toolCall?.toolName ?? chunk.item.name,
+							input: JSON.stringify(input),
+							providerMetadata: { [providerOptionsName]: { itemId: chunk.item.id } }
+						});
+						hasToolCalls = true;
+						customToolCallsByItemId.delete(chunk.item.id);
+					} else if (chunk.type === "response.output_item.done" && isOpenResponsesExtensionItem(chunk.item) && extensionRegistry.byItemType.has(chunk.item.type)) 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
+						});
+					}
+					else if (chunk.type === "response.output_item.added" && chunk.item.type === "reasoning") {
+						controller.enqueue({
+							type: "reasoning-start",
+							id: chunk.item.id
+						});
+						activeReasoningId = chunk.item.id;
+					} else if (chunk.type === "response.reasoning_summary_text.delta" || chunk.type === "response.reasoning_text.delta") {
+						const reasoningChunk = chunk;
+						controller.enqueue({
+							type: "reasoning-delta",
+							id: reasoningChunk.item_id,
+							delta: reasoningChunk.delta
+						});
+					} else if (chunk.type === "response.output_item.done" && chunk.item.type === "reasoning") {
+						controller.enqueue({
+							type: "reasoning-end",
+							id: chunk.item.id,
+							providerMetadata: createReasoningProviderMetadata({
+								part: chunk.item,
+								providerOptionsName
+							})
+						});
+						if (activeReasoningId === chunk.item.id) activeReasoningId = void 0;
+					} else if (chunk.type === "response.output_item.added" && chunk.item.type === "message") controller.enqueue({
+						type: "text-start",
+						id: chunk.item.id
+					});
+					else if (chunk.type === "response.output_text.delta") controller.enqueue({
+						type: "text-delta",
+						id: chunk.item_id,
+						delta: chunk.delta
+					});
+					else if (chunk.type === "response.output_item.done" && chunk.item.type === "message") {
+						const annotations = chunk.item.content.flatMap(getOutputTextAnnotations);
+						controller.enqueue({
+							type: "text-end",
+							id: chunk.item.id,
+							providerMetadata: { [providerOptionsName]: {
+								itemId: chunk.item.id,
+								...annotations.length > 0 && { annotations }
+							} }
+						});
+					} else if (chunk.type === "response.completed" || chunk.type === "response.incomplete") {
+						const reason = chunk.response.incomplete_details?.reason;
+						finishReason = {
+							unified: mapOpenResponsesFinishReason({
+								finishReason: reason,
+								hasToolCalls
+							}),
+							raw: reason ?? void 0
+						};
+						updateUsage(chunk.response.usage);
+					} else if (chunk.type === "response.failed") {
+						finishReason = {
+							unified: "error",
+							raw: chunk.response.error?.code ?? chunk.response.status
+						};
+						updateUsage(chunk.response.usage);
+						if (chunk.response.error != null) controller.enqueue({
+							type: "error",
+							error: createOpenResponsesStreamError({
+								type: chunk.type,
+								error: chunk.response.error,
+								data: chunk,
+								getResponseErrorMetadata
+							})
+						});
+					} else if (chunk.type === "error") {
+						finishReason = {
+							unified: "error",
+							raw: chunk.error.code
+						};
+						controller.enqueue({
+							type: "error",
+							error: createOpenResponsesStreamError({
+								type: chunk.type,
+								error: chunk.error,
+								data: chunk,
+								getResponseErrorMetadata
+							})
+						});
+					}
+				},
+				flush(controller) {
+					if (activeReasoningId != null) controller.enqueue({
+						type: "reasoning-end",
+						id: activeReasoningId
+					});
+					controller.enqueue({
+						type: "finish",
+						finishReason,
+						usage,
+						providerMetadata: void 0
+					});
+				}
+			})),
+			request: { body },
+			response: { headers: responseHeaders }
+		};
+	}
 };
-function createOpenResponsesStreamError({
-  type,
-  error,
-  data,
-  getResponseErrorMetadata
-}) {
-  return createProviderStreamError({
-    message: error.message,
-    type,
-    code: error.code,
-    ...getResponseErrorMetadata?.(error),
-    data
-  });
+function createOpenResponsesStreamError({ type, error, data, getResponseErrorMetadata }) {
+	return createProviderStreamError({
+		message: error.message,
+		type,
+		code: error.code,
+		...getResponseErrorMetadata?.(error),
+		data
+	});
 }
-function createReasoningProviderMetadata({
-  part,
-  providerOptionsName,
-  reasoningContent = part.content
-}) {
-  return {
-    [providerOptionsName]: {
-      itemId: part.id,
-      reasoningSummary: part.summary.map((summaryPart) => ({
-        type: "summary_text",
-        text: summaryPart.text
-      })),
-      reasoningContent: reasoningContent == null ? null : reasoningContent.map((contentPart) => ({
-        type: "reasoning_text",
-        text: contentPart.text
-      })),
-      ...part.encrypted_content != null && {
-        reasoningEncryptedContent: part.encrypted_content
-      }
-    }
-  };
+function createReasoningProviderMetadata({ part, providerOptionsName, reasoningContent = part.content }) {
+	return { [providerOptionsName]: {
+		itemId: part.id,
+		reasoningSummary: part.summary.map((summaryPart) => ({
+			type: "summary_text",
+			text: summaryPart.text
+		})),
+		reasoningContent: reasoningContent == null ? null : reasoningContent.map((contentPart) => ({
+			type: "reasoning_text",
+			text: contentPart.text
+		})),
+		...part.encrypted_content != null && { reasoningEncryptedContent: part.encrypted_content }
+	} };
 }
-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
-      })
-    )
-  ];
+async function decodeExtensionItem({ extensionRegistry, item, mode, providerOptionsName }) {
+	const extension = extensionRegistry.byItemType.get(item.type);
+	if (extension == null) return;
+	const decoded = await extension.decodeItem({
+		item,
+		mode
+	});
+	if (decoded == null) return;
+	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 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
-}) {
-  const providerMetadata = part.providerMetadata ?? {};
-  return {
-    ...part,
-    providerMetadata: {
-      ...providerMetadata,
-      [providerOptionsName]: {
-        ...providerMetadata[providerOptionsName],
-        openResponsesExtension: {
-          id: extension.id,
-          itemId: item.id
-        }
-      }
-    }
-  };
+function addExtensionItemReferenceMetadata({ extension, item, part, providerOptionsName }) {
+	const providerMetadata = part.providerMetadata ?? {};
+	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"
-  )) {
-    return [];
-  }
-  return value.annotations.map((annotation) => ({
-    type: "url_citation",
-    start_index: annotation.start_index,
-    end_index: annotation.end_index,
-    url: annotation.url,
-    title: annotation.title
-  }));
+	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")) return [];
+	return value.annotations.map((annotation) => ({
+		type: "url_citation",
+		start_index: annotation.start_index,
+		end_index: annotation.end_index,
+		url: annotation.url,
+		title: annotation.title
+	}));
 }
-
-// src/open-responses-provider.ts
+//#endregion
+//#region src/open-responses-provider.ts
 function createOpenResponses(options) {
-  const providerName = options.name;
-  const customToolId = options.customToolId ?? "open-responses.custom";
-  const extensionRegistry = createOpenResponsesExtensionRegistry(
-    options.experimental_extensions
-  );
-  const getHeaders = () => withUserAgentSuffix(
-    {
-      ...options.apiKey ? {
-        Authorization: `Bearer ${options.apiKey}`
-      } : {},
-      ...typeof options.headers === "function" ? options.headers() : options.headers
-    },
-    options.userAgentSuffix ?? `ai-sdk-open-responses/${VERSION}`
-  );
-  const createResponsesModel = (modelId) => {
-    return new OpenResponsesLanguageModel(modelId, {
-      provider: `${providerName}.responses`,
-      providerOptionsName: providerName,
-      headers: getHeaders,
-      url: options.url,
-      fetch: options.fetch,
-      failedResponseHandler: options.failedResponseHandler,
-      getResponseErrorMetadata: options.getResponseErrorMetadata,
-      generateId: () => generateId(),
-      extensionRegistry,
-      strictResponseInput: options.strictResponseInput,
-      customToolId,
-      structuredOutputs: options.structuredOutputs
-    });
-  };
-  const createLanguageModel = (modelId) => {
-    if (new.target) {
-      throw new Error(
-        "The OpenAI model function cannot be called with the new keyword."
-      );
-    }
-    return createResponsesModel(modelId);
-  };
-  const provider = function(modelId) {
-    return createLanguageModel(modelId);
-  };
-  provider.specificationVersion = "v4";
-  provider.languageModel = createLanguageModel;
-  provider.tools = createOpenResponsesTools({ customToolId });
-  provider.embeddingModel = (modelId) => {
-    throw new NoSuchModelError({ modelId, modelType: "embeddingModel" });
-  };
-  provider.imageModel = (modelId) => {
-    throw new NoSuchModelError({ modelId, modelType: "imageModel" });
-  };
-  return provider;
+	const providerName = options.name;
+	const customToolId = options.customToolId ?? "open-responses.custom";
+	const extensionRegistry = createOpenResponsesExtensionRegistry(options.experimental_extensions);
+	const getHeaders = () => withUserAgentSuffix({
+		...options.apiKey ? { Authorization: `Bearer ${options.apiKey}` } : {},
+		...typeof options.headers === "function" ? options.headers() : options.headers
+	}, options.userAgentSuffix ?? `ai-sdk-open-responses/2.0.58`);
+	const createResponsesModel = (modelId) => {
+		return new OpenResponsesLanguageModel(modelId, {
+			provider: `${providerName}.responses`,
+			providerOptionsName: providerName,
+			headers: getHeaders,
+			url: options.url,
+			fetch: options.fetch,
+			failedResponseHandler: options.failedResponseHandler,
+			getResponseErrorMetadata: options.getResponseErrorMetadata,
+			generateId: () => generateId(),
+			extensionRegistry,
+			strictResponseInput: options.strictResponseInput,
+			customToolId,
+			structuredOutputs: options.structuredOutputs
+		});
+	};
+	const createLanguageModel = (modelId) => {
+		if (new.target) throw new Error("The OpenAI model function cannot be called with the new keyword.");
+		return createResponsesModel(modelId);
+	};
+	const provider = function(modelId) {
+		return createLanguageModel(modelId);
+	};
+	provider.specificationVersion = "v4";
+	provider.languageModel = createLanguageModel;
+	provider.tools = createOpenResponsesTools({ customToolId });
+	provider.embeddingModel = (modelId) => {
+		throw new NoSuchModelError({
+			modelId,
+			modelType: "embeddingModel"
+		});
+	};
+	provider.imageModel = (modelId) => {
+		throw new NoSuchModelError({
+			modelId,
+			modelType: "imageModel"
+		});
+	};
+	return provider;
 }
-export {
-  VERSION,
-  createOpenResponses
-};
+//#endregion
+export { VERSION, createOpenResponses };
+
 //# sourceMappingURL=index.js.map