@mastra/core 1.0.0-beta.11 → 1.0.0-beta.13

package/dist/chunk-5VZGJTPR.js

@@ -0,0 +1,4837 @@
+import { ModelsDevGateway, parseModelRouterId } from './chunk-MRRFTNF4.js';
+import { NetlifyGateway } from './chunk-WPTTKULS.js';
+import { createJsonErrorResponseHandler, lazyValidator, zodSchema, lazySchema, createProviderDefinedToolFactoryWithOutputSchema, MastraModelGateway, createOpenAICompatible, createOpenAI, createGoogleGenerativeAI, parseProviderOptions, postJsonToApi, createJsonResponseHandler, combineHeaders, generateId, createEventSourceResponseHandler, isParsableJson, loadApiKey, withUserAgentSuffix, loadSetting, convertToBase64, convertBase64ToUint8Array, mediaTypeToExtension, postFormDataToApi, createBinaryResponseHandler, validateTypes } from './chunk-ARAQIW6E.js';
+import { PROVIDER_REGISTRY, GatewayRegistry } from './chunk-GIWC35YQ.js';
+import { InvalidResponseDataError, UnsupportedFunctionalityError, TooManyEmbeddingValuesForCallError, APICallError, InvalidPromptError } from './chunk-UBSPZTQX.js';
+import { AISDKV5LanguageModel } from './chunk-62Q7K656.js';
+import { RequestContext } from './chunk-6TBWJV35.js';
+import { MastraError } from './chunk-YPLZDWG7.js';
+import { InMemoryServerCache } from './chunk-3CKZSDTQ.js';
+import { createHash } from 'crypto';
+import { z } from 'zod/v4';
+
+var openaiErrorDataSchema = z.object({
+  error: z.object({
+    message: z.string(),
+    // The additional information below is handled loosely to support
+    // OpenAI-compatible providers that have slightly different error
+    // responses:
+    type: z.string().nullish(),
+    param: z.any().nullish(),
+    code: z.union([z.string(), z.number()]).nullish()
+  })
+});
+var openaiFailedResponseHandler = createJsonErrorResponseHandler({
+  errorSchema: openaiErrorDataSchema,
+  errorToMessage: (data) => data.error.message
+});
+function convertToOpenAIChatMessages({
+  prompt,
+  systemMessageMode = "system"
+}) {
+  const messages = [];
+  const warnings = [];
+  for (const { role, content } of prompt) {
+    switch (role) {
+      case "system": {
+        switch (systemMessageMode) {
+          case "system": {
+            messages.push({ role: "system", content });
+            break;
+          }
+          case "developer": {
+            messages.push({ role: "developer", content });
+            break;
+          }
+          case "remove": {
+            warnings.push({
+              type: "other",
+              message: "system messages are removed for this model"
+            });
+            break;
+          }
+          default: {
+            const _exhaustiveCheck = systemMessageMode;
+            throw new Error(
+              `Unsupported system message mode: ${_exhaustiveCheck}`
+            );
+          }
+        }
+        break;
+      }
+      case "user": {
+        if (content.length === 1 && content[0].type === "text") {
+          messages.push({ role: "user", content: content[0].text });
+          break;
+        }
+        messages.push({
+          role: "user",
+          content: content.map((part, index) => {
+            var _a, _b, _c;
+            switch (part.type) {
+              case "text": {
+                return { type: "text", text: part.text };
+              }
+              case "file": {
+                if (part.mediaType.startsWith("image/")) {
+                  const mediaType = part.mediaType === "image/*" ? "image/jpeg" : part.mediaType;
+                  return {
+                    type: "image_url",
+                    image_url: {
+                      url: part.data instanceof URL ? part.data.toString() : `data:${mediaType};base64,${convertToBase64(part.data)}`,
+                      // OpenAI specific extension: image detail
+                      detail: (_b = (_a = part.providerOptions) == null ? void 0 : _a.openai) == null ? void 0 : _b.imageDetail
+                    }
+                  };
+                } else if (part.mediaType.startsWith("audio/")) {
+                  if (part.data instanceof URL) {
+                    throw new UnsupportedFunctionalityError({
+                      functionality: "audio file parts with URLs"
+                    });
+                  }
+                  switch (part.mediaType) {
+                    case "audio/wav": {
+                      return {
+                        type: "input_audio",
+                        input_audio: {
+                          data: convertToBase64(part.data),
+                          format: "wav"
+                        }
+                      };
+                    }
+                    case "audio/mp3":
+                    case "audio/mpeg": {
+                      return {
+                        type: "input_audio",
+                        input_audio: {
+                          data: convertToBase64(part.data),
+                          format: "mp3"
+                        }
+                      };
+                    }
+                    default: {
+                      throw new UnsupportedFunctionalityError({
+                        functionality: `audio content parts with media type ${part.mediaType}`
+                      });
+                    }
+                  }
+                } else if (part.mediaType === "application/pdf") {
+                  if (part.data instanceof URL) {
+                    throw new UnsupportedFunctionalityError({
+                      functionality: "PDF file parts with URLs"
+                    });
+                  }
+                  return {
+                    type: "file",
+                    file: typeof part.data === "string" && part.data.startsWith("file-") ? { file_id: part.data } : {
+                      filename: (_c = part.filename) != null ? _c : `part-${index}.pdf`,
+                      file_data: `data:application/pdf;base64,${convertToBase64(part.data)}`
+                    }
+                  };
+                } else {
+                  throw new UnsupportedFunctionalityError({
+                    functionality: `file part media type ${part.mediaType}`
+                  });
+                }
+              }
+            }
+          })
+        });
+        break;
+      }
+      case "assistant": {
+        let text = "";
+        const toolCalls = [];
+        for (const part of content) {
+          switch (part.type) {
+            case "text": {
+              text += part.text;
+              break;
+            }
+            case "tool-call": {
+              toolCalls.push({
+                id: part.toolCallId,
+                type: "function",
+                function: {
+                  name: part.toolName,
+                  arguments: JSON.stringify(part.input)
+                }
+              });
+              break;
+            }
+          }
+        }
+        messages.push({
+          role: "assistant",
+          content: text,
+          tool_calls: toolCalls.length > 0 ? toolCalls : void 0
+        });
+        break;
+      }
+      case "tool": {
+        for (const toolResponse of content) {
+          const output = toolResponse.output;
+          let contentValue;
+          switch (output.type) {
+            case "text":
+            case "error-text":
+              contentValue = output.value;
+              break;
+            case "content":
+            case "json":
+            case "error-json":
+              contentValue = JSON.stringify(output.value);
+              break;
+          }
+          messages.push({
+            role: "tool",
+            tool_call_id: toolResponse.toolCallId,
+            content: contentValue
+          });
+        }
+        break;
+      }
+      default: {
+        const _exhaustiveCheck = role;
+        throw new Error(`Unsupported role: ${_exhaustiveCheck}`);
+      }
+    }
+  }
+  return { messages, warnings };
+}
+function getResponseMetadata({
+  id,
+  model,
+  created
+}) {
+  return {
+    id: id != null ? id : void 0,
+    modelId: model != null ? model : void 0,
+    timestamp: created ? new Date(created * 1e3) : void 0
+  };
+}
+function mapOpenAIFinishReason(finishReason) {
+  switch (finishReason) {
+    case "stop":
+      return "stop";
+    case "length":
+      return "length";
+    case "content_filter":
+      return "content-filter";
+    case "function_call":
+    case "tool_calls":
+      return "tool-calls";
+    default:
+      return "unknown";
+  }
+}
+var openaiChatResponseSchema = lazyValidator(
+  () => zodSchema(
+    z.object({
+      id: z.string().nullish(),
+      created: z.number().nullish(),
+      model: z.string().nullish(),
+      choices: z.array(
+        z.object({
+          message: z.object({
+            role: z.literal("assistant").nullish(),
+            content: z.string().nullish(),
+            tool_calls: z.array(
+              z.object({
+                id: z.string().nullish(),
+                type: z.literal("function"),
+                function: z.object({
+                  name: z.string(),
+                  arguments: z.string()
+                })
+              })
+            ).nullish(),
+            annotations: z.array(
+              z.object({
+                type: z.literal("url_citation"),
+                start_index: z.number(),
+                end_index: z.number(),
+                url: z.string(),
+                title: z.string()
+              })
+            ).nullish()
+          }),
+          index: z.number(),
+          logprobs: z.object({
+            content: z.array(
+              z.object({
+                token: z.string(),
+                logprob: z.number(),
+                top_logprobs: z.array(
+                  z.object({
+                    token: z.string(),
+                    logprob: z.number()
+                  })
+                )
+              })
+            ).nullish()
+          }).nullish(),
+          finish_reason: z.string().nullish()
+        })
+      ),
+      usage: z.object({
+        prompt_tokens: z.number().nullish(),
+        completion_tokens: z.number().nullish(),
+        total_tokens: z.number().nullish(),
+        prompt_tokens_details: z.object({
+          cached_tokens: z.number().nullish()
+        }).nullish(),
+        completion_tokens_details: z.object({
+          reasoning_tokens: z.number().nullish(),
+          accepted_prediction_tokens: z.number().nullish(),
+          rejected_prediction_tokens: z.number().nullish()
+        }).nullish()
+      }).nullish()
+    })
+  )
+);
+var openaiChatChunkSchema = lazyValidator(
+  () => zodSchema(
+    z.union([
+      z.object({
+        id: z.string().nullish(),
+        created: z.number().nullish(),
+        model: z.string().nullish(),
+        choices: z.array(
+          z.object({
+            delta: z.object({
+              role: z.enum(["assistant"]).nullish(),
+              content: z.string().nullish(),
+              tool_calls: z.array(
+                z.object({
+                  index: z.number(),
+                  id: z.string().nullish(),
+                  type: z.literal("function").nullish(),
+                  function: z.object({
+                    name: z.string().nullish(),
+                    arguments: z.string().nullish()
+                  })
+                })
+              ).nullish(),
+              annotations: z.array(
+                z.object({
+                  type: z.literal("url_citation"),
+                  start_index: z.number(),
+                  end_index: z.number(),
+                  url: z.string(),
+                  title: z.string()
+                })
+              ).nullish()
+            }).nullish(),
+            logprobs: z.object({
+              content: z.array(
+                z.object({
+                  token: z.string(),
+                  logprob: z.number(),
+                  top_logprobs: z.array(
+                    z.object({
+                      token: z.string(),
+                      logprob: z.number()
+                    })
+                  )
+                })
+              ).nullish()
+            }).nullish(),
+            finish_reason: z.string().nullish(),
+            index: z.number()
+          })
+        ),
+        usage: z.object({
+          prompt_tokens: z.number().nullish(),
+          completion_tokens: z.number().nullish(),
+          total_tokens: z.number().nullish(),
+          prompt_tokens_details: z.object({
+            cached_tokens: z.number().nullish()
+          }).nullish(),
+          completion_tokens_details: z.object({
+            reasoning_tokens: z.number().nullish(),
+            accepted_prediction_tokens: z.number().nullish(),
+            rejected_prediction_tokens: z.number().nullish()
+          }).nullish()
+        }).nullish()
+      }),
+      openaiErrorDataSchema
+    ])
+  )
+);
+var openaiChatLanguageModelOptions = lazyValidator(
+  () => zodSchema(
+    z.object({
+      /**
+       * Modify the likelihood of specified tokens appearing in the completion.
+       *
+       * Accepts a JSON object that maps tokens (specified by their token ID in
+       * the GPT tokenizer) to an associated bias value from -100 to 100.
+       */
+      logitBias: z.record(z.coerce.number(), z.number()).optional(),
+      /**
+       * Return the log probabilities of the tokens.
+       *
+       * Setting to true will return the log probabilities of the tokens that
+       * were generated.
+       *
+       * Setting to a number will return the log probabilities of the top n
+       * tokens that were generated.
+       */
+      logprobs: z.union([z.boolean(), z.number()]).optional(),
+      /**
+       * Whether to enable parallel function calling during tool use. Default to true.
+       */
+      parallelToolCalls: z.boolean().optional(),
+      /**
+       * A unique identifier representing your end-user, which can help OpenAI to
+       * monitor and detect abuse.
+       */
+      user: z.string().optional(),
+      /**
+       * Reasoning effort for reasoning models. Defaults to `medium`.
+       */
+      reasoningEffort: z.enum(["none", "minimal", "low", "medium", "high"]).optional(),
+      /**
+       * Maximum number of completion tokens to generate. Useful for reasoning models.
+       */
+      maxCompletionTokens: z.number().optional(),
+      /**
+       * Whether to enable persistence in responses API.
+       */
+      store: z.boolean().optional(),
+      /**
+       * Metadata to associate with the request.
+       */
+      metadata: z.record(z.string().max(64), z.string().max(512)).optional(),
+      /**
+       * Parameters for prediction mode.
+       */
+      prediction: z.record(z.string(), z.any()).optional(),
+      /**
+       * Whether to use structured outputs.
+       *
+       * @default true
+       */
+      structuredOutputs: z.boolean().optional(),
+      /**
+       * Service tier for the request.
+       * - 'auto': Default service tier. The request will be processed with the service tier configured in the
+       *           Project settings. Unless otherwise configured, the Project will use 'default'.
+       * - 'flex': 50% cheaper processing at the cost of increased latency. Only available for o3 and o4-mini models.
+       * - 'priority': Higher-speed processing with predictably low latency at premium cost. Available for Enterprise customers.
+       * - 'default': The request will be processed with the standard pricing and performance for the selected model.
+       *
+       * @default 'auto'
+       */
+      serviceTier: z.enum(["auto", "flex", "priority", "default"]).optional(),
+      /**
+       * Whether to use strict JSON schema validation.
+       *
+       * @default false
+       */
+      strictJsonSchema: z.boolean().optional(),
+      /**
+       * Controls the verbosity of the model's responses.
+       * Lower values will result in more concise responses, while higher values will result in more verbose responses.
+       */
+      textVerbosity: z.enum(["low", "medium", "high"]).optional(),
+      /**
+       * A cache key for prompt caching. Allows manual control over prompt caching behavior.
+       * Useful for improving cache hit rates and working around automatic caching issues.
+       */
+      promptCacheKey: z.string().optional(),
+      /**
+       * The retention policy for the prompt cache.
+       * - 'in_memory': Default. Standard prompt caching behavior.
+       * - '24h': Extended prompt caching that keeps cached prefixes active for up to 24 hours.
+       *          Currently only available for 5.1 series models.
+       *
+       * @default 'in_memory'
+       */
+      promptCacheRetention: z.enum(["in_memory", "24h"]).optional(),
+      /**
+       * A stable identifier used to help detect users of your application
+       * that may be violating OpenAI's usage policies. The IDs should be a
+       * string that uniquely identifies each user. We recommend hashing their
+       * username or email address, in order to avoid sending us any identifying
+       * information.
+       */
+      safetyIdentifier: z.string().optional()
+    })
+  )
+);
+function prepareChatTools({
+  tools,
+  toolChoice,
+  structuredOutputs,
+  strictJsonSchema
+}) {
+  tools = (tools == null ? void 0 : tools.length) ? tools : void 0;
+  const toolWarnings = [];
+  if (tools == null) {
+    return { tools: void 0, toolChoice: void 0, toolWarnings };
+  }
+  const openaiTools = [];
+  for (const tool of tools) {
+    switch (tool.type) {
+      case "function":
+        openaiTools.push({
+          type: "function",
+          function: {
+            name: tool.name,
+            description: tool.description,
+            parameters: tool.inputSchema,
+            strict: structuredOutputs ? strictJsonSchema : void 0
+          }
+        });
+        break;
+      default:
+        toolWarnings.push({ type: "unsupported-tool", tool });
+        break;
+    }
+  }
+  if (toolChoice == null) {
+    return { tools: openaiTools, toolChoice: void 0, toolWarnings };
+  }
+  const type = toolChoice.type;
+  switch (type) {
+    case "auto":
+    case "none":
+    case "required":
+      return { tools: openaiTools, toolChoice: type, toolWarnings };
+    case "tool":
+      return {
+        tools: openaiTools,
+        toolChoice: {
+          type: "function",
+          function: {
+            name: toolChoice.toolName
+          }
+        },
+        toolWarnings
+      };
+    default: {
+      const _exhaustiveCheck = type;
+      throw new UnsupportedFunctionalityError({
+        functionality: `tool choice type: ${_exhaustiveCheck}`
+      });
+    }
+  }
+}
+var OpenAIChatLanguageModel = class {
+  constructor(modelId, config) {
+    this.specificationVersion = "v2";
+    this.supportedUrls = {
+      "image/*": [/^https?:\/\/.*$/]
+    };
+    this.modelId = modelId;
+    this.config = config;
+  }
+  get provider() {
+    return this.config.provider;
+  }
+  async getArgs({
+    prompt,
+    maxOutputTokens,
+    temperature,
+    topP,
+    topK,
+    frequencyPenalty,
+    presencePenalty,
+    stopSequences,
+    responseFormat,
+    seed,
+    tools,
+    toolChoice,
+    providerOptions
+  }) {
+    var _a, _b, _c, _d;
+    const warnings = [];
+    const openaiOptions = (_a = await parseProviderOptions({
+      provider: "openai",
+      providerOptions,
+      schema: openaiChatLanguageModelOptions
+    })) != null ? _a : {};
+    const structuredOutputs = (_b = openaiOptions.structuredOutputs) != null ? _b : true;
+    if (topK != null) {
+      warnings.push({
+        type: "unsupported-setting",
+        setting: "topK"
+      });
+    }
+    if ((responseFormat == null ? void 0 : responseFormat.type) === "json" && responseFormat.schema != null && !structuredOutputs) {
+      warnings.push({
+        type: "unsupported-setting",
+        setting: "responseFormat",
+        details: "JSON response format schema is only supported with structuredOutputs"
+      });
+    }
+    const { messages, warnings: messageWarnings } = convertToOpenAIChatMessages(
+      {
+        prompt,
+        systemMessageMode: getSystemMessageMode(this.modelId)
+      }
+    );
+    warnings.push(...messageWarnings);
+    const strictJsonSchema = (_c = openaiOptions.strictJsonSchema) != null ? _c : false;
+    const baseArgs = {
+      // model id:
+      model: this.modelId,
+      // model specific settings:
+      logit_bias: openaiOptions.logitBias,
+      logprobs: openaiOptions.logprobs === true || typeof openaiOptions.logprobs === "number" ? true : void 0,
+      top_logprobs: typeof openaiOptions.logprobs === "number" ? openaiOptions.logprobs : typeof openaiOptions.logprobs === "boolean" ? openaiOptions.logprobs ? 0 : void 0 : void 0,
+      user: openaiOptions.user,
+      parallel_tool_calls: openaiOptions.parallelToolCalls,
+      // standardized settings:
+      max_tokens: maxOutputTokens,
+      temperature,
+      top_p: topP,
+      frequency_penalty: frequencyPenalty,
+      presence_penalty: presencePenalty,
+      response_format: (responseFormat == null ? void 0 : responseFormat.type) === "json" ? structuredOutputs && responseFormat.schema != null ? {
+        type: "json_schema",
+        json_schema: {
+          schema: responseFormat.schema,
+          strict: strictJsonSchema,
+          name: (_d = responseFormat.name) != null ? _d : "response",
+          description: responseFormat.description
+        }
+      } : { type: "json_object" } : void 0,
+      stop: stopSequences,
+      seed,
+      verbosity: openaiOptions.textVerbosity,
+      // openai specific settings:
+      // TODO AI SDK 6: remove, we auto-map maxOutputTokens now
+      max_completion_tokens: openaiOptions.maxCompletionTokens,
+      store: openaiOptions.store,
+      metadata: openaiOptions.metadata,
+      prediction: openaiOptions.prediction,
+      reasoning_effort: openaiOptions.reasoningEffort,
+      service_tier: openaiOptions.serviceTier,
+      prompt_cache_key: openaiOptions.promptCacheKey,
+      prompt_cache_retention: openaiOptions.promptCacheRetention,
+      safety_identifier: openaiOptions.safetyIdentifier,
+      // messages:
+      messages
+    };
+    if (isReasoningModel(this.modelId)) {
+      if (baseArgs.temperature != null) {
+        baseArgs.temperature = void 0;
+        warnings.push({
+          type: "unsupported-setting",
+          setting: "temperature",
+          details: "temperature is not supported for reasoning models"
+        });
+      }
+      if (baseArgs.top_p != null) {
+        baseArgs.top_p = void 0;
+        warnings.push({
+          type: "unsupported-setting",
+          setting: "topP",
+          details: "topP is not supported for reasoning models"
+        });
+      }
+      if (baseArgs.frequency_penalty != null) {
+        baseArgs.frequency_penalty = void 0;
+        warnings.push({
+          type: "unsupported-setting",
+          setting: "frequencyPenalty",
+          details: "frequencyPenalty is not supported for reasoning models"
+        });
+      }
+      if (baseArgs.presence_penalty != null) {
+        baseArgs.presence_penalty = void 0;
+        warnings.push({
+          type: "unsupported-setting",
+          setting: "presencePenalty",
+          details: "presencePenalty is not supported for reasoning models"
+        });
+      }
+      if (baseArgs.logit_bias != null) {
+        baseArgs.logit_bias = void 0;
+        warnings.push({
+          type: "other",
+          message: "logitBias is not supported for reasoning models"
+        });
+      }
+      if (baseArgs.logprobs != null) {
+        baseArgs.logprobs = void 0;
+        warnings.push({
+          type: "other",
+          message: "logprobs is not supported for reasoning models"
+        });
+      }
+      if (baseArgs.top_logprobs != null) {
+        baseArgs.top_logprobs = void 0;
+        warnings.push({
+          type: "other",
+          message: "topLogprobs is not supported for reasoning models"
+        });
+      }
+      if (baseArgs.max_tokens != null) {
+        if (baseArgs.max_completion_tokens == null) {
+          baseArgs.max_completion_tokens = baseArgs.max_tokens;
+        }
+        baseArgs.max_tokens = void 0;
+      }
+    } else if (this.modelId.startsWith("gpt-4o-search-preview") || this.modelId.startsWith("gpt-4o-mini-search-preview")) {
+      if (baseArgs.temperature != null) {
+        baseArgs.temperature = void 0;
+        warnings.push({
+          type: "unsupported-setting",
+          setting: "temperature",
+          details: "temperature is not supported for the search preview models and has been removed."
+        });
+      }
+    }
+    if (openaiOptions.serviceTier === "flex" && !supportsFlexProcessing(this.modelId)) {
+      warnings.push({
+        type: "unsupported-setting",
+        setting: "serviceTier",
+        details: "flex processing is only available for o3, o4-mini, and gpt-5 models"
+      });
+      baseArgs.service_tier = void 0;
+    }
+    if (openaiOptions.serviceTier === "priority" && !supportsPriorityProcessing(this.modelId)) {
+      warnings.push({
+        type: "unsupported-setting",
+        setting: "serviceTier",
+        details: "priority processing is only available for supported models (gpt-4, gpt-5, gpt-5-mini, o3, o4-mini) and requires Enterprise access. gpt-5-nano is not supported"
+      });
+      baseArgs.service_tier = void 0;
+    }
+    const {
+      tools: openaiTools,
+      toolChoice: openaiToolChoice,
+      toolWarnings
+    } = prepareChatTools({
+      tools,
+      toolChoice,
+      structuredOutputs,
+      strictJsonSchema
+    });
+    return {
+      args: {
+        ...baseArgs,
+        tools: openaiTools,
+        tool_choice: openaiToolChoice
+      },
+      warnings: [...warnings, ...toolWarnings]
+    };
+  }
+  async doGenerate(options) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n;
+    const { args: body, warnings } = await this.getArgs(options);
+    const {
+      responseHeaders,
+      value: response,
+      rawValue: rawResponse
+    } = await postJsonToApi({
+      url: this.config.url({
+        path: "/chat/completions",
+        modelId: this.modelId
+      }),
+      headers: combineHeaders(this.config.headers(), options.headers),
+      body,
+      failedResponseHandler: openaiFailedResponseHandler,
+      successfulResponseHandler: createJsonResponseHandler(
+        openaiChatResponseSchema
+      ),
+      abortSignal: options.abortSignal,
+      fetch: this.config.fetch
+    });
+    const choice = response.choices[0];
+    const content = [];
+    const text = choice.message.content;
+    if (text != null && text.length > 0) {
+      content.push({ type: "text", text });
+    }
+    for (const toolCall of (_a = choice.message.tool_calls) != null ? _a : []) {
+      content.push({
+        type: "tool-call",
+        toolCallId: (_b = toolCall.id) != null ? _b : generateId(),
+        toolName: toolCall.function.name,
+        input: toolCall.function.arguments
+      });
+    }
+    for (const annotation of (_c = choice.message.annotations) != null ? _c : []) {
+      content.push({
+        type: "source",
+        sourceType: "url",
+        id: generateId(),
+        url: annotation.url,
+        title: annotation.title
+      });
+    }
+    const completionTokenDetails = (_d = response.usage) == null ? void 0 : _d.completion_tokens_details;
+    const promptTokenDetails = (_e = response.usage) == null ? void 0 : _e.prompt_tokens_details;
+    const providerMetadata = { openai: {} };
+    if ((completionTokenDetails == null ? void 0 : completionTokenDetails.accepted_prediction_tokens) != null) {
+      providerMetadata.openai.acceptedPredictionTokens = completionTokenDetails == null ? void 0 : completionTokenDetails.accepted_prediction_tokens;
+    }
+    if ((completionTokenDetails == null ? void 0 : completionTokenDetails.rejected_prediction_tokens) != null) {
+      providerMetadata.openai.rejectedPredictionTokens = completionTokenDetails == null ? void 0 : completionTokenDetails.rejected_prediction_tokens;
+    }
+    if (((_f = choice.logprobs) == null ? void 0 : _f.content) != null) {
+      providerMetadata.openai.logprobs = choice.logprobs.content;
+    }
+    return {
+      content,
+      finishReason: mapOpenAIFinishReason(choice.finish_reason),
+      usage: {
+        inputTokens: (_h = (_g = response.usage) == null ? void 0 : _g.prompt_tokens) != null ? _h : void 0,
+        outputTokens: (_j = (_i = response.usage) == null ? void 0 : _i.completion_tokens) != null ? _j : void 0,
+        totalTokens: (_l = (_k = response.usage) == null ? void 0 : _k.total_tokens) != null ? _l : void 0,
+        reasoningTokens: (_m = completionTokenDetails == null ? void 0 : completionTokenDetails.reasoning_tokens) != null ? _m : void 0,
+        cachedInputTokens: (_n = promptTokenDetails == null ? void 0 : promptTokenDetails.cached_tokens) != null ? _n : void 0
+      },
+      request: { body },
+      response: {
+        ...getResponseMetadata(response),
+        headers: responseHeaders,
+        body: rawResponse
+      },
+      warnings,
+      providerMetadata
+    };
+  }
+  async doStream(options) {
+    const { args, warnings } = await this.getArgs(options);
+    const body = {
+      ...args,
+      stream: true,
+      stream_options: {
+        include_usage: true
+      }
+    };
+    const { responseHeaders, value: response } = await postJsonToApi({
+      url: this.config.url({
+        path: "/chat/completions",
+        modelId: this.modelId
+      }),
+      headers: combineHeaders(this.config.headers(), options.headers),
+      body,
+      failedResponseHandler: openaiFailedResponseHandler,
+      successfulResponseHandler: createEventSourceResponseHandler(
+        openaiChatChunkSchema
+      ),
+      abortSignal: options.abortSignal,
+      fetch: this.config.fetch
+    });
+    const toolCalls = [];
+    let finishReason = "unknown";
+    const usage = {
+      inputTokens: void 0,
+      outputTokens: void 0,
+      totalTokens: void 0
+    };
+    let metadataExtracted = false;
+    let isActiveText = false;
+    const providerMetadata = { openai: {} };
+    return {
+      stream: response.pipeThrough(
+        new TransformStream({
+          start(controller) {
+            controller.enqueue({ type: "stream-start", warnings });
+          },
+          transform(chunk, controller) {
+            var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x;
+            if (options.includeRawChunks) {
+              controller.enqueue({ type: "raw", rawValue: chunk.rawValue });
+            }
+            if (!chunk.success) {
+              finishReason = "error";
+              controller.enqueue({ type: "error", error: chunk.error });
+              return;
+            }
+            const value = chunk.value;
+            if ("error" in value) {
+              finishReason = "error";
+              controller.enqueue({ type: "error", error: value.error });
+              return;
+            }
+            if (!metadataExtracted) {
+              const metadata = getResponseMetadata(value);
+              if (Object.values(metadata).some(Boolean)) {
+                metadataExtracted = true;
+                controller.enqueue({
+                  type: "response-metadata",
+                  ...getResponseMetadata(value)
+                });
+              }
+            }
+            if (value.usage != null) {
+              usage.inputTokens = (_a = value.usage.prompt_tokens) != null ? _a : void 0;
+              usage.outputTokens = (_b = value.usage.completion_tokens) != null ? _b : void 0;
+              usage.totalTokens = (_c = value.usage.total_tokens) != null ? _c : void 0;
+              usage.reasoningTokens = (_e = (_d = value.usage.completion_tokens_details) == null ? void 0 : _d.reasoning_tokens) != null ? _e : void 0;
+              usage.cachedInputTokens = (_g = (_f = value.usage.prompt_tokens_details) == null ? void 0 : _f.cached_tokens) != null ? _g : void 0;
+              if (((_h = value.usage.completion_tokens_details) == null ? void 0 : _h.accepted_prediction_tokens) != null) {
+                providerMetadata.openai.acceptedPredictionTokens = (_i = value.usage.completion_tokens_details) == null ? void 0 : _i.accepted_prediction_tokens;
+              }
+              if (((_j = value.usage.completion_tokens_details) == null ? void 0 : _j.rejected_prediction_tokens) != null) {
+                providerMetadata.openai.rejectedPredictionTokens = (_k = value.usage.completion_tokens_details) == null ? void 0 : _k.rejected_prediction_tokens;
+              }
+            }
+            const choice = value.choices[0];
+            if ((choice == null ? void 0 : choice.finish_reason) != null) {
+              finishReason = mapOpenAIFinishReason(choice.finish_reason);
+            }
+            if (((_l = choice == null ? void 0 : choice.logprobs) == null ? void 0 : _l.content) != null) {
+              providerMetadata.openai.logprobs = choice.logprobs.content;
+            }
+            if ((choice == null ? void 0 : choice.delta) == null) {
+              return;
+            }
+            const delta = choice.delta;
+            if (delta.content != null) {
+              if (!isActiveText) {
+                controller.enqueue({ type: "text-start", id: "0" });
+                isActiveText = true;
+              }
+              controller.enqueue({
+                type: "text-delta",
+                id: "0",
+                delta: delta.content
+              });
+            }
+            if (delta.tool_calls != null) {
+              for (const toolCallDelta of delta.tool_calls) {
+                const index = toolCallDelta.index;
+                if (toolCalls[index] == null) {
+                  if (toolCallDelta.type !== "function") {
+                    throw new InvalidResponseDataError({
+                      data: toolCallDelta,
+                      message: `Expected 'function' type.`
+                    });
+                  }
+                  if (toolCallDelta.id == null) {
+                    throw new InvalidResponseDataError({
+                      data: toolCallDelta,
+                      message: `Expected 'id' to be a string.`
+                    });
+                  }
+                  if (((_m = toolCallDelta.function) == null ? void 0 : _m.name) == null) {
+                    throw new InvalidResponseDataError({
+                      data: toolCallDelta,
+                      message: `Expected 'function.name' to be a string.`
+                    });
+                  }
+                  controller.enqueue({
+                    type: "tool-input-start",
+                    id: toolCallDelta.id,
+                    toolName: toolCallDelta.function.name
+                  });
+                  toolCalls[index] = {
+                    id: toolCallDelta.id,
+                    type: "function",
+                    function: {
+                      name: toolCallDelta.function.name,
+                      arguments: (_n = toolCallDelta.function.arguments) != null ? _n : ""
+                    },
+                    hasFinished: false
+                  };
+                  const toolCall2 = toolCalls[index];
+                  if (((_o = toolCall2.function) == null ? void 0 : _o.name) != null && ((_p = toolCall2.function) == null ? void 0 : _p.arguments) != null) {
+                    if (toolCall2.function.arguments.length > 0) {
+                      controller.enqueue({
+                        type: "tool-input-delta",
+                        id: toolCall2.id,
+                        delta: toolCall2.function.arguments
+                      });
+                    }
+                    if (isParsableJson(toolCall2.function.arguments)) {
+                      controller.enqueue({
+                        type: "tool-input-end",
+                        id: toolCall2.id
+                      });
+                      controller.enqueue({
+                        type: "tool-call",
+                        toolCallId: (_q = toolCall2.id) != null ? _q : generateId(),
+                        toolName: toolCall2.function.name,
+                        input: toolCall2.function.arguments
+                      });
+                      toolCall2.hasFinished = true;
+                    }
+                  }
+                  continue;
+                }
+                const toolCall = toolCalls[index];
+                if (toolCall.hasFinished) {
+                  continue;
+                }
+                if (((_r = toolCallDelta.function) == null ? void 0 : _r.arguments) != null) {
+                  toolCall.function.arguments += (_t = (_s = toolCallDelta.function) == null ? void 0 : _s.arguments) != null ? _t : "";
+                }
+                controller.enqueue({
+                  type: "tool-input-delta",
+                  id: toolCall.id,
+                  delta: (_u = toolCallDelta.function.arguments) != null ? _u : ""
+                });
+                if (((_v = toolCall.function) == null ? void 0 : _v.name) != null && ((_w = toolCall.function) == null ? void 0 : _w.arguments) != null && isParsableJson(toolCall.function.arguments)) {
+                  controller.enqueue({
+                    type: "tool-input-end",
+                    id: toolCall.id
+                  });
+                  controller.enqueue({
+                    type: "tool-call",
+                    toolCallId: (_x = toolCall.id) != null ? _x : generateId(),
+                    toolName: toolCall.function.name,
+                    input: toolCall.function.arguments
+                  });
+                  toolCall.hasFinished = true;
+                }
+              }
+            }
+            if (delta.annotations != null) {
+              for (const annotation of delta.annotations) {
+                controller.enqueue({
+                  type: "source",
+                  sourceType: "url",
+                  id: generateId(),
+                  url: annotation.url,
+                  title: annotation.title
+                });
+              }
+            }
+          },
+          flush(controller) {
+            if (isActiveText) {
+              controller.enqueue({ type: "text-end", id: "0" });
+            }
+            controller.enqueue({
+              type: "finish",
+              finishReason,
+              usage,
+              ...providerMetadata != null ? { providerMetadata } : {}
+            });
+          }
+        })
+      ),
+      request: { body },
+      response: { headers: responseHeaders }
+    };
+  }
+};
+function isReasoningModel(modelId) {
+  return (modelId.startsWith("o") || modelId.startsWith("gpt-5")) && !modelId.startsWith("gpt-5-chat");
+}
+function supportsFlexProcessing(modelId) {
+  return modelId.startsWith("o3") || modelId.startsWith("o4-mini") || modelId.startsWith("gpt-5") && !modelId.startsWith("gpt-5-chat");
+}
+function supportsPriorityProcessing(modelId) {
+  return modelId.startsWith("gpt-4") || modelId.startsWith("gpt-5-mini") || modelId.startsWith("gpt-5") && !modelId.startsWith("gpt-5-nano") && !modelId.startsWith("gpt-5-chat") || modelId.startsWith("o3") || modelId.startsWith("o4-mini");
+}
+function getSystemMessageMode(modelId) {
+  var _a, _b;
+  if (!isReasoningModel(modelId)) {
+    return "system";
+  }
+  return (_b = (_a = reasoningModels[modelId]) == null ? void 0 : _a.systemMessageMode) != null ? _b : "developer";
+}
+var reasoningModels = {
+  o3: {
+    systemMessageMode: "developer"
+  },
+  "o3-2025-04-16": {
+    systemMessageMode: "developer"
+  },
+  "o3-mini": {
+    systemMessageMode: "developer"
+  },
+  "o3-mini-2025-01-31": {
+    systemMessageMode: "developer"
+  },
+  "o4-mini": {
+    systemMessageMode: "developer"
+  },
+  "o4-mini-2025-04-16": {
+    systemMessageMode: "developer"
+  }
+};
+function convertToOpenAICompletionPrompt({
+  prompt,
+  user = "user",
+  assistant = "assistant"
+}) {
+  let text = "";
+  if (prompt[0].role === "system") {
+    text += `${prompt[0].content}
+
+`;
+    prompt = prompt.slice(1);
+  }
+  for (const { role, content } of prompt) {
+    switch (role) {
+      case "system": {
+        throw new InvalidPromptError({
+          message: "Unexpected system message in prompt: ${content}",
+          prompt
+        });
+      }
+      case "user": {
+        const userMessage = content.map((part) => {
+          switch (part.type) {
+            case "text": {
+              return part.text;
+            }
+          }
+        }).filter(Boolean).join("");
+        text += `${user}:
+${userMessage}
+
+`;
+        break;
+      }
+      case "assistant": {
+        const assistantMessage = content.map((part) => {
+          switch (part.type) {
+            case "text": {
+              return part.text;
+            }
+            case "tool-call": {
+              throw new UnsupportedFunctionalityError({
+                functionality: "tool-call messages"
+              });
+            }
+          }
+        }).join("");
+        text += `${assistant}:
+${assistantMessage}
+
+`;
+        break;
+      }
+      case "tool": {
+        throw new UnsupportedFunctionalityError({
+          functionality: "tool messages"
+        });
+      }
+      default: {
+        const _exhaustiveCheck = role;
+        throw new Error(`Unsupported role: ${_exhaustiveCheck}`);
+      }
+    }
+  }
+  text += `${assistant}:
+`;
+  return {
+    prompt: text,
+    stopSequences: [`
+${user}:`]
+  };
+}
+function getResponseMetadata2({
+  id,
+  model,
+  created
+}) {
+  return {
+    id: id != null ? id : void 0,
+    modelId: model != null ? model : void 0,
+    timestamp: created != null ? new Date(created * 1e3) : void 0
+  };
+}
+function mapOpenAIFinishReason2(finishReason) {
+  switch (finishReason) {
+    case "stop":
+      return "stop";
+    case "length":
+      return "length";
+    case "content_filter":
+      return "content-filter";
+    case "function_call":
+    case "tool_calls":
+      return "tool-calls";
+    default:
+      return "unknown";
+  }
+}
+var openaiCompletionResponseSchema = lazyValidator(
+  () => zodSchema(
+    z.object({
+      id: z.string().nullish(),
+      created: z.number().nullish(),
+      model: z.string().nullish(),
+      choices: z.array(
+        z.object({
+          text: z.string(),
+          finish_reason: z.string(),
+          logprobs: z.object({
+            tokens: z.array(z.string()),
+            token_logprobs: z.array(z.number()),
+            top_logprobs: z.array(z.record(z.string(), z.number())).nullish()
+          }).nullish()
+        })
+      ),
+      usage: z.object({
+        prompt_tokens: z.number(),
+        completion_tokens: z.number(),
+        total_tokens: z.number()
+      }).nullish()
+    })
+  )
+);
+var openaiCompletionChunkSchema = lazyValidator(
+  () => zodSchema(
+    z.union([
+      z.object({
+        id: z.string().nullish(),
+        created: z.number().nullish(),
+        model: z.string().nullish(),
+        choices: z.array(
+          z.object({
+            text: z.string(),
+            finish_reason: z.string().nullish(),
+            index: z.number(),
+            logprobs: z.object({
+              tokens: z.array(z.string()),
+              token_logprobs: z.array(z.number()),
+              top_logprobs: z.array(z.record(z.string(), z.number())).nullish()
+            }).nullish()
+          })
+        ),
+        usage: z.object({
+          prompt_tokens: z.number(),
+          completion_tokens: z.number(),
+          total_tokens: z.number()
+        }).nullish()
+      }),
+      openaiErrorDataSchema
+    ])
+  )
+);
+var openaiCompletionProviderOptions = lazyValidator(
+  () => zodSchema(
+    z.object({
+      /**
+      Echo back the prompt in addition to the completion.
+         */
+      echo: z.boolean().optional(),
+      /**
+      Modify the likelihood of specified tokens appearing in the completion.
+      
+      Accepts a JSON object that maps tokens (specified by their token ID in
+      the GPT tokenizer) to an associated bias value from -100 to 100. You
+      can use this tokenizer tool to convert text to token IDs. Mathematically,
+      the bias is added to the logits generated by the model prior to sampling.
+      The exact effect will vary per model, but values between -1 and 1 should
+      decrease or increase likelihood of selection; values like -100 or 100
+      should result in a ban or exclusive selection of the relevant token.
+      
+      As an example, you can pass {"50256": -100} to prevent the <|endoftext|>
+      token from being generated.
+       */
+      logitBias: z.record(z.string(), z.number()).optional(),
+      /**
+      The suffix that comes after a completion of inserted text.
+       */
+      suffix: z.string().optional(),
+      /**
+      A unique identifier representing your end-user, which can help OpenAI to
+      monitor and detect abuse. Learn more.
+       */
+      user: z.string().optional(),
+      /**
+      Return the log probabilities of the tokens. Including logprobs will increase
+      the response size and can slow down response times. However, it can
+      be useful to better understand how the model is behaving.
+      Setting to true will return the log probabilities of the tokens that
+      were generated.
+      Setting to a number will return the log probabilities of the top n
+      tokens that were generated.
+         */
+      logprobs: z.union([z.boolean(), z.number()]).optional()
+    })
+  )
+);
+var OpenAICompletionLanguageModel = class {
+  constructor(modelId, config) {
+    this.specificationVersion = "v2";
+    this.supportedUrls = {
+      // No URLs are supported for completion models.
+    };
+    this.modelId = modelId;
+    this.config = config;
+  }
+  get providerOptionsName() {
+    return this.config.provider.split(".")[0].trim();
+  }
+  get provider() {
+    return this.config.provider;
+  }
+  async getArgs({
+    prompt,
+    maxOutputTokens,
+    temperature,
+    topP,
+    topK,
+    frequencyPenalty,
+    presencePenalty,
+    stopSequences: userStopSequences,
+    responseFormat,
+    tools,
+    toolChoice,
+    seed,
+    providerOptions
+  }) {
+    const warnings = [];
+    const openaiOptions = {
+      ...await parseProviderOptions({
+        provider: "openai",
+        providerOptions,
+        schema: openaiCompletionProviderOptions
+      }),
+      ...await parseProviderOptions({
+        provider: this.providerOptionsName,
+        providerOptions,
+        schema: openaiCompletionProviderOptions
+      })
+    };
+    if (topK != null) {
+      warnings.push({ type: "unsupported-setting", setting: "topK" });
+    }
+    if (tools == null ? void 0 : tools.length) {
+      warnings.push({ type: "unsupported-setting", setting: "tools" });
+    }
+    if (toolChoice != null) {
+      warnings.push({ type: "unsupported-setting", setting: "toolChoice" });
+    }
+    if (responseFormat != null && responseFormat.type !== "text") {
+      warnings.push({
+        type: "unsupported-setting",
+        setting: "responseFormat",
+        details: "JSON response format is not supported."
+      });
+    }
+    const { prompt: completionPrompt, stopSequences } = convertToOpenAICompletionPrompt({ prompt });
+    const stop = [...stopSequences != null ? stopSequences : [], ...userStopSequences != null ? userStopSequences : []];
+    return {
+      args: {
+        // model id:
+        model: this.modelId,
+        // model specific settings:
+        echo: openaiOptions.echo,
+        logit_bias: openaiOptions.logitBias,
+        logprobs: (openaiOptions == null ? void 0 : openaiOptions.logprobs) === true ? 0 : (openaiOptions == null ? void 0 : openaiOptions.logprobs) === false ? void 0 : openaiOptions == null ? void 0 : openaiOptions.logprobs,
+        suffix: openaiOptions.suffix,
+        user: openaiOptions.user,
+        // standardized settings:
+        max_tokens: maxOutputTokens,
+        temperature,
+        top_p: topP,
+        frequency_penalty: frequencyPenalty,
+        presence_penalty: presencePenalty,
+        seed,
+        // prompt:
+        prompt: completionPrompt,
+        // stop sequences:
+        stop: stop.length > 0 ? stop : void 0
+      },
+      warnings
+    };
+  }
+  async doGenerate(options) {
+    var _a, _b, _c;
+    const { args, warnings } = await this.getArgs(options);
+    const {
+      responseHeaders,
+      value: response,
+      rawValue: rawResponse
+    } = await postJsonToApi({
+      url: this.config.url({
+        path: "/completions",
+        modelId: this.modelId
+      }),
+      headers: combineHeaders(this.config.headers(), options.headers),
+      body: args,
+      failedResponseHandler: openaiFailedResponseHandler,
+      successfulResponseHandler: createJsonResponseHandler(
+        openaiCompletionResponseSchema
+      ),
+      abortSignal: options.abortSignal,
+      fetch: this.config.fetch
+    });
+    const choice = response.choices[0];
+    const providerMetadata = { openai: {} };
+    if (choice.logprobs != null) {
+      providerMetadata.openai.logprobs = choice.logprobs;
+    }
+    return {
+      content: [{ type: "text", text: choice.text }],
+      usage: {
+        inputTokens: (_a = response.usage) == null ? void 0 : _a.prompt_tokens,
+        outputTokens: (_b = response.usage) == null ? void 0 : _b.completion_tokens,
+        totalTokens: (_c = response.usage) == null ? void 0 : _c.total_tokens
+      },
+      finishReason: mapOpenAIFinishReason2(choice.finish_reason),
+      request: { body: args },
+      response: {
+        ...getResponseMetadata2(response),
+        headers: responseHeaders,
+        body: rawResponse
+      },
+      providerMetadata,
+      warnings
+    };
+  }
+  async doStream(options) {
+    const { args, warnings } = await this.getArgs(options);
+    const body = {
+      ...args,
+      stream: true,
+      stream_options: {
+        include_usage: true
+      }
+    };
+    const { responseHeaders, value: response } = await postJsonToApi({
+      url: this.config.url({
+        path: "/completions",
+        modelId: this.modelId
+      }),
+      headers: combineHeaders(this.config.headers(), options.headers),
+      body,
+      failedResponseHandler: openaiFailedResponseHandler,
+      successfulResponseHandler: createEventSourceResponseHandler(
+        openaiCompletionChunkSchema
+      ),
+      abortSignal: options.abortSignal,
+      fetch: this.config.fetch
+    });
+    let finishReason = "unknown";
+    const providerMetadata = { openai: {} };
+    const usage = {
+      inputTokens: void 0,
+      outputTokens: void 0,
+      totalTokens: void 0
+    };
+    let isFirstChunk = true;
+    return {
+      stream: response.pipeThrough(
+        new TransformStream({
+          start(controller) {
+            controller.enqueue({ type: "stream-start", warnings });
+          },
+          transform(chunk, controller) {
+            if (options.includeRawChunks) {
+              controller.enqueue({ type: "raw", rawValue: chunk.rawValue });
+            }
+            if (!chunk.success) {
+              finishReason = "error";
+              controller.enqueue({ type: "error", error: chunk.error });
+              return;
+            }
+            const value = chunk.value;
+            if ("error" in value) {
+              finishReason = "error";
+              controller.enqueue({ type: "error", error: value.error });
+              return;
+            }
+            if (isFirstChunk) {
+              isFirstChunk = false;
+              controller.enqueue({
+                type: "response-metadata",
+                ...getResponseMetadata2(value)
+              });
+              controller.enqueue({ type: "text-start", id: "0" });
+            }
+            if (value.usage != null) {
+              usage.inputTokens = value.usage.prompt_tokens;
+              usage.outputTokens = value.usage.completion_tokens;
+              usage.totalTokens = value.usage.total_tokens;
+            }
+            const choice = value.choices[0];
+            if ((choice == null ? void 0 : choice.finish_reason) != null) {
+              finishReason = mapOpenAIFinishReason2(choice.finish_reason);
+            }
+            if ((choice == null ? void 0 : choice.logprobs) != null) {
+              providerMetadata.openai.logprobs = choice.logprobs;
+            }
+            if ((choice == null ? void 0 : choice.text) != null && choice.text.length > 0) {
+              controller.enqueue({
+                type: "text-delta",
+                id: "0",
+                delta: choice.text
+              });
+            }
+          },
+          flush(controller) {
+            if (!isFirstChunk) {
+              controller.enqueue({ type: "text-end", id: "0" });
+            }
+            controller.enqueue({
+              type: "finish",
+              finishReason,
+              providerMetadata,
+              usage
+            });
+          }
+        })
+      ),
+      request: { body },
+      response: { headers: responseHeaders }
+    };
+  }
+};
+var openaiEmbeddingProviderOptions = lazyValidator(
+  () => zodSchema(
+    z.object({
+      /**
+      The number of dimensions the resulting output embeddings should have.
+      Only supported in text-embedding-3 and later models.
+         */
+      dimensions: z.number().optional(),
+      /**
+      A unique identifier representing your end-user, which can help OpenAI to
+      monitor and detect abuse. Learn more.
+      */
+      user: z.string().optional()
+    })
+  )
+);
+var openaiTextEmbeddingResponseSchema = lazyValidator(
+  () => zodSchema(
+    z.object({
+      data: z.array(z.object({ embedding: z.array(z.number()) })),
+      usage: z.object({ prompt_tokens: z.number() }).nullish()
+    })
+  )
+);
+var OpenAIEmbeddingModel = class {
+  constructor(modelId, config) {
+    this.specificationVersion = "v2";
+    this.maxEmbeddingsPerCall = 2048;
+    this.supportsParallelCalls = true;
+    this.modelId = modelId;
+    this.config = config;
+  }
+  get provider() {
+    return this.config.provider;
+  }
+  async doEmbed({
+    values,
+    headers,
+    abortSignal,
+    providerOptions
+  }) {
+    var _a;
+    if (values.length > this.maxEmbeddingsPerCall) {
+      throw new TooManyEmbeddingValuesForCallError({
+        provider: this.provider,
+        modelId: this.modelId,
+        maxEmbeddingsPerCall: this.maxEmbeddingsPerCall,
+        values
+      });
+    }
+    const openaiOptions = (_a = await parseProviderOptions({
+      provider: "openai",
+      providerOptions,
+      schema: openaiEmbeddingProviderOptions
+    })) != null ? _a : {};
+    const {
+      responseHeaders,
+      value: response,
+      rawValue
+    } = await postJsonToApi({
+      url: this.config.url({
+        path: "/embeddings",
+        modelId: this.modelId
+      }),
+      headers: combineHeaders(this.config.headers(), headers),
+      body: {
+        model: this.modelId,
+        input: values,
+        encoding_format: "float",
+        dimensions: openaiOptions.dimensions,
+        user: openaiOptions.user
+      },
+      failedResponseHandler: openaiFailedResponseHandler,
+      successfulResponseHandler: createJsonResponseHandler(
+        openaiTextEmbeddingResponseSchema
+      ),
+      abortSignal,
+      fetch: this.config.fetch
+    });
+    return {
+      embeddings: response.data.map((item) => item.embedding),
+      usage: response.usage ? { tokens: response.usage.prompt_tokens } : void 0,
+      response: { headers: responseHeaders, body: rawValue }
+    };
+  }
+};
+var openaiImageResponseSchema = lazyValidator(
+  () => zodSchema(
+    z.object({
+      data: z.array(
+        z.object({
+          b64_json: z.string(),
+          revised_prompt: z.string().nullish()
+        })
+      )
+    })
+  )
+);
+var modelMaxImagesPerCall = {
+  "dall-e-3": 1,
+  "dall-e-2": 10,
+  "gpt-image-1": 10,
+  "gpt-image-1-mini": 10
+};
+var hasDefaultResponseFormat = /* @__PURE__ */ new Set([
+  "gpt-image-1",
+  "gpt-image-1-mini"
+]);
+var OpenAIImageModel = class {
+  constructor(modelId, config) {
+    this.modelId = modelId;
+    this.config = config;
+    this.specificationVersion = "v2";
+  }
+  get maxImagesPerCall() {
+    var _a;
+    return (_a = modelMaxImagesPerCall[this.modelId]) != null ? _a : 1;
+  }
+  get provider() {
+    return this.config.provider;
+  }
+  async doGenerate({
+    prompt,
+    n,
+    size,
+    aspectRatio,
+    seed,
+    providerOptions,
+    headers,
+    abortSignal
+  }) {
+    var _a, _b, _c, _d;
+    const warnings = [];
+    if (aspectRatio != null) {
+      warnings.push({
+        type: "unsupported-setting",
+        setting: "aspectRatio",
+        details: "This model does not support aspect ratio. Use `size` instead."
+      });
+    }
+    if (seed != null) {
+      warnings.push({ type: "unsupported-setting", setting: "seed" });
+    }
+    const currentDate = (_c = (_b = (_a = this.config._internal) == null ? void 0 : _a.currentDate) == null ? void 0 : _b.call(_a)) != null ? _c : /* @__PURE__ */ new Date();
+    const { value: response, responseHeaders } = await postJsonToApi({
+      url: this.config.url({
+        path: "/images/generations",
+        modelId: this.modelId
+      }),
+      headers: combineHeaders(this.config.headers(), headers),
+      body: {
+        model: this.modelId,
+        prompt,
+        n,
+        size,
+        ...(_d = providerOptions.openai) != null ? _d : {},
+        ...!hasDefaultResponseFormat.has(this.modelId) ? { response_format: "b64_json" } : {}
+      },
+      failedResponseHandler: openaiFailedResponseHandler,
+      successfulResponseHandler: createJsonResponseHandler(
+        openaiImageResponseSchema
+      ),
+      abortSignal,
+      fetch: this.config.fetch
+    });
+    return {
+      images: response.data.map((item) => item.b64_json),
+      warnings,
+      response: {
+        timestamp: currentDate,
+        modelId: this.modelId,
+        headers: responseHeaders
+      },
+      providerMetadata: {
+        openai: {
+          images: response.data.map(
+            (item) => item.revised_prompt ? {
+              revisedPrompt: item.revised_prompt
+            } : null
+          )
+        }
+      }
+    };
+  }
+};
+var openaiTranscriptionResponseSchema = lazyValidator(
+  () => zodSchema(
+    z.object({
+      text: z.string(),
+      language: z.string().nullish(),
+      duration: z.number().nullish(),
+      words: z.array(
+        z.object({
+          word: z.string(),
+          start: z.number(),
+          end: z.number()
+        })
+      ).nullish(),
+      segments: z.array(
+        z.object({
+          id: z.number(),
+          seek: z.number(),
+          start: z.number(),
+          end: z.number(),
+          text: z.string(),
+          tokens: z.array(z.number()),
+          temperature: z.number(),
+          avg_logprob: z.number(),
+          compression_ratio: z.number(),
+          no_speech_prob: z.number()
+        })
+      ).nullish()
+    })
+  )
+);
+var openAITranscriptionProviderOptions = lazyValidator(
+  () => zodSchema(
+    z.object({
+      /**
+       * Additional information to include in the transcription response.
+       */
+      include: z.array(z.string()).optional(),
+      /**
+       * The language of the input audio in ISO-639-1 format.
+       */
+      language: z.string().optional(),
+      /**
+       * An optional text to guide the model's style or continue a previous audio segment.
+       */
+      prompt: z.string().optional(),
+      /**
+       * The sampling temperature, between 0 and 1.
+       * @default 0
+       */
+      temperature: z.number().min(0).max(1).default(0).optional(),
+      /**
+       * The timestamp granularities to populate for this transcription.
+       * @default ['segment']
+       */
+      timestampGranularities: z.array(z.enum(["word", "segment"])).default(["segment"]).optional()
+    })
+  )
+);
+var languageMap = {
+  afrikaans: "af",
+  arabic: "ar",
+  armenian: "hy",
+  azerbaijani: "az",
+  belarusian: "be",
+  bosnian: "bs",
+  bulgarian: "bg",
+  catalan: "ca",
+  chinese: "zh",
+  croatian: "hr",
+  czech: "cs",
+  danish: "da",
+  dutch: "nl",
+  english: "en",
+  estonian: "et",
+  finnish: "fi",
+  french: "fr",
+  galician: "gl",
+  german: "de",
+  greek: "el",
+  hebrew: "he",
+  hindi: "hi",
+  hungarian: "hu",
+  icelandic: "is",
+  indonesian: "id",
+  italian: "it",
+  japanese: "ja",
+  kannada: "kn",
+  kazakh: "kk",
+  korean: "ko",
+  latvian: "lv",
+  lithuanian: "lt",
+  macedonian: "mk",
+  malay: "ms",
+  marathi: "mr",
+  maori: "mi",
+  nepali: "ne",
+  norwegian: "no",
+  persian: "fa",
+  polish: "pl",
+  portuguese: "pt",
+  romanian: "ro",
+  russian: "ru",
+  serbian: "sr",
+  slovak: "sk",
+  slovenian: "sl",
+  spanish: "es",
+  swahili: "sw",
+  swedish: "sv",
+  tagalog: "tl",
+  tamil: "ta",
+  thai: "th",
+  turkish: "tr",
+  ukrainian: "uk",
+  urdu: "ur",
+  vietnamese: "vi",
+  welsh: "cy"
+};
+var OpenAITranscriptionModel = class {
+  constructor(modelId, config) {
+    this.modelId = modelId;
+    this.config = config;
+    this.specificationVersion = "v2";
+  }
+  get provider() {
+    return this.config.provider;
+  }
+  async getArgs({
+    audio,
+    mediaType,
+    providerOptions
+  }) {
+    const warnings = [];
+    const openAIOptions = await parseProviderOptions({
+      provider: "openai",
+      providerOptions,
+      schema: openAITranscriptionProviderOptions
+    });
+    const formData = new FormData();
+    const blob = audio instanceof Uint8Array ? new Blob([audio]) : new Blob([convertBase64ToUint8Array(audio)]);
+    formData.append("model", this.modelId);
+    const fileExtension = mediaTypeToExtension(mediaType);
+    formData.append(
+      "file",
+      new File([blob], "audio", { type: mediaType }),
+      `audio.${fileExtension}`
+    );
+    if (openAIOptions) {
+      const transcriptionModelOptions = {
+        include: openAIOptions.include,
+        language: openAIOptions.language,
+        prompt: openAIOptions.prompt,
+        // https://platform.openai.com/docs/api-reference/audio/createTranscription#audio_createtranscription-response_format
+        // prefer verbose_json to get segments for models that support it
+        response_format: [
+          "gpt-4o-transcribe",
+          "gpt-4o-mini-transcribe"
+        ].includes(this.modelId) ? "json" : "verbose_json",
+        temperature: openAIOptions.temperature,
+        timestamp_granularities: openAIOptions.timestampGranularities
+      };
+      for (const [key, value] of Object.entries(transcriptionModelOptions)) {
+        if (value != null) {
+          if (Array.isArray(value)) {
+            for (const item of value) {
+              formData.append(`${key}[]`, String(item));
+            }
+          } else {
+            formData.append(key, String(value));
+          }
+        }
+      }
+    }
+    return {
+      formData,
+      warnings
+    };
+  }
+  async doGenerate(options) {
+    var _a, _b, _c, _d, _e, _f, _g, _h;
+    const currentDate = (_c = (_b = (_a = this.config._internal) == null ? void 0 : _a.currentDate) == null ? void 0 : _b.call(_a)) != null ? _c : /* @__PURE__ */ new Date();
+    const { formData, warnings } = await this.getArgs(options);
+    const {
+      value: response,
+      responseHeaders,
+      rawValue: rawResponse
+    } = await postFormDataToApi({
+      url: this.config.url({
+        path: "/audio/transcriptions",
+        modelId: this.modelId
+      }),
+      headers: combineHeaders(this.config.headers(), options.headers),
+      formData,
+      failedResponseHandler: openaiFailedResponseHandler,
+      successfulResponseHandler: createJsonResponseHandler(
+        openaiTranscriptionResponseSchema
+      ),
+      abortSignal: options.abortSignal,
+      fetch: this.config.fetch
+    });
+    const language = response.language != null && response.language in languageMap ? languageMap[response.language] : void 0;
+    return {
+      text: response.text,
+      segments: (_g = (_f = (_d = response.segments) == null ? void 0 : _d.map((segment) => ({
+        text: segment.text,
+        startSecond: segment.start,
+        endSecond: segment.end
+      }))) != null ? _f : (_e = response.words) == null ? void 0 : _e.map((word) => ({
+        text: word.word,
+        startSecond: word.start,
+        endSecond: word.end
+      }))) != null ? _g : [],
+      language,
+      durationInSeconds: (_h = response.duration) != null ? _h : void 0,
+      warnings,
+      response: {
+        timestamp: currentDate,
+        modelId: this.modelId,
+        headers: responseHeaders,
+        body: rawResponse
+      }
+    };
+  }
+};
+var openaiSpeechProviderOptionsSchema = lazyValidator(
+  () => zodSchema(
+    z.object({
+      instructions: z.string().nullish(),
+      speed: z.number().min(0.25).max(4).default(1).nullish()
+    })
+  )
+);
+var OpenAISpeechModel = class {
+  constructor(modelId, config) {
+    this.modelId = modelId;
+    this.config = config;
+    this.specificationVersion = "v2";
+  }
+  get provider() {
+    return this.config.provider;
+  }
+  async getArgs({
+    text,
+    voice = "alloy",
+    outputFormat = "mp3",
+    speed,
+    instructions,
+    language,
+    providerOptions
+  }) {
+    const warnings = [];
+    const openAIOptions = await parseProviderOptions({
+      provider: "openai",
+      providerOptions,
+      schema: openaiSpeechProviderOptionsSchema
+    });
+    const requestBody = {
+      model: this.modelId,
+      input: text,
+      voice,
+      response_format: "mp3",
+      speed,
+      instructions
+    };
+    if (outputFormat) {
+      if (["mp3", "opus", "aac", "flac", "wav", "pcm"].includes(outputFormat)) {
+        requestBody.response_format = outputFormat;
+      } else {
+        warnings.push({
+          type: "unsupported-setting",
+          setting: "outputFormat",
+          details: `Unsupported output format: ${outputFormat}. Using mp3 instead.`
+        });
+      }
+    }
+    if (openAIOptions) {
+      const speechModelOptions = {};
+      for (const key in speechModelOptions) {
+        const value = speechModelOptions[key];
+        if (value !== void 0) {
+          requestBody[key] = value;
+        }
+      }
+    }
+    if (language) {
+      warnings.push({
+        type: "unsupported-setting",
+        setting: "language",
+        details: `OpenAI speech models do not support language selection. Language parameter "${language}" was ignored.`
+      });
+    }
+    return {
+      requestBody,
+      warnings
+    };
+  }
+  async doGenerate(options) {
+    var _a, _b, _c;
+    const currentDate = (_c = (_b = (_a = this.config._internal) == null ? void 0 : _a.currentDate) == null ? void 0 : _b.call(_a)) != null ? _c : /* @__PURE__ */ new Date();
+    const { requestBody, warnings } = await this.getArgs(options);
+    const {
+      value: audio,
+      responseHeaders,
+      rawValue: rawResponse
+    } = await postJsonToApi({
+      url: this.config.url({
+        path: "/audio/speech",
+        modelId: this.modelId
+      }),
+      headers: combineHeaders(this.config.headers(), options.headers),
+      body: requestBody,
+      failedResponseHandler: openaiFailedResponseHandler,
+      successfulResponseHandler: createBinaryResponseHandler(),
+      abortSignal: options.abortSignal,
+      fetch: this.config.fetch
+    });
+    return {
+      audio,
+      warnings,
+      request: {
+        body: JSON.stringify(requestBody)
+      },
+      response: {
+        timestamp: currentDate,
+        modelId: this.modelId,
+        headers: responseHeaders,
+        body: rawResponse
+      }
+    };
+  }
+};
+var localShellInputSchema = lazySchema(
+  () => zodSchema(
+    z.object({
+      action: z.object({
+        type: z.literal("exec"),
+        command: z.array(z.string()),
+        timeoutMs: z.number().optional(),
+        user: z.string().optional(),
+        workingDirectory: z.string().optional(),
+        env: z.record(z.string(), z.string()).optional()
+      })
+    })
+  )
+);
+var localShellOutputSchema = lazySchema(
+  () => zodSchema(z.object({ output: z.string() }))
+);
+createProviderDefinedToolFactoryWithOutputSchema({
+  id: "openai.local_shell",
+  name: "local_shell",
+  inputSchema: localShellInputSchema,
+  outputSchema: localShellOutputSchema
+});
+function isFileId(data, prefixes) {
+  if (!prefixes) return false;
+  return prefixes.some((prefix) => data.startsWith(prefix));
+}
+async function convertToOpenAIResponsesInput({
+  prompt,
+  systemMessageMode,
+  fileIdPrefixes,
+  store,
+  hasLocalShellTool = false
+}) {
+  var _a, _b, _c, _d;
+  const input = [];
+  const warnings = [];
+  for (const { role, content } of prompt) {
+    switch (role) {
+      case "system": {
+        switch (systemMessageMode) {
+          case "system": {
+            input.push({ role: "system", content });
+            break;
+          }
+          case "developer": {
+            input.push({ role: "developer", content });
+            break;
+          }
+          case "remove": {
+            warnings.push({
+              type: "other",
+              message: "system messages are removed for this model"
+            });
+            break;
+          }
+          default: {
+            const _exhaustiveCheck = systemMessageMode;
+            throw new Error(
+              `Unsupported system message mode: ${_exhaustiveCheck}`
+            );
+          }
+        }
+        break;
+      }
+      case "user": {
+        input.push({
+          role: "user",
+          content: content.map((part, index) => {
+            var _a2, _b2, _c2;
+            switch (part.type) {
+              case "text": {
+                return { type: "input_text", text: part.text };
+              }
+              case "file": {
+                if (part.mediaType.startsWith("image/")) {
+                  const mediaType = part.mediaType === "image/*" ? "image/jpeg" : part.mediaType;
+                  return {
+                    type: "input_image",
+                    ...part.data instanceof URL ? { image_url: part.data.toString() } : typeof part.data === "string" && isFileId(part.data, fileIdPrefixes) ? { file_id: part.data } : {
+                      image_url: `data:${mediaType};base64,${convertToBase64(part.data)}`
+                    },
+                    detail: (_b2 = (_a2 = part.providerOptions) == null ? void 0 : _a2.openai) == null ? void 0 : _b2.imageDetail
+                  };
+                } else if (part.mediaType === "application/pdf") {
+                  if (part.data instanceof URL) {
+                    return {
+                      type: "input_file",
+                      file_url: part.data.toString()
+                    };
+                  }
+                  return {
+                    type: "input_file",
+                    ...typeof part.data === "string" && isFileId(part.data, fileIdPrefixes) ? { file_id: part.data } : {
+                      filename: (_c2 = part.filename) != null ? _c2 : `part-${index}.pdf`,
+                      file_data: `data:application/pdf;base64,${convertToBase64(part.data)}`
+                    }
+                  };
+                } else {
+                  throw new UnsupportedFunctionalityError({
+                    functionality: `file part media type ${part.mediaType}`
+                  });
+                }
+              }
+            }
+          })
+        });
+        break;
+      }
+      case "assistant": {
+        const reasoningMessages = {};
+        for (const part of content) {
+          switch (part.type) {
+            case "text": {
+              const id = (_b = (_a = part.providerOptions) == null ? void 0 : _a.openai) == null ? void 0 : _b.itemId;
+              if (store && id != null) {
+                input.push({ type: "item_reference", id });
+                break;
+              }
+              input.push({
+                role: "assistant",
+                content: [{ type: "output_text", text: part.text }],
+                id
+              });
+              break;
+            }
+            case "tool-call": {
+              if (part.providerExecuted) {
+                break;
+              }
+              const id = (_d = (_c = part.providerOptions) == null ? void 0 : _c.openai) == null ? void 0 : _d.itemId;
+              if (store && id != null) {
+                input.push({ type: "item_reference", id });
+                break;
+              }
+              if (hasLocalShellTool && part.toolName === "local_shell") {
+                const parsedInput = await validateTypes({
+                  value: part.input,
+                  schema: localShellInputSchema
+                });
+                input.push({
+                  type: "local_shell_call",
+                  call_id: part.toolCallId,
+                  id,
+                  action: {
+                    type: "exec",
+                    command: parsedInput.action.command,
+                    timeout_ms: parsedInput.action.timeoutMs,
+                    user: parsedInput.action.user,
+                    working_directory: parsedInput.action.workingDirectory,
+                    env: parsedInput.action.env
+                  }
+                });
+                break;
+              }
+              input.push({
+                type: "function_call",
+                call_id: part.toolCallId,
+                name: part.toolName,
+                arguments: JSON.stringify(part.input),
+                id
+              });
+              break;
+            }
+            // assistant tool result parts are from provider-executed tools:
+            case "tool-result": {
+              if (store) {
+                input.push({ type: "item_reference", id: part.toolCallId });
+              } else {
+                warnings.push({
+                  type: "other",
+                  message: `Results for OpenAI tool ${part.toolName} are not sent to the API when store is false`
+                });
+              }
+              break;
+            }
+            case "reasoning": {
+              const providerOptions = await parseProviderOptions({
+                provider: "openai",
+                providerOptions: part.providerOptions,
+                schema: openaiResponsesReasoningProviderOptionsSchema
+              });
+              const reasoningId = providerOptions == null ? void 0 : providerOptions.itemId;
+              if (reasoningId != null) {
+                const reasoningMessage = reasoningMessages[reasoningId];
+                if (store) {
+                  if (reasoningMessage === void 0) {
+                    input.push({ type: "item_reference", id: reasoningId });
+                    reasoningMessages[reasoningId] = {
+                      type: "reasoning",
+                      id: reasoningId,
+                      summary: []
+                    };
+                  }
+                } else {
+                  const summaryParts = [];
+                  if (part.text.length > 0) {
+                    summaryParts.push({
+                      type: "summary_text",
+                      text: part.text
+                    });
+                  } else if (reasoningMessage !== void 0) {
+                    warnings.push({
+                      type: "other",
+                      message: `Cannot append empty reasoning part to existing reasoning sequence. Skipping reasoning part: ${JSON.stringify(part)}.`
+                    });
+                  }
+                  if (reasoningMessage === void 0) {
+                    reasoningMessages[reasoningId] = {
+                      type: "reasoning",
+                      id: reasoningId,
+                      encrypted_content: providerOptions == null ? void 0 : providerOptions.reasoningEncryptedContent,
+                      summary: summaryParts
+                    };
+                    input.push(reasoningMessages[reasoningId]);
+                  } else {
+                    reasoningMessage.summary.push(...summaryParts);
+                    if ((providerOptions == null ? void 0 : providerOptions.reasoningEncryptedContent) != null) {
+                      reasoningMessage.encrypted_content = providerOptions.reasoningEncryptedContent;
+                    }
+                  }
+                }
+              } else {
+                warnings.push({
+                  type: "other",
+                  message: `Non-OpenAI reasoning parts are not supported. Skipping reasoning part: ${JSON.stringify(part)}.`
+                });
+              }
+              break;
+            }
+          }
+        }
+        break;
+      }
+      case "tool": {
+        for (const part of content) {
+          const output = part.output;
+          if (hasLocalShellTool && part.toolName === "local_shell" && output.type === "json") {
+            const parsedOutput = await validateTypes({
+              value: output.value,
+              schema: localShellOutputSchema
+            });
+            input.push({
+              type: "local_shell_call_output",
+              call_id: part.toolCallId,
+              output: parsedOutput.output
+            });
+            break;
+          }
+          let contentValue;
+          switch (output.type) {
+            case "text":
+            case "error-text":
+              contentValue = output.value;
+              break;
+            case "json":
+            case "error-json":
+              contentValue = JSON.stringify(output.value);
+              break;
+            case "content":
+              contentValue = output.value.map((item) => {
+                switch (item.type) {
+                  case "text": {
+                    return { type: "input_text", text: item.text };
+                  }
+                  case "media": {
+                    return item.mediaType.startsWith("image/") ? {
+                      type: "input_image",
+                      image_url: `data:${item.mediaType};base64,${item.data}`
+                    } : {
+                      type: "input_file",
+                      filename: "data",
+                      file_data: `data:${item.mediaType};base64,${item.data}`
+                    };
+                  }
+                }
+              });
+              break;
+          }
+          input.push({
+            type: "function_call_output",
+            call_id: part.toolCallId,
+            output: contentValue
+          });
+        }
+        break;
+      }
+      default: {
+        const _exhaustiveCheck = role;
+        throw new Error(`Unsupported role: ${_exhaustiveCheck}`);
+      }
+    }
+  }
+  return { input, warnings };
+}
+var openaiResponsesReasoningProviderOptionsSchema = z.object({
+  itemId: z.string().nullish(),
+  reasoningEncryptedContent: z.string().nullish()
+});
+function mapOpenAIResponseFinishReason({
+  finishReason,
+  hasFunctionCall
+}) {
+  switch (finishReason) {
+    case void 0:
+    case null:
+      return hasFunctionCall ? "tool-calls" : "stop";
+    case "max_output_tokens":
+      return "length";
+    case "content_filter":
+      return "content-filter";
+    default:
+      return hasFunctionCall ? "tool-calls" : "unknown";
+  }
+}
+var openaiResponsesChunkSchema = lazyValidator(
+  () => zodSchema(
+    z.union([
+      z.object({
+        type: z.literal("response.output_text.delta"),
+        item_id: z.string(),
+        delta: z.string(),
+        logprobs: z.array(
+          z.object({
+            token: z.string(),
+            logprob: z.number(),
+            top_logprobs: z.array(
+              z.object({
+                token: z.string(),
+                logprob: z.number()
+              })
+            )
+          })
+        ).nullish()
+      }),
+      z.object({
+        type: z.enum(["response.completed", "response.incomplete"]),
+        response: z.object({
+          incomplete_details: z.object({ reason: z.string() }).nullish(),
+          usage: z.object({
+            input_tokens: z.number(),
+            input_tokens_details: z.object({ cached_tokens: z.number().nullish() }).nullish(),
+            output_tokens: z.number(),
+            output_tokens_details: z.object({ reasoning_tokens: z.number().nullish() }).nullish()
+          }),
+          service_tier: z.string().nullish()
+        })
+      }),
+      z.object({
+        type: z.literal("response.created"),
+        response: z.object({
+          id: z.string(),
+          created_at: z.number(),
+          model: z.string(),
+          service_tier: z.string().nullish()
+        })
+      }),
+      z.object({
+        type: z.literal("response.output_item.added"),
+        output_index: z.number(),
+        item: z.discriminatedUnion("type", [
+          z.object({
+            type: z.literal("message"),
+            id: z.string()
+          }),
+          z.object({
+            type: z.literal("reasoning"),
+            id: z.string(),
+            encrypted_content: z.string().nullish()
+          }),
+          z.object({
+            type: z.literal("function_call"),
+            id: z.string(),
+            call_id: z.string(),
+            name: z.string(),
+            arguments: z.string()
+          }),
+          z.object({
+            type: z.literal("web_search_call"),
+            id: z.string(),
+            status: z.string()
+          }),
+          z.object({
+            type: z.literal("computer_call"),
+            id: z.string(),
+            status: z.string()
+          }),
+          z.object({
+            type: z.literal("file_search_call"),
+            id: z.string()
+          }),
+          z.object({
+            type: z.literal("image_generation_call"),
+            id: z.string()
+          }),
+          z.object({
+            type: z.literal("code_interpreter_call"),
+            id: z.string(),
+            container_id: z.string(),
+            code: z.string().nullable(),
+            outputs: z.array(
+              z.discriminatedUnion("type", [
+                z.object({ type: z.literal("logs"), logs: z.string() }),
+                z.object({ type: z.literal("image"), url: z.string() })
+              ])
+            ).nullable(),
+            status: z.string()
+          })
+        ])
+      }),
+      z.object({
+        type: z.literal("response.output_item.done"),
+        output_index: z.number(),
+        item: z.discriminatedUnion("type", [
+          z.object({
+            type: z.literal("message"),
+            id: z.string()
+          }),
+          z.object({
+            type: z.literal("reasoning"),
+            id: z.string(),
+            encrypted_content: z.string().nullish()
+          }),
+          z.object({
+            type: z.literal("function_call"),
+            id: z.string(),
+            call_id: z.string(),
+            name: z.string(),
+            arguments: z.string(),
+            status: z.literal("completed")
+          }),
+          z.object({
+            type: z.literal("code_interpreter_call"),
+            id: z.string(),
+            code: z.string().nullable(),
+            container_id: z.string(),
+            outputs: z.array(
+              z.discriminatedUnion("type", [
+                z.object({ type: z.literal("logs"), logs: z.string() }),
+                z.object({ type: z.literal("image"), url: z.string() })
+              ])
+            ).nullable()
+          }),
+          z.object({
+            type: z.literal("image_generation_call"),
+            id: z.string(),
+            result: z.string()
+          }),
+          z.object({
+            type: z.literal("web_search_call"),
+            id: z.string(),
+            status: z.string(),
+            action: z.discriminatedUnion("type", [
+              z.object({
+                type: z.literal("search"),
+                query: z.string().nullish(),
+                sources: z.array(
+                  z.discriminatedUnion("type", [
+                    z.object({ type: z.literal("url"), url: z.string() }),
+                    z.object({ type: z.literal("api"), name: z.string() })
+                  ])
+                ).nullish()
+              }),
+              z.object({
+                type: z.literal("open_page"),
+                url: z.string()
+              }),
+              z.object({
+                type: z.literal("find"),
+                url: z.string(),
+                pattern: z.string()
+              })
+            ])
+          }),
+          z.object({
+            type: z.literal("file_search_call"),
+            id: z.string(),
+            queries: z.array(z.string()),
+            results: z.array(
+              z.object({
+                attributes: z.record(z.string(), z.unknown()),
+                file_id: z.string(),
+                filename: z.string(),
+                score: z.number(),
+                text: z.string()
+              })
+            ).nullish()
+          }),
+          z.object({
+            type: z.literal("local_shell_call"),
+            id: z.string(),
+            call_id: z.string(),
+            action: z.object({
+              type: z.literal("exec"),
+              command: z.array(z.string()),
+              timeout_ms: z.number().optional(),
+              user: z.string().optional(),
+              working_directory: z.string().optional(),
+              env: z.record(z.string(), z.string()).optional()
+            })
+          }),
+          z.object({
+            type: z.literal("computer_call"),
+            id: z.string(),
+            status: z.literal("completed")
+          })
+        ])
+      }),
+      z.object({
+        type: z.literal("response.function_call_arguments.delta"),
+        item_id: z.string(),
+        output_index: z.number(),
+        delta: z.string()
+      }),
+      z.object({
+        type: z.literal("response.image_generation_call.partial_image"),
+        item_id: z.string(),
+        output_index: z.number(),
+        partial_image_b64: z.string()
+      }),
+      z.object({
+        type: z.literal("response.code_interpreter_call_code.delta"),
+        item_id: z.string(),
+        output_index: z.number(),
+        delta: z.string()
+      }),
+      z.object({
+        type: z.literal("response.code_interpreter_call_code.done"),
+        item_id: z.string(),
+        output_index: z.number(),
+        code: z.string()
+      }),
+      z.object({
+        type: z.literal("response.output_text.annotation.added"),
+        annotation: z.discriminatedUnion("type", [
+          z.object({
+            type: z.literal("url_citation"),
+            start_index: z.number(),
+            end_index: z.number(),
+            url: z.string(),
+            title: z.string()
+          }),
+          z.object({
+            type: z.literal("file_citation"),
+            file_id: z.string(),
+            filename: z.string().nullish(),
+            index: z.number().nullish(),
+            start_index: z.number().nullish(),
+            end_index: z.number().nullish(),
+            quote: z.string().nullish()
+          })
+        ])
+      }),
+      z.object({
+        type: z.literal("response.reasoning_summary_part.added"),
+        item_id: z.string(),
+        summary_index: z.number()
+      }),
+      z.object({
+        type: z.literal("response.reasoning_summary_text.delta"),
+        item_id: z.string(),
+        summary_index: z.number(),
+        delta: z.string()
+      }),
+      z.object({
+        type: z.literal("response.reasoning_summary_part.done"),
+        item_id: z.string(),
+        summary_index: z.number()
+      }),
+      z.object({
+        type: z.literal("error"),
+        sequence_number: z.number(),
+        error: z.object({
+          type: z.string(),
+          code: z.string(),
+          message: z.string(),
+          param: z.string().nullish()
+        })
+      }),
+      z.object({ type: z.string() }).loose().transform((value) => ({
+        type: "unknown_chunk",
+        message: value.type
+      }))
+      // fallback for unknown chunks
+    ])
+  )
+);
+var openaiResponsesResponseSchema = lazyValidator(
+  () => zodSchema(
+    z.object({
+      id: z.string().optional(),
+      created_at: z.number().optional(),
+      error: z.object({
+        message: z.string(),
+        type: z.string(),
+        param: z.string().nullish(),
+        code: z.string()
+      }).nullish(),
+      model: z.string().optional(),
+      output: z.array(
+        z.discriminatedUnion("type", [
+          z.object({
+            type: z.literal("message"),
+            role: z.literal("assistant"),
+            id: z.string(),
+            content: z.array(
+              z.object({
+                type: z.literal("output_text"),
+                text: z.string(),
+                logprobs: z.array(
+                  z.object({
+                    token: z.string(),
+                    logprob: z.number(),
+                    top_logprobs: z.array(
+                      z.object({
+                        token: z.string(),
+                        logprob: z.number()
+                      })
+                    )
+                  })
+                ).nullish(),
+                annotations: z.array(
+                  z.discriminatedUnion("type", [
+                    z.object({
+                      type: z.literal("url_citation"),
+                      start_index: z.number(),
+                      end_index: z.number(),
+                      url: z.string(),
+                      title: z.string()
+                    }),
+                    z.object({
+                      type: z.literal("file_citation"),
+                      file_id: z.string(),
+                      filename: z.string().nullish(),
+                      index: z.number().nullish(),
+                      start_index: z.number().nullish(),
+                      end_index: z.number().nullish(),
+                      quote: z.string().nullish()
+                    }),
+                    z.object({
+                      type: z.literal("container_file_citation"),
+                      container_id: z.string(),
+                      file_id: z.string(),
+                      filename: z.string().nullish(),
+                      start_index: z.number().nullish(),
+                      end_index: z.number().nullish(),
+                      index: z.number().nullish()
+                    }),
+                    z.object({
+                      type: z.literal("file_path"),
+                      file_id: z.string(),
+                      index: z.number().nullish()
+                    })
+                  ])
+                )
+              })
+            )
+          }),
+          z.object({
+            type: z.literal("web_search_call"),
+            id: z.string(),
+            status: z.string(),
+            action: z.discriminatedUnion("type", [
+              z.object({
+                type: z.literal("search"),
+                query: z.string().nullish(),
+                sources: z.array(
+                  z.discriminatedUnion("type", [
+                    z.object({ type: z.literal("url"), url: z.string() }),
+                    z.object({ type: z.literal("api"), name: z.string() })
+                  ])
+                ).nullish()
+              }),
+              z.object({
+                type: z.literal("open_page"),
+                url: z.string()
+              }),
+              z.object({
+                type: z.literal("find"),
+                url: z.string(),
+                pattern: z.string()
+              })
+            ])
+          }),
+          z.object({
+            type: z.literal("file_search_call"),
+            id: z.string(),
+            queries: z.array(z.string()),
+            results: z.array(
+              z.object({
+                attributes: z.record(
+                  z.string(),
+                  z.union([z.string(), z.number(), z.boolean()])
+                ),
+                file_id: z.string(),
+                filename: z.string(),
+                score: z.number(),
+                text: z.string()
+              })
+            ).nullish()
+          }),
+          z.object({
+            type: z.literal("code_interpreter_call"),
+            id: z.string(),
+            code: z.string().nullable(),
+            container_id: z.string(),
+            outputs: z.array(
+              z.discriminatedUnion("type", [
+                z.object({ type: z.literal("logs"), logs: z.string() }),
+                z.object({ type: z.literal("image"), url: z.string() })
+              ])
+            ).nullable()
+          }),
+          z.object({
+            type: z.literal("image_generation_call"),
+            id: z.string(),
+            result: z.string()
+          }),
+          z.object({
+            type: z.literal("local_shell_call"),
+            id: z.string(),
+            call_id: z.string(),
+            action: z.object({
+              type: z.literal("exec"),
+              command: z.array(z.string()),
+              timeout_ms: z.number().optional(),
+              user: z.string().optional(),
+              working_directory: z.string().optional(),
+              env: z.record(z.string(), z.string()).optional()
+            })
+          }),
+          z.object({
+            type: z.literal("function_call"),
+            call_id: z.string(),
+            name: z.string(),
+            arguments: z.string(),
+            id: z.string()
+          }),
+          z.object({
+            type: z.literal("computer_call"),
+            id: z.string(),
+            status: z.string().optional()
+          }),
+          z.object({
+            type: z.literal("reasoning"),
+            id: z.string(),
+            encrypted_content: z.string().nullish(),
+            summary: z.array(
+              z.object({
+                type: z.literal("summary_text"),
+                text: z.string()
+              })
+            )
+          })
+        ])
+      ).optional(),
+      service_tier: z.string().nullish(),
+      incomplete_details: z.object({ reason: z.string() }).nullish(),
+      usage: z.object({
+        input_tokens: z.number(),
+        input_tokens_details: z.object({ cached_tokens: z.number().nullish() }).nullish(),
+        output_tokens: z.number(),
+        output_tokens_details: z.object({ reasoning_tokens: z.number().nullish() }).nullish()
+      }).optional()
+    })
+  )
+);
+var TOP_LOGPROBS_MAX = 20;
+var openaiResponsesProviderOptionsSchema = lazyValidator(
+  () => zodSchema(
+    z.object({
+      conversation: z.string().nullish(),
+      include: z.array(
+        z.enum([
+          "reasoning.encrypted_content",
+          // handled internally by default, only needed for unknown reasoning models
+          "file_search_call.results",
+          "message.output_text.logprobs"
+        ])
+      ).nullish(),
+      instructions: z.string().nullish(),
+      /**
+       * Return the log probabilities of the tokens.
+       *
+       * Setting to true will return the log probabilities of the tokens that
+       * were generated.
+       *
+       * Setting to a number will return the log probabilities of the top n
+       * tokens that were generated.
+       *
+       * @see https://platform.openai.com/docs/api-reference/responses/create
+       * @see https://cookbook.openai.com/examples/using_logprobs
+       */
+      logprobs: z.union([z.boolean(), z.number().min(1).max(TOP_LOGPROBS_MAX)]).optional(),
+      /**
+       * The maximum number of total calls to built-in tools that can be processed in a response.
+       * This maximum number applies across all built-in tool calls, not per individual tool.
+       * Any further attempts to call a tool by the model will be ignored.
+       */
+      maxToolCalls: z.number().nullish(),
+      metadata: z.any().nullish(),
+      parallelToolCalls: z.boolean().nullish(),
+      previousResponseId: z.string().nullish(),
+      promptCacheKey: z.string().nullish(),
+      /**
+       * The retention policy for the prompt cache.
+       * - 'in_memory': Default. Standard prompt caching behavior.
+       * - '24h': Extended prompt caching that keeps cached prefixes active for up to 24 hours.
+       *          Currently only available for 5.1 series models.
+       *
+       * @default 'in_memory'
+       */
+      promptCacheRetention: z.enum(["in_memory", "24h"]).nullish(),
+      reasoningEffort: z.string().nullish(),
+      reasoningSummary: z.string().nullish(),
+      safetyIdentifier: z.string().nullish(),
+      serviceTier: z.enum(["auto", "flex", "priority", "default"]).nullish(),
+      store: z.boolean().nullish(),
+      strictJsonSchema: z.boolean().nullish(),
+      textVerbosity: z.enum(["low", "medium", "high"]).nullish(),
+      truncation: z.enum(["auto", "disabled"]).nullish(),
+      user: z.string().nullish()
+    })
+  )
+);
+var codeInterpreterInputSchema = lazySchema(
+  () => zodSchema(
+    z.object({
+      code: z.string().nullish(),
+      containerId: z.string()
+    })
+  )
+);
+var codeInterpreterOutputSchema = lazySchema(
+  () => zodSchema(
+    z.object({
+      outputs: z.array(
+        z.discriminatedUnion("type", [
+          z.object({ type: z.literal("logs"), logs: z.string() }),
+          z.object({ type: z.literal("image"), url: z.string() })
+        ])
+      ).nullish()
+    })
+  )
+);
+var codeInterpreterArgsSchema = lazySchema(
+  () => zodSchema(
+    z.object({
+      container: z.union([
+        z.string(),
+        z.object({
+          fileIds: z.array(z.string()).optional()
+        })
+      ]).optional()
+    })
+  )
+);
+var codeInterpreterToolFactory = createProviderDefinedToolFactoryWithOutputSchema({
+  id: "openai.code_interpreter",
+  name: "code_interpreter",
+  inputSchema: codeInterpreterInputSchema,
+  outputSchema: codeInterpreterOutputSchema
+});
+var codeInterpreter = (args = {}) => {
+  return codeInterpreterToolFactory(args);
+};
+var comparisonFilterSchema = z.object({
+  key: z.string(),
+  type: z.enum(["eq", "ne", "gt", "gte", "lt", "lte"]),
+  value: z.union([z.string(), z.number(), z.boolean()])
+});
+var compoundFilterSchema = z.object({
+  type: z.enum(["and", "or"]),
+  filters: z.array(
+    z.union([comparisonFilterSchema, z.lazy(() => compoundFilterSchema)])
+  )
+});
+var fileSearchArgsSchema = lazySchema(
+  () => zodSchema(
+    z.object({
+      vectorStoreIds: z.array(z.string()),
+      maxNumResults: z.number().optional(),
+      ranking: z.object({
+        ranker: z.string().optional(),
+        scoreThreshold: z.number().optional()
+      }).optional(),
+      filters: z.union([comparisonFilterSchema, compoundFilterSchema]).optional()
+    })
+  )
+);
+var fileSearchOutputSchema = lazySchema(
+  () => zodSchema(
+    z.object({
+      queries: z.array(z.string()),
+      results: z.array(
+        z.object({
+          attributes: z.record(z.string(), z.unknown()),
+          fileId: z.string(),
+          filename: z.string(),
+          score: z.number(),
+          text: z.string()
+        })
+      ).nullable()
+    })
+  )
+);
+var fileSearch = createProviderDefinedToolFactoryWithOutputSchema({
+  id: "openai.file_search",
+  name: "file_search",
+  inputSchema: z.object({}),
+  outputSchema: fileSearchOutputSchema
+});
+var webSearchArgsSchema = lazySchema(
+  () => zodSchema(
+    z.object({
+      externalWebAccess: z.boolean().optional(),
+      filters: z.object({ allowedDomains: z.array(z.string()).optional() }).optional(),
+      searchContextSize: z.enum(["low", "medium", "high"]).optional(),
+      userLocation: z.object({
+        type: z.literal("approximate"),
+        country: z.string().optional(),
+        city: z.string().optional(),
+        region: z.string().optional(),
+        timezone: z.string().optional()
+      }).optional()
+    })
+  )
+);
+var webSearchInputSchema = lazySchema(() => zodSchema(z.object({})));
+var webSearchOutputSchema = lazySchema(
+  () => zodSchema(
+    z.object({
+      action: z.discriminatedUnion("type", [
+        z.object({
+          type: z.literal("search"),
+          query: z.string().optional()
+        }),
+        z.object({
+          type: z.literal("openPage"),
+          url: z.string()
+        }),
+        z.object({
+          type: z.literal("find"),
+          url: z.string(),
+          pattern: z.string()
+        })
+      ]),
+      sources: z.array(
+        z.discriminatedUnion("type", [
+          z.object({ type: z.literal("url"), url: z.string() }),
+          z.object({ type: z.literal("api"), name: z.string() })
+        ])
+      ).optional()
+    })
+  )
+);
+createProviderDefinedToolFactoryWithOutputSchema({
+  id: "openai.web_search",
+  name: "web_search",
+  inputSchema: webSearchInputSchema,
+  outputSchema: webSearchOutputSchema
+});
+var webSearchPreviewArgsSchema = lazySchema(
+  () => zodSchema(
+    z.object({
+      searchContextSize: z.enum(["low", "medium", "high"]).optional(),
+      userLocation: z.object({
+        type: z.literal("approximate"),
+        country: z.string().optional(),
+        city: z.string().optional(),
+        region: z.string().optional(),
+        timezone: z.string().optional()
+      }).optional()
+    })
+  )
+);
+var webSearchPreviewInputSchema = lazySchema(
+  () => zodSchema(z.object({}))
+);
+var webSearchPreviewOutputSchema = lazySchema(
+  () => zodSchema(
+    z.object({
+      action: z.discriminatedUnion("type", [
+        z.object({
+          type: z.literal("search"),
+          query: z.string().optional()
+        }),
+        z.object({
+          type: z.literal("openPage"),
+          url: z.string()
+        }),
+        z.object({
+          type: z.literal("find"),
+          url: z.string(),
+          pattern: z.string()
+        })
+      ])
+    })
+  )
+);
+var webSearchPreview = createProviderDefinedToolFactoryWithOutputSchema({
+  id: "openai.web_search_preview",
+  name: "web_search_preview",
+  inputSchema: webSearchPreviewInputSchema,
+  outputSchema: webSearchPreviewOutputSchema
+});
+var imageGenerationArgsSchema = lazySchema(
+  () => zodSchema(
+    z.object({
+      background: z.enum(["auto", "opaque", "transparent"]).optional(),
+      inputFidelity: z.enum(["low", "high"]).optional(),
+      inputImageMask: z.object({
+        fileId: z.string().optional(),
+        imageUrl: z.string().optional()
+      }).optional(),
+      model: z.string().optional(),
+      moderation: z.enum(["auto"]).optional(),
+      outputCompression: z.number().int().min(0).max(100).optional(),
+      outputFormat: z.enum(["png", "jpeg", "webp"]).optional(),
+      partialImages: z.number().int().min(0).max(3).optional(),
+      quality: z.enum(["auto", "low", "medium", "high"]).optional(),
+      size: z.enum(["1024x1024", "1024x1536", "1536x1024", "auto"]).optional()
+    }).strict()
+  )
+);
+var imageGenerationInputSchema = lazySchema(() => zodSchema(z.object({})));
+var imageGenerationOutputSchema = lazySchema(
+  () => zodSchema(z.object({ result: z.string() }))
+);
+var imageGenerationToolFactory = createProviderDefinedToolFactoryWithOutputSchema({
+  id: "openai.image_generation",
+  name: "image_generation",
+  inputSchema: imageGenerationInputSchema,
+  outputSchema: imageGenerationOutputSchema
+});
+var imageGeneration = (args = {}) => {
+  return imageGenerationToolFactory(args);
+};
+async function prepareResponsesTools({
+  tools,
+  toolChoice,
+  strictJsonSchema
+}) {
+  tools = (tools == null ? void 0 : tools.length) ? tools : void 0;
+  const toolWarnings = [];
+  if (tools == null) {
+    return { tools: void 0, toolChoice: void 0, toolWarnings };
+  }
+  const openaiTools = [];
+  for (const tool of tools) {
+    switch (tool.type) {
+      case "function":
+        openaiTools.push({
+          type: "function",
+          name: tool.name,
+          description: tool.description,
+          parameters: tool.inputSchema,
+          strict: strictJsonSchema
+        });
+        break;
+      case "provider-defined": {
+        switch (tool.id) {
+          case "openai.file_search": {
+            const args = await validateTypes({
+              value: tool.args,
+              schema: fileSearchArgsSchema
+            });
+            openaiTools.push({
+              type: "file_search",
+              vector_store_ids: args.vectorStoreIds,
+              max_num_results: args.maxNumResults,
+              ranking_options: args.ranking ? {
+                ranker: args.ranking.ranker,
+                score_threshold: args.ranking.scoreThreshold
+              } : void 0,
+              filters: args.filters
+            });
+            break;
+          }
+          case "openai.local_shell": {
+            openaiTools.push({
+              type: "local_shell"
+            });
+            break;
+          }
+          case "openai.web_search_preview": {
+            const args = await validateTypes({
+              value: tool.args,
+              schema: webSearchPreviewArgsSchema
+            });
+            openaiTools.push({
+              type: "web_search_preview",
+              search_context_size: args.searchContextSize,
+              user_location: args.userLocation
+            });
+            break;
+          }
+          case "openai.web_search": {
+            const args = await validateTypes({
+              value: tool.args,
+              schema: webSearchArgsSchema
+            });
+            openaiTools.push({
+              type: "web_search",
+              filters: args.filters != null ? { allowed_domains: args.filters.allowedDomains } : void 0,
+              external_web_access: args.externalWebAccess,
+              search_context_size: args.searchContextSize,
+              user_location: args.userLocation
+            });
+            break;
+          }
+          case "openai.code_interpreter": {
+            const args = await validateTypes({
+              value: tool.args,
+              schema: codeInterpreterArgsSchema
+            });
+            openaiTools.push({
+              type: "code_interpreter",
+              container: args.container == null ? { type: "auto", file_ids: void 0 } : typeof args.container === "string" ? args.container : { type: "auto", file_ids: args.container.fileIds }
+            });
+            break;
+          }
+          case "openai.image_generation": {
+            const args = await validateTypes({
+              value: tool.args,
+              schema: imageGenerationArgsSchema
+            });
+            openaiTools.push({
+              type: "image_generation",
+              background: args.background,
+              input_fidelity: args.inputFidelity,
+              input_image_mask: args.inputImageMask ? {
+                file_id: args.inputImageMask.fileId,
+                image_url: args.inputImageMask.imageUrl
+              } : void 0,
+              model: args.model,
+              size: args.size,
+              quality: args.quality,
+              moderation: args.moderation,
+              output_format: args.outputFormat,
+              output_compression: args.outputCompression
+            });
+            break;
+          }
+        }
+        break;
+      }
+      default:
+        toolWarnings.push({ type: "unsupported-tool", tool });
+        break;
+    }
+  }
+  if (toolChoice == null) {
+    return { tools: openaiTools, toolChoice: void 0, toolWarnings };
+  }
+  const type = toolChoice.type;
+  switch (type) {
+    case "auto":
+    case "none":
+    case "required":
+      return { tools: openaiTools, toolChoice: type, toolWarnings };
+    case "tool":
+      return {
+        tools: openaiTools,
+        toolChoice: toolChoice.toolName === "code_interpreter" || toolChoice.toolName === "file_search" || toolChoice.toolName === "image_generation" || toolChoice.toolName === "web_search_preview" || toolChoice.toolName === "web_search" ? { type: toolChoice.toolName } : { type: "function", name: toolChoice.toolName },
+        toolWarnings
+      };
+    default: {
+      const _exhaustiveCheck = type;
+      throw new UnsupportedFunctionalityError({
+        functionality: `tool choice type: ${_exhaustiveCheck}`
+      });
+    }
+  }
+}
+var OpenAIResponsesLanguageModel = class {
+  constructor(modelId, config) {
+    this.specificationVersion = "v2";
+    this.supportedUrls = {
+      "image/*": [/^https?:\/\/.*$/],
+      "application/pdf": [/^https?:\/\/.*$/]
+    };
+    this.modelId = modelId;
+    this.config = config;
+  }
+  get provider() {
+    return this.config.provider;
+  }
+  async getArgs({
+    maxOutputTokens,
+    temperature,
+    stopSequences,
+    topP,
+    topK,
+    presencePenalty,
+    frequencyPenalty,
+    seed,
+    prompt,
+    providerOptions,
+    tools,
+    toolChoice,
+    responseFormat
+  }) {
+    var _a, _b, _c, _d;
+    const warnings = [];
+    const modelConfig = getResponsesModelConfig(this.modelId);
+    if (topK != null) {
+      warnings.push({ type: "unsupported-setting", setting: "topK" });
+    }
+    if (seed != null) {
+      warnings.push({ type: "unsupported-setting", setting: "seed" });
+    }
+    if (presencePenalty != null) {
+      warnings.push({
+        type: "unsupported-setting",
+        setting: "presencePenalty"
+      });
+    }
+    if (frequencyPenalty != null) {
+      warnings.push({
+        type: "unsupported-setting",
+        setting: "frequencyPenalty"
+      });
+    }
+    if (stopSequences != null) {
+      warnings.push({ type: "unsupported-setting", setting: "stopSequences" });
+    }
+    const openaiOptions = await parseProviderOptions({
+      provider: "openai",
+      providerOptions,
+      schema: openaiResponsesProviderOptionsSchema
+    });
+    if ((openaiOptions == null ? void 0 : openaiOptions.conversation) && (openaiOptions == null ? void 0 : openaiOptions.previousResponseId)) {
+      warnings.push({
+        type: "unsupported-setting",
+        setting: "conversation",
+        details: "conversation and previousResponseId cannot be used together"
+      });
+    }
+    const { input, warnings: inputWarnings } = await convertToOpenAIResponsesInput({
+      prompt,
+      systemMessageMode: modelConfig.systemMessageMode,
+      fileIdPrefixes: this.config.fileIdPrefixes,
+      store: (_a = openaiOptions == null ? void 0 : openaiOptions.store) != null ? _a : true,
+      hasLocalShellTool: hasOpenAITool("openai.local_shell")
+    });
+    warnings.push(...inputWarnings);
+    const strictJsonSchema = (_b = openaiOptions == null ? void 0 : openaiOptions.strictJsonSchema) != null ? _b : false;
+    let include = openaiOptions == null ? void 0 : openaiOptions.include;
+    function addInclude(key) {
+      if (include == null) {
+        include = [key];
+      } else if (!include.includes(key)) {
+        include = [...include, key];
+      }
+    }
+    function hasOpenAITool(id) {
+      return (tools == null ? void 0 : tools.find(
+        (tool) => tool.type === "provider-defined" && tool.id === id
+      )) != null;
+    }
+    const topLogprobs = typeof (openaiOptions == null ? void 0 : openaiOptions.logprobs) === "number" ? openaiOptions == null ? void 0 : openaiOptions.logprobs : (openaiOptions == null ? void 0 : openaiOptions.logprobs) === true ? TOP_LOGPROBS_MAX : void 0;
+    if (topLogprobs) {
+      addInclude("message.output_text.logprobs");
+    }
+    const webSearchToolName = (_c = tools == null ? void 0 : tools.find(
+      (tool) => tool.type === "provider-defined" && (tool.id === "openai.web_search" || tool.id === "openai.web_search_preview")
+    )) == null ? void 0 : _c.name;
+    if (webSearchToolName) {
+      addInclude("web_search_call.action.sources");
+    }
+    if (hasOpenAITool("openai.code_interpreter")) {
+      addInclude("code_interpreter_call.outputs");
+    }
+    const store = openaiOptions == null ? void 0 : openaiOptions.store;
+    if (store === false && modelConfig.isReasoningModel) {
+      addInclude("reasoning.encrypted_content");
+    }
+    const baseArgs = {
+      model: this.modelId,
+      input,
+      temperature,
+      top_p: topP,
+      max_output_tokens: maxOutputTokens,
+      ...((responseFormat == null ? void 0 : responseFormat.type) === "json" || (openaiOptions == null ? void 0 : openaiOptions.textVerbosity)) && {
+        text: {
+          ...(responseFormat == null ? void 0 : responseFormat.type) === "json" && {
+            format: responseFormat.schema != null ? {
+              type: "json_schema",
+              strict: strictJsonSchema,
+              name: (_d = responseFormat.name) != null ? _d : "response",
+              description: responseFormat.description,
+              schema: responseFormat.schema
+            } : { type: "json_object" }
+          },
+          ...(openaiOptions == null ? void 0 : openaiOptions.textVerbosity) && {
+            verbosity: openaiOptions.textVerbosity
+          }
+        }
+      },
+      // provider options:
+      conversation: openaiOptions == null ? void 0 : openaiOptions.conversation,
+      max_tool_calls: openaiOptions == null ? void 0 : openaiOptions.maxToolCalls,
+      metadata: openaiOptions == null ? void 0 : openaiOptions.metadata,
+      parallel_tool_calls: openaiOptions == null ? void 0 : openaiOptions.parallelToolCalls,
+      previous_response_id: openaiOptions == null ? void 0 : openaiOptions.previousResponseId,
+      store,
+      user: openaiOptions == null ? void 0 : openaiOptions.user,
+      instructions: openaiOptions == null ? void 0 : openaiOptions.instructions,
+      service_tier: openaiOptions == null ? void 0 : openaiOptions.serviceTier,
+      include,
+      prompt_cache_key: openaiOptions == null ? void 0 : openaiOptions.promptCacheKey,
+      prompt_cache_retention: openaiOptions == null ? void 0 : openaiOptions.promptCacheRetention,
+      safety_identifier: openaiOptions == null ? void 0 : openaiOptions.safetyIdentifier,
+      top_logprobs: topLogprobs,
+      truncation: openaiOptions == null ? void 0 : openaiOptions.truncation,
+      // model-specific settings:
+      ...modelConfig.isReasoningModel && ((openaiOptions == null ? void 0 : openaiOptions.reasoningEffort) != null || (openaiOptions == null ? void 0 : openaiOptions.reasoningSummary) != null) && {
+        reasoning: {
+          ...(openaiOptions == null ? void 0 : openaiOptions.reasoningEffort) != null && {
+            effort: openaiOptions.reasoningEffort
+          },
+          ...(openaiOptions == null ? void 0 : openaiOptions.reasoningSummary) != null && {
+            summary: openaiOptions.reasoningSummary
+          }
+        }
+      }
+    };
+    if (modelConfig.isReasoningModel) {
+      if (baseArgs.temperature != null) {
+        baseArgs.temperature = void 0;
+        warnings.push({
+          type: "unsupported-setting",
+          setting: "temperature",
+          details: "temperature is not supported for reasoning models"
+        });
+      }
+      if (baseArgs.top_p != null) {
+        baseArgs.top_p = void 0;
+        warnings.push({
+          type: "unsupported-setting",
+          setting: "topP",
+          details: "topP is not supported for reasoning models"
+        });
+      }
+    } else {
+      if ((openaiOptions == null ? void 0 : openaiOptions.reasoningEffort) != null) {
+        warnings.push({
+          type: "unsupported-setting",
+          setting: "reasoningEffort",
+          details: "reasoningEffort is not supported for non-reasoning models"
+        });
+      }
+      if ((openaiOptions == null ? void 0 : openaiOptions.reasoningSummary) != null) {
+        warnings.push({
+          type: "unsupported-setting",
+          setting: "reasoningSummary",
+          details: "reasoningSummary is not supported for non-reasoning models"
+        });
+      }
+    }
+    if ((openaiOptions == null ? void 0 : openaiOptions.serviceTier) === "flex" && !modelConfig.supportsFlexProcessing) {
+      warnings.push({
+        type: "unsupported-setting",
+        setting: "serviceTier",
+        details: "flex processing is only available for o3, o4-mini, and gpt-5 models"
+      });
+      delete baseArgs.service_tier;
+    }
+    if ((openaiOptions == null ? void 0 : openaiOptions.serviceTier) === "priority" && !modelConfig.supportsPriorityProcessing) {
+      warnings.push({
+        type: "unsupported-setting",
+        setting: "serviceTier",
+        details: "priority processing is only available for supported models (gpt-4, gpt-5, gpt-5-mini, o3, o4-mini) and requires Enterprise access. gpt-5-nano is not supported"
+      });
+      delete baseArgs.service_tier;
+    }
+    const {
+      tools: openaiTools,
+      toolChoice: openaiToolChoice,
+      toolWarnings
+    } = await prepareResponsesTools({
+      tools,
+      toolChoice,
+      strictJsonSchema
+    });
+    return {
+      webSearchToolName,
+      args: {
+        ...baseArgs,
+        tools: openaiTools,
+        tool_choice: openaiToolChoice
+      },
+      warnings: [...warnings, ...toolWarnings],
+      store
+    };
+  }
+  async doGenerate(options) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r, _s;
+    const {
+      args: body,
+      warnings,
+      webSearchToolName
+    } = await this.getArgs(options);
+    const url = this.config.url({
+      path: "/responses",
+      modelId: this.modelId
+    });
+    const {
+      responseHeaders,
+      value: response,
+      rawValue: rawResponse
+    } = await postJsonToApi({
+      url,
+      headers: combineHeaders(this.config.headers(), options.headers),
+      body,
+      failedResponseHandler: openaiFailedResponseHandler,
+      successfulResponseHandler: createJsonResponseHandler(
+        openaiResponsesResponseSchema
+      ),
+      abortSignal: options.abortSignal,
+      fetch: this.config.fetch
+    });
+    if (response.error) {
+      throw new APICallError({
+        message: response.error.message,
+        url,
+        requestBodyValues: body,
+        statusCode: 400,
+        responseHeaders,
+        responseBody: rawResponse,
+        isRetryable: false
+      });
+    }
+    const content = [];
+    const logprobs = [];
+    let hasFunctionCall = false;
+    for (const part of response.output) {
+      switch (part.type) {
+        case "reasoning": {
+          if (part.summary.length === 0) {
+            part.summary.push({ type: "summary_text", text: "" });
+          }
+          for (const summary of part.summary) {
+            content.push({
+              type: "reasoning",
+              text: summary.text,
+              providerMetadata: {
+                openai: {
+                  itemId: part.id,
+                  reasoningEncryptedContent: (_a = part.encrypted_content) != null ? _a : null
+                }
+              }
+            });
+          }
+          break;
+        }
+        case "image_generation_call": {
+          content.push({
+            type: "tool-call",
+            toolCallId: part.id,
+            toolName: "image_generation",
+            input: "{}",
+            providerExecuted: true
+          });
+          content.push({
+            type: "tool-result",
+            toolCallId: part.id,
+            toolName: "image_generation",
+            result: {
+              result: part.result
+            },
+            providerExecuted: true
+          });
+          break;
+        }
+        case "local_shell_call": {
+          content.push({
+            type: "tool-call",
+            toolCallId: part.call_id,
+            toolName: "local_shell",
+            input: JSON.stringify({
+              action: part.action
+            }),
+            providerMetadata: {
+              openai: {
+                itemId: part.id
+              }
+            }
+          });
+          break;
+        }
+        case "message": {
+          for (const contentPart of part.content) {
+            if (((_c = (_b = options.providerOptions) == null ? void 0 : _b.openai) == null ? void 0 : _c.logprobs) && contentPart.logprobs) {
+              logprobs.push(contentPart.logprobs);
+            }
+            content.push({
+              type: "text",
+              text: contentPart.text,
+              providerMetadata: {
+                openai: {
+                  itemId: part.id
+                }
+              }
+            });
+            for (const annotation of contentPart.annotations) {
+              if (annotation.type === "url_citation") {
+                content.push({
+                  type: "source",
+                  sourceType: "url",
+                  id: (_f = (_e = (_d = this.config).generateId) == null ? void 0 : _e.call(_d)) != null ? _f : generateId(),
+                  url: annotation.url,
+                  title: annotation.title
+                });
+              } else if (annotation.type === "file_citation") {
+                content.push({
+                  type: "source",
+                  sourceType: "document",
+                  id: (_i = (_h = (_g = this.config).generateId) == null ? void 0 : _h.call(_g)) != null ? _i : generateId(),
+                  mediaType: "text/plain",
+                  title: (_k = (_j = annotation.quote) != null ? _j : annotation.filename) != null ? _k : "Document",
+                  filename: (_l = annotation.filename) != null ? _l : annotation.file_id,
+                  ...annotation.file_id ? {
+                    providerMetadata: {
+                      openai: {
+                        fileId: annotation.file_id
+                      }
+                    }
+                  } : {}
+                });
+              }
+            }
+          }
+          break;
+        }
+        case "function_call": {
+          hasFunctionCall = true;
+          content.push({
+            type: "tool-call",
+            toolCallId: part.call_id,
+            toolName: part.name,
+            input: part.arguments,
+            providerMetadata: {
+              openai: {
+                itemId: part.id
+              }
+            }
+          });
+          break;
+        }
+        case "web_search_call": {
+          content.push({
+            type: "tool-call",
+            toolCallId: part.id,
+            toolName: webSearchToolName != null ? webSearchToolName : "web_search",
+            input: JSON.stringify({}),
+            providerExecuted: true
+          });
+          content.push({
+            type: "tool-result",
+            toolCallId: part.id,
+            toolName: webSearchToolName != null ? webSearchToolName : "web_search",
+            result: mapWebSearchOutput(part.action),
+            providerExecuted: true
+          });
+          break;
+        }
+        case "computer_call": {
+          content.push({
+            type: "tool-call",
+            toolCallId: part.id,
+            toolName: "computer_use",
+            input: "",
+            providerExecuted: true
+          });
+          content.push({
+            type: "tool-result",
+            toolCallId: part.id,
+            toolName: "computer_use",
+            result: {
+              type: "computer_use_tool_result",
+              status: part.status || "completed"
+            },
+            providerExecuted: true
+          });
+          break;
+        }
+        case "file_search_call": {
+          content.push({
+            type: "tool-call",
+            toolCallId: part.id,
+            toolName: "file_search",
+            input: "{}",
+            providerExecuted: true
+          });
+          content.push({
+            type: "tool-result",
+            toolCallId: part.id,
+            toolName: "file_search",
+            result: {
+              queries: part.queries,
+              results: (_n = (_m = part.results) == null ? void 0 : _m.map((result) => ({
+                attributes: result.attributes,
+                fileId: result.file_id,
+                filename: result.filename,
+                score: result.score,
+                text: result.text
+              }))) != null ? _n : null
+            },
+            providerExecuted: true
+          });
+          break;
+        }
+        case "code_interpreter_call": {
+          content.push({
+            type: "tool-call",
+            toolCallId: part.id,
+            toolName: "code_interpreter",
+            input: JSON.stringify({
+              code: part.code,
+              containerId: part.container_id
+            }),
+            providerExecuted: true
+          });
+          content.push({
+            type: "tool-result",
+            toolCallId: part.id,
+            toolName: "code_interpreter",
+            result: {
+              outputs: part.outputs
+            },
+            providerExecuted: true
+          });
+          break;
+        }
+      }
+    }
+    const providerMetadata = {
+      openai: {
+        ...response.id != null ? { responseId: response.id } : {}
+      }
+    };
+    if (logprobs.length > 0) {
+      providerMetadata.openai.logprobs = logprobs;
+    }
+    if (typeof response.service_tier === "string") {
+      providerMetadata.openai.serviceTier = response.service_tier;
+    }
+    const usage = response.usage;
+    return {
+      content,
+      finishReason: mapOpenAIResponseFinishReason({
+        finishReason: (_o = response.incomplete_details) == null ? void 0 : _o.reason,
+        hasFunctionCall
+      }),
+      usage: {
+        inputTokens: usage.input_tokens,
+        outputTokens: usage.output_tokens,
+        totalTokens: usage.input_tokens + usage.output_tokens,
+        reasoningTokens: (_q = (_p = usage.output_tokens_details) == null ? void 0 : _p.reasoning_tokens) != null ? _q : void 0,
+        cachedInputTokens: (_s = (_r = usage.input_tokens_details) == null ? void 0 : _r.cached_tokens) != null ? _s : void 0
+      },
+      request: { body },
+      response: {
+        id: response.id,
+        timestamp: new Date(response.created_at * 1e3),
+        modelId: response.model,
+        headers: responseHeaders,
+        body: rawResponse
+      },
+      providerMetadata,
+      warnings
+    };
+  }
+  async doStream(options) {
+    const {
+      args: body,
+      warnings,
+      webSearchToolName,
+      store
+    } = await this.getArgs(options);
+    const { responseHeaders, value: response } = await postJsonToApi({
+      url: this.config.url({
+        path: "/responses",
+        modelId: this.modelId
+      }),
+      headers: combineHeaders(this.config.headers(), options.headers),
+      body: {
+        ...body,
+        stream: true
+      },
+      failedResponseHandler: openaiFailedResponseHandler,
+      successfulResponseHandler: createEventSourceResponseHandler(
+        openaiResponsesChunkSchema
+      ),
+      abortSignal: options.abortSignal,
+      fetch: this.config.fetch
+    });
+    const self = this;
+    let finishReason = "unknown";
+    const usage = {
+      inputTokens: void 0,
+      outputTokens: void 0,
+      totalTokens: void 0
+    };
+    const logprobs = [];
+    let responseId = null;
+    const ongoingToolCalls = {};
+    const ongoingAnnotations = [];
+    let hasFunctionCall = false;
+    const activeReasoning = {};
+    let serviceTier;
+    return {
+      stream: response.pipeThrough(
+        new TransformStream({
+          start(controller) {
+            controller.enqueue({ type: "stream-start", warnings });
+          },
+          transform(chunk, controller) {
+            var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r, _s, _t, _u, _v;
+            if (options.includeRawChunks) {
+              controller.enqueue({ type: "raw", rawValue: chunk.rawValue });
+            }
+            if (!chunk.success) {
+              finishReason = "error";
+              controller.enqueue({ type: "error", error: chunk.error });
+              return;
+            }
+            const value = chunk.value;
+            if (isResponseOutputItemAddedChunk(value)) {
+              if (value.item.type === "function_call") {
+                ongoingToolCalls[value.output_index] = {
+                  toolName: value.item.name,
+                  toolCallId: value.item.call_id
+                };
+                controller.enqueue({
+                  type: "tool-input-start",
+                  id: value.item.call_id,
+                  toolName: value.item.name
+                });
+              } else if (value.item.type === "web_search_call") {
+                ongoingToolCalls[value.output_index] = {
+                  toolName: webSearchToolName != null ? webSearchToolName : "web_search",
+                  toolCallId: value.item.id
+                };
+                controller.enqueue({
+                  type: "tool-input-start",
+                  id: value.item.id,
+                  toolName: webSearchToolName != null ? webSearchToolName : "web_search",
+                  providerExecuted: true
+                });
+                controller.enqueue({
+                  type: "tool-input-end",
+                  id: value.item.id
+                });
+                controller.enqueue({
+                  type: "tool-call",
+                  toolCallId: value.item.id,
+                  toolName: webSearchToolName != null ? webSearchToolName : "web_search",
+                  input: JSON.stringify({}),
+                  providerExecuted: true
+                });
+              } else if (value.item.type === "computer_call") {
+                ongoingToolCalls[value.output_index] = {
+                  toolName: "computer_use",
+                  toolCallId: value.item.id
+                };
+                controller.enqueue({
+                  type: "tool-input-start",
+                  id: value.item.id,
+                  toolName: "computer_use",
+                  providerExecuted: true
+                });
+              } else if (value.item.type === "code_interpreter_call") {
+                ongoingToolCalls[value.output_index] = {
+                  toolName: "code_interpreter",
+                  toolCallId: value.item.id,
+                  codeInterpreter: {
+                    containerId: value.item.container_id
+                  }
+                };
+                controller.enqueue({
+                  type: "tool-input-start",
+                  id: value.item.id,
+                  toolName: "code_interpreter",
+                  providerExecuted: true
+                });
+                controller.enqueue({
+                  type: "tool-input-delta",
+                  id: value.item.id,
+                  delta: `{"containerId":"${value.item.container_id}","code":"`
+                });
+              } else if (value.item.type === "file_search_call") {
+                controller.enqueue({
+                  type: "tool-call",
+                  toolCallId: value.item.id,
+                  toolName: "file_search",
+                  input: "{}",
+                  providerExecuted: true
+                });
+              } else if (value.item.type === "image_generation_call") {
+                controller.enqueue({
+                  type: "tool-call",
+                  toolCallId: value.item.id,
+                  toolName: "image_generation",
+                  input: "{}",
+                  providerExecuted: true
+                });
+              } else if (value.item.type === "message") {
+                ongoingAnnotations.splice(0, ongoingAnnotations.length);
+                controller.enqueue({
+                  type: "text-start",
+                  id: value.item.id,
+                  providerMetadata: {
+                    openai: {
+                      itemId: value.item.id
+                    }
+                  }
+                });
+              } else if (isResponseOutputItemAddedChunk(value) && value.item.type === "reasoning") {
+                activeReasoning[value.item.id] = {
+                  encryptedContent: value.item.encrypted_content,
+                  summaryParts: { 0: "active" }
+                };
+                controller.enqueue({
+                  type: "reasoning-start",
+                  id: `${value.item.id}:0`,
+                  providerMetadata: {
+                    openai: {
+                      itemId: value.item.id,
+                      reasoningEncryptedContent: (_a = value.item.encrypted_content) != null ? _a : null
+                    }
+                  }
+                });
+              }
+            } else if (isResponseOutputItemDoneChunk(value) && value.item.type !== "message") {
+              if (value.item.type === "function_call") {
+                ongoingToolCalls[value.output_index] = void 0;
+                hasFunctionCall = true;
+                controller.enqueue({
+                  type: "tool-input-end",
+                  id: value.item.call_id
+                });
+                controller.enqueue({
+                  type: "tool-call",
+                  toolCallId: value.item.call_id,
+                  toolName: value.item.name,
+                  input: value.item.arguments,
+                  providerMetadata: {
+                    openai: {
+                      itemId: value.item.id
+                    }
+                  }
+                });
+              } else if (value.item.type === "web_search_call") {
+                ongoingToolCalls[value.output_index] = void 0;
+                controller.enqueue({
+                  type: "tool-result",
+                  toolCallId: value.item.id,
+                  toolName: webSearchToolName != null ? webSearchToolName : "web_search",
+                  result: mapWebSearchOutput(value.item.action),
+                  providerExecuted: true
+                });
+              } else if (value.item.type === "computer_call") {
+                ongoingToolCalls[value.output_index] = void 0;
+                controller.enqueue({
+                  type: "tool-input-end",
+                  id: value.item.id
+                });
+                controller.enqueue({
+                  type: "tool-call",
+                  toolCallId: value.item.id,
+                  toolName: "computer_use",
+                  input: "",
+                  providerExecuted: true
+                });
+                controller.enqueue({
+                  type: "tool-result",
+                  toolCallId: value.item.id,
+                  toolName: "computer_use",
+                  result: {
+                    type: "computer_use_tool_result",
+                    status: value.item.status || "completed"
+                  },
+                  providerExecuted: true
+                });
+              } else if (value.item.type === "file_search_call") {
+                ongoingToolCalls[value.output_index] = void 0;
+                controller.enqueue({
+                  type: "tool-result",
+                  toolCallId: value.item.id,
+                  toolName: "file_search",
+                  result: {
+                    queries: value.item.queries,
+                    results: (_c = (_b = value.item.results) == null ? void 0 : _b.map((result) => ({
+                      attributes: result.attributes,
+                      fileId: result.file_id,
+                      filename: result.filename,
+                      score: result.score,
+                      text: result.text
+                    }))) != null ? _c : null
+                  },
+                  providerExecuted: true
+                });
+              } else if (value.item.type === "code_interpreter_call") {
+                ongoingToolCalls[value.output_index] = void 0;
+                controller.enqueue({
+                  type: "tool-result",
+                  toolCallId: value.item.id,
+                  toolName: "code_interpreter",
+                  result: {
+                    outputs: value.item.outputs
+                  },
+                  providerExecuted: true
+                });
+              } else if (value.item.type === "image_generation_call") {
+                controller.enqueue({
+                  type: "tool-result",
+                  toolCallId: value.item.id,
+                  toolName: "image_generation",
+                  result: {
+                    result: value.item.result
+                  },
+                  providerExecuted: true
+                });
+              } else if (value.item.type === "local_shell_call") {
+                ongoingToolCalls[value.output_index] = void 0;
+                controller.enqueue({
+                  type: "tool-call",
+                  toolCallId: value.item.call_id,
+                  toolName: "local_shell",
+                  input: JSON.stringify({
+                    action: {
+                      type: "exec",
+                      command: value.item.action.command,
+                      timeoutMs: value.item.action.timeout_ms,
+                      user: value.item.action.user,
+                      workingDirectory: value.item.action.working_directory,
+                      env: value.item.action.env
+                    }
+                  }),
+                  providerMetadata: {
+                    openai: { itemId: value.item.id }
+                  }
+                });
+              } else if (value.item.type === "reasoning") {
+                const activeReasoningPart = activeReasoning[value.item.id];
+                const summaryPartIndices = Object.entries(
+                  activeReasoningPart.summaryParts
+                ).filter(
+                  ([_, status]) => status === "active" || status === "can-conclude"
+                ).map(([summaryIndex]) => summaryIndex);
+                for (const summaryIndex of summaryPartIndices) {
+                  controller.enqueue({
+                    type: "reasoning-end",
+                    id: `${value.item.id}:${summaryIndex}`,
+                    providerMetadata: {
+                      openai: {
+                        itemId: value.item.id,
+                        reasoningEncryptedContent: (_d = value.item.encrypted_content) != null ? _d : null
+                      }
+                    }
+                  });
+                }
+                delete activeReasoning[value.item.id];
+              }
+            } else if (isResponseFunctionCallArgumentsDeltaChunk(value)) {
+              const toolCall = ongoingToolCalls[value.output_index];
+              if (toolCall != null) {
+                controller.enqueue({
+                  type: "tool-input-delta",
+                  id: toolCall.toolCallId,
+                  delta: value.delta
+                });
+              }
+            } else if (isResponseCodeInterpreterCallCodeDeltaChunk(value)) {
+              const toolCall = ongoingToolCalls[value.output_index];
+              if (toolCall != null) {
+                controller.enqueue({
+                  type: "tool-input-delta",
+                  id: toolCall.toolCallId,
+                  // The delta is code, which is embedding in a JSON string.
+                  // To escape it, we use JSON.stringify and slice to remove the outer quotes.
+                  delta: JSON.stringify(value.delta).slice(1, -1)
+                });
+              }
+            } else if (isResponseCodeInterpreterCallCodeDoneChunk(value)) {
+              const toolCall = ongoingToolCalls[value.output_index];
+              if (toolCall != null) {
+                controller.enqueue({
+                  type: "tool-input-delta",
+                  id: toolCall.toolCallId,
+                  delta: '"}'
+                });
+                controller.enqueue({
+                  type: "tool-input-end",
+                  id: toolCall.toolCallId
+                });
+                controller.enqueue({
+                  type: "tool-call",
+                  toolCallId: toolCall.toolCallId,
+                  toolName: "code_interpreter",
+                  input: JSON.stringify({
+                    code: value.code,
+                    containerId: toolCall.codeInterpreter.containerId
+                  }),
+                  providerExecuted: true
+                });
+              }
+            } else if (isResponseCreatedChunk(value)) {
+              responseId = value.response.id;
+              controller.enqueue({
+                type: "response-metadata",
+                id: value.response.id,
+                timestamp: new Date(value.response.created_at * 1e3),
+                modelId: value.response.model
+              });
+            } else if (isTextDeltaChunk(value)) {
+              controller.enqueue({
+                type: "text-delta",
+                id: value.item_id,
+                delta: value.delta
+              });
+              if (((_f = (_e = options.providerOptions) == null ? void 0 : _e.openai) == null ? void 0 : _f.logprobs) && value.logprobs) {
+                logprobs.push(value.logprobs);
+              }
+            } else if (value.type === "response.reasoning_summary_part.added") {
+              if (value.summary_index > 0) {
+                const activeReasoningPart = activeReasoning[value.item_id];
+                activeReasoningPart.summaryParts[value.summary_index] = "active";
+                for (const summaryIndex of Object.keys(
+                  activeReasoningPart.summaryParts
+                )) {
+                  if (activeReasoningPart.summaryParts[summaryIndex] === "can-conclude") {
+                    controller.enqueue({
+                      type: "reasoning-end",
+                      id: `${value.item_id}:${summaryIndex}`,
+                      providerMetadata: { openai: { itemId: value.item_id } }
+                    });
+                    activeReasoningPart.summaryParts[summaryIndex] = "concluded";
+                  }
+                }
+                controller.enqueue({
+                  type: "reasoning-start",
+                  id: `${value.item_id}:${value.summary_index}`,
+                  providerMetadata: {
+                    openai: {
+                      itemId: value.item_id,
+                      reasoningEncryptedContent: (_h = (_g = activeReasoning[value.item_id]) == null ? void 0 : _g.encryptedContent) != null ? _h : null
+                    }
+                  }
+                });
+              }
+            } else if (value.type === "response.reasoning_summary_text.delta") {
+              controller.enqueue({
+                type: "reasoning-delta",
+                id: `${value.item_id}:${value.summary_index}`,
+                delta: value.delta,
+                providerMetadata: {
+                  openai: {
+                    itemId: value.item_id
+                  }
+                }
+              });
+            } else if (value.type === "response.reasoning_summary_part.done") {
+              if (store) {
+                controller.enqueue({
+                  type: "reasoning-end",
+                  id: `${value.item_id}:${value.summary_index}`,
+                  providerMetadata: {
+                    openai: { itemId: value.item_id }
+                  }
+                });
+                activeReasoning[value.item_id].summaryParts[value.summary_index] = "concluded";
+              } else {
+                activeReasoning[value.item_id].summaryParts[value.summary_index] = "can-conclude";
+              }
+            } else if (isResponseFinishedChunk(value)) {
+              finishReason = mapOpenAIResponseFinishReason({
+                finishReason: (_i = value.response.incomplete_details) == null ? void 0 : _i.reason,
+                hasFunctionCall
+              });
+              usage.inputTokens = value.response.usage.input_tokens;
+              usage.outputTokens = value.response.usage.output_tokens;
+              usage.totalTokens = value.response.usage.input_tokens + value.response.usage.output_tokens;
+              usage.reasoningTokens = (_k = (_j = value.response.usage.output_tokens_details) == null ? void 0 : _j.reasoning_tokens) != null ? _k : void 0;
+              usage.cachedInputTokens = (_m = (_l = value.response.usage.input_tokens_details) == null ? void 0 : _l.cached_tokens) != null ? _m : void 0;
+              if (typeof value.response.service_tier === "string") {
+                serviceTier = value.response.service_tier;
+              }
+            } else if (isResponseAnnotationAddedChunk(value)) {
+              ongoingAnnotations.push(value.annotation);
+              if (value.annotation.type === "url_citation") {
+                controller.enqueue({
+                  type: "source",
+                  sourceType: "url",
+                  id: (_p = (_o = (_n = self.config).generateId) == null ? void 0 : _o.call(_n)) != null ? _p : generateId(),
+                  url: value.annotation.url,
+                  title: value.annotation.title
+                });
+              } else if (value.annotation.type === "file_citation") {
+                controller.enqueue({
+                  type: "source",
+                  sourceType: "document",
+                  id: (_s = (_r = (_q = self.config).generateId) == null ? void 0 : _r.call(_q)) != null ? _s : generateId(),
+                  mediaType: "text/plain",
+                  title: (_u = (_t = value.annotation.quote) != null ? _t : value.annotation.filename) != null ? _u : "Document",
+                  filename: (_v = value.annotation.filename) != null ? _v : value.annotation.file_id,
+                  ...value.annotation.file_id ? {
+                    providerMetadata: {
+                      openai: {
+                        fileId: value.annotation.file_id
+                      }
+                    }
+                  } : {}
+                });
+              }
+            } else if (isResponseOutputItemDoneChunk(value) && value.item.type === "message") {
+              controller.enqueue({
+                type: "text-end",
+                id: value.item.id,
+                providerMetadata: {
+                  openai: {
+                    itemId: value.item.id,
+                    ...ongoingAnnotations.length > 0 && {
+                      annotations: ongoingAnnotations
+                    }
+                  }
+                }
+              });
+            } else if (isErrorChunk(value)) {
+              controller.enqueue({ type: "error", error: value });
+            }
+          },
+          flush(controller) {
+            const providerMetadata = {
+              openai: {
+                responseId
+              }
+            };
+            if (logprobs.length > 0) {
+              providerMetadata.openai.logprobs = logprobs;
+            }
+            if (serviceTier !== void 0) {
+              providerMetadata.openai.serviceTier = serviceTier;
+            }
+            controller.enqueue({
+              type: "finish",
+              finishReason,
+              usage,
+              providerMetadata
+            });
+          }
+        })
+      ),
+      request: { body },
+      response: { headers: responseHeaders }
+    };
+  }
+};
+function isTextDeltaChunk(chunk) {
+  return chunk.type === "response.output_text.delta";
+}
+function isResponseOutputItemDoneChunk(chunk) {
+  return chunk.type === "response.output_item.done";
+}
+function isResponseFinishedChunk(chunk) {
+  return chunk.type === "response.completed" || chunk.type === "response.incomplete";
+}
+function isResponseCreatedChunk(chunk) {
+  return chunk.type === "response.created";
+}
+function isResponseFunctionCallArgumentsDeltaChunk(chunk) {
+  return chunk.type === "response.function_call_arguments.delta";
+}
+function isResponseCodeInterpreterCallCodeDeltaChunk(chunk) {
+  return chunk.type === "response.code_interpreter_call_code.delta";
+}
+function isResponseCodeInterpreterCallCodeDoneChunk(chunk) {
+  return chunk.type === "response.code_interpreter_call_code.done";
+}
+function isResponseOutputItemAddedChunk(chunk) {
+  return chunk.type === "response.output_item.added";
+}
+function isResponseAnnotationAddedChunk(chunk) {
+  return chunk.type === "response.output_text.annotation.added";
+}
+function isErrorChunk(chunk) {
+  return chunk.type === "error";
+}
+function getResponsesModelConfig(modelId) {
+  const supportsFlexProcessing2 = modelId.startsWith("o3") || modelId.startsWith("o4-mini") || modelId.startsWith("gpt-5") && !modelId.startsWith("gpt-5-chat");
+  const supportsPriorityProcessing2 = modelId.startsWith("gpt-4") || modelId.startsWith("gpt-5-mini") || modelId.startsWith("gpt-5") && !modelId.startsWith("gpt-5-nano") && !modelId.startsWith("gpt-5-chat") || modelId.startsWith("o3") || modelId.startsWith("o4-mini");
+  const defaults = {
+    systemMessageMode: "system",
+    supportsFlexProcessing: supportsFlexProcessing2,
+    supportsPriorityProcessing: supportsPriorityProcessing2
+  };
+  if (modelId.startsWith("gpt-5-chat")) {
+    return {
+      ...defaults,
+      isReasoningModel: false
+    };
+  }
+  if (modelId.startsWith("o") || modelId.startsWith("gpt-5") || modelId.startsWith("codex-") || modelId.startsWith("computer-use")) {
+    return {
+      ...defaults,
+      isReasoningModel: true,
+      systemMessageMode: "developer"
+    };
+  }
+  return {
+    ...defaults,
+    isReasoningModel: false
+  };
+}
+function mapWebSearchOutput(action) {
+  var _a;
+  switch (action.type) {
+    case "search":
+      return {
+        action: { type: "search", query: (_a = action.query) != null ? _a : void 0 },
+        // include sources when provided by the Responses API (behind include flag)
+        ...action.sources != null && { sources: action.sources }
+      };
+    case "open_page":
+      return { action: { type: "openPage", url: action.url } };
+    case "find":
+      return {
+        action: { type: "find", url: action.url, pattern: action.pattern }
+      };
+  }
+}
+
+// ../../node_modules/.pnpm/@ai-sdk+azure@2.0.74_zod@3.25.76/node_modules/@ai-sdk/azure/dist/index.mjs
+var azureOpenaiTools = {
+  codeInterpreter,
+  fileSearch,
+  imageGeneration,
+  webSearchPreview
+};
+var VERSION = "2.0.74" ;
+function createAzure(options = {}) {
+  var _a;
+  const getHeaders = () => {
+    const baseHeaders = {
+      "api-key": loadApiKey({
+        apiKey: options.apiKey,
+        environmentVariableName: "AZURE_API_KEY",
+        description: "Azure OpenAI"
+      }),
+      ...options.headers
+    };
+    return withUserAgentSuffix(baseHeaders, `ai-sdk/azure/${VERSION}`);
+  };
+  const getResourceName = () => loadSetting({
+    settingValue: options.resourceName,
+    settingName: "resourceName",
+    environmentVariableName: "AZURE_RESOURCE_NAME",
+    description: "Azure OpenAI resource name"
+  });
+  const apiVersion = (_a = options.apiVersion) != null ? _a : "v1";
+  const url = ({ path, modelId }) => {
+    var _a2;
+    const baseUrlPrefix = (_a2 = options.baseURL) != null ? _a2 : `https://${getResourceName()}.openai.azure.com/openai`;
+    let fullUrl;
+    if (options.useDeploymentBasedUrls) {
+      fullUrl = new URL(`${baseUrlPrefix}/deployments/${modelId}${path}`);
+    } else {
+      fullUrl = new URL(`${baseUrlPrefix}/v1${path}`);
+    }
+    fullUrl.searchParams.set("api-version", apiVersion);
+    return fullUrl.toString();
+  };
+  const createChatModel = (deploymentName) => new OpenAIChatLanguageModel(deploymentName, {
+    provider: "azure.chat",
+    url,
+    headers: getHeaders,
+    fetch: options.fetch
+  });
+  const createCompletionModel = (modelId) => new OpenAICompletionLanguageModel(modelId, {
+    provider: "azure.completion",
+    url,
+    headers: getHeaders,
+    fetch: options.fetch
+  });
+  const createEmbeddingModel = (modelId) => new OpenAIEmbeddingModel(modelId, {
+    provider: "azure.embeddings",
+    headers: getHeaders,
+    url,
+    fetch: options.fetch
+  });
+  const createResponsesModel = (modelId) => new OpenAIResponsesLanguageModel(modelId, {
+    provider: "azure.responses",
+    url,
+    headers: getHeaders,
+    fetch: options.fetch,
+    fileIdPrefixes: ["assistant-"]
+  });
+  const createImageModel = (modelId) => new OpenAIImageModel(modelId, {
+    provider: "azure.image",
+    url,
+    headers: getHeaders,
+    fetch: options.fetch
+  });
+  const createTranscriptionModel = (modelId) => new OpenAITranscriptionModel(modelId, {
+    provider: "azure.transcription",
+    url,
+    headers: getHeaders,
+    fetch: options.fetch
+  });
+  const createSpeechModel = (modelId) => new OpenAISpeechModel(modelId, {
+    provider: "azure.speech",
+    url,
+    headers: getHeaders,
+    fetch: options.fetch
+  });
+  const provider = function(deploymentId) {
+    if (new.target) {
+      throw new Error(
+        "The Azure OpenAI model function cannot be called with the new keyword."
+      );
+    }
+    return createChatModel(deploymentId);
+  };
+  provider.languageModel = createChatModel;
+  provider.chat = createChatModel;
+  provider.completion = createCompletionModel;
+  provider.embedding = createEmbeddingModel;
+  provider.image = createImageModel;
+  provider.imageModel = createImageModel;
+  provider.textEmbedding = createEmbeddingModel;
+  provider.textEmbeddingModel = createEmbeddingModel;
+  provider.responses = createResponsesModel;
+  provider.transcription = createTranscriptionModel;
+  provider.speech = createSpeechModel;
+  provider.tools = azureOpenaiTools;
+  return provider;
+}
+createAzure();
+
+// src/llm/model/gateways/azure.ts
+var AzureOpenAIGateway = class extends MastraModelGateway {
+  constructor(config) {
+    super();
+    this.config = config;
+    this.validateConfig();
+  }
+  id = "azure-openai";
+  name = "azure-openai";
+  tokenCache = new InMemoryServerCache();
+  validateConfig() {
+    if (!this.config.resourceName) {
+      throw new MastraError({
+        id: "AZURE_GATEWAY_INVALID_CONFIG",
+        domain: "LLM",
+        category: "UNKNOWN",
+        text: "resourceName is required for Azure OpenAI gateway"
+      });
+    }
+    if (!this.config.apiKey) {
+      throw new MastraError({
+        id: "AZURE_GATEWAY_INVALID_CONFIG",
+        domain: "LLM",
+        category: "UNKNOWN",
+        text: "apiKey is required for Azure OpenAI gateway"
+      });
+    }
+    const hasDeployments = this.config.deployments && this.config.deployments.length > 0;
+    const hasManagement = this.config.management !== void 0;
+    if (hasDeployments && hasManagement) {
+      console.warn(
+        "[AzureOpenAIGateway] Both deployments and management credentials provided. Using static deployments list and ignoring management API."
+      );
+    }
+    if (hasManagement) {
+      this.getManagementCredentials(this.config.management);
+    }
+  }
+  async fetchProviders() {
+    if (this.config.deployments && this.config.deployments.length > 0) {
+      return {
+        "azure-openai": {
+          apiKeyEnvVar: [],
+          apiKeyHeader: "api-key",
+          name: "Azure OpenAI",
+          models: this.config.deployments,
+          docUrl: "https://learn.microsoft.com/en-us/azure/ai-services/openai/",
+          gateway: "azure-openai"
+        }
+      };
+    }
+    if (!this.config.management) {
+      return {
+        "azure-openai": {
+          apiKeyEnvVar: [],
+          apiKeyHeader: "api-key",
+          name: "Azure OpenAI",
+          models: [],
+          docUrl: "https://learn.microsoft.com/en-us/azure/ai-services/openai/",
+          gateway: "azure-openai"
+        }
+      };
+    }
+    try {
+      const credentials = this.getManagementCredentials(this.config.management);
+      const token = await this.getAzureADToken({
+        tenantId: credentials.tenantId,
+        clientId: credentials.clientId,
+        clientSecret: credentials.clientSecret
+      });
+      const deployments = await this.fetchDeployments(token, {
+        subscriptionId: credentials.subscriptionId,
+        resourceGroup: credentials.resourceGroup,
+        resourceName: this.config.resourceName
+      });
+      return {
+        "azure-openai": {
+          apiKeyEnvVar: [],
+          apiKeyHeader: "api-key",
+          name: "Azure OpenAI",
+          models: deployments.map((d) => d.name),
+          docUrl: "https://learn.microsoft.com/en-us/azure/ai-services/openai/",
+          gateway: "azure-openai"
+        }
+      };
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : String(error);
+      console.warn(
+        `[AzureOpenAIGateway] Deployment discovery failed: ${errorMsg}`,
+        "\nReturning fallback configuration. Azure OpenAI can still be used by manually specifying deployment names."
+      );
+      return {
+        "azure-openai": {
+          apiKeyEnvVar: [],
+          apiKeyHeader: "api-key",
+          name: "Azure OpenAI",
+          models: [],
+          docUrl: "https://learn.microsoft.com/en-us/azure/ai-services/openai/",
+          gateway: "azure-openai"
+        }
+      };
+    }
+  }
+  getManagementCredentials(management) {
+    const { tenantId, clientId, clientSecret, subscriptionId, resourceGroup } = management;
+    const missing = [];
+    if (!tenantId) missing.push("tenantId");
+    if (!clientId) missing.push("clientId");
+    if (!clientSecret) missing.push("clientSecret");
+    if (!subscriptionId) missing.push("subscriptionId");
+    if (!resourceGroup) missing.push("resourceGroup");
+    if (missing.length > 0) {
+      throw new MastraError({
+        id: "AZURE_MANAGEMENT_CREDENTIALS_MISSING",
+        domain: "LLM",
+        category: "UNKNOWN",
+        text: `Management credentials incomplete. Missing: ${missing.join(", ")}. Required fields: tenantId, clientId, clientSecret, subscriptionId, resourceGroup.`
+      });
+    }
+    return {
+      tenantId,
+      clientId,
+      clientSecret,
+      subscriptionId,
+      resourceGroup
+    };
+  }
+  async getAzureADToken(credentials) {
+    const { tenantId, clientId, clientSecret } = credentials;
+    const cacheKey = `azure-mgmt-token:${tenantId}:${clientId}`;
+    const cached = await this.tokenCache.get(cacheKey);
+    if (cached && cached.expiresAt > Date.now() / 1e3 + 60) {
+      return cached.token;
+    }
+    const tokenEndpoint = `https://login.microsoftonline.com/${tenantId}/oauth2/v2.0/token`;
+    const body = new URLSearchParams({
+      grant_type: "client_credentials",
+      client_id: clientId,
+      client_secret: clientSecret,
+      scope: "https://management.azure.com/.default"
+    });
+    const response = await fetch(tokenEndpoint, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/x-www-form-urlencoded"
+      },
+      body: body.toString()
+    });
+    if (!response.ok) {
+      const error = await response.text();
+      throw new MastraError({
+        id: "AZURE_AD_TOKEN_ERROR",
+        domain: "LLM",
+        category: "UNKNOWN",
+        text: `Failed to get Azure AD token: ${response.status} ${error}`
+      });
+    }
+    const tokenResponse = await response.json();
+    const expiresAt = Math.floor(Date.now() / 1e3) + tokenResponse.expires_in;
+    await this.tokenCache.set(cacheKey, {
+      token: tokenResponse.access_token,
+      expiresAt
+    });
+    return tokenResponse.access_token;
+  }
+  async fetchDeployments(token, credentials) {
+    const { subscriptionId, resourceGroup, resourceName } = credentials;
+    let url = `https://management.azure.com/subscriptions/${subscriptionId}/resourceGroups/${resourceGroup}/providers/Microsoft.CognitiveServices/accounts/${resourceName}/deployments?api-version=2024-10-01`;
+    const allDeployments = [];
+    while (url) {
+      const response = await fetch(url, {
+        headers: {
+          Authorization: `Bearer ${token}`,
+          "Content-Type": "application/json"
+        }
+      });
+      if (!response.ok) {
+        const error = await response.text();
+        throw new MastraError({
+          id: "AZURE_DEPLOYMENTS_FETCH_ERROR",
+          domain: "LLM",
+          category: "UNKNOWN",
+          text: `Failed to fetch Azure deployments: ${response.status} ${error}`
+        });
+      }
+      const data = await response.json();
+      allDeployments.push(...data.value);
+      url = data.nextLink;
+    }
+    const successfulDeployments = allDeployments.filter((d) => d.properties.provisioningState === "Succeeded");
+    return successfulDeployments;
+  }
+  buildUrl(_routerId, _envVars) {
+    return void 0;
+  }
+  async getApiKey(_modelId) {
+    return this.config.apiKey;
+  }
+  async resolveLanguageModel({
+    modelId,
+    apiKey
+  }) {
+    const apiVersion = this.config.apiVersion || "2024-04-01-preview";
+    return createAzure({
+      resourceName: this.config.resourceName,
+      apiKey,
+      apiVersion,
+      useDeploymentBasedUrls: true
+    })(modelId);
+  }
+};
+
+// src/llm/model/gateways/index.ts
+function findGatewayForModel(gatewayId, gateways) {
+  const prefixedGateway = gateways.find(
+    (g) => g.id !== "models.dev" && (g.id === gatewayId || gatewayId.startsWith(`${g.id}/`))
+  );
+  if (prefixedGateway) {
+    return prefixedGateway;
+  }
+  const modelsDevGateway = gateways.find((g) => g.id === "models.dev");
+  if (modelsDevGateway) {
+    return modelsDevGateway;
+  }
+  throw new MastraError({
+    id: "MODEL_ROUTER_NO_GATEWAY_FOUND",
+    category: "USER",
+    domain: "MODEL_ROUTER",
+    text: `No Mastra model router gateway found for model id ${gatewayId}`
+  });
+}
+
+// src/llm/model/router.ts
+function getStaticProvidersByGateway(name) {
+  return Object.fromEntries(Object.entries(PROVIDER_REGISTRY).filter(([_provider, config]) => config.gateway === name));
+}
+var defaultGateways = [new NetlifyGateway(), new ModelsDevGateway(getStaticProvidersByGateway(`models.dev`))];
+var ModelRouterLanguageModel = class _ModelRouterLanguageModel {
+  specificationVersion = "v2";
+  defaultObjectGenerationMode = "json";
+  supportsStructuredOutputs = true;
+  supportsImageUrls = true;
+  supportedUrls = {};
+  modelId;
+  provider;
+  config;
+  gateway;
+  constructor(config, customGateways) {
+    let normalizedConfig;
+    if (typeof config === "string") {
+      normalizedConfig = { id: config };
+    } else if ("providerId" in config && "modelId" in config) {
+      normalizedConfig = {
+        id: `${config.providerId}/${config.modelId}`,
+        url: config.url,
+        apiKey: config.apiKey,
+        headers: config.headers
+      };
+    } else {
+      normalizedConfig = {
+        id: config.id,
+        url: config.url,
+        apiKey: config.apiKey,
+        headers: config.headers
+      };
+    }
+    const parsedConfig = {
+      ...normalizedConfig,
+      routerId: normalizedConfig.id
+    };
+    this.gateway = findGatewayForModel(normalizedConfig.id, [...customGateways || [], ...defaultGateways]);
+    const gatewayPrefix = this.gateway.id === "models.dev" ? void 0 : this.gateway.id;
+    const parsed = parseModelRouterId(normalizedConfig.id, gatewayPrefix);
+    this.provider = parsed.providerId || "openai-compatible";
+    if (parsed.providerId && parsed.modelId !== normalizedConfig.id) {
+      parsedConfig.id = parsed.modelId;
+    }
+    this.modelId = parsedConfig.id;
+    this.config = parsedConfig;
+  }
+  async doGenerate(options) {
+    let apiKey;
+    try {
+      if (this.config.url) {
+        apiKey = this.config.apiKey || "";
+      } else {
+        apiKey = this.config.apiKey || await this.gateway.getApiKey(this.config.routerId);
+      }
+    } catch (error) {
+      return {
+        stream: new ReadableStream({
+          start(controller) {
+            controller.enqueue({
+              type: "error",
+              error
+            });
+            controller.close();
+          }
+        })
+      };
+    }
+    const gatewayPrefix = this.gateway.id === "models.dev" ? void 0 : this.gateway.id;
+    const model = await this.resolveLanguageModel({
+      apiKey,
+      headers: this.config.headers,
+      ...parseModelRouterId(this.config.routerId, gatewayPrefix)
+    });
+    const aiSDKV5Model = new AISDKV5LanguageModel(model);
+    return aiSDKV5Model.doGenerate(options);
+  }
+  async doStream(options) {
+    let apiKey;
+    try {
+      if (this.config.url) {
+        apiKey = this.config.apiKey || "";
+      } else {
+        apiKey = this.config.apiKey || await this.gateway.getApiKey(this.config.routerId);
+      }
+    } catch (error) {
+      return {
+        stream: new ReadableStream({
+          start(controller) {
+            controller.enqueue({
+              type: "error",
+              error
+            });
+            controller.close();
+          }
+        })
+      };
+    }
+    const gatewayPrefix = this.gateway.id === "models.dev" ? void 0 : this.gateway.id;
+    const model = await this.resolveLanguageModel({
+      apiKey,
+      headers: this.config.headers,
+      ...parseModelRouterId(this.config.routerId, gatewayPrefix)
+    });
+    const aiSDKV5Model = new AISDKV5LanguageModel(model);
+    return aiSDKV5Model.doStream(options);
+  }
+  async resolveLanguageModel({
+    modelId,
+    providerId,
+    apiKey,
+    headers
+  }) {
+    const key = createHash("sha256").update(
+      this.gateway.id + modelId + providerId + apiKey + (this.config.url || "") + (headers ? JSON.stringify(headers) : "")
+    ).digest("hex");
+    if (_ModelRouterLanguageModel.modelInstances.has(key)) return _ModelRouterLanguageModel.modelInstances.get(key);
+    if (this.config.url) {
+      const modelInstance2 = createOpenAICompatible({
+        name: providerId,
+        apiKey,
+        baseURL: this.config.url,
+        headers: this.config.headers,
+        supportsStructuredOutputs: true
+      }).chatModel(modelId);
+      _ModelRouterLanguageModel.modelInstances.set(key, modelInstance2);
+      return modelInstance2;
+    }
+    const modelInstance = await this.gateway.resolveLanguageModel({ modelId, providerId, apiKey, headers });
+    _ModelRouterLanguageModel.modelInstances.set(key, modelInstance);
+    return modelInstance;
+  }
+  static modelInstances = /* @__PURE__ */ new Map();
+};
+
+// src/llm/model/resolve-model.ts
+function isOpenAICompatibleObjectConfig(modelConfig) {
+  if (typeof modelConfig === "object" && "specificationVersion" in modelConfig) return false;
+  if (typeof modelConfig === "object" && !("model" in modelConfig)) {
+    if ("id" in modelConfig) return true;
+    if ("providerId" in modelConfig && "modelId" in modelConfig) return true;
+  }
+  return false;
+}
+async function resolveModelConfig(modelConfig, requestContext = new RequestContext(), mastra) {
+  if (typeof modelConfig === "function") {
+    modelConfig = await modelConfig({ requestContext, mastra });
+  }
+  if (modelConfig instanceof ModelRouterLanguageModel || modelConfig instanceof AISDKV5LanguageModel) {
+    return modelConfig;
+  }
+  if (typeof modelConfig === "object" && "specificationVersion" in modelConfig) {
+    if (modelConfig.specificationVersion === "v2") {
+      return new AISDKV5LanguageModel(modelConfig);
+    }
+    return modelConfig;
+  }
+  const gatewayRecord = mastra?.listGateways();
+  const customGateways = gatewayRecord ? Object.values(gatewayRecord) : void 0;
+  if (typeof modelConfig === "string" || isOpenAICompatibleObjectConfig(modelConfig)) {
+    return new ModelRouterLanguageModel(modelConfig, customGateways);
+  }
+  throw new Error("Invalid model configuration provided");
+}
+
+// src/llm/model/embedding-router.ts
+var ModelRouterEmbeddingModel = class {
+  specificationVersion = "v2";
+  modelId;
+  provider;
+  maxEmbeddingsPerCall = 2048;
+  supportsParallelCalls = true;
+  providerModel;
+  constructor(config) {
+    let normalizedConfig;
+    if (typeof config === "string") {
+      const parts = config.split("/");
+      if (parts.length !== 2) {
+        throw new Error(`Invalid model string format: "${config}". Expected format: "provider/model"`);
+      }
+      const [providerId, modelId] = parts;
+      normalizedConfig = { providerId, modelId };
+    } else if ("providerId" in config && "modelId" in config) {
+      normalizedConfig = {
+        providerId: config.providerId,
+        modelId: config.modelId,
+        url: config.url,
+        apiKey: config.apiKey,
+        headers: config.headers
+      };
+    } else {
+      const parts = config.id.split("/");
+      if (parts.length !== 2) {
+        throw new Error(`Invalid model string format: "${config.id}". Expected format: "provider/model"`);
+      }
+      const [providerId, modelId] = parts;
+      normalizedConfig = {
+        providerId,
+        modelId,
+        url: config.url,
+        apiKey: config.apiKey,
+        headers: config.headers
+      };
+    }
+    this.provider = normalizedConfig.providerId;
+    this.modelId = normalizedConfig.modelId;
+    if (normalizedConfig.url) {
+      const apiKey = normalizedConfig.apiKey || "";
+      this.providerModel = createOpenAICompatible({
+        name: normalizedConfig.providerId,
+        apiKey,
+        baseURL: normalizedConfig.url,
+        headers: normalizedConfig.headers
+      }).textEmbeddingModel(normalizedConfig.modelId);
+    } else {
+      const registry = GatewayRegistry.getInstance();
+      const providerConfig = registry.getProviderConfig(normalizedConfig.providerId);
+      if (!providerConfig) {
+        throw new Error(`Unknown provider: ${normalizedConfig.providerId}`);
+      }
+      let apiKey = normalizedConfig.apiKey;
+      if (!apiKey) {
+        const apiKeyEnvVar = providerConfig.apiKeyEnvVar;
+        if (Array.isArray(apiKeyEnvVar)) {
+          for (const envVar of apiKeyEnvVar) {
+            apiKey = process.env[envVar];
+            if (apiKey) break;
+          }
+        } else {
+          apiKey = process.env[apiKeyEnvVar];
+        }
+      }
+      if (!apiKey) {
+        const envVarDisplay = Array.isArray(providerConfig.apiKeyEnvVar) ? providerConfig.apiKeyEnvVar.join(" or ") : providerConfig.apiKeyEnvVar;
+        throw new Error(`API key not found for provider ${normalizedConfig.providerId}. Set ${envVarDisplay}`);
+      }
+      if (normalizedConfig.providerId === "openai") {
+        this.providerModel = createOpenAI({ apiKey }).textEmbeddingModel(
+          normalizedConfig.modelId
+        );
+      } else if (normalizedConfig.providerId === "google") {
+        this.providerModel = createGoogleGenerativeAI({ apiKey }).textEmbedding(
+          normalizedConfig.modelId
+        );
+      } else {
+        if (!providerConfig.url) {
+          throw new Error(`Provider ${normalizedConfig.providerId} does not have a URL configured`);
+        }
+        this.providerModel = createOpenAICompatible({
+          name: normalizedConfig.providerId,
+          apiKey,
+          baseURL: providerConfig.url
+        }).textEmbeddingModel(normalizedConfig.modelId);
+      }
+    }
+    if (this.providerModel.maxEmbeddingsPerCall !== void 0) {
+      this.maxEmbeddingsPerCall = this.providerModel.maxEmbeddingsPerCall;
+    }
+    if (this.providerModel.supportsParallelCalls !== void 0) {
+      this.supportsParallelCalls = this.providerModel.supportsParallelCalls;
+    }
+  }
+  async doEmbed(args) {
+    return this.providerModel.doEmbed(args);
+  }
+};
+
+export { AzureOpenAIGateway, ModelRouterEmbeddingModel, ModelRouterLanguageModel, resolveModelConfig };
+//# sourceMappingURL=chunk-5VZGJTPR.js.map
+//# sourceMappingURL=chunk-5VZGJTPR.js.map