'use strict';

var chunkOCS2GTEN_cjs = require('./chunk-OCS2GTEN.cjs');
var chunk4SCYX53T_cjs = require('./chunk-4SCYX53T.cjs');
var v4 = require('zod/v4');

// ../../../../../setup-pnpm/node_modules/.bin/store/v11/links/@ai-sdk/openai-compatible/2.0.48/6bc655d386f10be38a51d245d1ac2f722ea6d3a404005744bd9a8345d698d3e5/node_modules/@ai-sdk/openai-compatible/dist/internal/index.mjs
function convertOpenAICompatibleChatUsage(usage) {
  var _a15, _b, _c, _d, _e, _f;
  if (usage == null) {
    return {
      inputTokens: {
        total: void 0,
        noCache: void 0,
        cacheRead: void 0,
        cacheWrite: void 0
      },
      outputTokens: {
        total: void 0,
        text: void 0,
        reasoning: void 0
      },
      raw: void 0
    };
  }
  const promptTokens = (_a15 = usage.prompt_tokens) != null ? _a15 : 0;
  const completionTokens = (_b = usage.completion_tokens) != null ? _b : 0;
  const cacheReadTokens = (_d = (_c = usage.prompt_tokens_details) == null ? void 0 : _c.cached_tokens) != null ? _d : 0;
  const reasoningTokens = (_f = (_e = usage.completion_tokens_details) == null ? void 0 : _e.reasoning_tokens) != null ? _f : 0;
  return {
    inputTokens: {
      total: promptTokens,
      noCache: promptTokens - cacheReadTokens,
      cacheRead: cacheReadTokens,
      cacheWrite: void 0
    },
    outputTokens: {
      total: completionTokens,
      text: completionTokens - reasoningTokens,
      reasoning: reasoningTokens
    },
    raw: usage
  };
}
function mapOpenAICompatibleFinishReason(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 "other";
  }
}
function getResponseMetadata({
  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 prepareTools({
  tools,
  toolChoice
}) {
  tools = (tools == null ? void 0 : tools.length) ? tools : void 0;
  const toolWarnings = [];
  if (tools == null) {
    return { tools: void 0, toolChoice: void 0, toolWarnings };
  }
  const openaiCompatTools = [];
  for (const tool of tools) {
    if (tool.type === "provider") {
      toolWarnings.push({
        type: "unsupported",
        feature: `provider-defined tool ${tool.id}`
      });
    } else {
      openaiCompatTools.push({
        type: "function",
        function: {
          name: tool.name,
          description: tool.description,
          parameters: tool.inputSchema,
          ...tool.strict != null ? { strict: tool.strict } : {}
        }
      });
    }
  }
  if (toolChoice == null) {
    return { tools: openaiCompatTools, toolChoice: void 0, toolWarnings };
  }
  const type = toolChoice.type;
  switch (type) {
    case "auto":
    case "none":
    case "required":
      return { tools: openaiCompatTools, toolChoice: type, toolWarnings };
    case "tool":
      return {
        tools: openaiCompatTools,
        toolChoice: {
          type: "function",
          function: { name: toolChoice.toolName }
        },
        toolWarnings
      };
    default: {
      const _exhaustiveCheck = type;
      throw new chunkOCS2GTEN_cjs.UnsupportedFunctionalityError2({
        functionality: `tool choice type: ${_exhaustiveCheck}`
      });
    }
  }
}
var alibabaLanguageModelOptions = v4.z.object({
  /**
   * Enable thinking/reasoning mode for supported models.
   * When enabled, the model generates reasoning content before the response.
   *
   * @default false
   */
  enableThinking: v4.z.boolean().optional(),
  /**
   * Maximum number of reasoning tokens to generate.
   */
  thinkingBudget: v4.z.number().positive().optional(),
  /**
   * Whether to enable parallel function calling during tool use.
   *
   * @default true
   */
  parallelToolCalls: v4.z.boolean().optional()
});
var alibabaErrorDataSchema = v4.z.object({
  error: v4.z.object({
    message: v4.z.string(),
    code: v4.z.string().nullish(),
    type: v4.z.string().nullish()
  })
});
var alibabaFailedResponseHandler = chunkOCS2GTEN_cjs.createJsonErrorResponseHandler2({
  errorSchema: alibabaErrorDataSchema,
  errorToMessage: (data) => data.error.message
});
function convertAlibabaUsage(usage) {
  var _a15, _b, _c, _d;
  const baseUsage = convertOpenAICompatibleChatUsage(usage);
  const cacheWriteTokens = (_b = (_a15 = usage == null ? void 0 : usage.prompt_tokens_details) == null ? void 0 : _a15.cache_creation_input_tokens) != null ? _b : 0;
  const noCacheTokens = ((_c = baseUsage.inputTokens.total) != null ? _c : 0) - ((_d = baseUsage.inputTokens.cacheRead) != null ? _d : 0) - cacheWriteTokens;
  return {
    ...baseUsage,
    inputTokens: {
      ...baseUsage.inputTokens,
      cacheWrite: cacheWriteTokens,
      noCache: noCacheTokens
    }
  };
}
function formatImageUrl({
  data,
  mediaType
}) {
  return data instanceof URL ? data.toString() : `data:${mediaType};base64,${chunkOCS2GTEN_cjs.convertToBase642(data)}`;
}
function convertToAlibabaChatMessages({
  prompt,
  cacheControlValidator
}) {
  var _a15, _b;
  const messages = [];
  for (const { role, content, ...message } of prompt) {
    const messageCacheControl = cacheControlValidator == null ? void 0 : cacheControlValidator.getCacheControl(
      message.providerOptions
    );
    switch (role) {
      case "system": {
        if (messageCacheControl) {
          messages.push({
            role: "system",
            content: [
              {
                type: "text",
                text: content,
                cache_control: messageCacheControl
              }
            ]
          });
        } else {
          messages.push({ role: "system", content });
        }
        break;
      }
      case "user": {
        messages.push({
          role: "user",
          content: content.map((part, index) => {
            var _a22;
            const isLastPart = index === content.length - 1;
            const partCacheControl = (_a22 = cacheControlValidator == null ? void 0 : cacheControlValidator.getCacheControl(part.providerOptions)) != null ? _a22 : isLastPart ? messageCacheControl : void 0;
            switch (part.type) {
              case "text": {
                return {
                  type: "text",
                  text: part.text,
                  ...partCacheControl ? { cache_control: partCacheControl } : {}
                };
              }
              case "file": {
                if (part.mediaType.startsWith("image/")) {
                  const mediaType = part.mediaType === "image/*" ? "image/jpeg" : part.mediaType;
                  return {
                    type: "image_url",
                    image_url: {
                      url: formatImageUrl({ data: part.data, mediaType })
                    },
                    ...partCacheControl ? { cache_control: partCacheControl } : {}
                  };
                } else {
                  throw new chunkOCS2GTEN_cjs.UnsupportedFunctionalityError2({
                    functionality: "Only image file parts are supported"
                  });
                }
              }
            }
          })
        });
        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;
            }
            case "reasoning": {
              text += part.text;
              break;
            }
          }
        }
        messages.push({
          role: "assistant",
          content: messageCacheControl ? [{ type: "text", text, cache_control: messageCacheControl }] : text || null,
          tool_calls: toolCalls.length > 0 ? toolCalls : void 0
        });
        break;
      }
      case "tool": {
        const toolResponses = content.filter(
          (r) => r.type !== "tool-approval-response"
        );
        for (let i = 0; i < toolResponses.length; i++) {
          const toolResponse = toolResponses[i];
          const output = toolResponse.output;
          const isLastPart = i === toolResponses.length - 1;
          const partCacheControl = (_a15 = cacheControlValidator == null ? void 0 : cacheControlValidator.getCacheControl(
            toolResponse.providerOptions
          )) != null ? _a15 : isLastPart ? messageCacheControl : void 0;
          let contentValue;
          switch (output.type) {
            case "text":
            case "error-text":
              contentValue = output.value;
              break;
            case "execution-denied":
              contentValue = (_b = output.reason) != null ? _b : "Tool execution denied.";
              break;
            case "content":
            case "json":
            case "error-json":
              contentValue = JSON.stringify(output.value);
              break;
          }
          messages.push({
            role: "tool",
            tool_call_id: toolResponse.toolCallId,
            content: partCacheControl ? [
              {
                type: "text",
                text: contentValue,
                cache_control: partCacheControl
              }
            ] : contentValue
          });
        }
        break;
      }
      default: {
        const _exhaustiveCheck = role;
        throw new Error(`Unsupported role: ${_exhaustiveCheck}`);
      }
    }
  }
  return messages;
}
var MAX_CACHE_BREAKPOINTS = 4;
function getCacheControl(providerMetadata) {
  var _a15;
  const alibaba2 = providerMetadata == null ? void 0 : providerMetadata.alibaba;
  const cacheControlValue = (_a15 = alibaba2 == null ? void 0 : alibaba2.cacheControl) != null ? _a15 : alibaba2 == null ? void 0 : alibaba2.cache_control;
  return cacheControlValue;
}
var CacheControlValidator = class {
  constructor() {
    this.breakpointCount = 0;
    this.warnings = [];
  }
  getCacheControl(providerMetadata) {
    const cacheControlValue = getCacheControl(providerMetadata);
    if (!cacheControlValue) {
      return void 0;
    }
    this.breakpointCount++;
    if (this.breakpointCount > MAX_CACHE_BREAKPOINTS) {
      this.warnings.push({
        type: "other",
        message: `Max breakpoint limit exceeded. Only the last ${MAX_CACHE_BREAKPOINTS} cache markers will take effect.`
      });
    }
    return cacheControlValue;
  }
  getWarnings() {
    return this.warnings;
  }
};
var AlibabaLanguageModel = class {
  constructor(modelId, config) {
    this.specificationVersion = "v3";
    this.supportedUrls = {
      "image/*": [/^https?:\/\/.*$/]
    };
    this.modelId = modelId;
    this.config = config;
  }
  get provider() {
    return this.config.provider;
  }
  /**
   * Builds request arguments for Alibaba API call.
   * Converts AI SDK options to Alibaba API format.
   */
  async getArgs({
    prompt,
    maxOutputTokens,
    temperature,
    topP,
    topK,
    frequencyPenalty,
    presencePenalty,
    stopSequences,
    responseFormat,
    seed,
    providerOptions,
    tools,
    toolChoice
  }) {
    var _a15;
    const warnings = [];
    const cacheControlValidator = new CacheControlValidator();
    const alibabaOptions = await chunkOCS2GTEN_cjs.parseProviderOptions2({
      provider: "alibaba",
      providerOptions,
      schema: alibabaLanguageModelOptions
    });
    if (frequencyPenalty != null) {
      warnings.push({ type: "unsupported", feature: "frequencyPenalty" });
    }
    const baseArgs = {
      model: this.modelId,
      max_tokens: maxOutputTokens,
      temperature,
      top_p: topP,
      top_k: topK,
      presence_penalty: presencePenalty,
      stop: stopSequences,
      seed,
      response_format: (responseFormat == null ? void 0 : responseFormat.type) === "json" ? responseFormat.schema != null ? {
        type: "json_schema",
        json_schema: {
          schema: responseFormat.schema,
          name: (_a15 = responseFormat.name) != null ? _a15 : "response",
          description: responseFormat.description
        }
      } : { type: "json_object" } : void 0,
      // Alibaba-specific options
      ...(alibabaOptions == null ? void 0 : alibabaOptions.enableThinking) != null ? { enable_thinking: alibabaOptions.enableThinking } : {},
      ...(alibabaOptions == null ? void 0 : alibabaOptions.thinkingBudget) != null ? { thinking_budget: alibabaOptions.thinkingBudget } : {},
      // Convert messages with cache control support
      messages: convertToAlibabaChatMessages({
        prompt,
        cacheControlValidator
      })
    };
    const {
      tools: alibabaTools,
      toolChoice: alibabaToolChoice,
      toolWarnings
    } = prepareTools({ tools, toolChoice });
    warnings.push(...cacheControlValidator.getWarnings());
    return {
      args: {
        ...baseArgs,
        tools: alibabaTools,
        tool_choice: alibabaToolChoice,
        ...alibabaTools != null && (alibabaOptions == null ? void 0 : alibabaOptions.parallelToolCalls) !== void 0 ? { parallel_tool_calls: alibabaOptions.parallelToolCalls } : {}
      },
      warnings: [...warnings, ...toolWarnings]
    };
  }
  async doGenerate(options) {
    var _a15;
    const { args, warnings } = await this.getArgs(options);
    const {
      responseHeaders,
      value: response,
      rawValue: rawResponse
    } = await chunkOCS2GTEN_cjs.postJsonToApi2({
      url: `${this.config.baseURL}/chat/completions`,
      headers: chunkOCS2GTEN_cjs.combineHeaders2(this.config.headers(), options.headers),
      body: args,
      failedResponseHandler: alibabaFailedResponseHandler,
      successfulResponseHandler: chunkOCS2GTEN_cjs.createJsonResponseHandler2(
        alibabaChatResponseSchema
      ),
      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 });
    }
    const reasoning = choice.message.reasoning_content;
    if (reasoning != null && reasoning.length > 0) {
      content.push({
        type: "reasoning",
        text: reasoning
      });
    }
    if (choice.message.tool_calls != null) {
      for (const toolCall of choice.message.tool_calls) {
        content.push({
          type: "tool-call",
          toolCallId: toolCall.id,
          toolName: toolCall.function.name,
          input: toolCall.function.arguments
        });
      }
    }
    return {
      content,
      finishReason: {
        unified: mapOpenAICompatibleFinishReason(choice.finish_reason),
        raw: (_a15 = choice.finish_reason) != null ? _a15 : void 0
      },
      usage: convertAlibabaUsage(response.usage),
      request: { body: JSON.stringify(args) },
      response: {
        ...getResponseMetadata(response),
        headers: responseHeaders,
        body: rawResponse
      },
      warnings
    };
  }
  async doStream(options) {
    const { args, warnings } = await this.getArgs(options);
    const body = {
      ...args,
      stream: true,
      stream_options: this.config.includeUsage ? { include_usage: true } : void 0
    };
    const { responseHeaders, value: response } = await chunkOCS2GTEN_cjs.postJsonToApi2({
      url: `${this.config.baseURL}/chat/completions`,
      headers: chunkOCS2GTEN_cjs.combineHeaders2(this.config.headers(), options.headers),
      body,
      failedResponseHandler: alibabaFailedResponseHandler,
      successfulResponseHandler: chunkOCS2GTEN_cjs.createEventSourceResponseHandler2(
        alibabaChatChunkSchema
      ),
      abortSignal: options.abortSignal,
      fetch: this.config.fetch
    });
    let finishReason = {
      unified: "other",
      raw: void 0
    };
    let usage = void 0;
    let isFirstChunk = true;
    let activeText = false;
    let activeReasoningId = null;
    const toolCalls = [];
    return {
      stream: response.pipeThrough(
        new TransformStream({
          start(controller) {
            controller.enqueue({ type: "stream-start", warnings });
          },
          transform(chunk, controller) {
            var _a15, _b, _c, _d;
            if (options.includeRawChunks) {
              controller.enqueue({ type: "raw", rawValue: chunk.rawValue });
            }
            if (!chunk.success) {
              controller.enqueue({ type: "error", error: chunk.error });
              return;
            }
            const value = chunk.value;
            if (isFirstChunk) {
              isFirstChunk = false;
              controller.enqueue({
                type: "response-metadata",
                ...getResponseMetadata(value)
              });
            }
            if (value.usage != null) {
              usage = value.usage;
            }
            if (value.choices.length === 0) {
              return;
            }
            const choice = value.choices[0];
            const delta = choice.delta;
            if (delta.reasoning_content != null && delta.reasoning_content.length > 0) {
              if (activeReasoningId == null) {
                if (activeText) {
                  controller.enqueue({ type: "text-end", id: "0" });
                  activeText = false;
                }
                activeReasoningId = chunkOCS2GTEN_cjs.generateId2();
                controller.enqueue({
                  type: "reasoning-start",
                  id: activeReasoningId
                });
              }
              controller.enqueue({
                type: "reasoning-delta",
                id: activeReasoningId,
                delta: delta.reasoning_content
              });
            }
            if (delta.content != null && delta.content.length > 0) {
              if (activeReasoningId != null) {
                controller.enqueue({
                  type: "reasoning-end",
                  id: activeReasoningId
                });
                activeReasoningId = null;
              }
              if (!activeText) {
                controller.enqueue({ type: "text-start", id: "0" });
                activeText = true;
              }
              controller.enqueue({
                type: "text-delta",
                id: "0",
                delta: delta.content
              });
            }
            if (delta.tool_calls != null) {
              if (activeReasoningId != null) {
                controller.enqueue({
                  type: "reasoning-end",
                  id: activeReasoningId
                });
                activeReasoningId = null;
              }
              if (activeText) {
                controller.enqueue({ type: "text-end", id: "0" });
                activeText = false;
              }
              for (const toolCallDelta of delta.tool_calls) {
                const index = (_a15 = toolCallDelta.index) != null ? _a15 : toolCalls.length;
                if (toolCalls[index] == null) {
                  if (toolCallDelta.id == null) {
                    throw new chunkOCS2GTEN_cjs.InvalidResponseDataError2({
                      data: toolCallDelta,
                      message: `Expected 'id' to be a string.`
                    });
                  }
                  if (((_b = toolCallDelta.function) == null ? void 0 : _b.name) == null) {
                    throw new chunkOCS2GTEN_cjs.InvalidResponseDataError2({
                      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: (_c = toolCallDelta.function.arguments) != null ? _c : ""
                    },
                    hasFinished: false
                  };
                  const toolCall2 = toolCalls[index];
                  if (toolCall2.function.arguments.length > 0) {
                    controller.enqueue({
                      type: "tool-input-delta",
                      id: toolCall2.id,
                      delta: toolCall2.function.arguments
                    });
                  }
                  if (chunkOCS2GTEN_cjs.isParsableJson2(toolCall2.function.arguments)) {
                    controller.enqueue({
                      type: "tool-input-end",
                      id: toolCall2.id
                    });
                    controller.enqueue({
                      type: "tool-call",
                      toolCallId: toolCall2.id,
                      toolName: toolCall2.function.name,
                      input: toolCall2.function.arguments
                    });
                    toolCall2.hasFinished = true;
                  }
                  continue;
                }
                const toolCall = toolCalls[index];
                if (toolCall.hasFinished) {
                  continue;
                }
                if (((_d = toolCallDelta.function) == null ? void 0 : _d.arguments) != null) {
                  toolCall.function.arguments += toolCallDelta.function.arguments;
                  controller.enqueue({
                    type: "tool-input-delta",
                    id: toolCall.id,
                    delta: toolCallDelta.function.arguments
                  });
                }
                if (chunkOCS2GTEN_cjs.isParsableJson2(toolCall.function.arguments)) {
                  controller.enqueue({
                    type: "tool-input-end",
                    id: toolCall.id
                  });
                  controller.enqueue({
                    type: "tool-call",
                    toolCallId: toolCall.id,
                    toolName: toolCall.function.name,
                    input: toolCall.function.arguments
                  });
                  toolCall.hasFinished = true;
                }
              }
            }
            if (choice.finish_reason != null) {
              finishReason = {
                unified: mapOpenAICompatibleFinishReason(choice.finish_reason),
                raw: choice.finish_reason
              };
            }
          },
          flush(controller) {
            if (activeReasoningId != null) {
              controller.enqueue({
                type: "reasoning-end",
                id: activeReasoningId
              });
            }
            if (activeText) {
              controller.enqueue({ type: "text-end", id: "0" });
            }
            controller.enqueue({
              type: "finish",
              finishReason,
              usage: convertAlibabaUsage(usage)
            });
          }
        })
      ),
      request: { body: JSON.stringify(body) },
      response: { headers: responseHeaders }
    };
  }
};
var alibabaUsageSchema = v4.z.object({
  prompt_tokens: v4.z.number(),
  completion_tokens: v4.z.number(),
  total_tokens: v4.z.number(),
  prompt_tokens_details: v4.z.object({
    cached_tokens: v4.z.number().nullish(),
    cache_creation_input_tokens: v4.z.number().nullish()
  }).nullish(),
  completion_tokens_details: v4.z.object({
    reasoning_tokens: v4.z.number().nullish()
  }).nullish()
});
var alibabaChatResponseSchema = v4.z.object({
  id: v4.z.string().nullish(),
  created: v4.z.number().nullish(),
  model: v4.z.string().nullish(),
  choices: v4.z.array(
    v4.z.object({
      message: v4.z.object({
        role: v4.z.literal("assistant").nullish(),
        content: v4.z.string().nullish(),
        reasoning_content: v4.z.string().nullish(),
        // Alibaba thinking mode
        tool_calls: v4.z.array(
          v4.z.object({
            id: v4.z.string(),
            type: v4.z.literal("function"),
            function: v4.z.object({
              name: v4.z.string(),
              arguments: v4.z.string()
            })
          })
        ).nullish()
      }),
      finish_reason: v4.z.string().nullish(),
      index: v4.z.number()
    })
  ),
  usage: alibabaUsageSchema.nullish()
});
var alibabaChatChunkSchema = v4.z.object({
  id: v4.z.string().nullish(),
  created: v4.z.number().nullish(),
  model: v4.z.string().nullish(),
  choices: v4.z.array(
    v4.z.object({
      delta: v4.z.object({
        role: v4.z.enum(["assistant"]).nullish(),
        content: v4.z.string().nullish(),
        reasoning_content: v4.z.string().nullish(),
        // Alibaba thinking mode delta
        tool_calls: v4.z.array(
          v4.z.object({
            index: v4.z.number().nullish(),
            // Index for accumulating tool calls
            id: v4.z.string().nullish(),
            type: v4.z.literal("function").nullish(),
            function: v4.z.object({
              name: v4.z.string().nullish(),
              arguments: v4.z.string().nullish()
            }).nullish()
          })
        ).nullish()
      }),
      finish_reason: v4.z.string().nullish(),
      index: v4.z.number()
    })
  ),
  usage: alibabaUsageSchema.nullish()
  // Usage only appears in final chunk
});
var alibabaVideoModelOptionsSchema = chunkOCS2GTEN_cjs.lazySchema2(
  () => chunkOCS2GTEN_cjs.zodSchema2(
    v4.z.object({
      negativePrompt: v4.z.string().nullish(),
      audioUrl: v4.z.string().nullish(),
      promptExtend: v4.z.boolean().nullish(),
      shotType: v4.z.enum(["single", "multi"]).nullish(),
      watermark: v4.z.boolean().nullish(),
      audio: v4.z.boolean().nullish(),
      referenceUrls: v4.z.array(v4.z.string()).nullish(),
      pollIntervalMs: v4.z.number().positive().nullish(),
      pollTimeoutMs: v4.z.number().positive().nullish()
    }).passthrough()
  )
);
var alibabaVideoErrorSchema = v4.z.object({
  code: v4.z.string().nullish(),
  message: v4.z.string(),
  request_id: v4.z.string().nullish()
});
var alibabaVideoFailedResponseHandler = chunkOCS2GTEN_cjs.createJsonErrorResponseHandler2({
  errorSchema: alibabaVideoErrorSchema,
  errorToMessage: (data) => data.message
});
var alibabaVideoCreateTaskSchema = v4.z.object({
  output: v4.z.object({
    task_status: v4.z.string(),
    task_id: v4.z.string()
  }).nullish(),
  request_id: v4.z.string().nullish()
});
var alibabaVideoTaskStatusSchema = v4.z.object({
  output: v4.z.object({
    task_id: v4.z.string(),
    task_status: v4.z.string(),
    video_url: v4.z.string().nullish(),
    submit_time: v4.z.string().nullish(),
    scheduled_time: v4.z.string().nullish(),
    end_time: v4.z.string().nullish(),
    orig_prompt: v4.z.string().nullish(),
    actual_prompt: v4.z.string().nullish(),
    code: v4.z.string().nullish(),
    message: v4.z.string().nullish()
  }).nullish(),
  usage: v4.z.object({
    duration: v4.z.number().nullish(),
    output_video_duration: v4.z.number().nullish(),
    SR: v4.z.number().nullish(),
    size: v4.z.string().nullish()
  }).nullish(),
  request_id: v4.z.string().nullish()
});
function detectMode(modelId) {
  if (modelId.includes("-i2v")) return "i2v";
  if (modelId.includes("-r2v")) return "r2v";
  return "t2v";
}
var AlibabaVideoModel = class {
  constructor(modelId, config) {
    this.modelId = modelId;
    this.config = config;
    this.specificationVersion = "v3";
    this.maxVideosPerCall = 1;
  }
  get provider() {
    return this.config.provider;
  }
  async doGenerate(options) {
    var _a15, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k;
    const currentDate = (_c = (_b = (_a15 = this.config._internal) == null ? void 0 : _a15.currentDate) == null ? void 0 : _b.call(_a15)) != null ? _c : /* @__PURE__ */ new Date();
    const warnings = [];
    const mode = detectMode(this.modelId);
    const alibabaOptions = await chunkOCS2GTEN_cjs.parseProviderOptions2({
      provider: "alibaba",
      providerOptions: options.providerOptions,
      schema: alibabaVideoModelOptionsSchema
    });
    const input = {};
    if (options.prompt != null) {
      input.prompt = options.prompt;
    }
    if ((alibabaOptions == null ? void 0 : alibabaOptions.negativePrompt) != null) {
      input.negative_prompt = alibabaOptions.negativePrompt;
    }
    if ((alibabaOptions == null ? void 0 : alibabaOptions.audioUrl) != null) {
      input.audio_url = alibabaOptions.audioUrl;
    }
    if (mode === "i2v" && options.image != null) {
      if (options.image.type === "url") {
        input.img_url = options.image.url;
      } else {
        const base64Data = typeof options.image.data === "string" ? options.image.data : chunkOCS2GTEN_cjs.convertUint8ArrayToBase642(options.image.data);
        input.img_url = base64Data;
      }
    }
    if (mode === "r2v" && (alibabaOptions == null ? void 0 : alibabaOptions.referenceUrls) != null) {
      input.reference_urls = alibabaOptions.referenceUrls;
    }
    const parameters = {};
    if (options.duration != null) {
      parameters.duration = options.duration;
    }
    if (options.seed != null) {
      parameters.seed = options.seed;
    }
    if (options.resolution != null) {
      if (mode === "i2v") {
        const resolutionMap = {
          "1280x720": "720P",
          "720x1280": "720P",
          "960x960": "720P",
          "1088x832": "720P",
          "832x1088": "720P",
          "1920x1080": "1080P",
          "1080x1920": "1080P",
          "1440x1440": "1080P",
          "1632x1248": "1080P",
          "1248x1632": "1080P",
          "832x480": "480P",
          "480x832": "480P",
          "624x624": "480P"
        };
        parameters.resolution = resolutionMap[options.resolution] || options.resolution;
      } else {
        parameters.size = options.resolution.replace("x", "*");
      }
    }
    if ((alibabaOptions == null ? void 0 : alibabaOptions.promptExtend) != null) {
      parameters.prompt_extend = alibabaOptions.promptExtend;
    }
    if ((alibabaOptions == null ? void 0 : alibabaOptions.shotType) != null) {
      parameters.shot_type = alibabaOptions.shotType;
    }
    if ((alibabaOptions == null ? void 0 : alibabaOptions.watermark) != null) {
      parameters.watermark = alibabaOptions.watermark;
    }
    if ((alibabaOptions == null ? void 0 : alibabaOptions.audio) != null) {
      parameters.audio = alibabaOptions.audio;
    }
    if (options.aspectRatio) {
      warnings.push({
        type: "unsupported",
        feature: "aspectRatio",
        details: "Alibaba video models use explicit size/resolution dimensions. Use the resolution option or providerOptions.alibaba for size control."
      });
    }
    if (options.fps) {
      warnings.push({
        type: "unsupported",
        feature: "fps",
        details: "Alibaba video models do not support custom FPS."
      });
    }
    if (options.n != null && options.n > 1) {
      warnings.push({
        type: "unsupported",
        feature: "n",
        details: "Alibaba video models only support generating 1 video per call."
      });
    }
    const { value: createResponse } = await chunkOCS2GTEN_cjs.postJsonToApi2({
      url: `${this.config.baseURL}/api/v1/services/aigc/video-generation/video-synthesis`,
      headers: chunkOCS2GTEN_cjs.combineHeaders2(
        await chunkOCS2GTEN_cjs.resolve2(this.config.headers),
        options.headers,
        {
          "X-DashScope-Async": "enable"
        }
      ),
      body: {
        model: this.modelId,
        input,
        parameters
      },
      successfulResponseHandler: chunkOCS2GTEN_cjs.createJsonResponseHandler2(
        alibabaVideoCreateTaskSchema
      ),
      failedResponseHandler: alibabaVideoFailedResponseHandler,
      abortSignal: options.abortSignal,
      fetch: this.config.fetch
    });
    const taskId = (_d = createResponse.output) == null ? void 0 : _d.task_id;
    if (!taskId) {
      throw new chunkOCS2GTEN_cjs.AISDKError({
        name: "ALIBABA_VIDEO_GENERATION_ERROR",
        message: `No task_id returned from Alibaba API. Response: ${JSON.stringify(createResponse)}`
      });
    }
    const pollIntervalMs = (_e = alibabaOptions == null ? void 0 : alibabaOptions.pollIntervalMs) != null ? _e : 5e3;
    const pollTimeoutMs = (_f = alibabaOptions == null ? void 0 : alibabaOptions.pollTimeoutMs) != null ? _f : 6e5;
    const startTime = Date.now();
    let finalResponse;
    let responseHeaders;
    while (true) {
      await chunkOCS2GTEN_cjs.delay(pollIntervalMs, { abortSignal: options.abortSignal });
      if (Date.now() - startTime > pollTimeoutMs) {
        throw new chunkOCS2GTEN_cjs.AISDKError({
          name: "ALIBABA_VIDEO_GENERATION_TIMEOUT",
          message: `Video generation timed out after ${pollTimeoutMs}ms`
        });
      }
      const { value: statusResponse, responseHeaders: pollHeaders } = await chunkOCS2GTEN_cjs.getFromApi({
        url: `${this.config.baseURL}/api/v1/tasks/${taskId}`,
        headers: chunkOCS2GTEN_cjs.combineHeaders2(
          await chunkOCS2GTEN_cjs.resolve2(this.config.headers),
          options.headers
        ),
        successfulResponseHandler: chunkOCS2GTEN_cjs.createJsonResponseHandler2(
          alibabaVideoTaskStatusSchema
        ),
        failedResponseHandler: alibabaVideoFailedResponseHandler,
        abortSignal: options.abortSignal,
        fetch: this.config.fetch
      });
      responseHeaders = pollHeaders;
      const taskStatus = (_g = statusResponse.output) == null ? void 0 : _g.task_status;
      if (taskStatus === "SUCCEEDED") {
        finalResponse = statusResponse;
        break;
      }
      if (taskStatus === "FAILED" || taskStatus === "CANCELED") {
        throw new chunkOCS2GTEN_cjs.AISDKError({
          name: "ALIBABA_VIDEO_GENERATION_FAILED",
          message: `Video generation ${taskStatus.toLowerCase()}. Task ID: ${taskId}. ${(_i = (_h = statusResponse.output) == null ? void 0 : _h.message) != null ? _i : ""}`
        });
      }
    }
    const videoUrl = (_j = finalResponse == null ? void 0 : finalResponse.output) == null ? void 0 : _j.video_url;
    if (!videoUrl) {
      throw new chunkOCS2GTEN_cjs.AISDKError({
        name: "ALIBABA_VIDEO_GENERATION_ERROR",
        message: `No video URL in response. Task ID: ${taskId}`
      });
    }
    return {
      videos: [
        {
          type: "url",
          url: videoUrl,
          mediaType: "video/mp4"
        }
      ],
      warnings,
      response: {
        timestamp: currentDate,
        modelId: this.modelId,
        headers: responseHeaders
      },
      providerMetadata: {
        alibaba: {
          taskId,
          videoUrl,
          ...((_k = finalResponse == null ? void 0 : finalResponse.output) == null ? void 0 : _k.actual_prompt) ? { actualPrompt: finalResponse.output.actual_prompt } : {},
          ...(finalResponse == null ? void 0 : finalResponse.usage) ? {
            usage: {
              duration: finalResponse.usage.duration,
              outputVideoDuration: finalResponse.usage.output_video_duration,
              resolution: finalResponse.usage.SR,
              size: finalResponse.usage.size
            }
          } : {}
        }
      }
    };
  }
};
var VERSION = "1.0.25" ;
function createAlibaba(options = {}) {
  var _a15, _b;
  const baseURL = (_a15 = chunkOCS2GTEN_cjs.withoutTrailingSlash2(options.baseURL)) != null ? _a15 : "https://dashscope-intl.aliyuncs.com/compatible-mode/v1";
  const videoBaseURL = (_b = chunkOCS2GTEN_cjs.withoutTrailingSlash2(options.videoBaseURL)) != null ? _b : "https://dashscope-intl.aliyuncs.com";
  const getHeaders = () => chunkOCS2GTEN_cjs.withUserAgentSuffix2(
    {
      Authorization: `Bearer ${chunkOCS2GTEN_cjs.loadApiKey2({
        apiKey: options.apiKey,
        environmentVariableName: "ALIBABA_API_KEY",
        description: "Alibaba Cloud (DashScope)"
      })}`,
      ...options.headers
    },
    `ai-sdk/alibaba/${VERSION}`
  );
  const createLanguageModel = (modelId) => {
    var _a22;
    return new AlibabaLanguageModel(modelId, {
      provider: "alibaba.chat",
      baseURL,
      headers: getHeaders,
      fetch: options.fetch,
      includeUsage: (_a22 = options.includeUsage) != null ? _a22 : true
    });
  };
  const createVideoModel = (modelId) => new AlibabaVideoModel(modelId, {
    provider: "alibaba.video",
    baseURL: videoBaseURL,
    headers: getHeaders,
    fetch: options.fetch
  });
  const provider = function(modelId) {
    if (new.target) {
      throw new Error(
        "The Alibaba model function cannot be called with the new keyword."
      );
    }
    return createLanguageModel(modelId);
  };
  provider.specificationVersion = "v3";
  provider.languageModel = createLanguageModel;
  provider.chatModel = createLanguageModel;
  provider.video = createVideoModel;
  provider.videoModel = createVideoModel;
  provider.imageModel = (modelId) => {
    throw new chunkOCS2GTEN_cjs.NoSuchModelError2({ modelId, modelType: "imageModel" });
  };
  provider.embeddingModel = (modelId) => {
    throw new chunkOCS2GTEN_cjs.NoSuchModelError2({ modelId, modelType: "embeddingModel" });
  };
  return provider;
}
createAlibaba();
var VERSION2 = "1.0.44" ;
var cerebrasErrorSchema = v4.z.object({
  message: v4.z.string(),
  type: v4.z.string(),
  param: v4.z.string(),
  code: v4.z.string()
});
var cerebrasErrorStructure = {
  errorSchema: cerebrasErrorSchema,
  errorToMessage: (data) => data.message
};
function createCerebras(options = {}) {
  var _a15;
  const baseURL = chunkOCS2GTEN_cjs.withoutTrailingSlash(
    (_a15 = options.baseURL) != null ? _a15 : "https://api.cerebras.ai/v1"
  );
  const getHeaders = () => chunkOCS2GTEN_cjs.withUserAgentSuffix(
    {
      Authorization: `Bearer ${chunkOCS2GTEN_cjs.loadApiKey({
        apiKey: options.apiKey,
        environmentVariableName: "CEREBRAS_API_KEY",
        description: "Cerebras API key"
      })}`,
      ...options.headers
    },
    `ai-sdk/cerebras/${VERSION2}`
  );
  const createLanguageModel = (modelId) => {
    return new chunkOCS2GTEN_cjs.OpenAICompatibleChatLanguageModel(modelId, {
      provider: `cerebras.chat`,
      url: ({ path }) => `${baseURL}${path}`,
      headers: getHeaders,
      fetch: options.fetch,
      errorStructure: cerebrasErrorStructure,
      supportsStructuredOutputs: true
    });
  };
  const provider = (modelId) => createLanguageModel(modelId);
  provider.languageModel = createLanguageModel;
  provider.chat = createLanguageModel;
  provider.textEmbeddingModel = (modelId) => {
    throw new chunkOCS2GTEN_cjs.NoSuchModelError({ modelId, modelType: "textEmbeddingModel" });
  };
  provider.imageModel = (modelId) => {
    throw new chunkOCS2GTEN_cjs.NoSuchModelError({ modelId, modelType: "imageModel" });
  };
  return provider;
}
createCerebras();
var DeepInfraImageModel = class {
  constructor(modelId, config) {
    this.modelId = modelId;
    this.config = config;
    this.specificationVersion = "v2";
    this.maxImagesPerCall = 1;
  }
  get provider() {
    return this.config.provider;
  }
  async doGenerate({
    prompt,
    n,
    size,
    aspectRatio,
    seed,
    providerOptions,
    headers,
    abortSignal
  }) {
    var _a15, _b, _c, _d;
    const warnings = [];
    const splitSize = size == null ? void 0 : size.split("x");
    const currentDate = (_c = (_b = (_a15 = this.config._internal) == null ? void 0 : _a15.currentDate) == null ? void 0 : _b.call(_a15)) != null ? _c : /* @__PURE__ */ new Date();
    const { value: response, responseHeaders } = await chunkOCS2GTEN_cjs.postJsonToApi({
      url: `${this.config.baseURL}/${this.modelId}`,
      headers: chunkOCS2GTEN_cjs.combineHeaders(this.config.headers(), headers),
      body: {
        prompt,
        num_images: n,
        ...aspectRatio && { aspect_ratio: aspectRatio },
        ...splitSize && { width: splitSize[0], height: splitSize[1] },
        ...seed != null && { seed },
        ...(_d = providerOptions.deepinfra) != null ? _d : {}
      },
      failedResponseHandler: chunkOCS2GTEN_cjs.createJsonErrorResponseHandler({
        errorSchema: deepInfraErrorSchema,
        errorToMessage: (error) => error.detail.error
      }),
      successfulResponseHandler: chunkOCS2GTEN_cjs.createJsonResponseHandler(
        deepInfraImageResponseSchema
      ),
      abortSignal,
      fetch: this.config.fetch
    });
    return {
      images: response.images.map(
        (image) => image.replace(/^data:image\/\w+;base64,/, "")
      ),
      warnings,
      response: {
        timestamp: currentDate,
        modelId: this.modelId,
        headers: responseHeaders
      }
    };
  }
};
var deepInfraErrorSchema = v4.z.object({
  detail: v4.z.object({
    error: v4.z.string()
  })
});
var deepInfraImageResponseSchema = v4.z.object({
  images: v4.z.array(v4.z.string())
});
var DeepInfraChatLanguageModel = class extends chunkOCS2GTEN_cjs.OpenAICompatibleChatLanguageModel {
  constructor(modelId, config) {
    super(modelId, config);
  }
  fixUsage(usage) {
    var _a15, _b;
    const outputTokens = (_a15 = usage.outputTokens) != null ? _a15 : 0;
    const reasoningTokens = (_b = usage.reasoningTokens) != null ? _b : 0;
    if (reasoningTokens > outputTokens) {
      const correctedOutputTokens = outputTokens + reasoningTokens;
      return {
        ...usage,
        outputTokens: correctedOutputTokens,
        totalTokens: usage.totalTokens != null ? usage.totalTokens + reasoningTokens : void 0
      };
    }
    return usage;
  }
  async doGenerate(options) {
    const result = await super.doGenerate(options);
    return {
      ...result,
      usage: this.fixUsage(result.usage)
    };
  }
  async doStream(options) {
    const result = await super.doStream(options);
    const fixUsage = this.fixUsage.bind(this);
    const transformedStream = result.stream.pipeThrough(
      new TransformStream({
        transform(chunk, controller) {
          if (chunk.type === "finish") {
            controller.enqueue({
              ...chunk,
              usage: fixUsage(chunk.usage)
            });
          } else {
            controller.enqueue(chunk);
          }
        }
      })
    );
    return {
      ...result,
      stream: transformedStream
    };
  }
};
var VERSION3 = "1.0.42" ;
function createDeepInfra(options = {}) {
  var _a15;
  const baseURL = chunkOCS2GTEN_cjs.withoutTrailingSlash(
    (_a15 = options.baseURL) != null ? _a15 : "https://api.deepinfra.com/v1"
  );
  const getHeaders = () => chunkOCS2GTEN_cjs.withUserAgentSuffix(
    {
      Authorization: `Bearer ${chunkOCS2GTEN_cjs.loadApiKey({
        apiKey: options.apiKey,
        environmentVariableName: "DEEPINFRA_API_KEY",
        description: "DeepInfra's API key"
      })}`,
      ...options.headers
    },
    `ai-sdk/deepinfra/${VERSION3}`
  );
  const getCommonModelConfig = (modelType) => ({
    provider: `deepinfra.${modelType}`,
    url: ({ path }) => `${baseURL}/openai${path}`,
    headers: getHeaders,
    fetch: options.fetch
  });
  const createChatModel = (modelId) => {
    return new DeepInfraChatLanguageModel(
      modelId,
      getCommonModelConfig("chat")
    );
  };
  const createCompletionModel = (modelId) => new chunkOCS2GTEN_cjs.OpenAICompatibleCompletionLanguageModel(
    modelId,
    getCommonModelConfig("completion")
  );
  const createTextEmbeddingModel = (modelId) => new chunkOCS2GTEN_cjs.OpenAICompatibleEmbeddingModel(
    modelId,
    getCommonModelConfig("embedding")
  );
  const createImageModel = (modelId) => new DeepInfraImageModel(modelId, {
    ...getCommonModelConfig("image"),
    baseURL: baseURL ? `${baseURL}/inference` : "https://api.deepinfra.com/v1/inference"
  });
  const provider = (modelId) => createChatModel(modelId);
  provider.completionModel = createCompletionModel;
  provider.chatModel = createChatModel;
  provider.image = createImageModel;
  provider.imageModel = createImageModel;
  provider.languageModel = createChatModel;
  provider.textEmbeddingModel = createTextEmbeddingModel;
  return provider;
}
createDeepInfra();
function convertToDeepSeekChatMessages({
  prompt,
  responseFormat,
  modelId
}) {
  const isDeepSeekV4 = modelId.includes("deepseek-v4");
  const messages = [];
  const warnings = [];
  if ((responseFormat == null ? void 0 : responseFormat.type) === "json") {
    if (responseFormat.schema == null) {
      messages.push({
        role: "system",
        content: "Return JSON."
      });
    } else {
      messages.push({
        role: "system",
        content: "Return JSON that conforms to the following schema: " + JSON.stringify(responseFormat.schema)
      });
    }
  }
  let lastUserMessageIndex = -1;
  for (let i = prompt.length - 1; i >= 0; i--) {
    if (prompt[i].role === "user") {
      lastUserMessageIndex = i;
      break;
    }
  }
  let index = -1;
  for (const { role, content } of prompt) {
    index++;
    switch (role) {
      case "system": {
        messages.push({ role: "system", content });
        break;
      }
      case "user": {
        let userContent = "";
        for (const part of content) {
          if (part.type === "text") {
            userContent += part.text;
          } else {
            warnings.push({
              type: "other",
              message: `Unsupported user message part type: ${part.type}`
            });
          }
        }
        messages.push({
          role: "user",
          content: userContent
        });
        break;
      }
      case "assistant": {
        let text = "";
        let reasoning;
        const toolCalls = [];
        for (const part of content) {
          switch (part.type) {
            case "text": {
              text += part.text;
              break;
            }
            case "reasoning": {
              if (index <= lastUserMessageIndex && !isDeepSeekV4) {
                break;
              }
              if (reasoning == null) {
                reasoning = part.text;
              } else {
                reasoning += 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,
          reasoning_content: reasoning != null ? reasoning : isDeepSeekV4 ? "" : void 0,
          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: {
        warnings.push({
          type: "other",
          message: `Unsupported message role: ${role}`
        });
        break;
      }
    }
  }
  return { messages, warnings };
}
var tokenUsageSchema = v4.z.object({
  prompt_tokens: v4.z.number().nullish(),
  completion_tokens: v4.z.number().nullish(),
  prompt_cache_hit_tokens: v4.z.number().nullish(),
  prompt_cache_miss_tokens: v4.z.number().nullish(),
  total_tokens: v4.z.number().nullish(),
  completion_tokens_details: v4.z.object({
    reasoning_tokens: v4.z.number().nullish()
  }).nullish()
}).nullish();
var deepSeekErrorSchema = v4.z.object({
  error: v4.z.object({
    message: v4.z.string(),
    type: v4.z.string().nullish(),
    param: v4.z.any().nullish(),
    code: v4.z.union([v4.z.string(), v4.z.number()]).nullish()
  })
});
var deepseekChatResponseSchema = v4.z.object({
  id: v4.z.string().nullish(),
  created: v4.z.number().nullish(),
  model: v4.z.string().nullish(),
  choices: v4.z.array(
    v4.z.object({
      message: v4.z.object({
        role: v4.z.literal("assistant").nullish(),
        content: v4.z.string().nullish(),
        reasoning_content: v4.z.string().nullish(),
        tool_calls: v4.z.array(
          v4.z.object({
            id: v4.z.string().nullish(),
            function: v4.z.object({
              name: v4.z.string(),
              arguments: v4.z.string()
            })
          })
        ).nullish()
      }),
      finish_reason: v4.z.string().nullish()
    })
  ),
  usage: tokenUsageSchema
});
var deepseekChatChunkSchema = chunkOCS2GTEN_cjs.lazySchema(
  () => chunkOCS2GTEN_cjs.zodSchema(
    v4.z.union([
      v4.z.object({
        id: v4.z.string().nullish(),
        created: v4.z.number().nullish(),
        model: v4.z.string().nullish(),
        choices: v4.z.array(
          v4.z.object({
            delta: v4.z.object({
              role: v4.z.enum(["assistant"]).nullish(),
              content: v4.z.string().nullish(),
              reasoning_content: v4.z.string().nullish(),
              tool_calls: v4.z.array(
                v4.z.object({
                  index: v4.z.number(),
                  id: v4.z.string().nullish(),
                  function: v4.z.object({
                    name: v4.z.string().nullish(),
                    arguments: v4.z.string().nullish()
                  })
                })
              ).nullish()
            }).nullish(),
            finish_reason: v4.z.string().nullish()
          })
        ),
        usage: tokenUsageSchema
      }),
      deepSeekErrorSchema
    ])
  )
);
var deepseekChatOptions = v4.z.object({
  /**
   * Type of thinking to use. Defaults to `enabled`.
   */
  thinking: v4.z.object({
    type: v4.z.enum(["enabled", "disabled"]).optional()
  }).optional(),
  /**
   * Controls the thinking strength for DeepSeek V4 reasoning models.
   */
  reasoningEffort: v4.z.enum(["high", "max"]).optional()
});
function prepareTools2({
  tools,
  toolChoice
}) {
  tools = (tools == null ? void 0 : tools.length) ? tools : void 0;
  const toolWarnings = [];
  if (tools == null) {
    return { tools: void 0, toolChoice: void 0, toolWarnings };
  }
  const deepseekTools = [];
  for (const tool of tools) {
    if (tool.type === "provider-defined") {
      toolWarnings.push({
        type: "unsupported-tool",
        tool
      });
    } else {
      deepseekTools.push({
        type: "function",
        function: {
          name: tool.name,
          description: tool.description,
          parameters: tool.inputSchema
        }
      });
    }
  }
  if (toolChoice == null) {
    return { tools: deepseekTools, toolChoice: void 0, toolWarnings };
  }
  const type = toolChoice.type;
  switch (type) {
    case "auto":
    case "none":
    case "required":
      return { tools: deepseekTools, toolChoice: type, toolWarnings };
    case "tool":
      return {
        tools: deepseekTools,
        toolChoice: {
          type: "function",
          function: { name: toolChoice.toolName }
        },
        toolWarnings
      };
    default: {
      const _exhaustiveCheck = type;
      throw new chunkOCS2GTEN_cjs.UnsupportedFunctionalityError({
        functionality: `tool choice type: ${_exhaustiveCheck}`
      });
    }
  }
}
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 mapDeepSeekFinishReason(finishReason) {
  switch (finishReason) {
    case "stop":
      return "stop";
    case "length":
      return "length";
    case "content_filter":
      return "content-filter";
    case "tool_calls":
      return "tool-calls";
    case "insufficient_system_resource":
      return "error";
    default:
      return "unknown";
  }
}
var DeepSeekChatLanguageModel = class {
  constructor(modelId, config) {
    this.specificationVersion = "v2";
    this.supportedUrls = {};
    this.modelId = modelId;
    this.config = config;
    this.failedResponseHandler = chunkOCS2GTEN_cjs.createJsonErrorResponseHandler({
      errorSchema: deepSeekErrorSchema,
      errorToMessage: (error) => error.error.message
    });
  }
  get provider() {
    return this.config.provider;
  }
  get providerOptionsName() {
    return this.config.provider.split(".")[0].trim();
  }
  async getArgs({
    prompt,
    maxOutputTokens,
    temperature,
    topP,
    topK,
    frequencyPenalty,
    presencePenalty,
    providerOptions,
    stopSequences,
    responseFormat,
    tools,
    toolChoice,
    seed
  }) {
    var _a15, _b;
    const deepseekOptions = (_a15 = await chunkOCS2GTEN_cjs.parseProviderOptions({
      provider: this.providerOptionsName,
      providerOptions,
      schema: deepseekChatOptions
    })) != null ? _a15 : {};
    const { messages, warnings } = convertToDeepSeekChatMessages({
      prompt,
      responseFormat,
      modelId: this.modelId
    });
    if (topK != null) {
      warnings.push({ type: "unsupported-setting", setting: "topK" });
    }
    if (seed != null) {
      warnings.push({ type: "unsupported-setting", setting: "seed" });
    }
    const {
      tools: deepseekTools,
      toolChoice: deepseekToolChoices,
      toolWarnings
    } = prepareTools2({
      tools,
      toolChoice
    });
    const thinking = ((_b = deepseekOptions.thinking) == null ? void 0 : _b.type) != null ? { type: deepseekOptions.thinking.type } : void 0;
    return {
      args: {
        model: this.modelId,
        max_tokens: maxOutputTokens,
        temperature,
        top_p: topP,
        frequency_penalty: frequencyPenalty,
        presence_penalty: presencePenalty,
        response_format: (responseFormat == null ? void 0 : responseFormat.type) === "json" ? { type: "json_object" } : void 0,
        stop: stopSequences,
        messages,
        tools: deepseekTools,
        tool_choice: deepseekToolChoices,
        thinking,
        ...(thinking == null ? void 0 : thinking.type) !== "disabled" && deepseekOptions.reasoningEffort != null && {
          reasoning_effort: deepseekOptions.reasoningEffort
        }
      },
      warnings: [...warnings, ...toolWarnings]
    };
  }
  async doGenerate(options) {
    var _a15, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p;
    const { args, warnings } = await this.getArgs({ ...options });
    const {
      responseHeaders,
      value: responseBody,
      rawValue: rawResponse
    } = await chunkOCS2GTEN_cjs.postJsonToApi({
      url: this.config.url({
        path: "/chat/completions",
        modelId: this.modelId
      }),
      headers: chunkOCS2GTEN_cjs.combineHeaders(this.config.headers(), options.headers),
      body: args,
      failedResponseHandler: this.failedResponseHandler,
      successfulResponseHandler: chunkOCS2GTEN_cjs.createJsonResponseHandler(
        deepseekChatResponseSchema
      ),
      abortSignal: options.abortSignal,
      fetch: this.config.fetch
    });
    const choice = responseBody.choices[0];
    const content = [];
    const reasoning = choice.message.reasoning_content;
    if (reasoning != null && reasoning.length > 0) {
      content.push({
        type: "reasoning",
        text: reasoning
      });
    }
    if (choice.message.tool_calls != null) {
      for (const toolCall of choice.message.tool_calls) {
        content.push({
          type: "tool-call",
          toolCallId: (_a15 = toolCall.id) != null ? _a15 : chunkOCS2GTEN_cjs.generateId(),
          toolName: toolCall.function.name,
          input: toolCall.function.arguments
        });
      }
    }
    const text = choice.message.content;
    if (text != null && text.length > 0) {
      content.push({ type: "text", text });
    }
    return {
      content,
      finishReason: mapDeepSeekFinishReason(choice.finish_reason),
      usage: {
        inputTokens: (_c = (_b = responseBody.usage) == null ? void 0 : _b.prompt_tokens) != null ? _c : void 0,
        outputTokens: (_e = (_d = responseBody.usage) == null ? void 0 : _d.completion_tokens) != null ? _e : void 0,
        totalTokens: (_g = (_f = responseBody.usage) == null ? void 0 : _f.total_tokens) != null ? _g : void 0,
        reasoningTokens: (_j = (_i = (_h = responseBody.usage) == null ? void 0 : _h.completion_tokens_details) == null ? void 0 : _i.reasoning_tokens) != null ? _j : void 0,
        cachedInputTokens: (_l = (_k = responseBody.usage) == null ? void 0 : _k.prompt_cache_hit_tokens) != null ? _l : void 0
      },
      providerMetadata: {
        [this.providerOptionsName]: {
          promptCacheHitTokens: (_n = (_m = responseBody.usage) == null ? void 0 : _m.prompt_cache_hit_tokens) != null ? _n : null,
          promptCacheMissTokens: (_p = (_o = responseBody.usage) == null ? void 0 : _o.prompt_cache_miss_tokens) != null ? _p : null
        }
      },
      request: { body: args },
      response: {
        ...getResponseMetadata2(responseBody),
        headers: responseHeaders,
        body: rawResponse
      },
      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 chunkOCS2GTEN_cjs.postJsonToApi({
      url: this.config.url({
        path: "/chat/completions",
        modelId: this.modelId
      }),
      headers: chunkOCS2GTEN_cjs.combineHeaders(this.config.headers(), options.headers),
      body,
      failedResponseHandler: this.failedResponseHandler,
      successfulResponseHandler: chunkOCS2GTEN_cjs.createEventSourceResponseHandler(
        deepseekChatChunkSchema
      ),
      abortSignal: options.abortSignal,
      fetch: this.config.fetch
    });
    const toolCalls = [];
    let finishReason = "unknown";
    let usage = void 0;
    let isFirstChunk = true;
    const providerOptionsName = this.providerOptionsName;
    let isActiveReasoning = false;
    let isActiveText = false;
    return {
      stream: response.pipeThrough(
        new TransformStream({
          start(controller) {
            controller.enqueue({ type: "stream-start", warnings });
          },
          transform(chunk, controller) {
            var _a15, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l;
            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.message });
              return;
            }
            if (isFirstChunk) {
              isFirstChunk = false;
              controller.enqueue({
                type: "response-metadata",
                ...getResponseMetadata2(value)
              });
            }
            if (value.usage != null) {
              usage = value.usage;
            }
            const choice = value.choices[0];
            if ((choice == null ? void 0 : choice.finish_reason) != null) {
              finishReason = mapDeepSeekFinishReason(choice.finish_reason);
            }
            if ((choice == null ? void 0 : choice.delta) == null) {
              return;
            }
            const delta = choice.delta;
            const reasoningContent = delta.reasoning_content;
            if (reasoningContent) {
              if (!isActiveReasoning) {
                controller.enqueue({
                  type: "reasoning-start",
                  id: "reasoning-0"
                });
                isActiveReasoning = true;
              }
              controller.enqueue({
                type: "reasoning-delta",
                id: "reasoning-0",
                delta: reasoningContent
              });
            }
            if (delta.content) {
              if (!isActiveText) {
                controller.enqueue({ type: "text-start", id: "txt-0" });
                isActiveText = true;
              }
              if (isActiveReasoning) {
                controller.enqueue({
                  type: "reasoning-end",
                  id: "reasoning-0"
                });
                isActiveReasoning = false;
              }
              controller.enqueue({
                type: "text-delta",
                id: "txt-0",
                delta: delta.content
              });
            }
            if (delta.tool_calls != null) {
              if (isActiveReasoning) {
                controller.enqueue({
                  type: "reasoning-end",
                  id: "reasoning-0"
                });
                isActiveReasoning = false;
              }
              for (const toolCallDelta of delta.tool_calls) {
                const index = toolCallDelta.index;
                if (toolCalls[index] == null) {
                  if (toolCallDelta.id == null) {
                    throw new chunkOCS2GTEN_cjs.InvalidResponseDataError({
                      data: toolCallDelta,
                      message: `Expected 'id' to be a string.`
                    });
                  }
                  if (((_a15 = toolCallDelta.function) == null ? void 0 : _a15.name) == null) {
                    throw new chunkOCS2GTEN_cjs.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: (_b = toolCallDelta.function.arguments) != null ? _b : ""
                    },
                    hasFinished: false
                  };
                  const toolCall2 = toolCalls[index];
                  if (((_c = toolCall2.function) == null ? void 0 : _c.name) != null && ((_d = toolCall2.function) == null ? void 0 : _d.arguments) != null) {
                    if (toolCall2.function.arguments.length > 0) {
                      controller.enqueue({
                        type: "tool-input-delta",
                        id: toolCall2.id,
                        delta: toolCall2.function.arguments
                      });
                    }
                    if (chunkOCS2GTEN_cjs.isParsableJson(toolCall2.function.arguments)) {
                      controller.enqueue({
                        type: "tool-input-end",
                        id: toolCall2.id
                      });
                      controller.enqueue({
                        type: "tool-call",
                        toolCallId: (_e = toolCall2.id) != null ? _e : chunkOCS2GTEN_cjs.generateId(),
                        toolName: toolCall2.function.name,
                        input: toolCall2.function.arguments
                      });
                      toolCall2.hasFinished = true;
                    }
                  }
                  continue;
                }
                const toolCall = toolCalls[index];
                if (toolCall.hasFinished) {
                  continue;
                }
                if (((_f = toolCallDelta.function) == null ? void 0 : _f.arguments) != null) {
                  toolCall.function.arguments += (_h = (_g = toolCallDelta.function) == null ? void 0 : _g.arguments) != null ? _h : "";
                }
                controller.enqueue({
                  type: "tool-input-delta",
                  id: toolCall.id,
                  delta: (_i = toolCallDelta.function.arguments) != null ? _i : ""
                });
                if (((_j = toolCall.function) == null ? void 0 : _j.name) != null && ((_k = toolCall.function) == null ? void 0 : _k.arguments) != null && chunkOCS2GTEN_cjs.isParsableJson(toolCall.function.arguments)) {
                  controller.enqueue({
                    type: "tool-input-end",
                    id: toolCall.id
                  });
                  controller.enqueue({
                    type: "tool-call",
                    toolCallId: (_l = toolCall.id) != null ? _l : chunkOCS2GTEN_cjs.generateId(),
                    toolName: toolCall.function.name,
                    input: toolCall.function.arguments
                  });
                  toolCall.hasFinished = true;
                }
              }
            }
          },
          flush(controller) {
            var _a15, _b, _c, _d, _e, _f, _g, _h, _i;
            if (isActiveReasoning) {
              controller.enqueue({ type: "reasoning-end", id: "reasoning-0" });
            }
            if (isActiveText) {
              controller.enqueue({ type: "text-end", id: "txt-0" });
            }
            for (const toolCall of toolCalls.filter(
              (toolCall2) => !toolCall2.hasFinished
            )) {
              controller.enqueue({
                type: "tool-input-end",
                id: toolCall.id
              });
              controller.enqueue({
                type: "tool-call",
                toolCallId: (_a15 = toolCall.id) != null ? _a15 : chunkOCS2GTEN_cjs.generateId(),
                toolName: toolCall.function.name,
                input: toolCall.function.arguments
              });
            }
            controller.enqueue({
              type: "finish",
              finishReason,
              usage: {
                inputTokens: (_b = usage == null ? void 0 : usage.prompt_tokens) != null ? _b : void 0,
                outputTokens: (_c = usage == null ? void 0 : usage.completion_tokens) != null ? _c : void 0,
                totalTokens: (_d = usage == null ? void 0 : usage.total_tokens) != null ? _d : void 0,
                reasoningTokens: (_f = (_e = usage == null ? void 0 : usage.completion_tokens_details) == null ? void 0 : _e.reasoning_tokens) != null ? _f : void 0,
                cachedInputTokens: (_g = usage == null ? void 0 : usage.prompt_cache_hit_tokens) != null ? _g : void 0
              },
              providerMetadata: {
                [providerOptionsName]: {
                  promptCacheHitTokens: (_h = usage == null ? void 0 : usage.prompt_cache_hit_tokens) != null ? _h : null,
                  promptCacheMissTokens: (_i = usage == null ? void 0 : usage.prompt_cache_miss_tokens) != null ? _i : null
                }
              }
            });
          }
        })
      ),
      request: { body },
      response: { headers: responseHeaders }
    };
  }
};
var VERSION4 = "1.0.40" ;
function createDeepSeek(options = {}) {
  var _a15;
  const baseURL = chunkOCS2GTEN_cjs.withoutTrailingSlash(
    (_a15 = options.baseURL) != null ? _a15 : "https://api.deepseek.com"
  );
  const getHeaders = () => chunkOCS2GTEN_cjs.withUserAgentSuffix(
    {
      Authorization: `Bearer ${chunkOCS2GTEN_cjs.loadApiKey({
        apiKey: options.apiKey,
        environmentVariableName: "DEEPSEEK_API_KEY",
        description: "DeepSeek API key"
      })}`,
      ...options.headers
    },
    `ai-sdk/deepseek/${VERSION4}`
  );
  const createLanguageModel = (modelId) => {
    return new DeepSeekChatLanguageModel(modelId, {
      provider: `deepseek.chat`,
      url: ({ path }) => `${baseURL}${path}`,
      headers: getHeaders,
      fetch: options.fetch
    });
  };
  const provider = (modelId) => createLanguageModel(modelId);
  provider.languageModel = createLanguageModel;
  provider.chat = createLanguageModel;
  provider.textEmbeddingModel = (modelId) => {
    throw new chunkOCS2GTEN_cjs.NoSuchModelError({ modelId, modelType: "textEmbeddingModel" });
  };
  provider.imageModel = (modelId) => {
    throw new chunkOCS2GTEN_cjs.NoSuchModelError({ modelId, modelType: "imageModel" });
  };
  return provider;
}
createDeepSeek();
function convertGroqUsage(usage) {
  var _a15, _b, _c, _d;
  if (usage == null) {
    return {
      inputTokens: {
        total: void 0,
        noCache: void 0,
        cacheRead: void 0,
        cacheWrite: void 0
      },
      outputTokens: {
        total: void 0,
        text: void 0,
        reasoning: void 0
      },
      raw: void 0
    };
  }
  const promptTokens = (_a15 = usage.prompt_tokens) != null ? _a15 : 0;
  const completionTokens = (_b = usage.completion_tokens) != null ? _b : 0;
  const reasoningTokens = (_d = (_c = usage.completion_tokens_details) == null ? void 0 : _c.reasoning_tokens) != null ? _d : void 0;
  const textTokens = reasoningTokens != null ? completionTokens - reasoningTokens : completionTokens;
  return {
    inputTokens: {
      total: promptTokens,
      noCache: promptTokens,
      cacheRead: void 0,
      cacheWrite: void 0
    },
    outputTokens: {
      total: completionTokens,
      text: textTokens,
      reasoning: reasoningTokens
    },
    raw: usage
  };
}
function convertToGroqChatMessages(prompt) {
  var _a15;
  const messages = [];
  for (const { role, content } of prompt) {
    switch (role) {
      case "system": {
        messages.push({ role: "system", content });
        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) => {
            switch (part.type) {
              case "text": {
                return { type: "text", text: part.text };
              }
              case "file": {
                if (!part.mediaType.startsWith("image/")) {
                  throw new chunkOCS2GTEN_cjs.UnsupportedFunctionalityError2({
                    functionality: "Non-image file content parts"
                  });
                }
                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,${chunkOCS2GTEN_cjs.convertToBase642(part.data)}`
                  }
                };
              }
            }
          })
        });
        break;
      }
      case "assistant": {
        let text = "";
        let reasoning = "";
        const toolCalls = [];
        for (const part of content) {
          switch (part.type) {
            // groq supports reasoning for tool-calls in multi-turn conversations
            // https://github.com/vercel/ai/issues/7860
            case "reasoning": {
              reasoning += part.text;
              break;
            }
            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,
          ...reasoning.length > 0 ? { reasoning } : null,
          ...toolCalls.length > 0 ? { tool_calls: toolCalls } : null
        });
        break;
      }
      case "tool": {
        for (const toolResponse of content) {
          if (toolResponse.type === "tool-approval-response") {
            continue;
          }
          const output = toolResponse.output;
          let contentValue;
          switch (output.type) {
            case "text":
            case "error-text":
              contentValue = output.value;
              break;
            case "execution-denied":
              contentValue = (_a15 = output.reason) != null ? _a15 : "Tool execution denied.";
              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;
}
function getResponseMetadata3({
  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
  };
}
var groqLanguageModelOptions = v4.z.object({
  reasoningFormat: v4.z.enum(["parsed", "raw", "hidden"]).optional(),
  /**
   * Specifies the reasoning effort level for model inference.
   * @see https://console.groq.com/docs/reasoning#reasoning-effort
   */
  reasoningEffort: v4.z.enum(["none", "default", "low", "medium", "high"]).optional(),
  /**
   * Whether to enable parallel function calling during tool use. Default to true.
   */
  parallelToolCalls: v4.z.boolean().optional(),
  /**
   * A unique identifier representing your end-user, which can help OpenAI to
   * monitor and detect abuse. Learn more.
   */
  user: v4.z.string().optional(),
  /**
   * Whether to use structured outputs.
   *
   * @default true
   */
  structuredOutputs: v4.z.boolean().optional(),
  /**
   * Whether to use strict JSON schema validation.
   * When true, the model uses constrained decoding to guarantee schema compliance.
   * Only used when structured outputs are enabled and a schema is provided.
   *
   * @default true
   */
  strictJsonSchema: v4.z.boolean().optional(),
  /**
   * Service tier for the request.
   * - 'on_demand': Default tier with consistent performance and fairness
   * - 'performance': Prioritized tier for latency-sensitive workloads
   * - 'flex': Higher throughput tier optimized for workloads that can handle occasional request failures
   * - 'auto': Uses on_demand rate limits, then falls back to flex tier if exceeded
   *
   * @default 'on_demand'
   */
  serviceTier: v4.z.enum(["on_demand", "performance", "flex", "auto"]).optional()
});
var groqErrorDataSchema = v4.z.object({
  error: v4.z.object({
    message: v4.z.string(),
    type: v4.z.string()
  })
});
var groqFailedResponseHandler = chunkOCS2GTEN_cjs.createJsonErrorResponseHandler2({
  errorSchema: groqErrorDataSchema,
  errorToMessage: (data) => data.error.message
});
var BROWSER_SEARCH_SUPPORTED_MODELS = [
  "openai/gpt-oss-20b",
  "openai/gpt-oss-120b"
];
function isBrowserSearchSupportedModel(modelId) {
  return BROWSER_SEARCH_SUPPORTED_MODELS.includes(modelId);
}
function getSupportedModelsString() {
  return BROWSER_SEARCH_SUPPORTED_MODELS.join(", ");
}
function prepareTools3({
  tools,
  toolChoice,
  modelId
}) {
  tools = (tools == null ? void 0 : tools.length) ? tools : void 0;
  const toolWarnings = [];
  if (tools == null) {
    return { tools: void 0, toolChoice: void 0, toolWarnings };
  }
  const groqTools2 = [];
  for (const tool of tools) {
    if (tool.type === "provider") {
      if (tool.id === "groq.browser_search") {
        if (!isBrowserSearchSupportedModel(modelId)) {
          toolWarnings.push({
            type: "unsupported",
            feature: `provider-defined tool ${tool.id}`,
            details: `Browser search is only supported on the following models: ${getSupportedModelsString()}. Current model: ${modelId}`
          });
        } else {
          groqTools2.push({
            type: "browser_search"
          });
        }
      } else {
        toolWarnings.push({
          type: "unsupported",
          feature: `provider-defined tool ${tool.id}`
        });
      }
    } else {
      groqTools2.push({
        type: "function",
        function: {
          name: tool.name,
          description: tool.description,
          parameters: tool.inputSchema,
          ...tool.strict != null ? { strict: tool.strict } : {}
        }
      });
    }
  }
  if (toolChoice == null) {
    return { tools: groqTools2, toolChoice: void 0, toolWarnings };
  }
  const type = toolChoice.type;
  switch (type) {
    case "auto":
    case "none":
    case "required":
      return { tools: groqTools2, toolChoice: type, toolWarnings };
    case "tool":
      return {
        tools: groqTools2,
        toolChoice: {
          type: "function",
          function: {
            name: toolChoice.toolName
          }
        },
        toolWarnings
      };
    default: {
      const _exhaustiveCheck = type;
      throw new chunkOCS2GTEN_cjs.UnsupportedFunctionalityError2({
        functionality: `tool choice type: ${_exhaustiveCheck}`
      });
    }
  }
}
function mapGroqFinishReason(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 "other";
  }
}
var GroqChatLanguageModel = class {
  constructor(modelId, config) {
    this.specificationVersion = "v3";
    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,
    stream,
    tools,
    toolChoice,
    providerOptions
  }) {
    var _a15, _b, _c;
    const warnings = [];
    const groqOptions = await chunkOCS2GTEN_cjs.parseProviderOptions2({
      provider: "groq",
      providerOptions,
      schema: groqLanguageModelOptions
    });
    const structuredOutputs = (_a15 = groqOptions == null ? void 0 : groqOptions.structuredOutputs) != null ? _a15 : true;
    const strictJsonSchema = (_b = groqOptions == null ? void 0 : groqOptions.strictJsonSchema) != null ? _b : true;
    if (topK != null) {
      warnings.push({ type: "unsupported", feature: "topK" });
    }
    if ((responseFormat == null ? void 0 : responseFormat.type) === "json" && responseFormat.schema != null && !structuredOutputs) {
      warnings.push({
        type: "unsupported",
        feature: "responseFormat",
        details: "JSON response format schema is only supported with structuredOutputs"
      });
    }
    const {
      tools: groqTools2,
      toolChoice: groqToolChoice,
      toolWarnings
    } = prepareTools3({ tools, toolChoice, modelId: this.modelId });
    return {
      args: {
        // model id:
        model: this.modelId,
        // model specific settings:
        user: groqOptions == null ? void 0 : groqOptions.user,
        parallel_tool_calls: groqOptions == null ? void 0 : groqOptions.parallelToolCalls,
        // standardized settings:
        max_tokens: maxOutputTokens,
        temperature,
        top_p: topP,
        frequency_penalty: frequencyPenalty,
        presence_penalty: presencePenalty,
        stop: stopSequences,
        seed,
        // response format:
        response_format: (responseFormat == null ? void 0 : responseFormat.type) === "json" ? structuredOutputs && responseFormat.schema != null ? {
          type: "json_schema",
          json_schema: {
            schema: responseFormat.schema,
            strict: strictJsonSchema,
            name: (_c = responseFormat.name) != null ? _c : "response",
            description: responseFormat.description
          }
        } : { type: "json_object" } : void 0,
        // provider options:
        reasoning_format: groqOptions == null ? void 0 : groqOptions.reasoningFormat,
        reasoning_effort: groqOptions == null ? void 0 : groqOptions.reasoningEffort,
        service_tier: groqOptions == null ? void 0 : groqOptions.serviceTier,
        // messages:
        messages: convertToGroqChatMessages(prompt),
        // tools:
        tools: groqTools2,
        tool_choice: groqToolChoice
      },
      warnings: [...warnings, ...toolWarnings]
    };
  }
  async doGenerate(options) {
    var _a15, _b;
    const { args, warnings } = await this.getArgs({
      ...options,
      stream: false
    });
    const body = JSON.stringify(args);
    const {
      responseHeaders,
      value: response,
      rawValue: rawResponse
    } = await chunkOCS2GTEN_cjs.postJsonToApi2({
      url: this.config.url({
        path: "/chat/completions",
        modelId: this.modelId
      }),
      headers: chunkOCS2GTEN_cjs.combineHeaders2(this.config.headers(), options.headers),
      body: args,
      failedResponseHandler: groqFailedResponseHandler,
      successfulResponseHandler: chunkOCS2GTEN_cjs.createJsonResponseHandler2(
        groqChatResponseSchema
      ),
      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 });
    }
    const reasoning = choice.message.reasoning;
    if (reasoning != null && reasoning.length > 0) {
      content.push({
        type: "reasoning",
        text: reasoning
      });
    }
    if (choice.message.tool_calls != null) {
      for (const toolCall of choice.message.tool_calls) {
        content.push({
          type: "tool-call",
          toolCallId: (_a15 = toolCall.id) != null ? _a15 : chunkOCS2GTEN_cjs.generateId2(),
          toolName: toolCall.function.name,
          input: toolCall.function.arguments
        });
      }
    }
    return {
      content,
      finishReason: {
        unified: mapGroqFinishReason(choice.finish_reason),
        raw: (_b = choice.finish_reason) != null ? _b : void 0
      },
      usage: convertGroqUsage(response.usage),
      response: {
        ...getResponseMetadata3(response),
        headers: responseHeaders,
        body: rawResponse
      },
      warnings,
      request: { body }
    };
  }
  async doStream(options) {
    const { args, warnings } = await this.getArgs({ ...options, stream: true });
    const body = JSON.stringify({ ...args, stream: true });
    const { responseHeaders, value: response } = await chunkOCS2GTEN_cjs.postJsonToApi2({
      url: this.config.url({
        path: "/chat/completions",
        modelId: this.modelId
      }),
      headers: chunkOCS2GTEN_cjs.combineHeaders2(this.config.headers(), options.headers),
      body: {
        ...args,
        stream: true
      },
      failedResponseHandler: groqFailedResponseHandler,
      successfulResponseHandler: chunkOCS2GTEN_cjs.createEventSourceResponseHandler2(groqChatChunkSchema),
      abortSignal: options.abortSignal,
      fetch: this.config.fetch
    });
    const toolCalls = [];
    let finishReason = {
      unified: "other",
      raw: void 0
    };
    let usage = void 0;
    let isFirstChunk = true;
    let isActiveText = false;
    let isActiveReasoning = false;
    return {
      stream: response.pipeThrough(
        new TransformStream({
          start(controller) {
            controller.enqueue({ type: "stream-start", warnings });
          },
          transform(chunk, controller) {
            var _a15, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m;
            if (options.includeRawChunks) {
              controller.enqueue({ type: "raw", rawValue: chunk.rawValue });
            }
            if (!chunk.success) {
              finishReason = {
                unified: "error",
                raw: void 0
              };
              controller.enqueue({ type: "error", error: chunk.error });
              return;
            }
            const value = chunk.value;
            if ("error" in value) {
              finishReason = {
                unified: "error",
                raw: void 0
              };
              controller.enqueue({ type: "error", error: value.error });
              return;
            }
            if (isFirstChunk) {
              isFirstChunk = false;
              controller.enqueue({
                type: "response-metadata",
                ...getResponseMetadata3(value)
              });
            }
            if (((_a15 = value.x_groq) == null ? void 0 : _a15.usage) != null) {
              usage = value.x_groq.usage;
            }
            const choice = value.choices[0];
            if ((choice == null ? void 0 : choice.finish_reason) != null) {
              finishReason = {
                unified: mapGroqFinishReason(choice.finish_reason),
                raw: choice.finish_reason
              };
            }
            if ((choice == null ? void 0 : choice.delta) == null) {
              return;
            }
            const delta = choice.delta;
            if (delta.reasoning != null && delta.reasoning.length > 0) {
              if (!isActiveReasoning) {
                controller.enqueue({
                  type: "reasoning-start",
                  id: "reasoning-0"
                });
                isActiveReasoning = true;
              }
              controller.enqueue({
                type: "reasoning-delta",
                id: "reasoning-0",
                delta: delta.reasoning
              });
            }
            if (delta.content != null && delta.content.length > 0) {
              if (isActiveReasoning) {
                controller.enqueue({
                  type: "reasoning-end",
                  id: "reasoning-0"
                });
                isActiveReasoning = false;
              }
              if (!isActiveText) {
                controller.enqueue({ type: "text-start", id: "txt-0" });
                isActiveText = true;
              }
              controller.enqueue({
                type: "text-delta",
                id: "txt-0",
                delta: delta.content
              });
            }
            if (delta.tool_calls != null) {
              if (isActiveReasoning) {
                controller.enqueue({
                  type: "reasoning-end",
                  id: "reasoning-0"
                });
                isActiveReasoning = false;
              }
              for (const toolCallDelta of delta.tool_calls) {
                const index = toolCallDelta.index;
                if (toolCalls[index] == null) {
                  if (toolCallDelta.type !== "function") {
                    throw new chunkOCS2GTEN_cjs.InvalidResponseDataError2({
                      data: toolCallDelta,
                      message: `Expected 'function' type.`
                    });
                  }
                  if (toolCallDelta.id == null) {
                    throw new chunkOCS2GTEN_cjs.InvalidResponseDataError2({
                      data: toolCallDelta,
                      message: `Expected 'id' to be a string.`
                    });
                  }
                  if (((_b = toolCallDelta.function) == null ? void 0 : _b.name) == null) {
                    throw new chunkOCS2GTEN_cjs.InvalidResponseDataError2({
                      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: (_c = toolCallDelta.function.arguments) != null ? _c : ""
                    },
                    hasFinished: false
                  };
                  const toolCall2 = toolCalls[index];
                  if (((_d = toolCall2.function) == null ? void 0 : _d.name) != null && ((_e = toolCall2.function) == null ? void 0 : _e.arguments) != null) {
                    if (toolCall2.function.arguments.length > 0) {
                      controller.enqueue({
                        type: "tool-input-delta",
                        id: toolCall2.id,
                        delta: toolCall2.function.arguments
                      });
                    }
                    if (chunkOCS2GTEN_cjs.isParsableJson2(toolCall2.function.arguments)) {
                      controller.enqueue({
                        type: "tool-input-end",
                        id: toolCall2.id
                      });
                      controller.enqueue({
                        type: "tool-call",
                        toolCallId: (_f = toolCall2.id) != null ? _f : chunkOCS2GTEN_cjs.generateId2(),
                        toolName: toolCall2.function.name,
                        input: toolCall2.function.arguments
                      });
                      toolCall2.hasFinished = true;
                    }
                  }
                  continue;
                }
                const toolCall = toolCalls[index];
                if (toolCall.hasFinished) {
                  continue;
                }
                if (((_g = toolCallDelta.function) == null ? void 0 : _g.arguments) != null) {
                  toolCall.function.arguments += (_i = (_h = toolCallDelta.function) == null ? void 0 : _h.arguments) != null ? _i : "";
                }
                controller.enqueue({
                  type: "tool-input-delta",
                  id: toolCall.id,
                  delta: (_j = toolCallDelta.function.arguments) != null ? _j : ""
                });
                if (((_k = toolCall.function) == null ? void 0 : _k.name) != null && ((_l = toolCall.function) == null ? void 0 : _l.arguments) != null && chunkOCS2GTEN_cjs.isParsableJson2(toolCall.function.arguments)) {
                  controller.enqueue({
                    type: "tool-input-end",
                    id: toolCall.id
                  });
                  controller.enqueue({
                    type: "tool-call",
                    toolCallId: (_m = toolCall.id) != null ? _m : chunkOCS2GTEN_cjs.generateId2(),
                    toolName: toolCall.function.name,
                    input: toolCall.function.arguments
                  });
                  toolCall.hasFinished = true;
                }
              }
            }
          },
          flush(controller) {
            if (isActiveReasoning) {
              controller.enqueue({ type: "reasoning-end", id: "reasoning-0" });
            }
            if (isActiveText) {
              controller.enqueue({ type: "text-end", id: "txt-0" });
            }
            controller.enqueue({
              type: "finish",
              finishReason,
              usage: convertGroqUsage(usage),
              ...{}
            });
          }
        })
      ),
      request: { body },
      response: { headers: responseHeaders }
    };
  }
};
var groqChatResponseSchema = v4.z.object({
  id: v4.z.string().nullish(),
  created: v4.z.number().nullish(),
  model: v4.z.string().nullish(),
  choices: v4.z.array(
    v4.z.object({
      message: v4.z.object({
        content: v4.z.string().nullish(),
        reasoning: v4.z.string().nullish(),
        tool_calls: v4.z.array(
          v4.z.object({
            id: v4.z.string().nullish(),
            type: v4.z.literal("function"),
            function: v4.z.object({
              name: v4.z.string(),
              arguments: v4.z.string()
            })
          })
        ).nullish()
      }),
      index: v4.z.number(),
      finish_reason: v4.z.string().nullish()
    })
  ),
  usage: v4.z.object({
    prompt_tokens: v4.z.number().nullish(),
    completion_tokens: v4.z.number().nullish(),
    total_tokens: v4.z.number().nullish(),
    prompt_tokens_details: v4.z.object({
      cached_tokens: v4.z.number().nullish()
    }).nullish(),
    completion_tokens_details: v4.z.object({
      reasoning_tokens: v4.z.number().nullish()
    }).nullish()
  }).nullish()
});
var groqChatChunkSchema = v4.z.union([
  v4.z.object({
    id: v4.z.string().nullish(),
    created: v4.z.number().nullish(),
    model: v4.z.string().nullish(),
    choices: v4.z.array(
      v4.z.object({
        delta: v4.z.object({
          content: v4.z.string().nullish(),
          reasoning: v4.z.string().nullish(),
          tool_calls: v4.z.array(
            v4.z.object({
              index: v4.z.number(),
              id: v4.z.string().nullish(),
              type: v4.z.literal("function").optional(),
              function: v4.z.object({
                name: v4.z.string().nullish(),
                arguments: v4.z.string().nullish()
              })
            })
          ).nullish()
        }).nullish(),
        finish_reason: v4.z.string().nullable().optional(),
        index: v4.z.number()
      })
    ),
    x_groq: v4.z.object({
      usage: v4.z.object({
        prompt_tokens: v4.z.number().nullish(),
        completion_tokens: v4.z.number().nullish(),
        total_tokens: v4.z.number().nullish(),
        prompt_tokens_details: v4.z.object({
          cached_tokens: v4.z.number().nullish()
        }).nullish(),
        completion_tokens_details: v4.z.object({
          reasoning_tokens: v4.z.number().nullish()
        }).nullish()
      }).nullish()
    }).nullish()
  }),
  groqErrorDataSchema
]);
var groqTranscriptionModelOptions = chunkOCS2GTEN_cjs.lazySchema2(
  () => chunkOCS2GTEN_cjs.zodSchema2(
    v4.z.object({
      language: v4.z.string().nullish(),
      prompt: v4.z.string().nullish(),
      responseFormat: v4.z.string().nullish(),
      temperature: v4.z.number().min(0).max(1).nullish(),
      timestampGranularities: v4.z.array(v4.z.string()).nullish()
    })
  )
);
var GroqTranscriptionModel = class {
  constructor(modelId, config) {
    this.modelId = modelId;
    this.config = config;
    this.specificationVersion = "v3";
  }
  get provider() {
    return this.config.provider;
  }
  async getArgs({
    audio,
    mediaType,
    providerOptions
  }) {
    var _a15, _b, _c, _d, _e;
    const warnings = [];
    const groqOptions = await chunkOCS2GTEN_cjs.parseProviderOptions2({
      provider: "groq",
      providerOptions,
      schema: groqTranscriptionModelOptions
    });
    const formData = new FormData();
    const blob = audio instanceof Uint8Array ? new Blob([audio]) : new Blob([chunkOCS2GTEN_cjs.convertBase64ToUint8Array2(audio)]);
    formData.append("model", this.modelId);
    const fileExtension = chunkOCS2GTEN_cjs.mediaTypeToExtension2(mediaType);
    formData.append(
      "file",
      new File([blob], "audio", { type: mediaType }),
      `audio.${fileExtension}`
    );
    if (groqOptions) {
      const transcriptionModelOptions = {
        language: (_a15 = groqOptions.language) != null ? _a15 : void 0,
        prompt: (_b = groqOptions.prompt) != null ? _b : void 0,
        response_format: (_c = groqOptions.responseFormat) != null ? _c : void 0,
        temperature: (_d = groqOptions.temperature) != null ? _d : void 0,
        timestamp_granularities: (_e = groqOptions.timestampGranularities) != null ? _e : void 0
      };
      for (const key in transcriptionModelOptions) {
        const value = transcriptionModelOptions[key];
        if (value !== void 0) {
          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 _a15, _b, _c, _d, _e, _f, _g;
    const currentDate = (_c = (_b = (_a15 = this.config._internal) == null ? void 0 : _a15.currentDate) == null ? void 0 : _b.call(_a15)) != null ? _c : /* @__PURE__ */ new Date();
    const { formData, warnings } = await this.getArgs(options);
    const {
      value: response,
      responseHeaders,
      rawValue: rawResponse
    } = await chunkOCS2GTEN_cjs.postFormDataToApi2({
      url: this.config.url({
        path: "/audio/transcriptions",
        modelId: this.modelId
      }),
      headers: chunkOCS2GTEN_cjs.combineHeaders2(this.config.headers(), options.headers),
      formData,
      failedResponseHandler: groqFailedResponseHandler,
      successfulResponseHandler: chunkOCS2GTEN_cjs.createJsonResponseHandler2(
        groqTranscriptionResponseSchema
      ),
      abortSignal: options.abortSignal,
      fetch: this.config.fetch
    });
    return {
      text: response.text,
      segments: (_e = (_d = response.segments) == null ? void 0 : _d.map((segment) => ({
        text: segment.text,
        startSecond: segment.start,
        endSecond: segment.end
      }))) != null ? _e : [],
      language: (_f = response.language) != null ? _f : void 0,
      durationInSeconds: (_g = response.duration) != null ? _g : void 0,
      warnings,
      response: {
        timestamp: currentDate,
        modelId: this.modelId,
        headers: responseHeaders,
        body: rawResponse
      }
    };
  }
};
var groqTranscriptionResponseSchema = v4.z.object({
  text: v4.z.string(),
  x_groq: v4.z.object({
    id: v4.z.string()
  }),
  // additional properties are returned when `response_format: 'verbose_json'` is
  task: v4.z.string().nullish(),
  language: v4.z.string().nullish(),
  duration: v4.z.number().nullish(),
  segments: v4.z.array(
    v4.z.object({
      id: v4.z.number(),
      seek: v4.z.number(),
      start: v4.z.number(),
      end: v4.z.number(),
      text: v4.z.string(),
      tokens: v4.z.array(v4.z.number()),
      temperature: v4.z.number(),
      avg_logprob: v4.z.number(),
      compression_ratio: v4.z.number(),
      no_speech_prob: v4.z.number()
    })
  ).nullish()
});
var browserSearch = chunkOCS2GTEN_cjs.createProviderToolFactory({
  id: "groq.browser_search",
  inputSchema: v4.z.object({})
});
var groqTools = {
  browserSearch
};
var VERSION5 = "3.0.39" ;
function createGroq(options = {}) {
  var _a15;
  const baseURL = (_a15 = chunkOCS2GTEN_cjs.withoutTrailingSlash2(options.baseURL)) != null ? _a15 : "https://api.groq.com/openai/v1";
  const getHeaders = () => chunkOCS2GTEN_cjs.withUserAgentSuffix2(
    {
      Authorization: `Bearer ${chunkOCS2GTEN_cjs.loadApiKey2({
        apiKey: options.apiKey,
        environmentVariableName: "GROQ_API_KEY",
        description: "Groq"
      })}`,
      ...options.headers
    },
    `ai-sdk/groq/${VERSION5}`
  );
  const createChatModel = (modelId) => new GroqChatLanguageModel(modelId, {
    provider: "groq.chat",
    url: ({ path }) => `${baseURL}${path}`,
    headers: getHeaders,
    fetch: options.fetch
  });
  const createLanguageModel = (modelId) => {
    if (new.target) {
      throw new Error(
        "The Groq model function cannot be called with the new keyword."
      );
    }
    return createChatModel(modelId);
  };
  const createTranscriptionModel = (modelId) => {
    return new GroqTranscriptionModel(modelId, {
      provider: "groq.transcription",
      url: ({ path }) => `${baseURL}${path}`,
      headers: getHeaders,
      fetch: options.fetch
    });
  };
  const provider = function(modelId) {
    return createLanguageModel(modelId);
  };
  provider.specificationVersion = "v3";
  provider.languageModel = createLanguageModel;
  provider.chat = createChatModel;
  provider.embeddingModel = (modelId) => {
    throw new chunkOCS2GTEN_cjs.NoSuchModelError2({ modelId, modelType: "embeddingModel" });
  };
  provider.textEmbeddingModel = provider.embeddingModel;
  provider.imageModel = (modelId) => {
    throw new chunkOCS2GTEN_cjs.NoSuchModelError2({ modelId, modelType: "imageModel" });
  };
  provider.transcription = createTranscriptionModel;
  provider.transcriptionModel = createTranscriptionModel;
  provider.tools = groqTools;
  return provider;
}
createGroq();
function convertMistralUsage(usage) {
  var _a15, _b, _c, _d, _e;
  if (usage == null) {
    return {
      inputTokens: {
        total: void 0,
        noCache: void 0,
        cacheRead: void 0,
        cacheWrite: void 0
      },
      outputTokens: {
        total: void 0,
        text: void 0,
        reasoning: void 0
      },
      raw: void 0
    };
  }
  const promptTokens = usage.prompt_tokens;
  const completionTokens = usage.completion_tokens;
  const cacheReadTokens = (_e = (_d = (_b = usage.num_cached_tokens) != null ? _b : (_a15 = usage.prompt_tokens_details) == null ? void 0 : _a15.cached_tokens) != null ? _d : (_c = usage.prompt_token_details) == null ? void 0 : _c.cached_tokens) != null ? _e : 0;
  return {
    inputTokens: {
      total: promptTokens,
      noCache: promptTokens - cacheReadTokens,
      cacheRead: cacheReadTokens || void 0,
      cacheWrite: void 0
    },
    outputTokens: {
      total: completionTokens,
      text: completionTokens,
      reasoning: void 0
    },
    raw: usage
  };
}
function formatFileUrl({
  data,
  mediaType
}) {
  return data instanceof URL ? data.toString() : `data:${mediaType};base64,${chunkOCS2GTEN_cjs.convertToBase642(data)}`;
}
function convertToMistralChatMessages(prompt) {
  var _a15;
  const messages = [];
  for (let i = 0; i < prompt.length; i++) {
    const { role, content } = prompt[i];
    const isLastMessage = i === prompt.length - 1;
    switch (role) {
      case "system": {
        messages.push({ role: "system", content });
        break;
      }
      case "user": {
        messages.push({
          role: "user",
          content: content.map((part) => {
            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: formatFileUrl({ data: part.data, mediaType })
                  };
                } else if (part.mediaType === "application/pdf") {
                  return {
                    type: "document_url",
                    document_url: formatFileUrl({
                      data: part.data,
                      mediaType: "application/pdf"
                    })
                  };
                } else {
                  throw new chunkOCS2GTEN_cjs.UnsupportedFunctionalityError2({
                    functionality: "Only images and PDF file parts are supported"
                  });
                }
              }
            }
          })
        });
        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;
            }
            case "reasoning": {
              text += part.text;
              break;
            }
            default: {
              throw new Error(
                `Unsupported content type in assistant message: ${part.type}`
              );
            }
          }
        }
        messages.push({
          role: "assistant",
          content: text,
          prefix: isLastMessage ? true : void 0,
          tool_calls: toolCalls.length > 0 ? toolCalls : void 0
        });
        break;
      }
      case "tool": {
        for (const toolResponse of content) {
          if (toolResponse.type === "tool-approval-response") {
            continue;
          }
          const output = toolResponse.output;
          let contentValue;
          switch (output.type) {
            case "text":
            case "error-text":
              contentValue = output.value;
              break;
            case "execution-denied":
              contentValue = (_a15 = output.reason) != null ? _a15 : "Tool execution denied.";
              break;
            case "content":
            case "json":
            case "error-json":
              contentValue = JSON.stringify(output.value);
              break;
          }
          messages.push({
            role: "tool",
            name: toolResponse.toolName,
            tool_call_id: toolResponse.toolCallId,
            content: contentValue
          });
        }
        break;
      }
      default: {
        const _exhaustiveCheck = role;
        throw new Error(`Unsupported role: ${_exhaustiveCheck}`);
      }
    }
  }
  return messages;
}
function getResponseMetadata4({
  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 mapMistralFinishReason(finishReason) {
  switch (finishReason) {
    case "stop":
      return "stop";
    case "length":
    case "model_length":
      return "length";
    case "tool_calls":
      return "tool-calls";
    default:
      return "other";
  }
}
var mistralLanguageModelOptions = v4.z.object({
  /**
   * Whether to inject a safety prompt before all conversations.
   *
   * Defaults to `false`.
   */
  safePrompt: v4.z.boolean().optional(),
  documentImageLimit: v4.z.number().optional(),
  documentPageLimit: v4.z.number().optional(),
  /**
   * Whether to use structured outputs.
   *
   * @default true
   */
  structuredOutputs: v4.z.boolean().optional(),
  /**
   * Whether to use strict JSON schema validation.
   *
   * @default false
   */
  strictJsonSchema: v4.z.boolean().optional(),
  /**
   * Whether to enable parallel function calling during tool use.
   * When set to false, the model will use at most one tool per response.
   *
   * @default true
   */
  parallelToolCalls: v4.z.boolean().optional(),
  /**
   * Controls the reasoning effort for models that support adjustable reasoning.
   *
   * - `'high'`: Enable reasoning
   * - `'none'`: Disable reasoning
   */
  reasoningEffort: v4.z.enum(["high", "none"]).optional()
});
var mistralErrorDataSchema = v4.z.object({
  object: v4.z.literal("error"),
  message: v4.z.string(),
  type: v4.z.string(),
  param: v4.z.string().nullable(),
  code: v4.z.string().nullable()
});
var mistralFailedResponseHandler = chunkOCS2GTEN_cjs.createJsonErrorResponseHandler2({
  errorSchema: mistralErrorDataSchema,
  errorToMessage: (data) => data.message
});
function prepareTools4({
  tools,
  toolChoice
}) {
  tools = (tools == null ? void 0 : tools.length) ? tools : void 0;
  const toolWarnings = [];
  if (tools == null) {
    return { tools: void 0, toolChoice: void 0, toolWarnings };
  }
  const mistralTools = [];
  for (const tool of tools) {
    if (tool.type === "provider") {
      toolWarnings.push({
        type: "unsupported",
        feature: `provider-defined tool ${tool.id}`
      });
    } else {
      mistralTools.push({
        type: "function",
        function: {
          name: tool.name,
          description: tool.description,
          parameters: tool.inputSchema,
          ...tool.strict != null ? { strict: tool.strict } : {}
        }
      });
    }
  }
  if (toolChoice == null) {
    return { tools: mistralTools, toolChoice: void 0, toolWarnings };
  }
  const type = toolChoice.type;
  switch (type) {
    case "auto":
    case "none":
      return { tools: mistralTools, toolChoice: type, toolWarnings };
    case "required":
      return { tools: mistralTools, toolChoice: "any", toolWarnings };
    // mistral does not support tool mode directly,
    // so we filter the tools and force the tool choice through 'any'
    case "tool":
      return {
        tools: mistralTools.filter(
          (tool) => tool.function.name === toolChoice.toolName
        ),
        toolChoice: "any",
        toolWarnings
      };
    default: {
      const _exhaustiveCheck = type;
      throw new chunkOCS2GTEN_cjs.UnsupportedFunctionalityError2({
        functionality: `tool choice type: ${_exhaustiveCheck}`
      });
    }
  }
}
var MistralChatLanguageModel = class {
  constructor(modelId, config) {
    this.specificationVersion = "v3";
    this.supportedUrls = {
      "application/pdf": [/^https:\/\/.*$/]
    };
    var _a15;
    this.modelId = modelId;
    this.config = config;
    this.generateId = (_a15 = config.generateId) != null ? _a15 : chunkOCS2GTEN_cjs.generateId2;
  }
  get provider() {
    return this.config.provider;
  }
  async getArgs({
    prompt,
    maxOutputTokens,
    temperature,
    topP,
    topK,
    frequencyPenalty,
    presencePenalty,
    stopSequences,
    responseFormat,
    seed,
    providerOptions,
    tools,
    toolChoice
  }) {
    var _a15, _b, _c, _d;
    const warnings = [];
    const options = (_a15 = await chunkOCS2GTEN_cjs.parseProviderOptions2({
      provider: "mistral",
      providerOptions,
      schema: mistralLanguageModelOptions
    })) != null ? _a15 : {};
    if (topK != null) {
      warnings.push({ type: "unsupported", feature: "topK" });
    }
    if (frequencyPenalty != null) {
      warnings.push({ type: "unsupported", feature: "frequencyPenalty" });
    }
    if (presencePenalty != null) {
      warnings.push({ type: "unsupported", feature: "presencePenalty" });
    }
    if (stopSequences != null) {
      warnings.push({ type: "unsupported", feature: "stopSequences" });
    }
    const structuredOutputs = (_b = options.structuredOutputs) != null ? _b : true;
    const strictJsonSchema = (_c = options.strictJsonSchema) != null ? _c : false;
    if ((responseFormat == null ? void 0 : responseFormat.type) === "json" && !(responseFormat == null ? void 0 : responseFormat.schema)) {
      prompt = chunkOCS2GTEN_cjs.injectJsonInstructionIntoMessages({
        messages: prompt,
        schema: responseFormat.schema
      });
    }
    const baseArgs = {
      // model id:
      model: this.modelId,
      // model specific settings:
      safe_prompt: options.safePrompt,
      // standardized settings:
      max_tokens: maxOutputTokens,
      temperature,
      top_p: topP,
      random_seed: seed,
      reasoning_effort: options.reasoningEffort,
      // response format:
      response_format: (responseFormat == null ? void 0 : responseFormat.type) === "json" ? structuredOutputs && (responseFormat == null ? void 0 : 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,
      // mistral-specific provider options:
      document_image_limit: options.documentImageLimit,
      document_page_limit: options.documentPageLimit,
      // messages:
      messages: convertToMistralChatMessages(prompt)
    };
    const {
      tools: mistralTools,
      toolChoice: mistralToolChoice,
      toolWarnings
    } = prepareTools4({
      tools,
      toolChoice
    });
    return {
      args: {
        ...baseArgs,
        tools: mistralTools,
        tool_choice: mistralToolChoice,
        ...mistralTools != null && options.parallelToolCalls !== void 0 ? { parallel_tool_calls: options.parallelToolCalls } : {}
      },
      warnings: [...warnings, ...toolWarnings]
    };
  }
  async doGenerate(options) {
    var _a15;
    const { args: body, warnings } = await this.getArgs(options);
    const {
      responseHeaders,
      value: response,
      rawValue: rawResponse
    } = await chunkOCS2GTEN_cjs.postJsonToApi2({
      url: `${this.config.baseURL}/chat/completions`,
      headers: chunkOCS2GTEN_cjs.combineHeaders2(this.config.headers(), options.headers),
      body,
      failedResponseHandler: mistralFailedResponseHandler,
      successfulResponseHandler: chunkOCS2GTEN_cjs.createJsonResponseHandler2(
        mistralChatResponseSchema
      ),
      abortSignal: options.abortSignal,
      fetch: this.config.fetch
    });
    const choice = response.choices[0];
    const content = [];
    if (choice.message.content != null && Array.isArray(choice.message.content)) {
      for (const part of choice.message.content) {
        if (part.type === "thinking") {
          const reasoningText = extractReasoningContent(part.thinking);
          if (reasoningText.length > 0) {
            content.push({ type: "reasoning", text: reasoningText });
          }
        } else if (part.type === "text") {
          if (part.text.length > 0) {
            content.push({ type: "text", text: part.text });
          }
        }
      }
    } else {
      const text = extractTextContent(choice.message.content);
      if (text != null && text.length > 0) {
        content.push({ type: "text", text });
      }
    }
    if (choice.message.tool_calls != null) {
      for (const toolCall of choice.message.tool_calls) {
        content.push({
          type: "tool-call",
          toolCallId: toolCall.id,
          toolName: toolCall.function.name,
          input: toolCall.function.arguments
        });
      }
    }
    return {
      content,
      finishReason: {
        unified: mapMistralFinishReason(choice.finish_reason),
        raw: (_a15 = choice.finish_reason) != null ? _a15 : void 0
      },
      usage: convertMistralUsage(response.usage),
      request: { body },
      response: {
        ...getResponseMetadata4(response),
        headers: responseHeaders,
        body: rawResponse
      },
      warnings
    };
  }
  async doStream(options) {
    const { args, warnings } = await this.getArgs(options);
    const body = { ...args, stream: true };
    const { responseHeaders, value: response } = await chunkOCS2GTEN_cjs.postJsonToApi2({
      url: `${this.config.baseURL}/chat/completions`,
      headers: chunkOCS2GTEN_cjs.combineHeaders2(this.config.headers(), options.headers),
      body,
      failedResponseHandler: mistralFailedResponseHandler,
      successfulResponseHandler: chunkOCS2GTEN_cjs.createEventSourceResponseHandler2(
        mistralChatChunkSchema
      ),
      abortSignal: options.abortSignal,
      fetch: this.config.fetch
    });
    let finishReason = {
      unified: "other",
      raw: void 0
    };
    let usage = void 0;
    let isFirstChunk = true;
    let activeText = false;
    let activeReasoningId = null;
    const generateId22 = this.generateId;
    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) {
              controller.enqueue({ type: "error", error: chunk.error });
              return;
            }
            const value = chunk.value;
            if (isFirstChunk) {
              isFirstChunk = false;
              controller.enqueue({
                type: "response-metadata",
                ...getResponseMetadata4(value)
              });
            }
            if (value.usage != null) {
              usage = value.usage;
            }
            const choice = value.choices[0];
            const delta = choice.delta;
            const textContent = extractTextContent(delta.content);
            if (delta.content != null && Array.isArray(delta.content)) {
              for (const part of delta.content) {
                if (part.type === "thinking") {
                  const reasoningDelta = extractReasoningContent(part.thinking);
                  if (reasoningDelta.length > 0) {
                    if (activeReasoningId == null) {
                      if (activeText) {
                        controller.enqueue({ type: "text-end", id: "0" });
                        activeText = false;
                      }
                      activeReasoningId = generateId22();
                      controller.enqueue({
                        type: "reasoning-start",
                        id: activeReasoningId
                      });
                    }
                    controller.enqueue({
                      type: "reasoning-delta",
                      id: activeReasoningId,
                      delta: reasoningDelta
                    });
                  }
                }
              }
            }
            if (textContent != null && textContent.length > 0) {
              if (!activeText) {
                if (activeReasoningId != null) {
                  controller.enqueue({
                    type: "reasoning-end",
                    id: activeReasoningId
                  });
                  activeReasoningId = null;
                }
                controller.enqueue({ type: "text-start", id: "0" });
                activeText = true;
              }
              controller.enqueue({
                type: "text-delta",
                id: "0",
                delta: textContent
              });
            }
            if ((delta == null ? void 0 : delta.tool_calls) != null) {
              for (const toolCall of delta.tool_calls) {
                const toolCallId = toolCall.id;
                const toolName = toolCall.function.name;
                const input = toolCall.function.arguments;
                controller.enqueue({
                  type: "tool-input-start",
                  id: toolCallId,
                  toolName
                });
                controller.enqueue({
                  type: "tool-input-delta",
                  id: toolCallId,
                  delta: input
                });
                controller.enqueue({
                  type: "tool-input-end",
                  id: toolCallId
                });
                controller.enqueue({
                  type: "tool-call",
                  toolCallId,
                  toolName,
                  input
                });
              }
            }
            if (choice.finish_reason != null) {
              finishReason = {
                unified: mapMistralFinishReason(choice.finish_reason),
                raw: choice.finish_reason
              };
            }
          },
          flush(controller) {
            if (activeReasoningId != null) {
              controller.enqueue({
                type: "reasoning-end",
                id: activeReasoningId
              });
            }
            if (activeText) {
              controller.enqueue({ type: "text-end", id: "0" });
            }
            controller.enqueue({
              type: "finish",
              finishReason,
              usage: convertMistralUsage(usage)
            });
          }
        })
      ),
      request: { body },
      response: { headers: responseHeaders }
    };
  }
};
function extractReasoningContent(thinking) {
  return thinking.filter((chunk) => chunk.type === "text").map((chunk) => chunk.text).join("");
}
function extractTextContent(content) {
  if (typeof content === "string") {
    return content;
  }
  if (content == null) {
    return void 0;
  }
  const textContent = [];
  for (const chunk of content) {
    const { type } = chunk;
    switch (type) {
      case "text":
        textContent.push(chunk.text);
        break;
      case "thinking":
      case "image_url":
      case "reference":
        break;
      default: {
        const _exhaustiveCheck = type;
        throw new Error(`Unsupported type: ${_exhaustiveCheck}`);
      }
    }
  }
  return textContent.length ? textContent.join("") : void 0;
}
var mistralContentSchema = v4.z.union([
  v4.z.string(),
  v4.z.array(
    v4.z.discriminatedUnion("type", [
      v4.z.object({
        type: v4.z.literal("text"),
        text: v4.z.string()
      }),
      v4.z.object({
        type: v4.z.literal("image_url"),
        image_url: v4.z.union([
          v4.z.string(),
          v4.z.object({
            url: v4.z.string(),
            detail: v4.z.string().nullable()
          })
        ])
      }),
      v4.z.object({
        type: v4.z.literal("reference"),
        reference_ids: v4.z.array(v4.z.union([v4.z.string(), v4.z.number()]))
      }),
      v4.z.object({
        type: v4.z.literal("thinking"),
        thinking: v4.z.array(
          v4.z.object({
            type: v4.z.literal("text"),
            text: v4.z.string()
          })
        )
      })
    ])
  )
]).nullish();
var mistralUsageSchema = v4.z.object({
  prompt_tokens: v4.z.number(),
  completion_tokens: v4.z.number(),
  total_tokens: v4.z.number(),
  num_cached_tokens: v4.z.number().nullish(),
  prompt_tokens_details: v4.z.object({ cached_tokens: v4.z.number().nullish() }).nullish(),
  prompt_token_details: v4.z.object({ cached_tokens: v4.z.number().nullish() }).nullish()
});
var mistralChatResponseSchema = v4.z.object({
  id: v4.z.string().nullish(),
  created: v4.z.number().nullish(),
  model: v4.z.string().nullish(),
  choices: v4.z.array(
    v4.z.object({
      message: v4.z.object({
        role: v4.z.literal("assistant"),
        content: mistralContentSchema,
        tool_calls: v4.z.array(
          v4.z.object({
            id: v4.z.string(),
            function: v4.z.object({ name: v4.z.string(), arguments: v4.z.string() })
          })
        ).nullish()
      }),
      index: v4.z.number(),
      finish_reason: v4.z.string().nullish()
    })
  ),
  object: v4.z.literal("chat.completion"),
  usage: mistralUsageSchema
});
var mistralChatChunkSchema = v4.z.object({
  id: v4.z.string().nullish(),
  created: v4.z.number().nullish(),
  model: v4.z.string().nullish(),
  choices: v4.z.array(
    v4.z.object({
      delta: v4.z.object({
        role: v4.z.enum(["assistant"]).optional(),
        content: mistralContentSchema,
        tool_calls: v4.z.array(
          v4.z.object({
            id: v4.z.string(),
            function: v4.z.object({ name: v4.z.string(), arguments: v4.z.string() })
          })
        ).nullish()
      }),
      finish_reason: v4.z.string().nullish(),
      index: v4.z.number()
    })
  ),
  usage: mistralUsageSchema.nullish()
});
var MistralEmbeddingModel = class {
  constructor(modelId, config) {
    this.specificationVersion = "v3";
    this.maxEmbeddingsPerCall = 32;
    this.supportsParallelCalls = false;
    this.modelId = modelId;
    this.config = config;
  }
  get provider() {
    return this.config.provider;
  }
  async doEmbed({
    values,
    abortSignal,
    headers
  }) {
    if (values.length > this.maxEmbeddingsPerCall) {
      throw new chunkOCS2GTEN_cjs.TooManyEmbeddingValuesForCallError2({
        provider: this.provider,
        modelId: this.modelId,
        maxEmbeddingsPerCall: this.maxEmbeddingsPerCall,
        values
      });
    }
    const {
      responseHeaders,
      value: response,
      rawValue
    } = await chunkOCS2GTEN_cjs.postJsonToApi2({
      url: `${this.config.baseURL}/embeddings`,
      headers: chunkOCS2GTEN_cjs.combineHeaders2(this.config.headers(), headers),
      body: {
        model: this.modelId,
        input: values,
        encoding_format: "float"
      },
      failedResponseHandler: mistralFailedResponseHandler,
      successfulResponseHandler: chunkOCS2GTEN_cjs.createJsonResponseHandler2(
        MistralTextEmbeddingResponseSchema
      ),
      abortSignal,
      fetch: this.config.fetch
    });
    return {
      warnings: [],
      embeddings: response.data.map((item) => item.embedding),
      usage: response.usage ? { tokens: response.usage.prompt_tokens } : void 0,
      response: { headers: responseHeaders, body: rawValue }
    };
  }
};
var MistralTextEmbeddingResponseSchema = v4.z.object({
  data: v4.z.array(v4.z.object({ embedding: v4.z.array(v4.z.number()) })),
  usage: v4.z.object({ prompt_tokens: v4.z.number() }).nullish()
});
var VERSION6 = "3.0.36" ;
function createMistral(options = {}) {
  var _a15;
  const baseURL = (_a15 = chunkOCS2GTEN_cjs.withoutTrailingSlash2(options.baseURL)) != null ? _a15 : "https://api.mistral.ai/v1";
  const getHeaders = () => chunkOCS2GTEN_cjs.withUserAgentSuffix2(
    {
      Authorization: `Bearer ${chunkOCS2GTEN_cjs.loadApiKey2({
        apiKey: options.apiKey,
        environmentVariableName: "MISTRAL_API_KEY",
        description: "Mistral"
      })}`,
      ...options.headers
    },
    `ai-sdk/mistral/${VERSION6}`
  );
  const createChatModel = (modelId) => new MistralChatLanguageModel(modelId, {
    provider: "mistral.chat",
    baseURL,
    headers: getHeaders,
    fetch: options.fetch,
    generateId: options.generateId
  });
  const createEmbeddingModel = (modelId) => new MistralEmbeddingModel(modelId, {
    provider: "mistral.embedding",
    baseURL,
    headers: getHeaders,
    fetch: options.fetch
  });
  const provider = function(modelId) {
    if (new.target) {
      throw new Error(
        "The Mistral model function cannot be called with the new keyword."
      );
    }
    return createChatModel(modelId);
  };
  provider.specificationVersion = "v3";
  provider.languageModel = createChatModel;
  provider.chat = createChatModel;
  provider.embedding = createEmbeddingModel;
  provider.embeddingModel = createEmbeddingModel;
  provider.textEmbedding = createEmbeddingModel;
  provider.textEmbeddingModel = createEmbeddingModel;
  provider.imageModel = (modelId) => {
    throw new chunkOCS2GTEN_cjs.NoSuchModelError2({ modelId, modelType: "imageModel" });
  };
  return provider;
}
createMistral();
function convertToPerplexityMessages(prompt) {
  const messages = [];
  for (const { role, content } of prompt) {
    switch (role) {
      case "system": {
        messages.push({ role: "system", content });
        break;
      }
      case "user":
      case "assistant": {
        const hasMultipartContent = content.some(
          (part) => part.type === "file" && part.mediaType.startsWith("image/") || part.type === "file" && part.mediaType === "application/pdf"
        );
        const messageContent = content.map((part, index) => {
          var _a15;
          switch (part.type) {
            case "text": {
              return {
                type: "text",
                text: part.text
              };
            }
            case "file": {
              if (part.mediaType === "application/pdf") {
                return part.data instanceof URL ? {
                  type: "file_url",
                  file_url: {
                    url: part.data.toString()
                  },
                  file_name: part.filename
                } : {
                  type: "file_url",
                  file_url: {
                    url: typeof part.data === "string" ? part.data : chunkOCS2GTEN_cjs.convertUint8ArrayToBase64(part.data)
                  },
                  file_name: part.filename || `document-${index}.pdf`
                };
              } else if (part.mediaType.startsWith("image/")) {
                return part.data instanceof URL ? {
                  type: "image_url",
                  image_url: {
                    url: part.data.toString()
                  }
                } : {
                  type: "image_url",
                  image_url: {
                    url: `data:${(_a15 = part.mediaType) != null ? _a15 : "image/jpeg"};base64,${typeof part.data === "string" ? part.data : chunkOCS2GTEN_cjs.convertUint8ArrayToBase64(part.data)}`
                  }
                };
              }
            }
          }
        }).filter(Boolean);
        messages.push({
          role,
          content: hasMultipartContent ? messageContent : messageContent.filter((part) => part.type === "text").map((part) => part.text).join("")
        });
        break;
      }
      case "tool": {
        throw new chunkOCS2GTEN_cjs.UnsupportedFunctionalityError({
          functionality: "Tool messages"
        });
      }
      default: {
        const _exhaustiveCheck = role;
        throw new Error(`Unsupported role: ${_exhaustiveCheck}`);
      }
    }
  }
  return messages;
}
function mapPerplexityFinishReason(finishReason) {
  switch (finishReason) {
    case "stop":
    case "length":
      return finishReason;
    default:
      return "unknown";
  }
}
var PerplexityLanguageModel = class {
  constructor(modelId, config) {
    this.specificationVersion = "v2";
    this.provider = "perplexity";
    this.supportedUrls = {
      // No URLs are supported.
    };
    this.modelId = modelId;
    this.config = config;
  }
  getArgs({
    prompt,
    maxOutputTokens,
    temperature,
    topP,
    topK,
    frequencyPenalty,
    presencePenalty,
    stopSequences,
    responseFormat,
    seed,
    providerOptions
  }) {
    var _a15;
    const warnings = [];
    if (topK != null) {
      warnings.push({
        type: "unsupported-setting",
        setting: "topK"
      });
    }
    if (stopSequences != null) {
      warnings.push({
        type: "unsupported-setting",
        setting: "stopSequences"
      });
    }
    if (seed != null) {
      warnings.push({
        type: "unsupported-setting",
        setting: "seed"
      });
    }
    return {
      args: {
        // model id:
        model: this.modelId,
        // standardized settings:
        frequency_penalty: frequencyPenalty,
        max_tokens: maxOutputTokens,
        presence_penalty: presencePenalty,
        temperature,
        top_k: topK,
        top_p: topP,
        // response format:
        response_format: (responseFormat == null ? void 0 : responseFormat.type) === "json" ? {
          type: "json_schema",
          json_schema: { schema: responseFormat.schema }
        } : void 0,
        // provider extensions
        ...(_a15 = providerOptions == null ? void 0 : providerOptions.perplexity) != null ? _a15 : {},
        // messages:
        messages: convertToPerplexityMessages(prompt)
      },
      warnings
    };
  }
  async doGenerate(options) {
    var _a15, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q;
    const { args: body, warnings } = this.getArgs(options);
    const {
      responseHeaders,
      value: response,
      rawValue: rawResponse
    } = await chunkOCS2GTEN_cjs.postJsonToApi({
      url: `${this.config.baseURL}/chat/completions`,
      headers: chunkOCS2GTEN_cjs.combineHeaders(this.config.headers(), options.headers),
      body,
      failedResponseHandler: chunkOCS2GTEN_cjs.createJsonErrorResponseHandler({
        errorSchema: perplexityErrorSchema,
        errorToMessage
      }),
      successfulResponseHandler: chunkOCS2GTEN_cjs.createJsonResponseHandler(
        perplexityResponseSchema
      ),
      abortSignal: options.abortSignal,
      fetch: this.config.fetch
    });
    const choice = response.choices[0];
    const content = [];
    const text = choice.message.content;
    if (text.length > 0) {
      content.push({ type: "text", text });
    }
    if (response.citations != null) {
      for (const url of response.citations) {
        content.push({
          type: "source",
          sourceType: "url",
          id: this.config.generateId(),
          url
        });
      }
    }
    return {
      content,
      finishReason: mapPerplexityFinishReason(choice.finish_reason),
      usage: {
        inputTokens: (_a15 = response.usage) == null ? void 0 : _a15.prompt_tokens,
        outputTokens: (_b = response.usage) == null ? void 0 : _b.completion_tokens,
        totalTokens: (_d = (_c = response.usage) == null ? void 0 : _c.total_tokens) != null ? _d : void 0,
        reasoningTokens: (_f = (_e = response.usage) == null ? void 0 : _e.reasoning_tokens) != null ? _f : void 0
      },
      request: { body },
      response: {
        ...getResponseMetadata5(response),
        headers: responseHeaders,
        body: rawResponse
      },
      warnings,
      providerMetadata: {
        perplexity: {
          images: (_h = (_g = response.images) == null ? void 0 : _g.map((image) => ({
            imageUrl: image.image_url,
            originUrl: image.origin_url,
            height: image.height,
            width: image.width
          }))) != null ? _h : null,
          usage: {
            citationTokens: (_j = (_i = response.usage) == null ? void 0 : _i.citation_tokens) != null ? _j : null,
            numSearchQueries: (_l = (_k = response.usage) == null ? void 0 : _k.num_search_queries) != null ? _l : null
          },
          cost: ((_m = response.usage) == null ? void 0 : _m.cost) ? {
            inputTokensCost: (_n = response.usage.cost.input_tokens_cost) != null ? _n : null,
            outputTokensCost: (_o = response.usage.cost.output_tokens_cost) != null ? _o : null,
            requestCost: (_p = response.usage.cost.request_cost) != null ? _p : null,
            totalCost: (_q = response.usage.cost.total_cost) != null ? _q : null
          } : null
        }
      }
    };
  }
  async doStream(options) {
    const { args, warnings } = this.getArgs(options);
    const body = { ...args, stream: true };
    const { responseHeaders, value: response } = await chunkOCS2GTEN_cjs.postJsonToApi({
      url: `${this.config.baseURL}/chat/completions`,
      headers: chunkOCS2GTEN_cjs.combineHeaders(this.config.headers(), options.headers),
      body,
      failedResponseHandler: chunkOCS2GTEN_cjs.createJsonErrorResponseHandler({
        errorSchema: perplexityErrorSchema,
        errorToMessage
      }),
      successfulResponseHandler: chunkOCS2GTEN_cjs.createEventSourceResponseHandler(
        perplexityChunkSchema
      ),
      abortSignal: options.abortSignal,
      fetch: this.config.fetch
    });
    let finishReason = "unknown";
    const usage = {
      inputTokens: void 0,
      outputTokens: void 0,
      totalTokens: void 0,
      reasoningTokens: void 0
    };
    const providerMetadata = {
      perplexity: {
        usage: {
          citationTokens: null,
          numSearchQueries: null
        },
        cost: null,
        images: null
      }
    };
    let isFirstChunk = true;
    let isActive = false;
    const self = this;
    return {
      stream: response.pipeThrough(
        new TransformStream({
          start(controller) {
            controller.enqueue({ type: "stream-start", warnings });
          },
          transform(chunk, controller) {
            var _a15, _b, _c, _d, _e, _f, _g, _h;
            if (options.includeRawChunks) {
              controller.enqueue({ type: "raw", rawValue: chunk.rawValue });
            }
            if (!chunk.success) {
              controller.enqueue({ type: "error", error: chunk.error });
              return;
            }
            const value = chunk.value;
            if (isFirstChunk) {
              controller.enqueue({
                type: "response-metadata",
                ...getResponseMetadata5(value)
              });
              (_a15 = value.citations) == null ? void 0 : _a15.forEach((url) => {
                controller.enqueue({
                  type: "source",
                  sourceType: "url",
                  id: self.config.generateId(),
                  url
                });
              });
              isFirstChunk = false;
            }
            if (value.usage != null) {
              usage.inputTokens = value.usage.prompt_tokens;
              usage.outputTokens = value.usage.completion_tokens;
              usage.reasoningTokens = (_b = value.usage.reasoning_tokens) != null ? _b : void 0;
              providerMetadata.perplexity.usage = {
                citationTokens: (_c = value.usage.citation_tokens) != null ? _c : null,
                numSearchQueries: (_d = value.usage.num_search_queries) != null ? _d : null
              };
              providerMetadata.perplexity.cost = value.usage.cost ? {
                inputTokensCost: (_e = value.usage.cost.input_tokens_cost) != null ? _e : null,
                outputTokensCost: (_f = value.usage.cost.output_tokens_cost) != null ? _f : null,
                requestCost: (_g = value.usage.cost.request_cost) != null ? _g : null,
                totalCost: (_h = value.usage.cost.total_cost) != null ? _h : null
              } : null;
            }
            if (value.images != null) {
              providerMetadata.perplexity.images = value.images.map((image) => ({
                imageUrl: image.image_url,
                originUrl: image.origin_url,
                height: image.height,
                width: image.width
              }));
            }
            const choice = value.choices[0];
            if ((choice == null ? void 0 : choice.finish_reason) != null) {
              finishReason = mapPerplexityFinishReason(choice.finish_reason);
            }
            if ((choice == null ? void 0 : choice.delta) == null) {
              return;
            }
            const delta = choice.delta;
            const textContent = delta.content;
            if (textContent != null) {
              if (!isActive) {
                controller.enqueue({ type: "text-start", id: "0" });
                isActive = true;
              }
              controller.enqueue({
                type: "text-delta",
                id: "0",
                delta: textContent
              });
            }
          },
          flush(controller) {
            if (isActive) {
              controller.enqueue({ type: "text-end", id: "0" });
            }
            controller.enqueue({
              type: "finish",
              finishReason,
              usage,
              providerMetadata
            });
          }
        })
      ),
      request: { body },
      response: { headers: responseHeaders }
    };
  }
};
function getResponseMetadata5({
  id,
  model,
  created
}) {
  return {
    id,
    modelId: model,
    timestamp: new Date(created * 1e3)
  };
}
var perplexityCostSchema = v4.z.object({
  input_tokens_cost: v4.z.number().nullish(),
  output_tokens_cost: v4.z.number().nullish(),
  request_cost: v4.z.number().nullish(),
  total_cost: v4.z.number().nullish()
});
var perplexityUsageSchema = v4.z.object({
  prompt_tokens: v4.z.number(),
  completion_tokens: v4.z.number(),
  total_tokens: v4.z.number().nullish(),
  citation_tokens: v4.z.number().nullish(),
  num_search_queries: v4.z.number().nullish(),
  reasoning_tokens: v4.z.number().nullish(),
  cost: perplexityCostSchema.nullish()
});
var perplexityImageSchema = v4.z.object({
  image_url: v4.z.string(),
  origin_url: v4.z.string(),
  height: v4.z.number(),
  width: v4.z.number()
});
var perplexityResponseSchema = v4.z.object({
  id: v4.z.string(),
  created: v4.z.number(),
  model: v4.z.string(),
  choices: v4.z.array(
    v4.z.object({
      message: v4.z.object({
        role: v4.z.literal("assistant"),
        content: v4.z.string()
      }),
      finish_reason: v4.z.string().nullish()
    })
  ),
  citations: v4.z.array(v4.z.string()).nullish(),
  images: v4.z.array(perplexityImageSchema).nullish(),
  usage: perplexityUsageSchema.nullish()
});
var perplexityChunkSchema = v4.z.object({
  id: v4.z.string(),
  created: v4.z.number(),
  model: v4.z.string(),
  choices: v4.z.array(
    v4.z.object({
      delta: v4.z.object({
        role: v4.z.literal("assistant"),
        content: v4.z.string()
      }),
      finish_reason: v4.z.string().nullish()
    })
  ),
  citations: v4.z.array(v4.z.string()).nullish(),
  images: v4.z.array(perplexityImageSchema).nullish(),
  usage: perplexityUsageSchema.nullish()
});
var perplexityErrorSchema = v4.z.object({
  error: v4.z.object({
    code: v4.z.number(),
    message: v4.z.string().nullish(),
    type: v4.z.string().nullish()
  })
});
var errorToMessage = (data) => {
  var _a15, _b;
  return (_b = (_a15 = data.error.message) != null ? _a15 : data.error.type) != null ? _b : "unknown error";
};
var VERSION7 = "2.0.30" ;
function createPerplexity(options = {}) {
  const getHeaders = () => chunkOCS2GTEN_cjs.withUserAgentSuffix(
    {
      Authorization: `Bearer ${chunkOCS2GTEN_cjs.loadApiKey({
        apiKey: options.apiKey,
        environmentVariableName: "PERPLEXITY_API_KEY",
        description: "Perplexity"
      })}`,
      ...options.headers
    },
    `ai-sdk/perplexity/${VERSION7}`
  );
  const createLanguageModel = (modelId) => {
    var _a15;
    return new PerplexityLanguageModel(modelId, {
      baseURL: chunkOCS2GTEN_cjs.withoutTrailingSlash(
        (_a15 = options.baseURL) != null ? _a15 : "https://api.perplexity.ai"
      ),
      headers: getHeaders,
      generateId: chunkOCS2GTEN_cjs.generateId,
      fetch: options.fetch
    });
  };
  const provider = (modelId) => createLanguageModel(modelId);
  provider.languageModel = createLanguageModel;
  provider.textEmbeddingModel = (modelId) => {
    throw new chunkOCS2GTEN_cjs.NoSuchModelError({ modelId, modelType: "textEmbeddingModel" });
  };
  provider.imageModel = (modelId) => {
    throw new chunkOCS2GTEN_cjs.NoSuchModelError({ modelId, modelType: "imageModel" });
  };
  return provider;
}
createPerplexity();
var TogetherAIImageModel = class {
  constructor(modelId, config) {
    this.modelId = modelId;
    this.config = config;
    this.specificationVersion = "v2";
    this.maxImagesPerCall = 1;
  }
  get provider() {
    return this.config.provider;
  }
  async doGenerate({
    prompt,
    n,
    size,
    seed,
    providerOptions,
    headers,
    abortSignal
  }) {
    var _a15, _b, _c, _d;
    const warnings = [];
    if (size != null) {
      warnings.push({
        type: "unsupported-setting",
        setting: "aspectRatio",
        details: "This model does not support the `aspectRatio` option. Use `size` instead."
      });
    }
    const currentDate = (_c = (_b = (_a15 = this.config._internal) == null ? void 0 : _a15.currentDate) == null ? void 0 : _b.call(_a15)) != null ? _c : /* @__PURE__ */ new Date();
    const splitSize = size == null ? void 0 : size.split("x");
    const { value: response, responseHeaders } = await chunkOCS2GTEN_cjs.postJsonToApi({
      url: `${this.config.baseURL}/images/generations`,
      headers: chunkOCS2GTEN_cjs.combineHeaders(this.config.headers(), headers),
      body: {
        model: this.modelId,
        prompt,
        seed,
        ...n > 1 ? { n } : {},
        ...splitSize && {
          width: parseInt(splitSize[0]),
          height: parseInt(splitSize[1])
        },
        response_format: "base64",
        ...(_d = providerOptions.togetherai) != null ? _d : {}
      },
      failedResponseHandler: chunkOCS2GTEN_cjs.createJsonErrorResponseHandler({
        errorSchema: togetheraiErrorSchema,
        errorToMessage: (data) => data.error.message
      }),
      successfulResponseHandler: chunkOCS2GTEN_cjs.createJsonResponseHandler(
        togetheraiImageResponseSchema
      ),
      abortSignal,
      fetch: this.config.fetch
    });
    return {
      images: response.data.map((item) => item.b64_json),
      warnings,
      response: {
        timestamp: currentDate,
        modelId: this.modelId,
        headers: responseHeaders
      }
    };
  }
};
var togetheraiImageResponseSchema = v4.z.object({
  data: v4.z.array(
    v4.z.object({
      b64_json: v4.z.string()
    })
  )
});
var togetheraiErrorSchema = v4.z.object({
  error: v4.z.object({
    message: v4.z.string()
  })
});
var VERSION8 = "1.0.42" ;
function loadDeprecatedApiKey() {
  if (typeof process === "undefined") {
    return void 0;
  }
  if (typeof process.env.TOGETHER_API_KEY === "string") {
    return void 0;
  }
  const key = process.env.TOGETHER_AI_API_KEY;
  if (typeof key === "string") {
    console.warn(
      "TOGETHER_AI_API_KEY is deprecated and will be removed in a future release. Please use TOGETHER_API_KEY instead."
    );
  }
  return key;
}
function createTogetherAI(options = {}) {
  var _a15;
  const baseURL = chunkOCS2GTEN_cjs.withoutTrailingSlash(
    (_a15 = options.baseURL) != null ? _a15 : "https://api.together.xyz/v1/"
  );
  const getHeaders = () => {
    var _a22;
    return chunkOCS2GTEN_cjs.withUserAgentSuffix(
      {
        Authorization: `Bearer ${chunkOCS2GTEN_cjs.loadApiKey({
          apiKey: (_a22 = options.apiKey) != null ? _a22 : loadDeprecatedApiKey(),
          environmentVariableName: "TOGETHER_API_KEY",
          description: "TogetherAI"
        })}`,
        ...options.headers
      },
      `ai-sdk/togetherai/${VERSION8}`
    );
  };
  const getCommonModelConfig = (modelType) => ({
    provider: `togetherai.${modelType}`,
    url: ({ path }) => `${baseURL}${path}`,
    headers: getHeaders,
    fetch: options.fetch
  });
  const createChatModel = (modelId) => {
    return new chunkOCS2GTEN_cjs.OpenAICompatibleChatLanguageModel(
      modelId,
      getCommonModelConfig("chat")
    );
  };
  const createCompletionModel = (modelId) => new chunkOCS2GTEN_cjs.OpenAICompatibleCompletionLanguageModel(
    modelId,
    getCommonModelConfig("completion")
  );
  const createTextEmbeddingModel = (modelId) => new chunkOCS2GTEN_cjs.OpenAICompatibleEmbeddingModel(
    modelId,
    getCommonModelConfig("embedding")
  );
  const createImageModel = (modelId) => new TogetherAIImageModel(modelId, {
    ...getCommonModelConfig("image"),
    baseURL: baseURL != null ? baseURL : "https://api.together.xyz/v1/"
  });
  const provider = (modelId) => createChatModel(modelId);
  provider.completionModel = createCompletionModel;
  provider.languageModel = createChatModel;
  provider.chatModel = createChatModel;
  provider.textEmbeddingModel = createTextEmbeddingModel;
  provider.image = createImageModel;
  provider.imageModel = createImageModel;
  return provider;
}
createTogetherAI();
function convertToXaiChatMessages(prompt) {
  var _a15;
  const messages = [];
  const warnings = [];
  for (const { role, content } of prompt) {
    switch (role) {
      case "system": {
        messages.push({ role: "system", content });
        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) => {
            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,${chunkOCS2GTEN_cjs.convertToBase642(part.data)}`
                    }
                  };
                } else {
                  throw new chunkOCS2GTEN_cjs.UnsupportedFunctionalityError2({
                    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) {
          if (toolResponse.type === "tool-approval-response") {
            continue;
          }
          const output = toolResponse.output;
          let contentValue;
          switch (output.type) {
            case "text":
            case "error-text":
              contentValue = output.value;
              break;
            case "execution-denied":
              contentValue = (_a15 = output.reason) != null ? _a15 : "Tool execution denied.";
              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 convertXaiChatUsage(usage) {
  var _a15, _b, _c, _d;
  const cacheReadTokens = (_b = (_a15 = usage.prompt_tokens_details) == null ? void 0 : _a15.cached_tokens) != null ? _b : 0;
  const reasoningTokens = (_d = (_c = usage.completion_tokens_details) == null ? void 0 : _c.reasoning_tokens) != null ? _d : 0;
  const promptTokensIncludesCached = cacheReadTokens <= usage.prompt_tokens;
  return {
    inputTokens: {
      total: promptTokensIncludesCached ? usage.prompt_tokens : usage.prompt_tokens + cacheReadTokens,
      noCache: promptTokensIncludesCached ? usage.prompt_tokens - cacheReadTokens : usage.prompt_tokens,
      cacheRead: cacheReadTokens,
      cacheWrite: void 0
    },
    outputTokens: {
      total: usage.completion_tokens + reasoningTokens,
      text: usage.completion_tokens,
      reasoning: reasoningTokens
    },
    raw: usage
  };
}
function getResponseMetadata6({
  id,
  model,
  created,
  created_at
}) {
  const unixTime = created != null ? created : created_at;
  return {
    id: id != null ? id : void 0,
    modelId: model != null ? model : void 0,
    timestamp: unixTime != null ? new Date(unixTime * 1e3) : void 0
  };
}
function mapXaiFinishReason(finishReason) {
  switch (finishReason) {
    case "stop":
      return "stop";
    case "length":
      return "length";
    case "tool_calls":
    case "function_call":
      return "tool-calls";
    case "content_filter":
      return "content-filter";
    default:
      return "other";
  }
}
var webSourceSchema = v4.z.object({
  type: v4.z.literal("web"),
  country: v4.z.string().length(2).optional(),
  excludedWebsites: v4.z.array(v4.z.string()).max(5).optional(),
  allowedWebsites: v4.z.array(v4.z.string()).max(5).optional(),
  safeSearch: v4.z.boolean().optional()
});
var xSourceSchema = v4.z.object({
  type: v4.z.literal("x"),
  excludedXHandles: v4.z.array(v4.z.string()).optional(),
  includedXHandles: v4.z.array(v4.z.string()).optional(),
  postFavoriteCount: v4.z.number().int().optional(),
  postViewCount: v4.z.number().int().optional(),
  /**
   * @deprecated use `includedXHandles` instead
   */
  xHandles: v4.z.array(v4.z.string()).optional()
});
var newsSourceSchema = v4.z.object({
  type: v4.z.literal("news"),
  country: v4.z.string().length(2).optional(),
  excludedWebsites: v4.z.array(v4.z.string()).max(5).optional(),
  safeSearch: v4.z.boolean().optional()
});
var rssSourceSchema = v4.z.object({
  type: v4.z.literal("rss"),
  links: v4.z.array(v4.z.string().url()).max(1)
  // currently only supports one RSS link
});
var searchSourceSchema = v4.z.discriminatedUnion("type", [
  webSourceSchema,
  xSourceSchema,
  newsSourceSchema,
  rssSourceSchema
]);
var xaiLanguageModelChatOptions = v4.z.object({
  reasoningEffort: v4.z.enum(["low", "high"]).optional(),
  logprobs: v4.z.boolean().optional(),
  topLogprobs: v4.z.number().int().min(0).max(8).optional(),
  /**
   * Whether to enable parallel function calling during tool use.
   * When true, the model can call multiple functions in parallel.
   * When false, the model will call functions sequentially.
   * Defaults to true.
   */
  parallel_function_calling: v4.z.boolean().optional(),
  searchParameters: v4.z.object({
    /**
     * search mode preference
     * - "off": disables search completely
     * - "auto": model decides whether to search (default)
     * - "on": always enables search
     */
    mode: v4.z.enum(["off", "auto", "on"]),
    /**
     * whether to return citations in the response
     * defaults to true
     */
    returnCitations: v4.z.boolean().optional(),
    /**
     * start date for search data (ISO8601 format: YYYY-MM-DD)
     */
    fromDate: v4.z.string().optional(),
    /**
     * end date for search data (ISO8601 format: YYYY-MM-DD)
     */
    toDate: v4.z.string().optional(),
    /**
     * maximum number of search results to consider
     * defaults to 20
     */
    maxSearchResults: v4.z.number().min(1).max(50).optional(),
    /**
     * data sources to search from.
     * defaults to [{ type: 'web' }, { type: 'x' }] if not specified.
     *
     * @example
     * sources: [{ type: 'web', country: 'US' }, { type: 'x' }]
     */
    sources: v4.z.array(searchSourceSchema).optional()
  }).optional()
});
var xaiErrorDataSchema = v4.z.object({
  error: v4.z.object({
    message: v4.z.string(),
    type: v4.z.string().nullish(),
    param: v4.z.any().nullish(),
    code: v4.z.union([v4.z.string(), v4.z.number()]).nullish()
  })
});
var xaiFailedResponseHandler = chunkOCS2GTEN_cjs.createJsonErrorResponseHandler2({
  errorSchema: xaiErrorDataSchema,
  errorToMessage: (data) => data.error.message
});
function prepareTools5({
  tools,
  toolChoice
}) {
  tools = (tools == null ? void 0 : tools.length) ? tools : void 0;
  const toolWarnings = [];
  if (tools == null) {
    return { tools: void 0, toolChoice: void 0, toolWarnings };
  }
  const xaiTools2 = [];
  for (const tool of tools) {
    if (tool.type === "provider") {
      toolWarnings.push({
        type: "unsupported",
        feature: `provider-defined tool ${tool.name}`
      });
    } else {
      xaiTools2.push({
        type: "function",
        function: {
          name: tool.name,
          description: tool.description,
          parameters: tool.inputSchema,
          ...tool.strict != null ? { strict: tool.strict } : {}
        }
      });
    }
  }
  if (toolChoice == null) {
    return { tools: xaiTools2, toolChoice: void 0, toolWarnings };
  }
  const type = toolChoice.type;
  switch (type) {
    case "auto":
    case "none":
      return { tools: xaiTools2, toolChoice: type, toolWarnings };
    case "required":
      return { tools: xaiTools2, toolChoice: "required", toolWarnings };
    case "tool":
      return {
        tools: xaiTools2,
        toolChoice: {
          type: "function",
          function: { name: toolChoice.toolName }
        },
        toolWarnings
      };
    default: {
      const _exhaustiveCheck = type;
      throw new chunkOCS2GTEN_cjs.UnsupportedFunctionalityError2({
        functionality: `tool choice type: ${_exhaustiveCheck}`
      });
    }
  }
}
var XaiChatLanguageModel = class {
  constructor(modelId, config) {
    this.specificationVersion = "v3";
    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,
    seed,
    responseFormat,
    providerOptions,
    tools,
    toolChoice
  }) {
    var _a15, _b, _c;
    const warnings = [];
    const options = (_a15 = await chunkOCS2GTEN_cjs.parseProviderOptions2({
      provider: "xai",
      providerOptions,
      schema: xaiLanguageModelChatOptions
    })) != null ? _a15 : {};
    if (topK != null) {
      warnings.push({ type: "unsupported", feature: "topK" });
    }
    if (frequencyPenalty != null) {
      warnings.push({ type: "unsupported", feature: "frequencyPenalty" });
    }
    if (presencePenalty != null) {
      warnings.push({ type: "unsupported", feature: "presencePenalty" });
    }
    if (stopSequences != null) {
      warnings.push({ type: "unsupported", feature: "stopSequences" });
    }
    const { messages, warnings: messageWarnings } = convertToXaiChatMessages(prompt);
    warnings.push(...messageWarnings);
    const {
      tools: xaiTools2,
      toolChoice: xaiToolChoice,
      toolWarnings
    } = prepareTools5({
      tools,
      toolChoice
    });
    warnings.push(...toolWarnings);
    const baseArgs = {
      // model id
      model: this.modelId,
      // standard generation settings
      logprobs: options.logprobs === true || options.topLogprobs != null ? true : void 0,
      top_logprobs: options.topLogprobs,
      max_completion_tokens: maxOutputTokens,
      temperature,
      top_p: topP,
      seed,
      reasoning_effort: options.reasoningEffort,
      // parallel function calling
      parallel_function_calling: options.parallel_function_calling,
      // response format
      response_format: (responseFormat == null ? void 0 : responseFormat.type) === "json" ? responseFormat.schema != null ? {
        type: "json_schema",
        json_schema: {
          name: (_b = responseFormat.name) != null ? _b : "response",
          schema: responseFormat.schema,
          strict: true
        }
      } : { type: "json_object" } : void 0,
      // search parameters
      search_parameters: options.searchParameters ? {
        mode: options.searchParameters.mode,
        return_citations: options.searchParameters.returnCitations,
        from_date: options.searchParameters.fromDate,
        to_date: options.searchParameters.toDate,
        max_search_results: options.searchParameters.maxSearchResults,
        sources: (_c = options.searchParameters.sources) == null ? void 0 : _c.map((source) => {
          var _a22;
          return {
            type: source.type,
            ...source.type === "web" && {
              country: source.country,
              excluded_websites: source.excludedWebsites,
              allowed_websites: source.allowedWebsites,
              safe_search: source.safeSearch
            },
            ...source.type === "x" && {
              excluded_x_handles: source.excludedXHandles,
              included_x_handles: (_a22 = source.includedXHandles) != null ? _a22 : source.xHandles,
              post_favorite_count: source.postFavoriteCount,
              post_view_count: source.postViewCount
            },
            ...source.type === "news" && {
              country: source.country,
              excluded_websites: source.excludedWebsites,
              safe_search: source.safeSearch
            },
            ...source.type === "rss" && {
              links: source.links
            }
          };
        })
      } : void 0,
      // messages in xai format
      messages,
      // tools in xai format
      tools: xaiTools2,
      tool_choice: xaiToolChoice
    };
    return {
      args: baseArgs,
      warnings
    };
  }
  async doGenerate(options) {
    var _a15, _b;
    const { args: body, warnings } = await this.getArgs(options);
    const url = `${(_a15 = this.config.baseURL) != null ? _a15 : "https://api.x.ai/v1"}/chat/completions`;
    const {
      responseHeaders,
      value: response,
      rawValue: rawResponse
    } = await chunkOCS2GTEN_cjs.postJsonToApi2({
      url,
      headers: chunkOCS2GTEN_cjs.combineHeaders2(this.config.headers(), options.headers),
      body,
      failedResponseHandler: xaiFailedResponseHandler,
      successfulResponseHandler: chunkOCS2GTEN_cjs.createJsonResponseHandler2(
        xaiChatResponseSchema
      ),
      abortSignal: options.abortSignal,
      fetch: this.config.fetch
    });
    if (response.error != null) {
      throw new chunkOCS2GTEN_cjs.APICallError2({
        message: response.error,
        url,
        requestBodyValues: body,
        statusCode: 200,
        responseHeaders,
        responseBody: JSON.stringify(rawResponse),
        isRetryable: response.code === "The service is currently unavailable"
      });
    }
    const choice = response.choices[0];
    const content = [];
    if (choice.message.content != null && choice.message.content.length > 0) {
      let text = choice.message.content;
      const lastMessage = body.messages[body.messages.length - 1];
      if ((lastMessage == null ? void 0 : lastMessage.role) === "assistant" && text === lastMessage.content) {
        text = "";
      }
      if (text.length > 0) {
        content.push({ type: "text", text });
      }
    }
    if (choice.message.reasoning_content != null && choice.message.reasoning_content.length > 0) {
      content.push({
        type: "reasoning",
        text: choice.message.reasoning_content
      });
    }
    if (choice.message.tool_calls != null) {
      for (const toolCall of choice.message.tool_calls) {
        content.push({
          type: "tool-call",
          toolCallId: toolCall.id,
          toolName: toolCall.function.name,
          input: toolCall.function.arguments
        });
      }
    }
    if (response.citations != null) {
      for (const url2 of response.citations) {
        content.push({
          type: "source",
          sourceType: "url",
          id: this.config.generateId(),
          url: url2
        });
      }
    }
    return {
      content,
      finishReason: {
        unified: mapXaiFinishReason(choice.finish_reason),
        raw: (_b = choice.finish_reason) != null ? _b : void 0
      },
      usage: response.usage ? convertXaiChatUsage(response.usage) : {
        inputTokens: { total: 0, noCache: 0, cacheRead: 0, cacheWrite: 0 },
        outputTokens: { total: 0, text: 0, reasoning: 0 }
      },
      request: { body },
      response: {
        ...getResponseMetadata6(response),
        headers: responseHeaders,
        body: rawResponse
      },
      warnings
    };
  }
  async doStream(options) {
    var _a15;
    const { args, warnings } = await this.getArgs(options);
    const body = {
      ...args,
      stream: true,
      stream_options: {
        include_usage: true
      }
    };
    const url = `${(_a15 = this.config.baseURL) != null ? _a15 : "https://api.x.ai/v1"}/chat/completions`;
    const { responseHeaders, value: response } = await chunkOCS2GTEN_cjs.postJsonToApi2({
      url,
      headers: chunkOCS2GTEN_cjs.combineHeaders2(this.config.headers(), options.headers),
      body,
      failedResponseHandler: xaiFailedResponseHandler,
      successfulResponseHandler: async ({ response: response2 }) => {
        const responseHeaders2 = chunkOCS2GTEN_cjs.extractResponseHeaders(response2);
        const contentType = response2.headers.get("content-type");
        if (contentType == null ? void 0 : contentType.includes("application/json")) {
          const responseBody = await response2.text();
          const parsedError = await chunkOCS2GTEN_cjs.safeParseJSON({
            text: responseBody,
            schema: xaiStreamErrorSchema
          });
          if (parsedError.success) {
            throw new chunkOCS2GTEN_cjs.APICallError2({
              message: parsedError.value.error,
              url,
              requestBodyValues: body,
              statusCode: 200,
              responseHeaders: responseHeaders2,
              responseBody,
              isRetryable: parsedError.value.code === "The service is currently unavailable"
            });
          }
          throw new chunkOCS2GTEN_cjs.APICallError2({
            message: "Invalid JSON response",
            url,
            requestBodyValues: body,
            statusCode: 200,
            responseHeaders: responseHeaders2,
            responseBody
          });
        }
        return chunkOCS2GTEN_cjs.createEventSourceResponseHandler2(xaiChatChunkSchema)({
          response: response2,
          url,
          requestBodyValues: body
        });
      },
      abortSignal: options.abortSignal,
      fetch: this.config.fetch
    });
    let finishReason = {
      unified: "other",
      raw: void 0
    };
    let usage = void 0;
    let isFirstChunk = true;
    const contentBlocks = {};
    const lastReasoningDeltas = {};
    let activeReasoningBlockId = void 0;
    const self = this;
    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) {
              controller.enqueue({ type: "error", error: chunk.error });
              return;
            }
            const value = chunk.value;
            if (isFirstChunk) {
              controller.enqueue({
                type: "response-metadata",
                ...getResponseMetadata6(value)
              });
              isFirstChunk = false;
            }
            if (value.citations != null) {
              for (const url2 of value.citations) {
                controller.enqueue({
                  type: "source",
                  sourceType: "url",
                  id: self.config.generateId(),
                  url: url2
                });
              }
            }
            if (value.usage != null) {
              usage = convertXaiChatUsage(value.usage);
            }
            const choice = value.choices[0];
            if ((choice == null ? void 0 : choice.finish_reason) != null) {
              finishReason = {
                unified: mapXaiFinishReason(choice.finish_reason),
                raw: choice.finish_reason
              };
            }
            if ((choice == null ? void 0 : choice.delta) == null) {
              return;
            }
            const delta = choice.delta;
            const choiceIndex = choice.index;
            if (delta.content != null && delta.content.length > 0) {
              const textContent = delta.content;
              if (activeReasoningBlockId != null && !contentBlocks[activeReasoningBlockId].ended) {
                controller.enqueue({
                  type: "reasoning-end",
                  id: activeReasoningBlockId
                });
                contentBlocks[activeReasoningBlockId].ended = true;
                activeReasoningBlockId = void 0;
              }
              const lastMessage = body.messages[body.messages.length - 1];
              if ((lastMessage == null ? void 0 : lastMessage.role) === "assistant" && textContent === lastMessage.content) {
                return;
              }
              const blockId = `text-${value.id || choiceIndex}`;
              if (contentBlocks[blockId] == null) {
                contentBlocks[blockId] = { type: "text", ended: false };
                controller.enqueue({
                  type: "text-start",
                  id: blockId
                });
              }
              controller.enqueue({
                type: "text-delta",
                id: blockId,
                delta: textContent
              });
            }
            if (delta.reasoning_content != null && delta.reasoning_content.length > 0) {
              const blockId = `reasoning-${value.id || choiceIndex}`;
              if (lastReasoningDeltas[blockId] === delta.reasoning_content) {
                return;
              }
              lastReasoningDeltas[blockId] = delta.reasoning_content;
              if (contentBlocks[blockId] == null) {
                contentBlocks[blockId] = { type: "reasoning", ended: false };
                activeReasoningBlockId = blockId;
                controller.enqueue({
                  type: "reasoning-start",
                  id: blockId
                });
              }
              controller.enqueue({
                type: "reasoning-delta",
                id: blockId,
                delta: delta.reasoning_content
              });
            }
            if (delta.tool_calls != null) {
              if (activeReasoningBlockId != null && !contentBlocks[activeReasoningBlockId].ended) {
                controller.enqueue({
                  type: "reasoning-end",
                  id: activeReasoningBlockId
                });
                contentBlocks[activeReasoningBlockId].ended = true;
                activeReasoningBlockId = void 0;
              }
              for (const toolCall of delta.tool_calls) {
                const toolCallId = toolCall.id;
                controller.enqueue({
                  type: "tool-input-start",
                  id: toolCallId,
                  toolName: toolCall.function.name
                });
                controller.enqueue({
                  type: "tool-input-delta",
                  id: toolCallId,
                  delta: toolCall.function.arguments
                });
                controller.enqueue({
                  type: "tool-input-end",
                  id: toolCallId
                });
                controller.enqueue({
                  type: "tool-call",
                  toolCallId,
                  toolName: toolCall.function.name,
                  input: toolCall.function.arguments
                });
              }
            }
          },
          flush(controller) {
            for (const [blockId, block] of Object.entries(contentBlocks)) {
              if (!block.ended) {
                controller.enqueue({
                  type: block.type === "text" ? "text-end" : "reasoning-end",
                  id: blockId
                });
              }
            }
            controller.enqueue({
              type: "finish",
              finishReason,
              usage: usage != null ? usage : {
                inputTokens: {
                  total: 0,
                  noCache: 0,
                  cacheRead: 0,
                  cacheWrite: 0
                },
                outputTokens: { total: 0, text: 0, reasoning: 0 }
              }
            });
          }
        })
      ),
      request: { body },
      response: { headers: responseHeaders }
    };
  }
};
var xaiUsageSchema = v4.z.object({
  prompt_tokens: v4.z.number(),
  completion_tokens: v4.z.number(),
  total_tokens: v4.z.number(),
  prompt_tokens_details: v4.z.object({
    text_tokens: v4.z.number().nullish(),
    audio_tokens: v4.z.number().nullish(),
    image_tokens: v4.z.number().nullish(),
    cached_tokens: v4.z.number().nullish()
  }).nullish(),
  completion_tokens_details: v4.z.object({
    reasoning_tokens: v4.z.number().nullish(),
    audio_tokens: v4.z.number().nullish(),
    accepted_prediction_tokens: v4.z.number().nullish(),
    rejected_prediction_tokens: v4.z.number().nullish()
  }).nullish()
});
var xaiChatResponseSchema = v4.z.object({
  id: v4.z.string().nullish(),
  created: v4.z.number().nullish(),
  model: v4.z.string().nullish(),
  choices: v4.z.array(
    v4.z.object({
      message: v4.z.object({
        role: v4.z.literal("assistant"),
        content: v4.z.string().nullish(),
        reasoning_content: v4.z.string().nullish(),
        tool_calls: v4.z.array(
          v4.z.object({
            id: v4.z.string(),
            type: v4.z.literal("function"),
            function: v4.z.object({
              name: v4.z.string(),
              arguments: v4.z.string()
            })
          })
        ).nullish()
      }),
      index: v4.z.number(),
      finish_reason: v4.z.string().nullish()
    })
  ).nullish(),
  object: v4.z.literal("chat.completion").nullish(),
  usage: xaiUsageSchema.nullish(),
  citations: v4.z.array(v4.z.string().url()).nullish(),
  code: v4.z.string().nullish(),
  error: v4.z.string().nullish()
});
var xaiChatChunkSchema = v4.z.object({
  id: v4.z.string().nullish(),
  created: v4.z.number().nullish(),
  model: v4.z.string().nullish(),
  choices: v4.z.array(
    v4.z.object({
      delta: v4.z.object({
        role: v4.z.enum(["assistant"]).optional(),
        content: v4.z.string().nullish(),
        reasoning_content: v4.z.string().nullish(),
        tool_calls: v4.z.array(
          v4.z.object({
            id: v4.z.string(),
            type: v4.z.literal("function"),
            function: v4.z.object({
              name: v4.z.string(),
              arguments: v4.z.string()
            })
          })
        ).nullish()
      }),
      finish_reason: v4.z.string().nullish(),
      index: v4.z.number()
    })
  ),
  usage: xaiUsageSchema.nullish(),
  citations: v4.z.array(v4.z.string().url()).nullish()
});
var xaiStreamErrorSchema = v4.z.object({
  code: v4.z.string(),
  error: v4.z.string()
});
var xaiImageModelOptions = v4.z.object({
  aspect_ratio: v4.z.string().optional(),
  output_format: v4.z.string().optional(),
  sync_mode: v4.z.boolean().optional(),
  resolution: v4.z.enum(["1k", "2k"]).optional(),
  quality: v4.z.enum(["low", "medium", "high"]).optional(),
  user: v4.z.string().optional()
});
var XaiImageModel = class {
  constructor(modelId, config) {
    this.modelId = modelId;
    this.config = config;
    this.specificationVersion = "v3";
    this.maxImagesPerCall = 3;
  }
  get provider() {
    return this.config.provider;
  }
  async doGenerate({
    prompt,
    n,
    size,
    aspectRatio,
    seed,
    providerOptions,
    headers,
    abortSignal,
    files,
    mask
  }) {
    var _a15, _b, _c, _d, _e;
    const warnings = [];
    if (size != null) {
      warnings.push({
        type: "unsupported",
        feature: "size",
        details: "This model does not support the `size` option. Use `aspectRatio` instead."
      });
    }
    if (seed != null) {
      warnings.push({
        type: "unsupported",
        feature: "seed"
      });
    }
    if (mask != null) {
      warnings.push({
        type: "unsupported",
        feature: "mask"
      });
    }
    const xaiOptions = await chunkOCS2GTEN_cjs.parseProviderOptions2({
      provider: "xai",
      providerOptions,
      schema: xaiImageModelOptions
    });
    const hasFiles = files != null && files.length > 0;
    const imageUrls = hasFiles ? files.map((file) => chunkOCS2GTEN_cjs.convertImageModelFileToDataUri(file)) : [];
    const endpoint = hasFiles ? "/images/edits" : "/images/generations";
    const body = {
      model: this.modelId,
      prompt,
      n,
      response_format: "b64_json"
    };
    if (aspectRatio != null) {
      body.aspect_ratio = aspectRatio;
    }
    if ((xaiOptions == null ? void 0 : xaiOptions.output_format) != null) {
      body.output_format = xaiOptions.output_format;
    }
    if ((xaiOptions == null ? void 0 : xaiOptions.sync_mode) != null) {
      body.sync_mode = xaiOptions.sync_mode;
    }
    if ((xaiOptions == null ? void 0 : xaiOptions.aspect_ratio) != null && aspectRatio == null) {
      body.aspect_ratio = xaiOptions.aspect_ratio;
    }
    if ((xaiOptions == null ? void 0 : xaiOptions.resolution) != null) {
      body.resolution = xaiOptions.resolution;
    }
    if ((xaiOptions == null ? void 0 : xaiOptions.quality) != null) {
      body.quality = xaiOptions.quality;
    }
    if ((xaiOptions == null ? void 0 : xaiOptions.user) != null) {
      body.user = xaiOptions.user;
    }
    if (imageUrls.length === 1) {
      body.image = { url: imageUrls[0], type: "image_url" };
    } else if (imageUrls.length > 1) {
      body.images = imageUrls.map((url) => ({ url, type: "image_url" }));
    }
    const baseURL = (_a15 = this.config.baseURL) != null ? _a15 : "https://api.x.ai/v1";
    const currentDate = (_d = (_c = (_b = this.config._internal) == null ? void 0 : _b.currentDate) == null ? void 0 : _c.call(_b)) != null ? _d : /* @__PURE__ */ new Date();
    const { value: response, responseHeaders } = await chunkOCS2GTEN_cjs.postJsonToApi2({
      url: `${baseURL}${endpoint}`,
      headers: chunkOCS2GTEN_cjs.combineHeaders2(this.config.headers(), headers),
      body,
      failedResponseHandler: xaiFailedResponseHandler,
      successfulResponseHandler: chunkOCS2GTEN_cjs.createJsonResponseHandler2(
        xaiImageResponseSchema
      ),
      abortSignal,
      fetch: this.config.fetch
    });
    const hasAllBase64 = response.data.every((image) => image.b64_json != null);
    const images = hasAllBase64 ? response.data.map((image) => image.b64_json) : await Promise.all(
      response.data.map(
        (image) => this.downloadImage(image.url, abortSignal)
      )
    );
    return {
      images,
      warnings,
      response: {
        timestamp: currentDate,
        modelId: this.modelId,
        headers: responseHeaders
      },
      providerMetadata: {
        xai: {
          images: response.data.map((item) => ({
            ...item.revised_prompt ? { revisedPrompt: item.revised_prompt } : {}
          })),
          ...((_e = response.usage) == null ? void 0 : _e.cost_in_usd_ticks) != null ? { costInUsdTicks: response.usage.cost_in_usd_ticks } : {}
        }
      }
    };
  }
  async downloadImage(url, abortSignal) {
    const { value } = await chunkOCS2GTEN_cjs.getFromApi({
      url,
      abortSignal,
      failedResponseHandler: chunkOCS2GTEN_cjs.createStatusCodeErrorResponseHandler(),
      successfulResponseHandler: chunkOCS2GTEN_cjs.createBinaryResponseHandler2(),
      fetch: this.config.fetch
    });
    return value;
  }
};
var xaiImageResponseSchema = v4.z.object({
  data: v4.z.array(
    v4.z.object({
      url: v4.z.string().nullish(),
      b64_json: v4.z.string().nullish(),
      revised_prompt: v4.z.string().nullish()
    })
  ),
  usage: v4.z.object({
    cost_in_usd_ticks: v4.z.number().nullish()
  }).nullish()
});
async function convertToXaiResponsesInput({
  prompt
}) {
  var _a15, _b, _c, _d, _e, _f, _g, _h, _i;
  const input = [];
  const inputWarnings = [];
  for (const message of prompt) {
    switch (message.role) {
      case "system": {
        input.push({
          role: "system",
          content: message.content
        });
        break;
      }
      case "user": {
        const contentParts = [];
        for (const block of message.content) {
          switch (block.type) {
            case "text": {
              contentParts.push({ type: "input_text", text: block.text });
              break;
            }
            case "file": {
              if (block.mediaType.startsWith("image/")) {
                const mediaType = block.mediaType === "image/*" ? "image/jpeg" : block.mediaType;
                const imageUrl = block.data instanceof URL ? block.data.toString() : `data:${mediaType};base64,${chunkOCS2GTEN_cjs.convertToBase642(block.data)}`;
                contentParts.push({ type: "input_image", image_url: imageUrl });
              } else if (block.data instanceof URL) {
                contentParts.push({
                  type: "input_file",
                  file_url: block.data.toString()
                });
              } else {
                throw new chunkOCS2GTEN_cjs.UnsupportedFunctionalityError2({
                  functionality: `file part media type ${block.mediaType} as inline data (xAI Responses requires a URL or a Files API reference for non-image files)`
                });
              }
              break;
            }
            default: {
              inputWarnings.push({
                type: "other",
                message: "xAI Responses API does not support this content type in user messages"
              });
            }
          }
        }
        input.push({
          role: "user",
          content: contentParts
        });
        break;
      }
      case "assistant": {
        for (const part of message.content) {
          switch (part.type) {
            case "text": {
              const id = typeof ((_b = (_a15 = part.providerOptions) == null ? void 0 : _a15.xai) == null ? void 0 : _b.itemId) === "string" ? part.providerOptions.xai.itemId : void 0;
              input.push({
                role: "assistant",
                content: part.text,
                id
              });
              break;
            }
            case "tool-call": {
              if (part.providerExecuted) {
                break;
              }
              const id = typeof ((_d = (_c = part.providerOptions) == null ? void 0 : _c.xai) == null ? void 0 : _d.itemId) === "string" ? part.providerOptions.xai.itemId : void 0;
              input.push({
                type: "function_call",
                id: id != null ? id : part.toolCallId,
                call_id: part.toolCallId,
                name: part.toolName,
                arguments: JSON.stringify(part.input),
                status: "completed"
              });
              break;
            }
            case "tool-result": {
              break;
            }
            case "reasoning": {
              const itemId = typeof ((_f = (_e = part.providerOptions) == null ? void 0 : _e.xai) == null ? void 0 : _f.itemId) === "string" ? part.providerOptions.xai.itemId : void 0;
              const encryptedContent = typeof ((_h = (_g = part.providerOptions) == null ? void 0 : _g.xai) == null ? void 0 : _h.reasoningEncryptedContent) === "string" ? part.providerOptions.xai.reasoningEncryptedContent : void 0;
              if (itemId != null || encryptedContent != null) {
                const summaryParts = [];
                if (part.text.length > 0) {
                  summaryParts.push({
                    type: "summary_text",
                    text: part.text
                  });
                }
                input.push({
                  type: "reasoning",
                  id: itemId != null ? itemId : "",
                  summary: summaryParts,
                  status: "completed",
                  ...encryptedContent != null && {
                    encrypted_content: encryptedContent
                  }
                });
              } else {
                inputWarnings.push({
                  type: "other",
                  message: "Reasoning parts without itemId or encrypted content cannot be sent back to xAI. Skipping."
                });
              }
              break;
            }
            case "file": {
              inputWarnings.push({
                type: "other",
                message: `xAI Responses API does not support ${part.type} in assistant messages`
              });
              break;
            }
            default: {
              inputWarnings.push({
                type: "other",
                message: "xAI Responses API does not support this content type in assistant messages"
              });
            }
          }
        }
        break;
      }
      case "tool": {
        for (const part of message.content) {
          if (part.type === "tool-approval-response") {
            continue;
          }
          const output = part.output;
          let outputValue;
          switch (output.type) {
            case "text":
            case "error-text":
              outputValue = output.value;
              break;
            case "execution-denied":
              outputValue = (_i = output.reason) != null ? _i : "tool execution denied";
              break;
            case "json":
            case "error-json":
              outputValue = JSON.stringify(output.value);
              break;
            case "content":
              outputValue = output.value.map((item) => {
                if (item.type === "text") {
                  return item.text;
                }
                return "";
              }).join("");
              break;
            default: {
              outputValue = "";
            }
          }
          input.push({
            type: "function_call_output",
            call_id: part.toolCallId,
            output: outputValue
          });
        }
        break;
      }
      default: {
        inputWarnings.push({
          type: "other",
          message: "unsupported message role"
        });
      }
    }
  }
  return { input, inputWarnings };
}
function convertXaiResponsesUsage(usage) {
  var _a15, _b, _c, _d;
  const cacheReadTokens = (_b = (_a15 = usage.input_tokens_details) == null ? void 0 : _a15.cached_tokens) != null ? _b : 0;
  const reasoningTokens = (_d = (_c = usage.output_tokens_details) == null ? void 0 : _c.reasoning_tokens) != null ? _d : 0;
  const inputTokensIncludesCached = cacheReadTokens <= usage.input_tokens;
  return {
    inputTokens: {
      total: inputTokensIncludesCached ? usage.input_tokens : usage.input_tokens + cacheReadTokens,
      noCache: inputTokensIncludesCached ? usage.input_tokens - cacheReadTokens : usage.input_tokens,
      cacheRead: cacheReadTokens,
      cacheWrite: void 0
    },
    outputTokens: {
      total: usage.output_tokens,
      text: usage.output_tokens - reasoningTokens,
      reasoning: reasoningTokens
    },
    raw: usage
  };
}
function mapXaiResponsesFinishReason(finishReason) {
  switch (finishReason) {
    case "stop":
    case "completed":
      return "stop";
    case "length":
    case "max_output_tokens":
      return "length";
    case "tool_calls":
    case "function_call":
      return "tool-calls";
    case "content_filter":
      return "content-filter";
    default:
      return "other";
  }
}
var annotationSchema = v4.z.union([
  v4.z.object({
    type: v4.z.literal("url_citation"),
    url: v4.z.string(),
    title: v4.z.string().optional()
  }),
  v4.z.object({
    type: v4.z.string()
  })
]);
var messageContentPartSchema = v4.z.object({
  type: v4.z.string(),
  text: v4.z.string().optional(),
  logprobs: v4.z.array(v4.z.any()).optional(),
  annotations: v4.z.array(annotationSchema).optional()
});
var reasoningSummaryPartSchema = v4.z.object({
  type: v4.z.string(),
  text: v4.z.string()
});
var toolCallSchema = v4.z.object({
  name: v4.z.string().optional(),
  arguments: v4.z.string().optional(),
  input: v4.z.string().optional(),
  call_id: v4.z.string().optional(),
  id: v4.z.string(),
  status: v4.z.string(),
  action: v4.z.any().optional()
});
var mcpCallSchema = v4.z.object({
  name: v4.z.string().optional(),
  arguments: v4.z.string().optional(),
  output: v4.z.string().optional(),
  error: v4.z.string().optional(),
  id: v4.z.string(),
  status: v4.z.string(),
  server_label: v4.z.string().optional()
});
var outputItemSchema = v4.z.discriminatedUnion("type", [
  v4.z.object({
    type: v4.z.literal("web_search_call"),
    ...toolCallSchema.shape
  }),
  v4.z.object({
    type: v4.z.literal("x_search_call"),
    ...toolCallSchema.shape
  }),
  v4.z.object({
    type: v4.z.literal("code_interpreter_call"),
    ...toolCallSchema.shape
  }),
  v4.z.object({
    type: v4.z.literal("code_execution_call"),
    ...toolCallSchema.shape
  }),
  v4.z.object({
    type: v4.z.literal("view_image_call"),
    ...toolCallSchema.shape
  }),
  v4.z.object({
    type: v4.z.literal("view_x_video_call"),
    ...toolCallSchema.shape
  }),
  v4.z.object({
    type: v4.z.literal("file_search_call"),
    id: v4.z.string(),
    status: v4.z.string(),
    queries: v4.z.array(v4.z.string()).optional(),
    results: v4.z.array(
      v4.z.object({
        file_id: v4.z.string(),
        filename: v4.z.string(),
        score: v4.z.number(),
        text: v4.z.string()
      })
    ).nullish()
  }),
  v4.z.object({
    type: v4.z.literal("custom_tool_call"),
    ...toolCallSchema.shape
  }),
  v4.z.object({
    type: v4.z.literal("mcp_call"),
    ...mcpCallSchema.shape
  }),
  v4.z.object({
    type: v4.z.literal("message"),
    role: v4.z.string(),
    content: v4.z.array(messageContentPartSchema),
    id: v4.z.string(),
    status: v4.z.string()
  }),
  v4.z.object({
    type: v4.z.literal("function_call"),
    name: v4.z.string(),
    arguments: v4.z.string(),
    call_id: v4.z.string(),
    id: v4.z.string()
  }),
  v4.z.object({
    type: v4.z.literal("reasoning"),
    id: v4.z.string(),
    summary: v4.z.array(reasoningSummaryPartSchema),
    status: v4.z.string(),
    encrypted_content: v4.z.string().nullish()
  })
]);
var xaiResponsesUsageSchema = v4.z.object({
  input_tokens: v4.z.number(),
  output_tokens: v4.z.number(),
  total_tokens: v4.z.number().optional(),
  input_tokens_details: v4.z.object({
    cached_tokens: v4.z.number().optional()
  }).optional(),
  output_tokens_details: v4.z.object({
    reasoning_tokens: v4.z.number().optional()
  }).optional(),
  num_sources_used: v4.z.number().optional(),
  num_server_side_tools_used: v4.z.number().optional()
});
var xaiResponsesResponseSchema = v4.z.object({
  id: v4.z.string().nullish(),
  created_at: v4.z.number().nullish(),
  model: v4.z.string().nullish(),
  object: v4.z.literal("response"),
  output: v4.z.array(outputItemSchema),
  usage: xaiResponsesUsageSchema.nullish(),
  status: v4.z.string()
});
var xaiResponsesChunkSchema = v4.z.union([
  v4.z.object({
    type: v4.z.literal("response.created"),
    response: xaiResponsesResponseSchema.partial({ usage: true, status: true })
  }),
  v4.z.object({
    type: v4.z.literal("response.in_progress"),
    response: xaiResponsesResponseSchema.partial({ usage: true, status: true })
  }),
  v4.z.object({
    type: v4.z.literal("response.output_item.added"),
    item: outputItemSchema,
    output_index: v4.z.number()
  }),
  v4.z.object({
    type: v4.z.literal("response.output_item.done"),
    item: outputItemSchema,
    output_index: v4.z.number()
  }),
  v4.z.object({
    type: v4.z.literal("response.content_part.added"),
    item_id: v4.z.string(),
    output_index: v4.z.number(),
    content_index: v4.z.number(),
    part: messageContentPartSchema
  }),
  v4.z.object({
    type: v4.z.literal("response.content_part.done"),
    item_id: v4.z.string(),
    output_index: v4.z.number(),
    content_index: v4.z.number(),
    part: messageContentPartSchema
  }),
  v4.z.object({
    type: v4.z.literal("response.output_text.delta"),
    item_id: v4.z.string(),
    output_index: v4.z.number(),
    content_index: v4.z.number(),
    delta: v4.z.string(),
    logprobs: v4.z.array(v4.z.any()).optional()
  }),
  v4.z.object({
    type: v4.z.literal("response.output_text.done"),
    item_id: v4.z.string(),
    output_index: v4.z.number(),
    content_index: v4.z.number(),
    text: v4.z.string(),
    logprobs: v4.z.array(v4.z.any()).optional(),
    annotations: v4.z.array(annotationSchema).optional()
  }),
  v4.z.object({
    type: v4.z.literal("response.output_text.annotation.added"),
    item_id: v4.z.string(),
    output_index: v4.z.number(),
    content_index: v4.z.number(),
    annotation_index: v4.z.number(),
    annotation: annotationSchema
  }),
  v4.z.object({
    type: v4.z.literal("response.reasoning_summary_part.added"),
    item_id: v4.z.string(),
    output_index: v4.z.number(),
    summary_index: v4.z.number(),
    part: reasoningSummaryPartSchema
  }),
  v4.z.object({
    type: v4.z.literal("response.reasoning_summary_part.done"),
    item_id: v4.z.string(),
    output_index: v4.z.number(),
    summary_index: v4.z.number(),
    part: reasoningSummaryPartSchema
  }),
  v4.z.object({
    type: v4.z.literal("response.reasoning_summary_text.delta"),
    item_id: v4.z.string(),
    output_index: v4.z.number(),
    summary_index: v4.z.number(),
    delta: v4.z.string()
  }),
  v4.z.object({
    type: v4.z.literal("response.reasoning_summary_text.done"),
    item_id: v4.z.string(),
    output_index: v4.z.number(),
    summary_index: v4.z.number(),
    text: v4.z.string()
  }),
  v4.z.object({
    type: v4.z.literal("response.reasoning_text.delta"),
    item_id: v4.z.string(),
    output_index: v4.z.number(),
    content_index: v4.z.number(),
    delta: v4.z.string()
  }),
  v4.z.object({
    type: v4.z.literal("response.reasoning_text.done"),
    item_id: v4.z.string(),
    output_index: v4.z.number(),
    content_index: v4.z.number(),
    text: v4.z.string()
  }),
  v4.z.object({
    type: v4.z.literal("response.web_search_call.in_progress"),
    item_id: v4.z.string(),
    output_index: v4.z.number()
  }),
  v4.z.object({
    type: v4.z.literal("response.web_search_call.searching"),
    item_id: v4.z.string(),
    output_index: v4.z.number()
  }),
  v4.z.object({
    type: v4.z.literal("response.web_search_call.completed"),
    item_id: v4.z.string(),
    output_index: v4.z.number()
  }),
  v4.z.object({
    type: v4.z.literal("response.x_search_call.in_progress"),
    item_id: v4.z.string(),
    output_index: v4.z.number()
  }),
  v4.z.object({
    type: v4.z.literal("response.x_search_call.searching"),
    item_id: v4.z.string(),
    output_index: v4.z.number()
  }),
  v4.z.object({
    type: v4.z.literal("response.x_search_call.completed"),
    item_id: v4.z.string(),
    output_index: v4.z.number()
  }),
  v4.z.object({
    type: v4.z.literal("response.file_search_call.in_progress"),
    item_id: v4.z.string(),
    output_index: v4.z.number()
  }),
  v4.z.object({
    type: v4.z.literal("response.file_search_call.searching"),
    item_id: v4.z.string(),
    output_index: v4.z.number()
  }),
  v4.z.object({
    type: v4.z.literal("response.file_search_call.completed"),
    item_id: v4.z.string(),
    output_index: v4.z.number()
  }),
  v4.z.object({
    type: v4.z.literal("response.code_execution_call.in_progress"),
    item_id: v4.z.string(),
    output_index: v4.z.number()
  }),
  v4.z.object({
    type: v4.z.literal("response.code_execution_call.executing"),
    item_id: v4.z.string(),
    output_index: v4.z.number()
  }),
  v4.z.object({
    type: v4.z.literal("response.code_execution_call.completed"),
    item_id: v4.z.string(),
    output_index: v4.z.number()
  }),
  v4.z.object({
    type: v4.z.literal("response.code_interpreter_call.in_progress"),
    item_id: v4.z.string(),
    output_index: v4.z.number()
  }),
  v4.z.object({
    type: v4.z.literal("response.code_interpreter_call.executing"),
    item_id: v4.z.string(),
    output_index: v4.z.number()
  }),
  v4.z.object({
    type: v4.z.literal("response.code_interpreter_call.interpreting"),
    item_id: v4.z.string(),
    output_index: v4.z.number()
  }),
  v4.z.object({
    type: v4.z.literal("response.code_interpreter_call.completed"),
    item_id: v4.z.string(),
    output_index: v4.z.number()
  }),
  // Code interpreter code streaming events
  v4.z.object({
    type: v4.z.literal("response.code_interpreter_call_code.delta"),
    item_id: v4.z.string(),
    output_index: v4.z.number(),
    delta: v4.z.string()
  }),
  v4.z.object({
    type: v4.z.literal("response.code_interpreter_call_code.done"),
    item_id: v4.z.string(),
    output_index: v4.z.number(),
    code: v4.z.string()
  }),
  v4.z.object({
    type: v4.z.literal("response.custom_tool_call_input.delta"),
    item_id: v4.z.string(),
    output_index: v4.z.number(),
    delta: v4.z.string()
  }),
  v4.z.object({
    type: v4.z.literal("response.custom_tool_call_input.done"),
    item_id: v4.z.string(),
    output_index: v4.z.number(),
    input: v4.z.string()
  }),
  // Function call arguments streaming events (standard function tools)
  v4.z.object({
    type: v4.z.literal("response.function_call_arguments.delta"),
    item_id: v4.z.string(),
    output_index: v4.z.number(),
    delta: v4.z.string()
  }),
  v4.z.object({
    type: v4.z.literal("response.function_call_arguments.done"),
    item_id: v4.z.string(),
    output_index: v4.z.number(),
    arguments: v4.z.string()
  }),
  v4.z.object({
    type: v4.z.literal("response.mcp_call.in_progress"),
    item_id: v4.z.string(),
    output_index: v4.z.number()
  }),
  v4.z.object({
    type: v4.z.literal("response.mcp_call.executing"),
    item_id: v4.z.string(),
    output_index: v4.z.number()
  }),
  v4.z.object({
    type: v4.z.literal("response.mcp_call.completed"),
    item_id: v4.z.string(),
    output_index: v4.z.number()
  }),
  v4.z.object({
    type: v4.z.literal("response.mcp_call.failed"),
    item_id: v4.z.string(),
    output_index: v4.z.number()
  }),
  v4.z.object({
    type: v4.z.literal("response.mcp_call_arguments.delta"),
    item_id: v4.z.string(),
    output_index: v4.z.number(),
    delta: v4.z.string()
  }),
  v4.z.object({
    type: v4.z.literal("response.mcp_call_arguments.done"),
    item_id: v4.z.string(),
    output_index: v4.z.number(),
    arguments: v4.z.string().optional()
  }),
  v4.z.object({
    type: v4.z.literal("response.mcp_call_output.delta"),
    item_id: v4.z.string(),
    output_index: v4.z.number(),
    delta: v4.z.string()
  }),
  v4.z.object({
    type: v4.z.literal("response.mcp_call_output.done"),
    item_id: v4.z.string(),
    output_index: v4.z.number(),
    output: v4.z.string().optional()
  }),
  v4.z.object({
    type: v4.z.literal("response.incomplete"),
    response: v4.z.object({
      incomplete_details: v4.z.object({ reason: v4.z.string() }).nullish(),
      usage: xaiResponsesUsageSchema.nullish()
    })
  }),
  v4.z.object({
    type: v4.z.literal("response.failed"),
    response: v4.z.object({
      error: v4.z.object({
        code: v4.z.string().nullish(),
        message: v4.z.string()
      }).nullish(),
      incomplete_details: v4.z.object({ reason: v4.z.string() }).nullish(),
      usage: xaiResponsesUsageSchema.nullish()
    })
  }),
  v4.z.object({
    type: v4.z.literal("error"),
    code: v4.z.string().nullish(),
    message: v4.z.string(),
    param: v4.z.string().nullish()
  }),
  v4.z.object({
    type: v4.z.literal("response.done"),
    response: xaiResponsesResponseSchema
  }),
  v4.z.object({
    type: v4.z.literal("response.completed"),
    response: xaiResponsesResponseSchema
  })
]);
var xaiLanguageModelResponsesOptions = v4.z.object({
  /**
   * Constrains how hard a reasoning model thinks before responding.
   * Possible values are `low` (uses fewer reasoning tokens), `medium` and `high` (uses more reasoning tokens).
   */
  reasoningEffort: v4.z.enum(["low", "medium", "high"]).optional(),
  logprobs: v4.z.boolean().optional(),
  topLogprobs: v4.z.number().int().min(0).max(8).optional(),
  /**
   * Whether to store the input message(s) and model response for later retrieval.
   * Must be set to `false` for teams with Zero Data Retention (ZDR) enabled,
   * otherwise the API will return an error.
   * @default true
   */
  store: v4.z.boolean().optional(),
  /**
   * The ID of the previous response from the model.
   */
  previousResponseId: v4.z.string().optional(),
  /**
   * Specify additional output data to include in the model response.
   * Example values: 'file_search_call.results'.
   */
  include: v4.z.array(v4.z.enum(["file_search_call.results"])).nullish()
});
var fileSearchArgsSchema = chunkOCS2GTEN_cjs.lazySchema2(
  () => chunkOCS2GTEN_cjs.zodSchema2(
    v4.z.object({
      vectorStoreIds: v4.z.array(v4.z.string()),
      maxNumResults: v4.z.number().optional()
    })
  )
);
var fileSearchOutputSchema = chunkOCS2GTEN_cjs.lazySchema2(
  () => chunkOCS2GTEN_cjs.zodSchema2(
    v4.z.object({
      queries: v4.z.array(v4.z.string()),
      results: v4.z.array(
        v4.z.object({
          fileId: v4.z.string(),
          filename: v4.z.string(),
          score: v4.z.number().min(0).max(1),
          text: v4.z.string()
        })
      ).nullable()
    })
  )
);
var fileSearchToolFactory = chunkOCS2GTEN_cjs.createProviderToolFactoryWithOutputSchema({
  id: "xai.file_search",
  inputSchema: chunkOCS2GTEN_cjs.lazySchema2(() => chunkOCS2GTEN_cjs.zodSchema2(v4.z.object({}))),
  outputSchema: fileSearchOutputSchema
});
var fileSearch = (args) => fileSearchToolFactory(args);
var mcpServerArgsSchema = chunkOCS2GTEN_cjs.lazySchema2(
  () => chunkOCS2GTEN_cjs.zodSchema2(
    v4.z.object({
      serverUrl: v4.z.string().describe("The URL of the MCP server"),
      serverLabel: v4.z.string().optional().describe("A label for the MCP server"),
      serverDescription: v4.z.string().optional().describe("Description of the MCP server"),
      allowedTools: v4.z.array(v4.z.string()).optional().describe("List of allowed tool names"),
      headers: v4.z.record(v4.z.string(), v4.z.string()).optional().describe("Custom headers to send"),
      authorization: v4.z.string().optional().describe("Authorization header value")
    })
  )
);
var mcpServerOutputSchema = chunkOCS2GTEN_cjs.lazySchema2(
  () => chunkOCS2GTEN_cjs.zodSchema2(
    v4.z.object({
      name: v4.z.string(),
      arguments: v4.z.string(),
      result: v4.z.unknown()
    })
  )
);
var mcpServerToolFactory = chunkOCS2GTEN_cjs.createProviderToolFactoryWithOutputSchema({
  id: "xai.mcp",
  inputSchema: chunkOCS2GTEN_cjs.lazySchema2(() => chunkOCS2GTEN_cjs.zodSchema2(v4.z.object({}))),
  outputSchema: mcpServerOutputSchema
});
var mcpServer = (args) => mcpServerToolFactory(args);
var webSearchArgsSchema = chunkOCS2GTEN_cjs.lazySchema2(
  () => chunkOCS2GTEN_cjs.zodSchema2(
    v4.z.object({
      allowedDomains: v4.z.array(v4.z.string()).max(5).optional(),
      excludedDomains: v4.z.array(v4.z.string()).max(5).optional(),
      enableImageUnderstanding: v4.z.boolean().optional()
    })
  )
);
var webSearchOutputSchema = chunkOCS2GTEN_cjs.lazySchema2(
  () => chunkOCS2GTEN_cjs.zodSchema2(
    v4.z.object({
      query: v4.z.string(),
      sources: v4.z.array(
        v4.z.object({
          title: v4.z.string(),
          url: v4.z.string(),
          snippet: v4.z.string()
        })
      )
    })
  )
);
var webSearchToolFactory = chunkOCS2GTEN_cjs.createProviderToolFactoryWithOutputSchema({
  id: "xai.web_search",
  inputSchema: chunkOCS2GTEN_cjs.lazySchema2(() => chunkOCS2GTEN_cjs.zodSchema2(v4.z.object({}))),
  outputSchema: webSearchOutputSchema
});
var webSearch = (args = {}) => webSearchToolFactory(args);
var xSearchArgsSchema = chunkOCS2GTEN_cjs.lazySchema2(
  () => chunkOCS2GTEN_cjs.zodSchema2(
    v4.z.object({
      allowedXHandles: v4.z.array(v4.z.string()).max(10).optional(),
      excludedXHandles: v4.z.array(v4.z.string()).max(10).optional(),
      fromDate: v4.z.string().optional(),
      toDate: v4.z.string().optional(),
      enableImageUnderstanding: v4.z.boolean().optional(),
      enableVideoUnderstanding: v4.z.boolean().optional()
    })
  )
);
var xSearchOutputSchema = chunkOCS2GTEN_cjs.lazySchema2(
  () => chunkOCS2GTEN_cjs.zodSchema2(
    v4.z.object({
      query: v4.z.string(),
      posts: v4.z.array(
        v4.z.object({
          author: v4.z.string(),
          text: v4.z.string(),
          url: v4.z.string(),
          likes: v4.z.number()
        })
      )
    })
  )
);
var xSearchToolFactory = chunkOCS2GTEN_cjs.createProviderToolFactoryWithOutputSchema({
  id: "xai.x_search",
  inputSchema: chunkOCS2GTEN_cjs.lazySchema2(() => chunkOCS2GTEN_cjs.zodSchema2(v4.z.object({}))),
  outputSchema: xSearchOutputSchema
});
var xSearch = (args = {}) => xSearchToolFactory(args);
async function prepareResponsesTools({
  tools,
  toolChoice
}) {
  const normalizedTools = (tools == null ? void 0 : tools.length) ? tools : void 0;
  const toolWarnings = [];
  if (normalizedTools == null) {
    return { tools: void 0, toolChoice: void 0, toolWarnings };
  }
  const xaiTools2 = [];
  const toolByName = /* @__PURE__ */ new Map();
  for (const tool of normalizedTools) {
    toolByName.set(tool.name, tool);
    if (tool.type === "provider") {
      switch (tool.id) {
        case "xai.web_search": {
          const args = await chunkOCS2GTEN_cjs.validateTypes2({
            value: tool.args,
            schema: webSearchArgsSchema
          });
          xaiTools2.push({
            type: "web_search",
            allowed_domains: args.allowedDomains,
            excluded_domains: args.excludedDomains,
            enable_image_understanding: args.enableImageUnderstanding
          });
          break;
        }
        case "xai.x_search": {
          const args = await chunkOCS2GTEN_cjs.validateTypes2({
            value: tool.args,
            schema: xSearchArgsSchema
          });
          xaiTools2.push({
            type: "x_search",
            allowed_x_handles: args.allowedXHandles,
            excluded_x_handles: args.excludedXHandles,
            from_date: args.fromDate,
            to_date: args.toDate,
            enable_image_understanding: args.enableImageUnderstanding,
            enable_video_understanding: args.enableVideoUnderstanding
          });
          break;
        }
        case "xai.code_execution": {
          xaiTools2.push({
            type: "code_interpreter"
          });
          break;
        }
        case "xai.view_image": {
          xaiTools2.push({
            type: "view_image"
          });
          break;
        }
        case "xai.view_x_video": {
          xaiTools2.push({
            type: "view_x_video"
          });
          break;
        }
        case "xai.file_search": {
          const args = await chunkOCS2GTEN_cjs.validateTypes2({
            value: tool.args,
            schema: fileSearchArgsSchema
          });
          xaiTools2.push({
            type: "file_search",
            vector_store_ids: args.vectorStoreIds,
            max_num_results: args.maxNumResults
          });
          break;
        }
        case "xai.mcp": {
          const args = await chunkOCS2GTEN_cjs.validateTypes2({
            value: tool.args,
            schema: mcpServerArgsSchema
          });
          xaiTools2.push({
            type: "mcp",
            server_url: args.serverUrl,
            server_label: args.serverLabel,
            server_description: args.serverDescription,
            allowed_tools: args.allowedTools,
            headers: args.headers,
            authorization: args.authorization
          });
          break;
        }
        default: {
          toolWarnings.push({
            type: "unsupported",
            feature: `provider-defined tool ${tool.name}`
          });
          break;
        }
      }
    } else {
      xaiTools2.push({
        type: "function",
        name: tool.name,
        description: tool.description,
        parameters: tool.inputSchema,
        ...tool.strict != null ? { strict: tool.strict } : {}
      });
    }
  }
  if (toolChoice == null) {
    return { tools: xaiTools2, toolChoice: void 0, toolWarnings };
  }
  const type = toolChoice.type;
  switch (type) {
    case "auto":
    case "none":
      return { tools: xaiTools2, toolChoice: type, toolWarnings };
    case "required":
      return { tools: xaiTools2, toolChoice: "required", toolWarnings };
    case "tool": {
      const selectedTool = toolByName.get(toolChoice.toolName);
      if (selectedTool == null) {
        return {
          tools: xaiTools2,
          toolChoice: void 0,
          toolWarnings
        };
      }
      if (selectedTool.type === "provider") {
        toolWarnings.push({
          type: "unsupported",
          feature: `toolChoice for server-side tool "${selectedTool.name}"`
        });
        return { tools: xaiTools2, toolChoice: void 0, toolWarnings };
      }
      return {
        tools: xaiTools2,
        toolChoice: { type: "function", name: selectedTool.name },
        toolWarnings
      };
    }
    default: {
      const _exhaustiveCheck = type;
      throw new chunkOCS2GTEN_cjs.UnsupportedFunctionalityError2({
        functionality: `tool choice type: ${_exhaustiveCheck}`
      });
    }
  }
}
var XaiResponsesLanguageModel = class {
  constructor(modelId, config) {
    this.specificationVersion = "v3";
    this.supportedUrls = {
      "image/*": [/^https?:\/\/.*$/],
      // xAI's Responses API accepts non-image documents (PDF, plain text, CSV, etc.) as
      // `{ type: 'input_file', file_url }`. Keeping these URLs intact here lets them pass
      // through to the converter instead of being downloaded to bytes by the SDK.
      "application/pdf": [/^https?:\/\/.*$/],
      "text/*": [/^https?:\/\/.*$/]
    };
    this.modelId = modelId;
    this.config = config;
  }
  get provider() {
    return this.config.provider;
  }
  async getArgs({
    prompt,
    maxOutputTokens,
    temperature,
    topP,
    stopSequences,
    seed,
    responseFormat,
    providerOptions,
    tools,
    toolChoice
  }) {
    var _a15, _b, _c, _d, _e, _f, _h;
    const warnings = [];
    const options = (_a15 = await chunkOCS2GTEN_cjs.parseProviderOptions2({
      provider: "xai",
      providerOptions,
      schema: xaiLanguageModelResponsesOptions
    })) != null ? _a15 : {};
    if (stopSequences != null) {
      warnings.push({ type: "unsupported", feature: "stopSequences" });
    }
    const webSearchToolName = (_b = tools == null ? void 0 : tools.find(
      (tool) => tool.type === "provider" && tool.id === "xai.web_search"
    )) == null ? void 0 : _b.name;
    const xSearchToolName = (_c = tools == null ? void 0 : tools.find(
      (tool) => tool.type === "provider" && tool.id === "xai.x_search"
    )) == null ? void 0 : _c.name;
    const codeExecutionToolName = (_d = tools == null ? void 0 : tools.find(
      (tool) => tool.type === "provider" && tool.id === "xai.code_execution"
    )) == null ? void 0 : _d.name;
    const mcpToolName = (_e = tools == null ? void 0 : tools.find(
      (tool) => tool.type === "provider" && tool.id === "xai.mcp"
    )) == null ? void 0 : _e.name;
    const fileSearchToolName = (_f = tools == null ? void 0 : tools.find(
      (tool) => tool.type === "provider" && tool.id === "xai.file_search"
    )) == null ? void 0 : _f.name;
    const { input, inputWarnings } = await convertToXaiResponsesInput({
      prompt});
    warnings.push(...inputWarnings);
    const {
      tools: xaiTools2,
      toolChoice: xaiToolChoice,
      toolWarnings
    } = await prepareResponsesTools({
      tools,
      toolChoice
    });
    warnings.push(...toolWarnings);
    let include = options.include ? [...options.include] : void 0;
    if (options.store === false) {
      if (include == null) {
        include = ["reasoning.encrypted_content"];
      } else {
        include = [...include, "reasoning.encrypted_content"];
      }
    }
    const baseArgs = {
      model: this.modelId,
      input,
      logprobs: options.logprobs === true || options.topLogprobs != null ? true : void 0,
      top_logprobs: options.topLogprobs,
      max_output_tokens: maxOutputTokens,
      temperature,
      top_p: topP,
      seed,
      ...(responseFormat == null ? void 0 : responseFormat.type) === "json" && {
        text: {
          format: responseFormat.schema != null ? {
            type: "json_schema",
            strict: true,
            name: (_h = responseFormat.name) != null ? _h : "response",
            description: responseFormat.description,
            schema: responseFormat.schema
          } : { type: "json_object" }
        }
      },
      ...options.reasoningEffort != null && {
        reasoning: { effort: options.reasoningEffort }
      },
      ...options.store === false && {
        store: options.store
      },
      ...include != null && {
        include
      },
      ...options.previousResponseId != null && {
        previous_response_id: options.previousResponseId
      }
    };
    if (xaiTools2 && xaiTools2.length > 0) {
      baseArgs.tools = xaiTools2;
    }
    if (xaiToolChoice != null) {
      baseArgs.tool_choice = xaiToolChoice;
    }
    return {
      args: baseArgs,
      warnings,
      webSearchToolName,
      xSearchToolName,
      codeExecutionToolName,
      mcpToolName,
      fileSearchToolName
    };
  }
  async doGenerate(options) {
    var _a15, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m;
    const {
      args: body,
      warnings,
      webSearchToolName,
      xSearchToolName,
      codeExecutionToolName,
      mcpToolName,
      fileSearchToolName
    } = await this.getArgs(options);
    const {
      responseHeaders,
      value: response,
      rawValue: rawResponse
    } = await chunkOCS2GTEN_cjs.postJsonToApi2({
      url: `${(_a15 = this.config.baseURL) != null ? _a15 : "https://api.x.ai/v1"}/responses`,
      headers: chunkOCS2GTEN_cjs.combineHeaders2(this.config.headers(), options.headers),
      body,
      failedResponseHandler: xaiFailedResponseHandler,
      successfulResponseHandler: chunkOCS2GTEN_cjs.createJsonResponseHandler2(
        xaiResponsesResponseSchema
      ),
      abortSignal: options.abortSignal,
      fetch: this.config.fetch
    });
    const content = [];
    let hasFunctionCall = false;
    const webSearchSubTools = [
      "web_search",
      "web_search_with_snippets",
      "browse_page"
    ];
    const xSearchSubTools = [
      "x_user_search",
      "x_keyword_search",
      "x_semantic_search",
      "x_thread_fetch"
    ];
    for (const part of response.output) {
      if (part.type === "file_search_call") {
        const toolName = fileSearchToolName != null ? fileSearchToolName : "file_search";
        content.push({
          type: "tool-call",
          toolCallId: part.id,
          toolName,
          input: "",
          providerExecuted: true
        });
        content.push({
          type: "tool-result",
          toolCallId: part.id,
          toolName,
          result: {
            queries: (_b = part.queries) != null ? _b : [],
            results: (_d = (_c = part.results) == null ? void 0 : _c.map((result) => ({
              fileId: result.file_id,
              filename: result.filename,
              score: result.score,
              text: result.text
            }))) != null ? _d : null
          }
        });
        continue;
      }
      if (part.type === "web_search_call" || part.type === "x_search_call" || part.type === "code_interpreter_call" || part.type === "code_execution_call" || part.type === "view_image_call" || part.type === "view_x_video_call" || part.type === "custom_tool_call" || part.type === "mcp_call") {
        let toolName = (_e = part.name) != null ? _e : "";
        if (webSearchSubTools.includes((_f = part.name) != null ? _f : "") || part.type === "web_search_call") {
          toolName = webSearchToolName != null ? webSearchToolName : "web_search";
        } else if (xSearchSubTools.includes((_g = part.name) != null ? _g : "") || part.type === "x_search_call") {
          toolName = xSearchToolName != null ? xSearchToolName : "x_search";
        } else if (part.name === "code_execution" || part.type === "code_interpreter_call" || part.type === "code_execution_call") {
          toolName = codeExecutionToolName != null ? codeExecutionToolName : "code_execution";
        } else if (part.type === "mcp_call") {
          toolName = (_h = mcpToolName != null ? mcpToolName : part.name) != null ? _h : "mcp";
        }
        const toolInput = part.type === "custom_tool_call" ? (_i = part.input) != null ? _i : "" : part.type === "mcp_call" ? (_j = part.arguments) != null ? _j : "" : (_k = part.arguments) != null ? _k : "";
        content.push({
          type: "tool-call",
          toolCallId: part.id,
          toolName,
          input: toolInput,
          providerExecuted: true
        });
        continue;
      }
      switch (part.type) {
        case "message": {
          for (const contentPart of part.content) {
            if (contentPart.text) {
              content.push({
                type: "text",
                text: contentPart.text
              });
            }
            if (contentPart.annotations) {
              for (const annotation of contentPart.annotations) {
                if (annotation.type === "url_citation" && "url" in annotation) {
                  content.push({
                    type: "source",
                    sourceType: "url",
                    id: this.config.generateId(),
                    url: annotation.url,
                    title: (_l = annotation.title) != null ? _l : annotation.url
                  });
                }
              }
            }
          }
          break;
        }
        case "function_call": {
          hasFunctionCall = true;
          content.push({
            type: "tool-call",
            toolCallId: part.call_id,
            toolName: part.name,
            input: part.arguments
          });
          break;
        }
        case "reasoning": {
          const summaryTexts = part.summary.map((s) => s.text).filter((text) => text && text.length > 0);
          const reasoningText = summaryTexts.join("");
          if (reasoningText || part.encrypted_content) {
            const hasMetadata = part.encrypted_content || part.id;
            content.push({
              type: "reasoning",
              text: reasoningText,
              ...hasMetadata && {
                providerMetadata: {
                  xai: {
                    ...part.encrypted_content && {
                      reasoningEncryptedContent: part.encrypted_content
                    },
                    ...part.id && { itemId: part.id }
                  }
                }
              }
            });
          }
          break;
        }
      }
    }
    return {
      content,
      finishReason: {
        unified: hasFunctionCall ? "tool-calls" : mapXaiResponsesFinishReason(response.status),
        raw: (_m = response.status) != null ? _m : void 0
      },
      usage: response.usage ? convertXaiResponsesUsage(response.usage) : {
        inputTokens: { total: 0, noCache: 0, cacheRead: 0, cacheWrite: 0 },
        outputTokens: { total: 0, text: 0, reasoning: 0 }
      },
      request: { body },
      response: {
        ...getResponseMetadata6(response),
        headers: responseHeaders,
        body: rawResponse
      },
      warnings
    };
  }
  async doStream(options) {
    var _a15;
    const {
      args,
      warnings,
      webSearchToolName,
      xSearchToolName,
      codeExecutionToolName,
      mcpToolName,
      fileSearchToolName
    } = await this.getArgs(options);
    const body = {
      ...args,
      stream: true
    };
    const { responseHeaders, value: response } = await chunkOCS2GTEN_cjs.postJsonToApi2({
      url: `${(_a15 = this.config.baseURL) != null ? _a15 : "https://api.x.ai/v1"}/responses`,
      headers: chunkOCS2GTEN_cjs.combineHeaders2(this.config.headers(), options.headers),
      body,
      failedResponseHandler: xaiFailedResponseHandler,
      successfulResponseHandler: chunkOCS2GTEN_cjs.createEventSourceResponseHandler2(
        xaiResponsesChunkSchema
      ),
      abortSignal: options.abortSignal,
      fetch: this.config.fetch
    });
    let finishReason = {
      unified: "other",
      raw: void 0
    };
    let hasFunctionCall = false;
    let usage = void 0;
    let isFirstChunk = true;
    const contentBlocks = {};
    const seenToolCalls = /* @__PURE__ */ new Set();
    const ongoingToolCalls = {};
    const activeReasoning = {};
    const self = this;
    return {
      stream: response.pipeThrough(
        new TransformStream({
          start(controller) {
            controller.enqueue({ type: "stream-start", warnings });
          },
          transform(chunk, controller) {
            var _a22, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o;
            if (options.includeRawChunks) {
              controller.enqueue({ type: "raw", rawValue: chunk.rawValue });
            }
            if (!chunk.success) {
              controller.enqueue({ type: "error", error: chunk.error });
              return;
            }
            const event = chunk.value;
            if (event.type === "response.created" || event.type === "response.in_progress") {
              if (isFirstChunk) {
                controller.enqueue({
                  type: "response-metadata",
                  ...getResponseMetadata6(event.response)
                });
                isFirstChunk = false;
              }
              return;
            }
            if (event.type === "response.reasoning_summary_part.added") {
              const blockId = `reasoning-${event.item_id}`;
              activeReasoning[event.item_id] = {};
              controller.enqueue({
                type: "reasoning-start",
                id: blockId,
                providerMetadata: {
                  xai: {
                    itemId: event.item_id
                  }
                }
              });
            }
            if (event.type === "response.reasoning_summary_text.delta") {
              const blockId = `reasoning-${event.item_id}`;
              controller.enqueue({
                type: "reasoning-delta",
                id: blockId,
                delta: event.delta,
                providerMetadata: {
                  xai: {
                    itemId: event.item_id
                  }
                }
              });
              return;
            }
            if (event.type === "response.reasoning_summary_text.done") {
              return;
            }
            if (event.type === "response.reasoning_text.delta") {
              const blockId = `reasoning-${event.item_id}`;
              if (activeReasoning[event.item_id] == null) {
                activeReasoning[event.item_id] = {};
                controller.enqueue({
                  type: "reasoning-start",
                  id: blockId,
                  providerMetadata: {
                    xai: {
                      itemId: event.item_id
                    }
                  }
                });
              }
              controller.enqueue({
                type: "reasoning-delta",
                id: blockId,
                delta: event.delta,
                providerMetadata: {
                  xai: {
                    itemId: event.item_id
                  }
                }
              });
              return;
            }
            if (event.type === "response.reasoning_text.done") {
              return;
            }
            if (event.type === "response.output_text.delta") {
              const blockId = `text-${event.item_id}`;
              if (contentBlocks[blockId] == null) {
                contentBlocks[blockId] = { type: "text" };
                controller.enqueue({
                  type: "text-start",
                  id: blockId
                });
              }
              controller.enqueue({
                type: "text-delta",
                id: blockId,
                delta: event.delta
              });
              return;
            }
            if (event.type === "response.output_text.done") {
              if (event.annotations) {
                for (const annotation of event.annotations) {
                  if (annotation.type === "url_citation" && "url" in annotation) {
                    controller.enqueue({
                      type: "source",
                      sourceType: "url",
                      id: self.config.generateId(),
                      url: annotation.url,
                      title: (_a22 = annotation.title) != null ? _a22 : annotation.url
                    });
                  }
                }
              }
              return;
            }
            if (event.type === "response.output_text.annotation.added") {
              const annotation = event.annotation;
              if (annotation.type === "url_citation" && "url" in annotation) {
                controller.enqueue({
                  type: "source",
                  sourceType: "url",
                  id: self.config.generateId(),
                  url: annotation.url,
                  title: (_b = annotation.title) != null ? _b : annotation.url
                });
              }
              return;
            }
            if (event.type === "response.done" || event.type === "response.completed" || event.type === "response.incomplete") {
              const response2 = event.response;
              if (response2.usage) {
                usage = convertXaiResponsesUsage(response2.usage);
              }
              if (event.type === "response.incomplete") {
                const reason = "incomplete_details" in response2 ? (_c = response2.incomplete_details) == null ? void 0 : _c.reason : void 0;
                finishReason = {
                  unified: reason ? mapXaiResponsesFinishReason(reason) : "other",
                  raw: reason != null ? reason : "incomplete"
                };
              } else if ("status" in response2 && response2.status) {
                finishReason = {
                  unified: hasFunctionCall ? "tool-calls" : mapXaiResponsesFinishReason(response2.status),
                  raw: response2.status
                };
              }
              return;
            }
            if (event.type === "response.failed") {
              const reason = (_d = event.response.incomplete_details) == null ? void 0 : _d.reason;
              finishReason = {
                unified: reason ? mapXaiResponsesFinishReason(reason) : "error",
                raw: reason != null ? reason : "error"
              };
              if (event.response.usage) {
                usage = convertXaiResponsesUsage(event.response.usage);
              }
              return;
            }
            if (event.type === "error") {
              controller.enqueue({ type: "error", error: event });
              return;
            }
            if (event.type === "response.custom_tool_call_input.delta" || event.type === "response.custom_tool_call_input.done") {
              return;
            }
            if (event.type === "response.function_call_arguments.delta") {
              const toolCall = ongoingToolCalls[event.output_index];
              if (toolCall != null) {
                controller.enqueue({
                  type: "tool-input-delta",
                  id: toolCall.toolCallId,
                  delta: event.delta
                });
              }
              return;
            }
            if (event.type === "response.function_call_arguments.done") {
              return;
            }
            if (event.type === "response.output_item.added" || event.type === "response.output_item.done") {
              const part = event.item;
              if (part.type === "reasoning") {
                if (event.type === "response.output_item.done") {
                  const blockId = `reasoning-${part.id}`;
                  if (!(part.id in activeReasoning)) {
                    activeReasoning[part.id] = {};
                    controller.enqueue({
                      type: "reasoning-start",
                      id: blockId,
                      providerMetadata: {
                        xai: {
                          ...part.id && { itemId: part.id }
                        }
                      }
                    });
                  }
                  controller.enqueue({
                    type: "reasoning-end",
                    id: blockId,
                    providerMetadata: {
                      xai: {
                        ...part.encrypted_content && {
                          reasoningEncryptedContent: part.encrypted_content
                        },
                        ...part.id && { itemId: part.id }
                      }
                    }
                  });
                  delete activeReasoning[part.id];
                }
                return;
              }
              if (part.type === "file_search_call") {
                const toolName = fileSearchToolName != null ? fileSearchToolName : "file_search";
                if (!seenToolCalls.has(part.id)) {
                  seenToolCalls.add(part.id);
                  controller.enqueue({
                    type: "tool-input-start",
                    id: part.id,
                    toolName
                  });
                  controller.enqueue({
                    type: "tool-input-delta",
                    id: part.id,
                    delta: ""
                  });
                  controller.enqueue({
                    type: "tool-input-end",
                    id: part.id
                  });
                  controller.enqueue({
                    type: "tool-call",
                    toolCallId: part.id,
                    toolName,
                    input: "",
                    providerExecuted: true
                  });
                }
                if (event.type === "response.output_item.done") {
                  controller.enqueue({
                    type: "tool-result",
                    toolCallId: part.id,
                    toolName,
                    result: {
                      queries: (_e = part.queries) != null ? _e : [],
                      results: (_g = (_f = part.results) == null ? void 0 : _f.map((result) => ({
                        fileId: result.file_id,
                        filename: result.filename,
                        score: result.score,
                        text: result.text
                      }))) != null ? _g : null
                    }
                  });
                }
                return;
              }
              if (part.type === "web_search_call" || part.type === "x_search_call" || part.type === "code_interpreter_call" || part.type === "code_execution_call" || part.type === "view_image_call" || part.type === "view_x_video_call" || part.type === "custom_tool_call" || part.type === "mcp_call") {
                const webSearchSubTools = [
                  "web_search",
                  "web_search_with_snippets",
                  "browse_page"
                ];
                const xSearchSubTools = [
                  "x_user_search",
                  "x_keyword_search",
                  "x_semantic_search",
                  "x_thread_fetch"
                ];
                let toolName = (_h = part.name) != null ? _h : "";
                if (webSearchSubTools.includes((_i = part.name) != null ? _i : "") || part.type === "web_search_call") {
                  toolName = webSearchToolName != null ? webSearchToolName : "web_search";
                } else if (xSearchSubTools.includes((_j = part.name) != null ? _j : "") || part.type === "x_search_call") {
                  toolName = xSearchToolName != null ? xSearchToolName : "x_search";
                } else if (part.name === "code_execution" || part.type === "code_interpreter_call" || part.type === "code_execution_call") {
                  toolName = codeExecutionToolName != null ? codeExecutionToolName : "code_execution";
                } else if (part.type === "mcp_call") {
                  toolName = (_k = mcpToolName != null ? mcpToolName : part.name) != null ? _k : "mcp";
                }
                const toolInput = part.type === "custom_tool_call" ? (_l = part.input) != null ? _l : "" : part.type === "mcp_call" ? (_m = part.arguments) != null ? _m : "" : (_n = part.arguments) != null ? _n : "";
                const shouldEmit = part.type === "custom_tool_call" ? event.type === "response.output_item.done" : !seenToolCalls.has(part.id);
                if (shouldEmit && !seenToolCalls.has(part.id)) {
                  seenToolCalls.add(part.id);
                  controller.enqueue({
                    type: "tool-input-start",
                    id: part.id,
                    toolName
                  });
                  controller.enqueue({
                    type: "tool-input-delta",
                    id: part.id,
                    delta: toolInput
                  });
                  controller.enqueue({
                    type: "tool-input-end",
                    id: part.id
                  });
                  controller.enqueue({
                    type: "tool-call",
                    toolCallId: part.id,
                    toolName,
                    input: toolInput,
                    providerExecuted: true
                  });
                }
                return;
              }
              if (part.type === "message") {
                for (const contentPart of part.content) {
                  if (contentPart.text && contentPart.text.length > 0) {
                    const blockId = `text-${part.id}`;
                    if (contentBlocks[blockId] == null) {
                      contentBlocks[blockId] = { type: "text" };
                      controller.enqueue({
                        type: "text-start",
                        id: blockId
                      });
                      controller.enqueue({
                        type: "text-delta",
                        id: blockId,
                        delta: contentPart.text
                      });
                    }
                  }
                  if (contentPart.annotations) {
                    for (const annotation of contentPart.annotations) {
                      if (annotation.type === "url_citation" && "url" in annotation) {
                        controller.enqueue({
                          type: "source",
                          sourceType: "url",
                          id: self.config.generateId(),
                          url: annotation.url,
                          title: (_o = annotation.title) != null ? _o : annotation.url
                        });
                      }
                    }
                  }
                }
              } else if (part.type === "function_call") {
                if (event.type === "response.output_item.added") {
                  ongoingToolCalls[event.output_index] = {
                    toolName: part.name,
                    toolCallId: part.call_id
                  };
                  controller.enqueue({
                    type: "tool-input-start",
                    id: part.call_id,
                    toolName: part.name
                  });
                } else if (event.type === "response.output_item.done") {
                  hasFunctionCall = true;
                  ongoingToolCalls[event.output_index] = void 0;
                  controller.enqueue({
                    type: "tool-input-end",
                    id: part.call_id
                  });
                  controller.enqueue({
                    type: "tool-call",
                    toolCallId: part.call_id,
                    toolName: part.name,
                    input: part.arguments
                  });
                }
              }
            }
          },
          flush(controller) {
            for (const [blockId, block] of Object.entries(contentBlocks)) {
              if (block.type === "text") {
                controller.enqueue({
                  type: "text-end",
                  id: blockId
                });
              }
            }
            controller.enqueue({
              type: "finish",
              finishReason,
              usage: usage != null ? usage : {
                inputTokens: {
                  total: 0,
                  noCache: 0,
                  cacheRead: 0,
                  cacheWrite: 0
                },
                outputTokens: { total: 0, text: 0, reasoning: 0 }
              }
            });
          }
        })
      ),
      request: { body },
      response: { headers: responseHeaders }
    };
  }
};
var codeExecutionOutputSchema = v4.z.object({
  output: v4.z.string().describe("the output of the code execution"),
  error: v4.z.string().optional().describe("any error that occurred")
});
var codeExecutionToolFactory = chunkOCS2GTEN_cjs.createProviderToolFactoryWithOutputSchema({
  id: "xai.code_execution",
  inputSchema: v4.z.object({}).describe("no input parameters"),
  outputSchema: codeExecutionOutputSchema
});
var codeExecution = (args = {}) => codeExecutionToolFactory(args);
var viewImageOutputSchema = v4.z.object({
  description: v4.z.string().describe("description of the image"),
  objects: v4.z.array(v4.z.string()).optional().describe("objects detected in the image")
});
var viewImageToolFactory = chunkOCS2GTEN_cjs.createProviderToolFactoryWithOutputSchema({
  id: "xai.view_image",
  inputSchema: v4.z.object({}).describe("no input parameters"),
  outputSchema: viewImageOutputSchema
});
var viewImage = (args = {}) => viewImageToolFactory(args);
var viewXVideoOutputSchema = v4.z.object({
  transcript: v4.z.string().optional().describe("transcript of the video"),
  description: v4.z.string().describe("description of the video content"),
  duration: v4.z.number().optional().describe("duration in seconds")
});
var viewXVideoToolFactory = chunkOCS2GTEN_cjs.createProviderToolFactoryWithOutputSchema({
  id: "xai.view_x_video",
  inputSchema: v4.z.object({}).describe("no input parameters"),
  outputSchema: viewXVideoOutputSchema
});
var viewXVideo = (args = {}) => viewXVideoToolFactory(args);
var xaiTools = {
  codeExecution,
  fileSearch,
  mcpServer,
  viewImage,
  viewXVideo,
  webSearch,
  xSearch
};
var VERSION9 = "3.0.89" ;
var nonEmptyStringSchema = v4.z.string().min(1);
var resolutionSchema = v4.z.enum(["480p", "720p"]);
var modeSchema = v4.z.enum(["edit-video", "extend-video", "reference-to-video"]);
var baseFields = {
  pollIntervalMs: v4.z.number().positive().nullish(),
  pollTimeoutMs: v4.z.number().positive().nullish(),
  resolution: resolutionSchema.nullish()
};
var editVideoSchema = v4.z.object({
  ...baseFields,
  mode: v4.z.literal("edit-video"),
  videoUrl: nonEmptyStringSchema,
  referenceImageUrls: v4.z.undefined().optional()
});
var extendVideoSchema = v4.z.object({
  ...baseFields,
  mode: v4.z.literal("extend-video"),
  videoUrl: nonEmptyStringSchema,
  referenceImageUrls: v4.z.undefined().optional()
});
var referenceToVideoSchema = v4.z.object({
  ...baseFields,
  mode: v4.z.literal("reference-to-video"),
  referenceImageUrls: v4.z.array(nonEmptyStringSchema).min(1).max(7),
  videoUrl: v4.z.undefined().optional()
});
var autoDetectSchema = v4.z.object({
  ...baseFields,
  mode: v4.z.undefined().optional(),
  videoUrl: nonEmptyStringSchema.optional(),
  referenceImageUrls: v4.z.array(nonEmptyStringSchema).min(1).max(7).optional()
});
v4.z.union([
  editVideoSchema,
  extendVideoSchema,
  referenceToVideoSchema,
  autoDetectSchema
]);
var runtimeSchema = v4.z.object({
  mode: modeSchema.optional(),
  videoUrl: nonEmptyStringSchema.optional(),
  referenceImageUrls: v4.z.array(nonEmptyStringSchema).min(1).max(7).optional(),
  ...baseFields
}).passthrough();
var xaiVideoModelOptionsSchema = chunkOCS2GTEN_cjs.lazySchema2(
  () => chunkOCS2GTEN_cjs.zodSchema2(runtimeSchema)
);
var RESOLUTION_MAP = {
  "1280x720": "720p",
  "854x480": "480p",
  "640x480": "480p"
};
function resolveVideoMode(options) {
  if ((options == null ? void 0 : options.mode) != null) {
    return options.mode;
  }
  if ((options == null ? void 0 : options.videoUrl) != null) {
    return "edit-video";
  }
  if ((options == null ? void 0 : options.referenceImageUrls) != null && options.referenceImageUrls.length > 0) {
    return "reference-to-video";
  }
  return void 0;
}
var XaiVideoModel = class {
  constructor(modelId, config) {
    this.modelId = modelId;
    this.config = config;
    this.specificationVersion = "v3";
    this.maxVideosPerCall = 1;
  }
  get provider() {
    return this.config.provider;
  }
  async doGenerate(options) {
    var _a15, _b, _c, _d, _e, _f, _g, _h, _i, _j;
    const currentDate = (_c = (_b = (_a15 = this.config._internal) == null ? void 0 : _a15.currentDate) == null ? void 0 : _b.call(_a15)) != null ? _c : /* @__PURE__ */ new Date();
    const warnings = [];
    const xaiOptions = await chunkOCS2GTEN_cjs.parseProviderOptions2({
      provider: "xai",
      providerOptions: options.providerOptions,
      schema: xaiVideoModelOptionsSchema
    });
    const effectiveMode = resolveVideoMode(xaiOptions);
    const isEdit = effectiveMode === "edit-video";
    const isExtension = effectiveMode === "extend-video";
    const hasReferenceImages = effectiveMode === "reference-to-video";
    if (options.fps != null) {
      warnings.push({
        type: "unsupported",
        feature: "fps",
        details: "xAI video models do not support custom FPS."
      });
    }
    if (options.seed != null) {
      warnings.push({
        type: "unsupported",
        feature: "seed",
        details: "xAI video models do not support seed."
      });
    }
    if (options.n != null && options.n > 1) {
      warnings.push({
        type: "unsupported",
        feature: "n",
        details: "xAI video models do not support generating multiple videos per call. Only 1 video will be generated."
      });
    }
    if (isEdit && options.duration != null) {
      warnings.push({
        type: "unsupported",
        feature: "duration",
        details: "xAI video editing does not support custom duration."
      });
    }
    if (isEdit && options.aspectRatio != null) {
      warnings.push({
        type: "unsupported",
        feature: "aspectRatio",
        details: "xAI video editing does not support custom aspect ratio."
      });
    }
    if (isEdit && ((xaiOptions == null ? void 0 : xaiOptions.resolution) != null || options.resolution != null)) {
      warnings.push({
        type: "unsupported",
        feature: "resolution",
        details: "xAI video editing does not support custom resolution."
      });
    }
    if (isExtension && options.aspectRatio != null) {
      warnings.push({
        type: "unsupported",
        feature: "aspectRatio",
        details: "xAI video extension does not support custom aspect ratio."
      });
    }
    if (isExtension && ((xaiOptions == null ? void 0 : xaiOptions.resolution) != null || options.resolution != null)) {
      warnings.push({
        type: "unsupported",
        feature: "resolution",
        details: "xAI video extension does not support custom resolution."
      });
    }
    const body = {
      model: this.modelId,
      prompt: options.prompt
    };
    const allowDuration = !isEdit;
    const allowAspectRatio = !isEdit && !isExtension;
    const allowResolution = !isEdit && !isExtension;
    if (allowDuration && options.duration != null) {
      body.duration = options.duration;
    }
    if (allowAspectRatio && options.aspectRatio != null) {
      body.aspect_ratio = options.aspectRatio;
    }
    if (allowResolution && (xaiOptions == null ? void 0 : xaiOptions.resolution) != null) {
      body.resolution = xaiOptions.resolution;
    } else if (allowResolution && options.resolution != null) {
      const mapped = RESOLUTION_MAP[options.resolution];
      if (mapped != null) {
        body.resolution = mapped;
      } else {
        warnings.push({
          type: "unsupported",
          feature: "resolution",
          details: `Unrecognized resolution "${options.resolution}". Use providerOptions.xai.resolution with "480p" or "720p" instead.`
        });
      }
    }
    if (isEdit) {
      body.video = { url: xaiOptions.videoUrl };
    }
    if (isExtension) {
      body.video = { url: xaiOptions.videoUrl };
    }
    if (options.image != null) {
      if (options.image.type === "url") {
        body.image = { url: options.image.url };
      } else {
        const base64Data = typeof options.image.data === "string" ? options.image.data : chunkOCS2GTEN_cjs.convertUint8ArrayToBase642(options.image.data);
        body.image = {
          url: `data:${options.image.mediaType};base64,${base64Data}`
        };
      }
    }
    if (hasReferenceImages) {
      body.reference_images = xaiOptions.referenceImageUrls.map((url) => ({
        url
      }));
    }
    if (xaiOptions != null) {
      for (const [key, value] of Object.entries(xaiOptions)) {
        if (![
          "mode",
          "pollIntervalMs",
          "pollTimeoutMs",
          "resolution",
          "videoUrl",
          "referenceImageUrls"
        ].includes(key)) {
          body[key] = value;
        }
      }
    }
    const baseURL = (_d = this.config.baseURL) != null ? _d : "https://api.x.ai/v1";
    let endpoint;
    if (isEdit) {
      endpoint = `${baseURL}/videos/edits`;
    } else if (isExtension) {
      endpoint = `${baseURL}/videos/extensions`;
    } else {
      endpoint = `${baseURL}/videos/generations`;
    }
    const { value: createResponse } = await chunkOCS2GTEN_cjs.postJsonToApi2({
      url: endpoint,
      headers: chunkOCS2GTEN_cjs.combineHeaders2(this.config.headers(), options.headers),
      body,
      failedResponseHandler: xaiFailedResponseHandler,
      successfulResponseHandler: chunkOCS2GTEN_cjs.createJsonResponseHandler2(
        xaiCreateVideoResponseSchema
      ),
      abortSignal: options.abortSignal,
      fetch: this.config.fetch
    });
    const requestId = createResponse.request_id;
    if (!requestId) {
      throw new chunkOCS2GTEN_cjs.AISDKError({
        name: "XAI_VIDEO_GENERATION_ERROR",
        message: `No request_id returned from xAI API. Response: ${JSON.stringify(createResponse)}`
      });
    }
    const pollIntervalMs = (_e = xaiOptions == null ? void 0 : xaiOptions.pollIntervalMs) != null ? _e : 5e3;
    const pollTimeoutMs = (_f = xaiOptions == null ? void 0 : xaiOptions.pollTimeoutMs) != null ? _f : 6e5;
    const startTime = Date.now();
    let responseHeaders;
    while (true) {
      await chunkOCS2GTEN_cjs.delay(pollIntervalMs, { abortSignal: options.abortSignal });
      if (Date.now() - startTime > pollTimeoutMs) {
        throw new chunkOCS2GTEN_cjs.AISDKError({
          name: "XAI_VIDEO_GENERATION_TIMEOUT",
          message: `Video generation timed out after ${pollTimeoutMs}ms`
        });
      }
      const { value: statusResponse, responseHeaders: pollHeaders } = await chunkOCS2GTEN_cjs.getFromApi({
        url: `${baseURL}/videos/${requestId}`,
        headers: chunkOCS2GTEN_cjs.combineHeaders2(this.config.headers(), options.headers),
        successfulResponseHandler: chunkOCS2GTEN_cjs.createJsonResponseHandler2(
          xaiVideoStatusResponseSchema
        ),
        failedResponseHandler: xaiFailedResponseHandler,
        abortSignal: options.abortSignal,
        fetch: this.config.fetch
      });
      responseHeaders = pollHeaders;
      if (statusResponse.status === "done" || statusResponse.status == null && ((_g = statusResponse.video) == null ? void 0 : _g.url)) {
        if (((_h = statusResponse.video) == null ? void 0 : _h.respect_moderation) === false) {
          throw new chunkOCS2GTEN_cjs.AISDKError({
            name: "XAI_VIDEO_MODERATION_ERROR",
            message: "Video generation was blocked due to a content policy violation."
          });
        }
        if (!((_i = statusResponse.video) == null ? void 0 : _i.url)) {
          throw new chunkOCS2GTEN_cjs.AISDKError({
            name: "XAI_VIDEO_GENERATION_ERROR",
            message: "Video generation completed but no video URL was returned."
          });
        }
        return {
          videos: [
            {
              type: "url",
              url: statusResponse.video.url,
              mediaType: "video/mp4"
            }
          ],
          warnings,
          response: {
            timestamp: currentDate,
            modelId: this.modelId,
            headers: responseHeaders
          },
          providerMetadata: {
            xai: {
              requestId,
              videoUrl: statusResponse.video.url,
              ...statusResponse.video.duration != null ? { duration: statusResponse.video.duration } : {},
              ...((_j = statusResponse.usage) == null ? void 0 : _j.cost_in_usd_ticks) != null ? { costInUsdTicks: statusResponse.usage.cost_in_usd_ticks } : {},
              ...statusResponse.progress != null ? { progress: statusResponse.progress } : {}
            }
          }
        };
      }
      if (statusResponse.status === "expired") {
        throw new chunkOCS2GTEN_cjs.AISDKError({
          name: "XAI_VIDEO_GENERATION_EXPIRED",
          message: "Video generation request expired."
        });
      }
      if (statusResponse.status === "failed") {
        throw new chunkOCS2GTEN_cjs.AISDKError({
          name: "XAI_VIDEO_GENERATION_FAILED",
          message: "Video generation failed."
        });
      }
    }
  }
};
var xaiCreateVideoResponseSchema = v4.z.object({
  request_id: v4.z.string().nullish()
});
var xaiVideoStatusResponseSchema = v4.z.object({
  status: v4.z.string().nullish(),
  video: v4.z.object({
    url: v4.z.string(),
    duration: v4.z.number().nullish(),
    respect_moderation: v4.z.boolean().nullish()
  }).nullish(),
  model: v4.z.string().nullish(),
  usage: v4.z.object({
    cost_in_usd_ticks: v4.z.number().nullish()
  }).nullish(),
  progress: v4.z.number().nullish(),
  error: v4.z.object({
    code: v4.z.string().nullish(),
    message: v4.z.string().nullish()
  }).nullish()
});
function createXai(options = {}) {
  var _a15;
  const baseURL = chunkOCS2GTEN_cjs.withoutTrailingSlash2(
    (_a15 = options.baseURL) != null ? _a15 : "https://api.x.ai/v1"
  );
  const getHeaders = () => chunkOCS2GTEN_cjs.withUserAgentSuffix2(
    {
      Authorization: `Bearer ${chunkOCS2GTEN_cjs.loadApiKey2({
        apiKey: options.apiKey,
        environmentVariableName: "XAI_API_KEY",
        description: "xAI API key"
      })}`,
      ...options.headers
    },
    `ai-sdk/xai/${VERSION9}`
  );
  const createChatLanguageModel = (modelId) => {
    return new XaiChatLanguageModel(modelId, {
      provider: "xai.chat",
      baseURL,
      headers: getHeaders,
      generateId: chunkOCS2GTEN_cjs.generateId2,
      fetch: options.fetch
    });
  };
  const createResponsesLanguageModel = (modelId) => {
    return new XaiResponsesLanguageModel(modelId, {
      provider: "xai.responses",
      baseURL,
      headers: getHeaders,
      generateId: chunkOCS2GTEN_cjs.generateId2,
      fetch: options.fetch
    });
  };
  const createImageModel = (modelId) => {
    return new XaiImageModel(modelId, {
      provider: "xai.image",
      baseURL,
      headers: getHeaders,
      fetch: options.fetch
    });
  };
  const createVideoModel = (modelId) => {
    return new XaiVideoModel(modelId, {
      provider: "xai.video",
      baseURL,
      headers: getHeaders,
      fetch: options.fetch
    });
  };
  const provider = (modelId) => createChatLanguageModel(modelId);
  provider.specificationVersion = "v3";
  provider.languageModel = createChatLanguageModel;
  provider.chat = createChatLanguageModel;
  provider.responses = createResponsesLanguageModel;
  provider.embeddingModel = (modelId) => {
    throw new chunkOCS2GTEN_cjs.NoSuchModelError2({ modelId, modelType: "embeddingModel" });
  };
  provider.textEmbeddingModel = provider.embeddingModel;
  provider.imageModel = createImageModel;
  provider.image = createImageModel;
  provider.videoModel = createVideoModel;
  provider.video = createVideoModel;
  provider.tools = xaiTools;
  return provider;
}
createXai();
var __defProp = Object.defineProperty;
var __defProps = Object.defineProperties;
var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
var __getOwnPropSymbols = Object.getOwnPropertySymbols;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __propIsEnum = Object.prototype.propertyIsEnumerable;
var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
var __spreadValues = (a, b) => {
  for (var prop in b || (b = {}))
    if (__hasOwnProp.call(b, prop))
      __defNormalProp(a, prop, b[prop]);
  if (__getOwnPropSymbols)
    for (var prop of __getOwnPropSymbols(b)) {
      if (__propIsEnum.call(b, prop))
        __defNormalProp(a, prop, b[prop]);
    }
  return a;
};
var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
var marker = "vercel.ai.error";
var symbol = Symbol.for(marker);
var _a;
var _AISDKError = class _AISDKError2 extends Error {
  /**
   * Creates an AI SDK Error.
   *
   * @param {Object} params - The parameters for creating the error.
   * @param {string} params.name - The name of the error.
   * @param {string} params.message - The error message.
   * @param {unknown} [params.cause] - The underlying cause of the error.
   */
  constructor({
    name: name14,
    message,
    cause
  }) {
    super(message);
    this[_a] = true;
    this.name = name14;
    this.cause = cause;
  }
  /**
   * Checks if the given error is an AI SDK Error.
   * @param {unknown} error - The error to check.
   * @returns {boolean} True if the error is an AI SDK Error, false otherwise.
   */
  static isInstance(error) {
    return _AISDKError2.hasMarker(error, marker);
  }
  static hasMarker(error, marker15) {
    const markerSymbol = Symbol.for(marker15);
    return error != null && typeof error === "object" && markerSymbol in error && typeof error[markerSymbol] === "boolean" && error[markerSymbol] === true;
  }
};
_a = symbol;
var AISDKError2 = _AISDKError;
var name = "AI_APICallError";
var marker2 = `vercel.ai.error.${name}`;
var symbol2 = Symbol.for(marker2);
var _a2;
var APICallError2 = class extends AISDKError2 {
  constructor({
    message,
    url,
    requestBodyValues,
    statusCode,
    responseHeaders,
    responseBody,
    cause,
    isRetryable = statusCode != null && (statusCode === 408 || // request timeout
    statusCode === 409 || // conflict
    statusCode === 429 || // too many requests
    statusCode >= 500),
    // server error
    data
  }) {
    super({ name, message, cause });
    this[_a2] = true;
    this.url = url;
    this.requestBodyValues = requestBodyValues;
    this.statusCode = statusCode;
    this.responseHeaders = responseHeaders;
    this.responseBody = responseBody;
    this.isRetryable = isRetryable;
    this.data = data;
  }
  static isInstance(error) {
    return AISDKError2.hasMarker(error, marker2);
  }
};
_a2 = symbol2;
var name2 = "AI_EmptyResponseBodyError";
var marker3 = `vercel.ai.error.${name2}`;
var symbol3 = Symbol.for(marker3);
var _a3;
var EmptyResponseBodyError = class extends AISDKError2 {
  // used in isInstance
  constructor({ message = "Empty response body" } = {}) {
    super({ name: name2, message });
    this[_a3] = true;
  }
  static isInstance(error) {
    return AISDKError2.hasMarker(error, marker3);
  }
};
_a3 = symbol3;
function getErrorMessage(error) {
  if (error == null) {
    return "unknown error";
  }
  if (typeof error === "string") {
    return error;
  }
  if (error instanceof Error) {
    return error.message;
  }
  return JSON.stringify(error);
}
var name3 = "AI_InvalidArgumentError";
var marker4 = `vercel.ai.error.${name3}`;
var symbol4 = Symbol.for(marker4);
var _a4;
var InvalidArgumentError = class extends AISDKError2 {
  constructor({
    message,
    cause,
    argument
  }) {
    super({ name: name3, message, cause });
    this[_a4] = true;
    this.argument = argument;
  }
  static isInstance(error) {
    return AISDKError2.hasMarker(error, marker4);
  }
};
_a4 = symbol4;
var name4 = "AI_InvalidPromptError";
var marker5 = `vercel.ai.error.${name4}`;
var symbol5 = Symbol.for(marker5);
var _a5;
var InvalidPromptError = class extends AISDKError2 {
  constructor({
    prompt,
    message,
    cause
  }) {
    super({ name: name4, message: `Invalid prompt: ${message}`, cause });
    this[_a5] = true;
    this.prompt = prompt;
  }
  static isInstance(error) {
    return AISDKError2.hasMarker(error, marker5);
  }
};
_a5 = symbol5;
var name5 = "AI_InvalidResponseDataError";
var marker6 = `vercel.ai.error.${name5}`;
var symbol6 = Symbol.for(marker6);
var _a6;
var InvalidResponseDataError3 = class extends AISDKError2 {
  constructor({
    data,
    message = `Invalid response data: ${JSON.stringify(data)}.`
  }) {
    super({ name: name5, message });
    this[_a6] = true;
    this.data = data;
  }
  static isInstance(error) {
    return AISDKError2.hasMarker(error, marker6);
  }
};
_a6 = symbol6;
var name6 = "AI_JSONParseError";
var marker7 = `vercel.ai.error.${name6}`;
var symbol7 = Symbol.for(marker7);
var _a7;
var JSONParseError = class extends AISDKError2 {
  constructor({ text, cause }) {
    super({
      name: name6,
      message: `JSON parsing failed: Text: ${text}.
Error message: ${getErrorMessage(cause)}`,
      cause
    });
    this[_a7] = true;
    this.text = text;
  }
  static isInstance(error) {
    return AISDKError2.hasMarker(error, marker7);
  }
};
_a7 = symbol7;
var name7 = "AI_LoadAPIKeyError";
var marker8 = `vercel.ai.error.${name7}`;
var symbol8 = Symbol.for(marker8);
var _a8;
var LoadAPIKeyError = class extends AISDKError2 {
  // used in isInstance
  constructor({ message }) {
    super({ name: name7, message });
    this[_a8] = true;
  }
  static isInstance(error) {
    return AISDKError2.hasMarker(error, marker8);
  }
};
_a8 = symbol8;
var name9 = "AI_NoContentGeneratedError";
var marker10 = `vercel.ai.error.${name9}`;
var symbol10 = Symbol.for(marker10);
var _a10;
var NoContentGeneratedError = class extends AISDKError2 {
  // used in isInstance
  constructor({
    message = "No content generated."
  } = {}) {
    super({ name: name9, message });
    this[_a10] = true;
  }
  static isInstance(error) {
    return AISDKError2.hasMarker(error, marker10);
  }
};
_a10 = symbol10;
var name12 = "AI_TypeValidationError";
var marker13 = `vercel.ai.error.${name12}`;
var symbol13 = Symbol.for(marker13);
var _a13;
var _TypeValidationError = class _TypeValidationError2 extends AISDKError2 {
  constructor({ value, cause }) {
    super({
      name: name12,
      message: `Type validation failed: Value: ${JSON.stringify(value)}.
Error message: ${getErrorMessage(cause)}`,
      cause
    });
    this[_a13] = true;
    this.value = value;
  }
  static isInstance(error) {
    return AISDKError2.hasMarker(error, marker13);
  }
  /**
   * Wraps an error into a TypeValidationError.
   * If the cause is already a TypeValidationError with the same value, it returns the cause.
   * Otherwise, it creates a new TypeValidationError.
   *
   * @param {Object} params - The parameters for wrapping the error.
   * @param {unknown} params.value - The value that failed validation.
   * @param {unknown} params.cause - The original error or cause of the validation failure.
   * @returns {TypeValidationError} A TypeValidationError instance.
   */
  static wrap({
    value,
    cause
  }) {
    return _TypeValidationError2.isInstance(cause) && cause.value === value ? cause : new _TypeValidationError2({ value, cause });
  }
};
_a13 = symbol13;
var TypeValidationError = _TypeValidationError;
var name13 = "AI_UnsupportedFunctionalityError";
var marker14 = `vercel.ai.error.${name13}`;
var symbol14 = Symbol.for(marker14);
var _a14;
var UnsupportedFunctionalityError3 = class extends AISDKError2 {
  constructor({
    functionality,
    message = `'${functionality}' functionality not supported.`
  }) {
    super({ name: name13, message });
    this[_a14] = true;
    this.functionality = functionality;
  }
  static isInstance(error) {
    return AISDKError2.hasMarker(error, marker14);
  }
};
_a14 = symbol14;
var ParseError = class extends Error {
  constructor(message, options) {
    super(message), this.name = "ParseError", this.type = options.type, this.field = options.field, this.value = options.value, this.line = options.line;
  }
};
function noop(_arg) {
}
function createParser(callbacks) {
  if (typeof callbacks == "function")
    throw new TypeError(
      "`callbacks` must be an object, got a function instead. Did you mean `{onEvent: fn}`?"
    );
  const { onEvent = noop, onError = noop, onRetry = noop, onComment } = callbacks;
  let incompleteLine = "", isFirstChunk = true, id, data = "", eventType = "";
  function feed(newChunk) {
    const chunk = isFirstChunk ? newChunk.replace(/^\xEF\xBB\xBF/, "") : newChunk, [complete, incomplete] = splitLines(`${incompleteLine}${chunk}`);
    for (const line of complete)
      parseLine(line);
    incompleteLine = incomplete, isFirstChunk = false;
  }
  function parseLine(line) {
    if (line === "") {
      dispatchEvent();
      return;
    }
    if (line.startsWith(":")) {
      onComment && onComment(line.slice(line.startsWith(": ") ? 2 : 1));
      return;
    }
    const fieldSeparatorIndex = line.indexOf(":");
    if (fieldSeparatorIndex !== -1) {
      const field = line.slice(0, fieldSeparatorIndex), offset = line[fieldSeparatorIndex + 1] === " " ? 2 : 1, value = line.slice(fieldSeparatorIndex + offset);
      processField(field, value, line);
      return;
    }
    processField(line, "", line);
  }
  function processField(field, value, line) {
    switch (field) {
      case "event":
        eventType = value;
        break;
      case "data":
        data = `${data}${value}
`;
        break;
      case "id":
        id = value.includes("\0") ? void 0 : value;
        break;
      case "retry":
        /^\d+$/.test(value) ? onRetry(parseInt(value, 10)) : onError(
          new ParseError(`Invalid \`retry\` value: "${value}"`, {
            type: "invalid-retry",
            value,
            line
          })
        );
        break;
      default:
        onError(
          new ParseError(
            `Unknown field "${field.length > 20 ? `${field.slice(0, 20)}\u2026` : field}"`,
            { type: "unknown-field", field, value, line }
          )
        );
        break;
    }
  }
  function dispatchEvent() {
    data.length > 0 && onEvent({
      id,
      event: eventType || void 0,
      // If the data buffer's last character is a U+000A LINE FEED (LF) character,
      // then remove the last character from the data buffer.
      data: data.endsWith(`
`) ? data.slice(0, -1) : data
    }), id = void 0, data = "", eventType = "";
  }
  function reset(options = {}) {
    incompleteLine && options.consume && parseLine(incompleteLine), isFirstChunk = true, id = void 0, data = "", eventType = "", incompleteLine = "";
  }
  return { feed, reset };
}
function splitLines(chunk) {
  const lines = [];
  let incompleteLine = "", searchIndex = 0;
  for (; searchIndex < chunk.length; ) {
    const crIndex = chunk.indexOf("\r", searchIndex), lfIndex = chunk.indexOf(`
`, searchIndex);
    let lineEnd = -1;
    if (crIndex !== -1 && lfIndex !== -1 ? lineEnd = Math.min(crIndex, lfIndex) : crIndex !== -1 ? lineEnd = crIndex : lfIndex !== -1 && (lineEnd = lfIndex), lineEnd === -1) {
      incompleteLine = chunk.slice(searchIndex);
      break;
    } else {
      const line = chunk.slice(searchIndex, lineEnd);
      lines.push(line), searchIndex = lineEnd + 1, chunk[searchIndex - 1] === "\r" && chunk[searchIndex] === `
` && searchIndex++;
    }
  }
  return [lines, incompleteLine];
}
var EventSourceParserStream = class extends TransformStream {
  constructor({ onError, onRetry, onComment } = {}) {
    let parser;
    super({
      start(controller) {
        parser = createParser({
          onEvent: (event) => {
            controller.enqueue(event);
          },
          onError(error) {
            onError === "terminate" ? controller.error(error) : typeof onError == "function" && onError(error);
          },
          onRetry,
          onComment
        });
      },
      transform(chunk) {
        parser.feed(chunk);
      }
    });
  }
};
new Set("ABCDEFGHIJKLMNOPQRSTUVXYZabcdefghijklmnopqrstuvxyz0123456789");
function combineHeaders3(...headers) {
  return headers.reduce(
    (combinedHeaders, currentHeaders) => __spreadValues(__spreadValues({}, combinedHeaders), currentHeaders != null ? currentHeaders : {}),
    {}
  );
}
function extractResponseHeaders2(response) {
  return Object.fromEntries([...response.headers]);
}
var createIdGenerator = ({
  prefix,
  size = 16,
  alphabet = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz",
  separator = "-"
} = {}) => {
  const generator = () => {
    const alphabetLength = alphabet.length;
    const chars = new Array(size);
    for (let i = 0; i < size; i++) {
      chars[i] = alphabet[Math.random() * alphabetLength | 0];
    }
    return chars.join("");
  };
  if (prefix == null) {
    return generator;
  }
  if (alphabet.includes(separator)) {
    throw new InvalidArgumentError({
      argument: "separator",
      message: `The separator "${separator}" must not be part of the alphabet "${alphabet}".`
    });
  }
  return () => `${prefix}${separator}${generator()}`;
};
var generateId3 = createIdGenerator();
function isAbortError(error) {
  return (error instanceof Error || error instanceof DOMException) && (error.name === "AbortError" || error.name === "ResponseAborted" || // Next.js
  error.name === "TimeoutError");
}
var FETCH_FAILED_ERROR_MESSAGES = ["fetch failed", "failed to fetch"];
function handleFetchError({
  error,
  url,
  requestBodyValues
}) {
  if (isAbortError(error)) {
    return error;
  }
  if (error instanceof TypeError && FETCH_FAILED_ERROR_MESSAGES.includes(error.message.toLowerCase())) {
    const cause = error.cause;
    if (cause != null) {
      return new APICallError2({
        message: `Cannot connect to API: ${cause.message}`,
        cause,
        url,
        requestBodyValues,
        isRetryable: true
        // retry when network error
      });
    }
  }
  return error;
}
function removeUndefinedEntries(record) {
  return Object.fromEntries(
    Object.entries(record).filter(([_key, value]) => value != null)
  );
}
function loadApiKey3({
  apiKey,
  environmentVariableName,
  apiKeyParameterName = "apiKey",
  description
}) {
  if (typeof apiKey === "string") {
    return apiKey;
  }
  if (apiKey != null) {
    throw new LoadAPIKeyError({
      message: `${description} API key must be a string.`
    });
  }
  if (typeof process === "undefined") {
    throw new LoadAPIKeyError({
      message: `${description} API key is missing. Pass it using the '${apiKeyParameterName}' parameter. Environment variables is not supported in this environment.`
    });
  }
  apiKey = process.env[environmentVariableName];
  if (apiKey == null) {
    throw new LoadAPIKeyError({
      message: `${description} API key is missing. Pass it using the '${apiKeyParameterName}' parameter or the ${environmentVariableName} environment variable.`
    });
  }
  if (typeof apiKey !== "string") {
    throw new LoadAPIKeyError({
      message: `${description} API key must be a string. The value of the ${environmentVariableName} environment variable is not a string.`
    });
  }
  return apiKey;
}
var suspectProtoRx = /"__proto__"\s*:/;
var suspectConstructorRx = /"constructor"\s*:/;
function _parse(text) {
  const obj = JSON.parse(text);
  if (obj === null || typeof obj !== "object") {
    return obj;
  }
  if (suspectProtoRx.test(text) === false && suspectConstructorRx.test(text) === false) {
    return obj;
  }
  return filter(obj);
}
function filter(obj) {
  let next = [obj];
  while (next.length) {
    const nodes = next;
    next = [];
    for (const node of nodes) {
      if (Object.prototype.hasOwnProperty.call(node, "__proto__")) {
        throw new SyntaxError("Object contains forbidden prototype property");
      }
      if (Object.prototype.hasOwnProperty.call(node, "constructor") && Object.prototype.hasOwnProperty.call(node.constructor, "prototype")) {
        throw new SyntaxError("Object contains forbidden prototype property");
      }
      for (const key in node) {
        const value = node[key];
        if (value && typeof value === "object") {
          next.push(value);
        }
      }
    }
  }
  return obj;
}
function secureJsonParse(text) {
  const { stackTraceLimit } = Error;
  Error.stackTraceLimit = 0;
  try {
    return _parse(text);
  } finally {
    Error.stackTraceLimit = stackTraceLimit;
  }
}
var validatorSymbol = /* @__PURE__ */ Symbol.for("vercel.ai.validator");
function validator(validate) {
  return { [validatorSymbol]: true, validate };
}
function isValidator(value) {
  return typeof value === "object" && value !== null && validatorSymbol in value && value[validatorSymbol] === true && "validate" in value;
}
function asValidator(value) {
  return isValidator(value) ? value : standardSchemaValidator(value);
}
function standardSchemaValidator(standardSchema) {
  return validator(async (value) => {
    const result = await standardSchema["~standard"].validate(value);
    return result.issues == null ? { success: true, value: result.value } : {
      success: false,
      error: new TypeValidationError({
        value,
        cause: result.issues
      })
    };
  });
}
async function validateTypes2({
  value,
  schema
}) {
  const result = await safeValidateTypes({ value, schema });
  if (!result.success) {
    throw TypeValidationError.wrap({ value, cause: result.error });
  }
  return result.value;
}
async function safeValidateTypes({
  value,
  schema
}) {
  const validator2 = asValidator(schema);
  try {
    if (validator2.validate == null) {
      return { success: true, value, rawValue: value };
    }
    const result = await validator2.validate(value);
    if (result.success) {
      return { success: true, value: result.value, rawValue: value };
    }
    return {
      success: false,
      error: TypeValidationError.wrap({ value, cause: result.error }),
      rawValue: value
    };
  } catch (error) {
    return {
      success: false,
      error: TypeValidationError.wrap({ value, cause: error }),
      rawValue: value
    };
  }
}
async function parseJSON({
  text,
  schema
}) {
  try {
    const value = secureJsonParse(text);
    if (schema == null) {
      return value;
    }
    return validateTypes2({ value, schema });
  } catch (error) {
    if (JSONParseError.isInstance(error) || TypeValidationError.isInstance(error)) {
      throw error;
    }
    throw new JSONParseError({ text, cause: error });
  }
}
async function safeParseJSON2({
  text,
  schema
}) {
  try {
    const value = secureJsonParse(text);
    if (schema == null) {
      return { success: true, value, rawValue: value };
    }
    return await safeValidateTypes({ value, schema });
  } catch (error) {
    return {
      success: false,
      error: JSONParseError.isInstance(error) ? error : new JSONParseError({ text, cause: error }),
      rawValue: void 0
    };
  }
}
function isParsableJson3(input) {
  try {
    secureJsonParse(input);
    return true;
  } catch (e) {
    return false;
  }
}
function parseJsonEventStream({
  stream,
  schema
}) {
  return stream.pipeThrough(new TextDecoderStream()).pipeThrough(new EventSourceParserStream()).pipeThrough(
    new TransformStream({
      async transform({ data }, controller) {
        if (data === "[DONE]") {
          return;
        }
        controller.enqueue(await safeParseJSON2({ text: data, schema }));
      }
    })
  );
}
var getOriginalFetch2 = () => globalThis.fetch;
var postJsonToApi3 = async ({
  url,
  headers,
  body,
  failedResponseHandler,
  successfulResponseHandler,
  abortSignal,
  fetch: fetch2
}) => postToApi({
  url,
  headers: __spreadValues({
    "Content-Type": "application/json"
  }, headers),
  body: {
    content: JSON.stringify(body),
    values: body
  },
  failedResponseHandler,
  successfulResponseHandler,
  abortSignal,
  fetch: fetch2
});
var postToApi = async ({
  url,
  headers = {},
  body,
  successfulResponseHandler,
  failedResponseHandler,
  abortSignal,
  fetch: fetch2 = getOriginalFetch2()
}) => {
  try {
    const response = await fetch2(url, {
      method: "POST",
      headers: removeUndefinedEntries(headers),
      body: body.content,
      signal: abortSignal
    });
    const responseHeaders = extractResponseHeaders2(response);
    if (!response.ok) {
      let errorInformation;
      try {
        errorInformation = await failedResponseHandler({
          response,
          url,
          requestBodyValues: body.values
        });
      } catch (error) {
        if (isAbortError(error) || APICallError2.isInstance(error)) {
          throw error;
        }
        throw new APICallError2({
          message: "Failed to process error response",
          cause: error,
          statusCode: response.status,
          url,
          responseHeaders,
          requestBodyValues: body.values
        });
      }
      throw errorInformation.value;
    }
    try {
      return await successfulResponseHandler({
        response,
        url,
        requestBodyValues: body.values
      });
    } catch (error) {
      if (error instanceof Error) {
        if (isAbortError(error) || APICallError2.isInstance(error)) {
          throw error;
        }
      }
      throw new APICallError2({
        message: "Failed to process successful response",
        cause: error,
        statusCode: response.status,
        url,
        responseHeaders,
        requestBodyValues: body.values
      });
    }
  } catch (error) {
    throw handleFetchError({ error, url, requestBodyValues: body.values });
  }
};
var createJsonErrorResponseHandler3 = ({
  errorSchema,
  errorToMessage: errorToMessage2,
  isRetryable
}) => async ({ response, url, requestBodyValues }) => {
  const responseBody = await response.text();
  const responseHeaders = extractResponseHeaders2(response);
  if (responseBody.trim() === "") {
    return {
      responseHeaders,
      value: new APICallError2({
        message: response.statusText,
        url,
        requestBodyValues,
        statusCode: response.status,
        responseHeaders,
        responseBody,
        isRetryable: isRetryable == null ? void 0 : isRetryable(response)
      })
    };
  }
  try {
    const parsedError = await parseJSON({
      text: responseBody,
      schema: errorSchema
    });
    return {
      responseHeaders,
      value: new APICallError2({
        message: errorToMessage2(parsedError),
        url,
        requestBodyValues,
        statusCode: response.status,
        responseHeaders,
        responseBody,
        data: parsedError,
        isRetryable: isRetryable == null ? void 0 : isRetryable(response, parsedError)
      })
    };
  } catch (parseError) {
    return {
      responseHeaders,
      value: new APICallError2({
        message: response.statusText,
        url,
        requestBodyValues,
        statusCode: response.status,
        responseHeaders,
        responseBody,
        isRetryable: isRetryable == null ? void 0 : isRetryable(response)
      })
    };
  }
};
var createEventSourceResponseHandler3 = (chunkSchema) => async ({ response }) => {
  const responseHeaders = extractResponseHeaders2(response);
  if (response.body == null) {
    throw new EmptyResponseBodyError({});
  }
  return {
    responseHeaders,
    value: parseJsonEventStream({
      stream: response.body,
      schema: chunkSchema
    })
  };
};
var createJsonResponseHandler3 = (responseSchema) => async ({ response, url, requestBodyValues }) => {
  const responseBody = await response.text();
  const parsedResult = await safeParseJSON2({
    text: responseBody,
    schema: responseSchema
  });
  const responseHeaders = extractResponseHeaders2(response);
  if (!parsedResult.success) {
    throw new APICallError2({
      message: "Invalid JSON response",
      cause: parsedResult.error,
      statusCode: response.status,
      responseHeaders,
      responseBody,
      url,
      requestBodyValues
    });
  }
  return {
    responseHeaders,
    value: parsedResult.value,
    rawValue: parsedResult.rawValue
  };
};
var { btoa} = globalThis;
function convertUint8ArrayToBase643(array) {
  let latin1string = "";
  for (let i = 0; i < array.length; i++) {
    latin1string += String.fromCodePoint(array[i]);
  }
  return btoa(latin1string);
}
function withoutTrailingSlash3(url) {
  return url == null ? void 0 : url.replace(/\/$/, "");
}
function isDefinedOrNotNull(value) {
  return value !== null && value !== void 0;
}
var ReasoningFormat = /* @__PURE__ */ ((ReasoningFormat2) => {
  ReasoningFormat2["Unknown"] = "unknown";
  ReasoningFormat2["OpenAIResponsesV1"] = "openai-responses-v1";
  ReasoningFormat2["XAIResponsesV1"] = "xai-responses-v1";
  ReasoningFormat2["AnthropicClaudeV1"] = "anthropic-claude-v1";
  ReasoningFormat2["GoogleGeminiV1"] = "google-gemini-v1";
  return ReasoningFormat2;
})(ReasoningFormat || {});
var CommonReasoningDetailSchema = v4.z.object({
  id: v4.z.string().nullish(),
  format: v4.z.enum(ReasoningFormat).nullish(),
  index: v4.z.number().optional()
}).loose();
var ReasoningDetailSummarySchema = v4.z.object({
  type: v4.z.literal(
    "reasoning.summary"
    /* Summary */
  ),
  summary: v4.z.string()
}).extend(CommonReasoningDetailSchema.shape);
var ReasoningDetailEncryptedSchema = v4.z.object({
  type: v4.z.literal(
    "reasoning.encrypted"
    /* Encrypted */
  ),
  data: v4.z.string()
}).extend(CommonReasoningDetailSchema.shape);
var ReasoningDetailTextSchema = v4.z.object({
  type: v4.z.literal(
    "reasoning.text"
    /* Text */
  ),
  text: v4.z.string().nullish(),
  signature: v4.z.string().nullish()
}).extend(CommonReasoningDetailSchema.shape);
var ReasoningDetailUnionSchema = v4.z.union([
  ReasoningDetailSummarySchema,
  ReasoningDetailEncryptedSchema,
  ReasoningDetailTextSchema
]);
var ReasoningDetailsWithUnknownSchema = v4.z.union([
  ReasoningDetailUnionSchema,
  v4.z.unknown().transform(() => null)
]);
var ReasoningDetailArraySchema = v4.z.array(ReasoningDetailsWithUnknownSchema).transform((d) => d.filter((d2) => !!d2));
v4.z.union([
  v4.z.object({
    delta: v4.z.object({
      reasoning_details: v4.z.array(ReasoningDetailsWithUnknownSchema)
    })
  }).transform(
    (data) => data.delta.reasoning_details.filter(isDefinedOrNotNull)
  ),
  v4.z.object({
    message: v4.z.object({
      reasoning_details: v4.z.array(ReasoningDetailsWithUnknownSchema)
    })
  }).transform(
    (data) => data.message.reasoning_details.filter(isDefinedOrNotNull)
  ),
  v4.z.object({
    text: v4.z.string(),
    reasoning_details: v4.z.array(ReasoningDetailsWithUnknownSchema)
  }).transform((data) => data.reasoning_details.filter(isDefinedOrNotNull))
]);
var OpenRouterErrorResponseSchema = v4.z.object({
  error: v4.z.object({
    code: v4.z.union([v4.z.string(), v4.z.number()]).nullable().optional().default(null),
    message: v4.z.string(),
    type: v4.z.string().nullable().optional().default(null),
    param: v4.z.any().nullable().optional().default(null)
  }).passthrough()
}).passthrough();
var openrouterFailedResponseHandler = createJsonErrorResponseHandler3({
  errorSchema: OpenRouterErrorResponseSchema,
  errorToMessage: (data) => data.error.message
});
var FileAnnotationSchema = v4.z.object({
  type: v4.z.literal("file"),
  file: v4.z.object({
    hash: v4.z.string(),
    name: v4.z.string(),
    content: v4.z.array(
      v4.z.object({
        type: v4.z.string(),
        text: v4.z.string().optional()
      }).catchall(v4.z.any())
    ).optional()
  }).catchall(v4.z.any())
}).catchall(v4.z.any());
var OpenRouterProviderMetadataSchema = v4.z.object({
  provider: v4.z.string(),
  reasoning_details: v4.z.array(ReasoningDetailUnionSchema).optional(),
  annotations: v4.z.array(FileAnnotationSchema).optional(),
  usage: v4.z.object({
    promptTokens: v4.z.number(),
    promptTokensDetails: v4.z.object({
      cachedTokens: v4.z.number()
    }).catchall(v4.z.any()).optional(),
    completionTokens: v4.z.number(),
    completionTokensDetails: v4.z.object({
      reasoningTokens: v4.z.number()
    }).catchall(v4.z.any()).optional(),
    totalTokens: v4.z.number(),
    cost: v4.z.number().optional(),
    costDetails: v4.z.object({
      upstreamInferenceCost: v4.z.number()
    }).catchall(v4.z.any()).optional()
  }).catchall(v4.z.any())
}).catchall(v4.z.any());
var OpenRouterProviderOptionsSchema = v4.z.object({
  openrouter: v4.z.object({
    reasoning_details: v4.z.array(ReasoningDetailUnionSchema).optional(),
    annotations: v4.z.array(FileAnnotationSchema).optional()
  }).optional()
}).optional();
function mapOpenRouterFinishReason(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 OPENROUTER_AUDIO_FORMATS = [
  "wav",
  "mp3",
  "aiff",
  "aac",
  "ogg",
  "flac",
  "m4a",
  "pcm16",
  "pcm24"
];
function isUrl({
  url,
  protocols
}) {
  try {
    const urlObj = new URL(url);
    return protocols.has(urlObj.protocol);
  } catch (_) {
    return false;
  }
}
function getFileUrl({
  part,
  defaultMediaType
}) {
  var _a15, _b;
  if (part.data instanceof Uint8Array) {
    const base64 = convertUint8ArrayToBase643(part.data);
    return `data:${(_a15 = part.mediaType) != null ? _a15 : defaultMediaType};base64,${base64}`;
  }
  const stringUrl = part.data.toString();
  if (isUrl({
    url: stringUrl,
    protocols: /* @__PURE__ */ new Set(["http:", "https:"])
  })) {
    return stringUrl;
  }
  return stringUrl.startsWith("data:") ? stringUrl : `data:${(_b = part.mediaType) != null ? _b : defaultMediaType};base64,${stringUrl}`;
}
function getMediaType(dataUrl, defaultMediaType) {
  var _a15;
  const match = dataUrl.match(/^data:([^;]+)/);
  return match ? (_a15 = match[1]) != null ? _a15 : defaultMediaType : defaultMediaType;
}
function getBase64FromDataUrl(dataUrl) {
  const match = dataUrl.match(/^data:[^;]*;base64,(.+)$/);
  return match ? match[1] : dataUrl;
}
var MIME_TO_FORMAT = {
  // MP3 variants
  mpeg: "mp3",
  mp3: "mp3",
  // WAV variants
  "x-wav": "wav",
  wave: "wav",
  wav: "wav",
  // OGG variants
  ogg: "ogg",
  vorbis: "ogg",
  // AAC variants
  aac: "aac",
  "x-aac": "aac",
  // M4A variants
  m4a: "m4a",
  "x-m4a": "m4a",
  mp4: "m4a",
  // AIFF variants
  aiff: "aiff",
  "x-aiff": "aiff",
  // FLAC
  flac: "flac",
  "x-flac": "flac",
  // PCM variants
  pcm16: "pcm16",
  pcm24: "pcm24"
};
function getInputAudioData(part) {
  const fileData = getFileUrl({
    part,
    defaultMediaType: "audio/mpeg"
  });
  if (isUrl({
    url: fileData,
    protocols: /* @__PURE__ */ new Set(["http:", "https:"])
  })) {
    throw new Error(
      `Audio files cannot be provided as URLs.

OpenRouter requires audio to be base64-encoded. Please:
1. Download the audio file locally
2. Read it as a Buffer or Uint8Array
3. Pass it as the data parameter

The AI SDK will automatically handle base64 encoding.

Learn more: https://openrouter.ai/docs/features/multimodal/audio`
    );
  }
  const data = getBase64FromDataUrl(fileData);
  const mediaType = part.mediaType || "audio/mpeg";
  const rawFormat = mediaType.replace("audio/", "");
  const format = MIME_TO_FORMAT[rawFormat];
  if (format === void 0) {
    const supportedList = OPENROUTER_AUDIO_FORMATS.join(", ");
    throw new Error(
      `Unsupported audio format: "${mediaType}"

OpenRouter supports the following audio formats: ${supportedList}

Learn more: https://openrouter.ai/docs/features/multimodal/audio`
    );
  }
  return { data, format };
}
function getCacheControl2(providerMetadata) {
  var _a15, _b, _c;
  const anthropic = providerMetadata == null ? void 0 : providerMetadata.anthropic;
  const openrouter2 = providerMetadata == null ? void 0 : providerMetadata.openrouter;
  return (_c = (_b = (_a15 = openrouter2 == null ? void 0 : openrouter2.cacheControl) != null ? _a15 : openrouter2 == null ? void 0 : openrouter2.cache_control) != null ? _b : anthropic == null ? void 0 : anthropic.cacheControl) != null ? _c : anthropic == null ? void 0 : anthropic.cache_control;
}
function convertToOpenRouterChatMessages(prompt) {
  var _a15, _b, _c, _d, _e, _f, _g, _h, _i, _j;
  const messages = [];
  for (const { role, content, providerOptions } of prompt) {
    switch (role) {
      case "system": {
        messages.push({
          role: "system",
          content,
          cache_control: getCacheControl2(providerOptions)
        });
        break;
      }
      case "user": {
        if (content.length === 1 && ((_a15 = content[0]) == null ? void 0 : _a15.type) === "text") {
          const cacheControl = (_b = getCacheControl2(providerOptions)) != null ? _b : getCacheControl2(content[0].providerOptions);
          const contentWithCacheControl = cacheControl ? [
            {
              type: "text",
              text: content[0].text,
              cache_control: cacheControl
            }
          ] : content[0].text;
          messages.push({
            role: "user",
            content: contentWithCacheControl
          });
          break;
        }
        const messageCacheControl = getCacheControl2(providerOptions);
        const contentParts = content.map(
          (part) => {
            var _a16, _b2, _c2, _d2, _e2, _f2, _g2;
            const cacheControl = (_a16 = getCacheControl2(part.providerOptions)) != null ? _a16 : messageCacheControl;
            switch (part.type) {
              case "text":
                return {
                  type: "text",
                  text: part.text,
                  // For text parts, only use part-specific cache control
                  cache_control: cacheControl
                };
              case "file": {
                if ((_b2 = part.mediaType) == null ? void 0 : _b2.startsWith("image/")) {
                  const url = getFileUrl({
                    part,
                    defaultMediaType: "image/jpeg"
                  });
                  return {
                    type: "image_url",
                    image_url: {
                      url
                    },
                    // For image parts, use part-specific or message-level cache control
                    cache_control: cacheControl
                  };
                }
                if ((_c2 = part.mediaType) == null ? void 0 : _c2.startsWith("audio/")) {
                  return {
                    type: "input_audio",
                    input_audio: getInputAudioData(part),
                    cache_control: cacheControl
                  };
                }
                const fileName = String(
                  (_g2 = (_f2 = (_e2 = (_d2 = part.providerOptions) == null ? void 0 : _d2.openrouter) == null ? void 0 : _e2.filename) != null ? _f2 : part.filename) != null ? _g2 : ""
                );
                const fileData = getFileUrl({
                  part,
                  defaultMediaType: "application/pdf"
                });
                if (isUrl({
                  url: fileData,
                  protocols: /* @__PURE__ */ new Set(["http:", "https:"])
                })) {
                  return {
                    type: "file",
                    file: {
                      filename: fileName,
                      file_data: fileData
                    }
                  };
                }
                return {
                  type: "file",
                  file: {
                    filename: fileName,
                    file_data: fileData
                  },
                  cache_control: cacheControl
                };
              }
              default: {
                return {
                  type: "text",
                  text: "",
                  cache_control: cacheControl
                };
              }
            }
          }
        );
        messages.push({
          role: "user",
          content: contentParts
        });
        break;
      }
      case "assistant": {
        let text = "";
        let reasoning = "";
        const toolCalls = [];
        const accumulatedReasoningDetails = [];
        for (const part of content) {
          switch (part.type) {
            case "text": {
              text += part.text;
              break;
            }
            case "tool-call": {
              const partReasoningDetails = (_c = part.providerOptions) == null ? void 0 : _c.openrouter;
              if ((partReasoningDetails == null ? void 0 : partReasoningDetails.reasoning_details) && Array.isArray(partReasoningDetails.reasoning_details)) {
                accumulatedReasoningDetails.push(
                  ...partReasoningDetails.reasoning_details
                );
              }
              toolCalls.push({
                id: part.toolCallId,
                type: "function",
                function: {
                  name: part.toolName,
                  arguments: JSON.stringify(part.input)
                }
              });
              break;
            }
            case "reasoning": {
              reasoning += part.text;
              const parsedPartProviderOptions = OpenRouterProviderOptionsSchema.safeParse(part.providerOptions);
              if (parsedPartProviderOptions.success && ((_e = (_d = parsedPartProviderOptions.data) == null ? void 0 : _d.openrouter) == null ? void 0 : _e.reasoning_details)) {
                accumulatedReasoningDetails.push(
                  ...parsedPartProviderOptions.data.openrouter.reasoning_details
                );
              }
              break;
            }
          }
        }
        const parsedProviderOptions = OpenRouterProviderOptionsSchema.safeParse(providerOptions);
        const messageReasoningDetails = parsedProviderOptions.success ? (_g = (_f = parsedProviderOptions.data) == null ? void 0 : _f.openrouter) == null ? void 0 : _g.reasoning_details : void 0;
        const messageAnnotations = parsedProviderOptions.success ? (_i = (_h = parsedProviderOptions.data) == null ? void 0 : _h.openrouter) == null ? void 0 : _i.annotations : void 0;
        const finalReasoningDetails = messageReasoningDetails && Array.isArray(messageReasoningDetails) && messageReasoningDetails.length > 0 ? messageReasoningDetails : accumulatedReasoningDetails.length > 0 ? accumulatedReasoningDetails : void 0;
        messages.push({
          role: "assistant",
          content: text,
          tool_calls: toolCalls.length > 0 ? toolCalls : void 0,
          reasoning: reasoning || void 0,
          reasoning_details: finalReasoningDetails,
          annotations: messageAnnotations,
          cache_control: getCacheControl2(providerOptions)
        });
        break;
      }
      case "tool": {
        for (const toolResponse of content) {
          const content2 = getToolResultContent(toolResponse);
          messages.push({
            role: "tool",
            tool_call_id: toolResponse.toolCallId,
            content: content2,
            cache_control: (_j = getCacheControl2(providerOptions)) != null ? _j : getCacheControl2(toolResponse.providerOptions)
          });
        }
        break;
      }
    }
  }
  return messages;
}
function getToolResultContent(input) {
  return input.output.type === "text" ? input.output.value : JSON.stringify(input.output.value);
}
v4.z.union([
  v4.z.literal("auto"),
  v4.z.literal("none"),
  v4.z.literal("required"),
  v4.z.object({
    type: v4.z.literal("function"),
    function: v4.z.object({
      name: v4.z.string()
    })
  })
]);
function getChatCompletionToolChoice(toolChoice) {
  switch (toolChoice.type) {
    case "auto":
    case "none":
    case "required":
      return toolChoice.type;
    case "tool": {
      return {
        type: "function",
        function: { name: toolChoice.toolName }
      };
    }
    default: {
      throw new InvalidArgumentError({
        argument: "toolChoice",
        message: `Invalid tool choice type: ${JSON.stringify(toolChoice)}`
      });
    }
  }
}
var ImageResponseSchema = v4.z.object({
  type: v4.z.literal("image_url"),
  image_url: v4.z.object({
    url: v4.z.string()
  }).passthrough()
}).passthrough();
var ImageResponseWithUnknownSchema = v4.z.union([
  ImageResponseSchema,
  v4.z.unknown().transform(() => null)
]);
var ImageResponseArraySchema = v4.z.array(ImageResponseWithUnknownSchema).transform((d) => d.filter((d2) => !!d2));
var OpenRouterChatCompletionBaseResponseSchema = v4.z.object({
  id: v4.z.string().optional(),
  model: v4.z.string().optional(),
  provider: v4.z.string().optional(),
  usage: v4.z.object({
    prompt_tokens: v4.z.number(),
    prompt_tokens_details: v4.z.object({
      cached_tokens: v4.z.number()
    }).passthrough().nullish(),
    completion_tokens: v4.z.number(),
    completion_tokens_details: v4.z.object({
      reasoning_tokens: v4.z.number()
    }).passthrough().nullish(),
    total_tokens: v4.z.number(),
    cost: v4.z.number().optional(),
    cost_details: v4.z.object({
      upstream_inference_cost: v4.z.number().nullish()
    }).passthrough().nullish()
  }).passthrough().nullish()
}).passthrough();
var OpenRouterNonStreamChatCompletionResponseSchema = v4.z.union([
  // Success response with choices
  OpenRouterChatCompletionBaseResponseSchema.extend({
    choices: v4.z.array(
      v4.z.object({
        message: v4.z.object({
          role: v4.z.literal("assistant"),
          content: v4.z.string().nullable().optional(),
          reasoning: v4.z.string().nullable().optional(),
          reasoning_details: ReasoningDetailArraySchema.nullish(),
          images: ImageResponseArraySchema.nullish(),
          tool_calls: v4.z.array(
            v4.z.object({
              id: v4.z.string().optional().nullable(),
              type: v4.z.literal("function"),
              function: v4.z.object({
                name: v4.z.string(),
                arguments: v4.z.string()
              }).passthrough()
            }).passthrough()
          ).optional(),
          annotations: v4.z.array(
            v4.z.union([
              // URL citation from web search
              v4.z.object({
                type: v4.z.literal("url_citation"),
                url_citation: v4.z.object({
                  end_index: v4.z.number(),
                  start_index: v4.z.number(),
                  title: v4.z.string(),
                  url: v4.z.string(),
                  content: v4.z.string().optional()
                }).passthrough()
              }).passthrough(),
              // File annotation from FileParserPlugin (old format)
              v4.z.object({
                type: v4.z.literal("file_annotation"),
                file_annotation: v4.z.object({
                  file_id: v4.z.string(),
                  quote: v4.z.string().optional()
                }).passthrough()
              }).passthrough(),
              // File annotation from FileParserPlugin (new format)
              v4.z.object({
                type: v4.z.literal("file"),
                file: v4.z.object({
                  hash: v4.z.string(),
                  name: v4.z.string(),
                  content: v4.z.array(
                    v4.z.object({
                      type: v4.z.string(),
                      text: v4.z.string().optional()
                    }).passthrough()
                  ).optional()
                }).passthrough()
              }).passthrough()
            ])
          ).nullish()
        }).passthrough(),
        index: v4.z.number().nullish(),
        logprobs: v4.z.object({
          content: v4.z.array(
            v4.z.object({
              token: v4.z.string(),
              logprob: v4.z.number(),
              top_logprobs: v4.z.array(
                v4.z.object({
                  token: v4.z.string(),
                  logprob: v4.z.number()
                }).passthrough()
              )
            }).passthrough()
          ).nullable()
        }).passthrough().nullable().optional(),
        finish_reason: v4.z.string().optional().nullable()
      }).passthrough()
    )
  }),
  // Error response (HTTP 200 with error payload)
  OpenRouterErrorResponseSchema.extend({
    user_id: v4.z.string().optional()
  })
]);
var OpenRouterStreamChatCompletionChunkSchema = v4.z.union([
  OpenRouterChatCompletionBaseResponseSchema.extend({
    choices: v4.z.array(
      v4.z.object({
        delta: v4.z.object({
          role: v4.z.enum(["assistant"]).optional(),
          content: v4.z.string().nullish(),
          reasoning: v4.z.string().nullish().optional(),
          reasoning_details: ReasoningDetailArraySchema.nullish(),
          images: ImageResponseArraySchema.nullish(),
          tool_calls: v4.z.array(
            v4.z.object({
              index: v4.z.number().nullish(),
              id: v4.z.string().nullish(),
              type: v4.z.literal("function").optional(),
              function: v4.z.object({
                name: v4.z.string().nullish(),
                arguments: v4.z.string().nullish()
              }).passthrough()
            }).passthrough()
          ).nullish(),
          annotations: v4.z.array(
            v4.z.union([
              // URL citation from web search
              v4.z.object({
                type: v4.z.literal("url_citation"),
                url_citation: v4.z.object({
                  end_index: v4.z.number(),
                  start_index: v4.z.number(),
                  title: v4.z.string(),
                  url: v4.z.string(),
                  content: v4.z.string().optional()
                }).passthrough()
              }).passthrough(),
              // File annotation from FileParserPlugin (old format)
              v4.z.object({
                type: v4.z.literal("file_annotation"),
                file_annotation: v4.z.object({
                  file_id: v4.z.string(),
                  quote: v4.z.string().optional()
                }).passthrough()
              }).passthrough(),
              // File annotation from FileParserPlugin (new format)
              v4.z.object({
                type: v4.z.literal("file"),
                file: v4.z.object({
                  hash: v4.z.string(),
                  name: v4.z.string(),
                  content: v4.z.array(
                    v4.z.object({
                      type: v4.z.string(),
                      text: v4.z.string().optional()
                    }).passthrough()
                  ).optional()
                }).passthrough()
              }).passthrough()
            ])
          ).nullish()
        }).passthrough().nullish(),
        logprobs: v4.z.object({
          content: v4.z.array(
            v4.z.object({
              token: v4.z.string(),
              logprob: v4.z.number(),
              top_logprobs: v4.z.array(
                v4.z.object({
                  token: v4.z.string(),
                  logprob: v4.z.number()
                }).passthrough()
              )
            }).passthrough()
          ).nullable()
        }).passthrough().nullish(),
        finish_reason: v4.z.string().nullable().optional(),
        index: v4.z.number().nullish()
      }).passthrough()
    )
  }),
  OpenRouterErrorResponseSchema
]);
var OpenRouterChatLanguageModel = class {
  constructor(modelId, settings, config) {
    this.specificationVersion = "v2";
    this.provider = "openrouter";
    this.defaultObjectGenerationMode = "tool";
    this.supportsImageUrls = true;
    this.supportedUrls = {
      "image/*": [
        /^data:image\/[a-zA-Z]+;base64,/,
        /^https?:\/\/.+\.(jpg|jpeg|png|gif|webp)$/i
      ],
      // 'text/*': [/^data:text\//, /^https?:\/\/.+$/],
      "application/*": [/^data:application\//, /^https?:\/\/.+$/]
    };
    this.modelId = modelId;
    this.settings = settings;
    this.config = config;
  }
  getArgs({
    prompt,
    maxOutputTokens,
    temperature,
    topP,
    frequencyPenalty,
    presencePenalty,
    seed,
    stopSequences,
    responseFormat,
    topK,
    tools,
    toolChoice
  }) {
    var _a15;
    const baseArgs = __spreadValues(__spreadValues({
      // model id:
      model: this.modelId,
      models: this.settings.models,
      // model specific settings:
      logit_bias: this.settings.logitBias,
      logprobs: this.settings.logprobs === true || typeof this.settings.logprobs === "number" ? true : void 0,
      top_logprobs: typeof this.settings.logprobs === "number" ? this.settings.logprobs : typeof this.settings.logprobs === "boolean" ? this.settings.logprobs ? 0 : void 0 : void 0,
      user: this.settings.user,
      parallel_tool_calls: this.settings.parallelToolCalls,
      // standardized settings:
      max_tokens: maxOutputTokens,
      temperature,
      top_p: topP,
      frequency_penalty: frequencyPenalty,
      presence_penalty: presencePenalty,
      seed,
      stop: stopSequences,
      response_format: (responseFormat == null ? void 0 : responseFormat.type) === "json" ? responseFormat.schema != null ? {
        type: "json_schema",
        json_schema: __spreadValues({
          schema: responseFormat.schema,
          strict: true,
          name: (_a15 = responseFormat.name) != null ? _a15 : "response"
        }, responseFormat.description && {
          description: responseFormat.description
        })
      } : { type: "json_object" } : void 0,
      top_k: topK,
      // messages:
      messages: convertToOpenRouterChatMessages(prompt),
      // OpenRouter specific settings:
      include_reasoning: this.settings.includeReasoning,
      reasoning: this.settings.reasoning,
      usage: this.settings.usage,
      // Web search settings:
      plugins: this.settings.plugins,
      web_search_options: this.settings.web_search_options,
      // Provider routing settings:
      provider: this.settings.provider,
      // Debug settings:
      debug: this.settings.debug
    }, this.config.extraBody), this.settings.extraBody);
    if (tools && tools.length > 0) {
      const mappedTools = tools.filter(
        (tool) => tool.type === "function"
      ).map((tool) => ({
        type: "function",
        function: {
          name: tool.name,
          description: tool.description,
          parameters: tool.inputSchema
        }
      }));
      return __spreadProps(__spreadValues({}, baseArgs), {
        tools: mappedTools,
        tool_choice: toolChoice ? getChatCompletionToolChoice(toolChoice) : void 0
      });
    }
    return baseArgs;
  }
  async doGenerate(options) {
    var _a15, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r, _s, _t, _u, _v, _w;
    const providerOptions = options.providerOptions || {};
    const openrouterOptions = providerOptions.openrouter || {};
    const args = __spreadValues(__spreadValues({}, this.getArgs(options)), openrouterOptions);
    const { value: responseValue, responseHeaders } = await postJsonToApi3({
      url: this.config.url({
        path: "/chat/completions",
        modelId: this.modelId
      }),
      headers: combineHeaders3(this.config.headers(), options.headers),
      body: args,
      failedResponseHandler: openrouterFailedResponseHandler,
      successfulResponseHandler: createJsonResponseHandler3(
        OpenRouterNonStreamChatCompletionResponseSchema
      ),
      abortSignal: options.abortSignal,
      fetch: this.config.fetch
    });
    if ("error" in responseValue) {
      const errorData = responseValue.error;
      throw new APICallError2({
        message: errorData.message,
        url: this.config.url({
          path: "/chat/completions",
          modelId: this.modelId
        }),
        requestBodyValues: args,
        statusCode: 200,
        responseHeaders,
        data: errorData
      });
    }
    const response = responseValue;
    const choice = response.choices[0];
    if (!choice) {
      throw new NoContentGeneratedError({
        message: "No choice in response"
      });
    }
    const usageInfo = response.usage ? {
      inputTokens: (_a15 = response.usage.prompt_tokens) != null ? _a15 : 0,
      outputTokens: (_b = response.usage.completion_tokens) != null ? _b : 0,
      totalTokens: ((_c = response.usage.prompt_tokens) != null ? _c : 0) + ((_d = response.usage.completion_tokens) != null ? _d : 0),
      reasoningTokens: (_f = (_e = response.usage.completion_tokens_details) == null ? void 0 : _e.reasoning_tokens) != null ? _f : 0,
      cachedInputTokens: (_h = (_g = response.usage.prompt_tokens_details) == null ? void 0 : _g.cached_tokens) != null ? _h : 0
    } : {
      inputTokens: 0,
      outputTokens: 0,
      totalTokens: 0,
      reasoningTokens: 0,
      cachedInputTokens: 0
    };
    const reasoningDetails = (_i = choice.message.reasoning_details) != null ? _i : [];
    const reasoning = reasoningDetails.length > 0 ? reasoningDetails.map((detail) => {
      switch (detail.type) {
        case "reasoning.text": {
          if (detail.text) {
            return {
              type: "reasoning",
              text: detail.text,
              providerMetadata: {
                openrouter: {
                  reasoning_details: [detail]
                }
              }
            };
          }
          break;
        }
        case "reasoning.summary": {
          if (detail.summary) {
            return {
              type: "reasoning",
              text: detail.summary,
              providerMetadata: {
                openrouter: {
                  reasoning_details: [detail]
                }
              }
            };
          }
          break;
        }
        case "reasoning.encrypted": {
          if (detail.data) {
            return {
              type: "reasoning",
              text: "[REDACTED]",
              providerMetadata: {
                openrouter: {
                  reasoning_details: [detail]
                }
              }
            };
          }
          break;
        }
      }
      return null;
    }).filter((p) => p !== null) : choice.message.reasoning ? [
      {
        type: "reasoning",
        text: choice.message.reasoning
      }
    ] : [];
    const content = [];
    content.push(...reasoning);
    if (choice.message.content) {
      content.push({
        type: "text",
        text: choice.message.content
      });
    }
    if (choice.message.tool_calls) {
      for (const toolCall of choice.message.tool_calls) {
        content.push({
          type: "tool-call",
          toolCallId: (_j = toolCall.id) != null ? _j : generateId3(),
          toolName: toolCall.function.name,
          input: toolCall.function.arguments,
          providerMetadata: {
            openrouter: {
              reasoning_details: reasoningDetails
            }
          }
        });
      }
    }
    if (choice.message.images) {
      for (const image of choice.message.images) {
        content.push({
          type: "file",
          mediaType: getMediaType(image.image_url.url, "image/jpeg"),
          data: getBase64FromDataUrl(image.image_url.url)
        });
      }
    }
    if (choice.message.annotations) {
      for (const annotation of choice.message.annotations) {
        if (annotation.type === "url_citation") {
          content.push({
            type: "source",
            sourceType: "url",
            id: annotation.url_citation.url,
            url: annotation.url_citation.url,
            title: annotation.url_citation.title,
            providerMetadata: {
              openrouter: {
                content: annotation.url_citation.content || ""
              }
            }
          });
        }
      }
    }
    const fileAnnotations = (_k = choice.message.annotations) == null ? void 0 : _k.filter(
      (a) => a.type === "file"
    );
    const hasToolCalls = choice.message.tool_calls && choice.message.tool_calls.length > 0;
    const hasEncryptedReasoning = reasoningDetails.some(
      (d) => d.type === "reasoning.encrypted" && d.data
    );
    const shouldOverrideFinishReason = hasToolCalls && hasEncryptedReasoning && choice.finish_reason === "stop";
    const effectiveFinishReason = shouldOverrideFinishReason ? "tool-calls" : mapOpenRouterFinishReason(choice.finish_reason);
    return {
      content,
      finishReason: effectiveFinishReason,
      usage: usageInfo,
      warnings: [],
      providerMetadata: {
        openrouter: OpenRouterProviderMetadataSchema.parse({
          provider: (_l = response.provider) != null ? _l : "",
          reasoning_details: (_m = choice.message.reasoning_details) != null ? _m : [],
          annotations: fileAnnotations && fileAnnotations.length > 0 ? fileAnnotations : void 0,
          usage: __spreadValues(__spreadValues(__spreadValues({
            promptTokens: (_n = usageInfo.inputTokens) != null ? _n : 0,
            completionTokens: (_o = usageInfo.outputTokens) != null ? _o : 0,
            totalTokens: (_p = usageInfo.totalTokens) != null ? _p : 0,
            cost: (_q = response.usage) == null ? void 0 : _q.cost
          }, ((_s = (_r = response.usage) == null ? void 0 : _r.prompt_tokens_details) == null ? void 0 : _s.cached_tokens) != null ? {
            promptTokensDetails: {
              cachedTokens: response.usage.prompt_tokens_details.cached_tokens
            }
          } : {}), ((_u = (_t = response.usage) == null ? void 0 : _t.completion_tokens_details) == null ? void 0 : _u.reasoning_tokens) != null ? {
            completionTokensDetails: {
              reasoningTokens: response.usage.completion_tokens_details.reasoning_tokens
            }
          } : {}), ((_w = (_v = response.usage) == null ? void 0 : _v.cost_details) == null ? void 0 : _w.upstream_inference_cost) != null ? {
            costDetails: {
              upstreamInferenceCost: response.usage.cost_details.upstream_inference_cost
            }
          } : {})
        })
      },
      request: { body: args },
      response: {
        id: response.id,
        modelId: response.model,
        headers: responseHeaders
      }
    };
  }
  async doStream(options) {
    var _a15;
    const providerOptions = options.providerOptions || {};
    const openrouterOptions = providerOptions.openrouter || {};
    const args = __spreadValues(__spreadValues({}, this.getArgs(options)), openrouterOptions);
    const { value: response, responseHeaders } = await postJsonToApi3({
      url: this.config.url({
        path: "/chat/completions",
        modelId: this.modelId
      }),
      headers: combineHeaders3(this.config.headers(), options.headers),
      body: __spreadProps(__spreadValues({}, args), {
        stream: true,
        // only include stream_options when in strict compatibility mode:
        stream_options: this.config.compatibility === "strict" ? __spreadValues({
          include_usage: true
        }, ((_a15 = this.settings.usage) == null ? void 0 : _a15.include) ? { include_usage: true } : {}) : void 0
      }),
      failedResponseHandler: openrouterFailedResponseHandler,
      successfulResponseHandler: createEventSourceResponseHandler3(
        OpenRouterStreamChatCompletionChunkSchema
      ),
      abortSignal: options.abortSignal,
      fetch: this.config.fetch
    });
    const toolCalls = [];
    let finishReason = "other";
    const usage = {
      inputTokens: Number.NaN,
      outputTokens: Number.NaN,
      totalTokens: Number.NaN,
      reasoningTokens: Number.NaN,
      cachedInputTokens: Number.NaN
    };
    const openrouterUsage = {};
    const accumulatedReasoningDetails = [];
    const accumulatedFileAnnotations = [];
    let textStarted = false;
    let reasoningStarted = false;
    let textId;
    let reasoningId;
    let openrouterResponseId;
    let provider;
    return {
      stream: response.pipeThrough(
        new TransformStream({
          transform(chunk, controller) {
            var _a16, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o;
            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 (value.provider) {
              provider = value.provider;
            }
            if (value.id) {
              openrouterResponseId = value.id;
              controller.enqueue({
                type: "response-metadata",
                id: value.id
              });
            }
            if (value.model) {
              controller.enqueue({
                type: "response-metadata",
                modelId: value.model
              });
            }
            if (value.usage != null) {
              usage.inputTokens = value.usage.prompt_tokens;
              usage.outputTokens = value.usage.completion_tokens;
              usage.totalTokens = value.usage.prompt_tokens + value.usage.completion_tokens;
              openrouterUsage.promptTokens = value.usage.prompt_tokens;
              if (value.usage.prompt_tokens_details) {
                const cachedInputTokens = (_a16 = value.usage.prompt_tokens_details.cached_tokens) != null ? _a16 : 0;
                usage.cachedInputTokens = cachedInputTokens;
                openrouterUsage.promptTokensDetails = {
                  cachedTokens: cachedInputTokens
                };
              }
              openrouterUsage.completionTokens = value.usage.completion_tokens;
              if (value.usage.completion_tokens_details) {
                const reasoningTokens = (_b = value.usage.completion_tokens_details.reasoning_tokens) != null ? _b : 0;
                usage.reasoningTokens = reasoningTokens;
                openrouterUsage.completionTokensDetails = {
                  reasoningTokens
                };
              }
              openrouterUsage.cost = value.usage.cost;
              openrouterUsage.totalTokens = value.usage.total_tokens;
              const upstreamInferenceCost = (_c = value.usage.cost_details) == null ? void 0 : _c.upstream_inference_cost;
              if (upstreamInferenceCost != null) {
                openrouterUsage.costDetails = {
                  upstreamInferenceCost
                };
              }
            }
            const choice = value.choices[0];
            if ((choice == null ? void 0 : choice.finish_reason) != null) {
              finishReason = mapOpenRouterFinishReason(choice.finish_reason);
            }
            if ((choice == null ? void 0 : choice.delta) == null) {
              return;
            }
            const delta = choice.delta;
            const emitReasoningChunk = (chunkText, providerMetadata) => {
              if (!reasoningStarted) {
                reasoningId = openrouterResponseId || generateId3();
                controller.enqueue({
                  providerMetadata,
                  type: "reasoning-start",
                  id: reasoningId
                });
                reasoningStarted = true;
              }
              controller.enqueue({
                providerMetadata,
                type: "reasoning-delta",
                delta: chunkText,
                id: reasoningId || generateId3()
              });
            };
            if (delta.reasoning_details && delta.reasoning_details.length > 0) {
              for (const detail of delta.reasoning_details) {
                if (detail.type === "reasoning.text") {
                  const lastDetail = accumulatedReasoningDetails[accumulatedReasoningDetails.length - 1];
                  if ((lastDetail == null ? void 0 : lastDetail.type) === "reasoning.text") {
                    lastDetail.text = (lastDetail.text || "") + (detail.text || "");
                    lastDetail.signature = lastDetail.signature || detail.signature;
                    lastDetail.format = lastDetail.format || detail.format;
                  } else {
                    accumulatedReasoningDetails.push(__spreadValues({}, detail));
                  }
                } else {
                  accumulatedReasoningDetails.push(detail);
                }
              }
              const reasoningMetadata = {
                openrouter: {
                  reasoning_details: delta.reasoning_details
                }
              };
              for (const detail of delta.reasoning_details) {
                switch (detail.type) {
                  case "reasoning.text": {
                    if (detail.text) {
                      emitReasoningChunk(detail.text, reasoningMetadata);
                    }
                    break;
                  }
                  case "reasoning.encrypted": {
                    if (detail.data) {
                      emitReasoningChunk("[REDACTED]", reasoningMetadata);
                    }
                    break;
                  }
                  case "reasoning.summary": {
                    if (detail.summary) {
                      emitReasoningChunk(detail.summary, reasoningMetadata);
                    }
                    break;
                  }
                }
              }
            } else if (delta.reasoning) {
              emitReasoningChunk(delta.reasoning);
            }
            if (delta.content) {
              if (reasoningStarted && !textStarted) {
                controller.enqueue({
                  type: "reasoning-end",
                  id: reasoningId || generateId3()
                });
                reasoningStarted = false;
              }
              if (!textStarted) {
                textId = openrouterResponseId || generateId3();
                controller.enqueue({
                  type: "text-start",
                  id: textId
                });
                textStarted = true;
              }
              controller.enqueue({
                type: "text-delta",
                delta: delta.content,
                id: textId || generateId3()
              });
            }
            if (delta.annotations) {
              for (const annotation of delta.annotations) {
                if (annotation.type === "url_citation") {
                  controller.enqueue({
                    type: "source",
                    sourceType: "url",
                    id: annotation.url_citation.url,
                    url: annotation.url_citation.url,
                    title: annotation.url_citation.title,
                    providerMetadata: {
                      openrouter: {
                        content: annotation.url_citation.content || ""
                      }
                    }
                  });
                } else if (annotation.type === "file") {
                  const file = annotation.file;
                  if (file && typeof file === "object" && "hash" in file && "name" in file) {
                    accumulatedFileAnnotations.push(
                      annotation
                    );
                  }
                }
              }
            }
            if (delta.tool_calls != null) {
              for (const toolCallDelta of delta.tool_calls) {
                const index = (_d = toolCallDelta.index) != null ? _d : toolCalls.length - 1;
                if (toolCalls[index] == null) {
                  if (toolCallDelta.type !== "function") {
                    throw new InvalidResponseDataError3({
                      data: toolCallDelta,
                      message: `Expected 'function' type.`
                    });
                  }
                  if (toolCallDelta.id == null) {
                    throw new InvalidResponseDataError3({
                      data: toolCallDelta,
                      message: `Expected 'id' to be a string.`
                    });
                  }
                  if (((_e = toolCallDelta.function) == null ? void 0 : _e.name) == null) {
                    throw new InvalidResponseDataError3({
                      data: toolCallDelta,
                      message: `Expected 'function.name' to be a string.`
                    });
                  }
                  toolCalls[index] = {
                    id: toolCallDelta.id,
                    type: "function",
                    function: {
                      name: toolCallDelta.function.name,
                      arguments: (_f = toolCallDelta.function.arguments) != null ? _f : ""
                    },
                    inputStarted: false,
                    sent: false
                  };
                  const toolCall2 = toolCalls[index];
                  if (toolCall2 == null) {
                    throw new InvalidResponseDataError3({
                      data: { index, toolCallsLength: toolCalls.length },
                      message: `Tool call at index ${index} is missing after creation.`
                    });
                  }
                  if (((_g = toolCall2.function) == null ? void 0 : _g.name) != null && ((_h = toolCall2.function) == null ? void 0 : _h.arguments) != null && isParsableJson3(toolCall2.function.arguments)) {
                    toolCall2.inputStarted = true;
                    controller.enqueue({
                      type: "tool-input-start",
                      id: toolCall2.id,
                      toolName: toolCall2.function.name
                    });
                    controller.enqueue({
                      type: "tool-input-delta",
                      id: toolCall2.id,
                      delta: toolCall2.function.arguments
                    });
                    controller.enqueue({
                      type: "tool-input-end",
                      id: toolCall2.id
                    });
                    controller.enqueue({
                      type: "tool-call",
                      toolCallId: toolCall2.id,
                      toolName: toolCall2.function.name,
                      input: toolCall2.function.arguments,
                      providerMetadata: {
                        openrouter: {
                          reasoning_details: accumulatedReasoningDetails
                        }
                      }
                    });
                    toolCall2.sent = true;
                  }
                  continue;
                }
                const toolCall = toolCalls[index];
                if (toolCall == null) {
                  throw new InvalidResponseDataError3({
                    data: {
                      index,
                      toolCallsLength: toolCalls.length,
                      toolCallDelta
                    },
                    message: `Tool call at index ${index} is missing during merge.`
                  });
                }
                if (!toolCall.inputStarted) {
                  toolCall.inputStarted = true;
                  controller.enqueue({
                    type: "tool-input-start",
                    id: toolCall.id,
                    toolName: toolCall.function.name
                  });
                }
                if (((_i = toolCallDelta.function) == null ? void 0 : _i.arguments) != null) {
                  toolCall.function.arguments += (_k = (_j = toolCallDelta.function) == null ? void 0 : _j.arguments) != null ? _k : "";
                }
                controller.enqueue({
                  type: "tool-input-delta",
                  id: toolCall.id,
                  delta: (_l = toolCallDelta.function.arguments) != null ? _l : ""
                });
                if (((_m = toolCall.function) == null ? void 0 : _m.name) != null && ((_n = toolCall.function) == null ? void 0 : _n.arguments) != null && isParsableJson3(toolCall.function.arguments)) {
                  controller.enqueue({
                    type: "tool-call",
                    toolCallId: (_o = toolCall.id) != null ? _o : generateId3(),
                    toolName: toolCall.function.name,
                    input: toolCall.function.arguments,
                    providerMetadata: {
                      openrouter: {
                        reasoning_details: accumulatedReasoningDetails
                      }
                    }
                  });
                  toolCall.sent = true;
                }
              }
            }
            if (delta.images != null) {
              for (const image of delta.images) {
                controller.enqueue({
                  type: "file",
                  mediaType: getMediaType(image.image_url.url, "image/jpeg"),
                  data: getBase64FromDataUrl(image.image_url.url)
                });
              }
            }
          },
          flush(controller) {
            var _a16;
            const hasToolCalls = toolCalls.length > 0;
            const hasEncryptedReasoning = accumulatedReasoningDetails.some(
              (d) => d.type === "reasoning.encrypted" && d.data
            );
            if (hasToolCalls && hasEncryptedReasoning && finishReason === "stop") {
              finishReason = "tool-calls";
            }
            if (finishReason === "tool-calls") {
              for (const toolCall of toolCalls) {
                if (toolCall && !toolCall.sent) {
                  controller.enqueue({
                    type: "tool-call",
                    toolCallId: (_a16 = toolCall.id) != null ? _a16 : generateId3(),
                    toolName: toolCall.function.name,
                    // Coerce invalid arguments to an empty JSON object
                    input: isParsableJson3(toolCall.function.arguments) ? toolCall.function.arguments : "{}",
                    providerMetadata: {
                      openrouter: {
                        reasoning_details: accumulatedReasoningDetails
                      }
                    }
                  });
                  toolCall.sent = true;
                }
              }
            }
            if (reasoningStarted) {
              controller.enqueue({
                type: "reasoning-end",
                id: reasoningId || generateId3()
              });
            }
            if (textStarted) {
              controller.enqueue({
                type: "text-end",
                id: textId || generateId3()
              });
            }
            const openrouterMetadata = {
              usage: openrouterUsage
            };
            if (provider !== void 0) {
              openrouterMetadata.provider = provider;
            }
            if (accumulatedReasoningDetails.length > 0) {
              openrouterMetadata.reasoning_details = accumulatedReasoningDetails;
            }
            if (accumulatedFileAnnotations.length > 0) {
              openrouterMetadata.annotations = accumulatedFileAnnotations;
            }
            controller.enqueue({
              type: "finish",
              finishReason,
              usage,
              providerMetadata: {
                openrouter: openrouterMetadata
              }
            });
          }
        })
      ),
      warnings: [],
      request: { body: args },
      response: { headers: responseHeaders }
    };
  }
};
function convertToOpenRouterCompletionPrompt({
  prompt,
  inputFormat,
  user = "user",
  assistant = "assistant"
}) {
  if (prompt.length === 1 && prompt[0] && prompt[0].role === "user" && prompt[0].content.length === 1 && prompt[0].content[0] && prompt[0].content[0].type === "text") {
    return { prompt: prompt[0].content[0].text };
  }
  let text = "";
  if (prompt[0] && 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;
            }
            case "file": {
              throw new UnsupportedFunctionalityError3({
                functionality: "file attachments"
              });
            }
            default: {
              return "";
            }
          }
        }).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 UnsupportedFunctionalityError3({
                  functionality: "tool-call messages"
                });
              }
              case "tool-result": {
                throw new UnsupportedFunctionalityError3({
                  functionality: "tool-result messages"
                });
              }
              case "reasoning": {
                throw new UnsupportedFunctionalityError3({
                  functionality: "reasoning messages"
                });
              }
              case "file": {
                throw new UnsupportedFunctionalityError3({
                  functionality: "file attachments"
                });
              }
              default: {
                return "";
              }
            }
          }
        ).join("");
        text += `${assistant}:
${assistantMessage}

`;
        break;
      }
      case "tool": {
        throw new UnsupportedFunctionalityError3({
          functionality: "tool messages"
        });
      }
    }
  }
  text += `${assistant}:
`;
  return {
    prompt: text
  };
}
var OpenRouterCompletionChunkSchema = v4.z.union([
  v4.z.object({
    id: v4.z.string().optional(),
    model: v4.z.string().optional(),
    choices: v4.z.array(
      v4.z.object({
        text: v4.z.string(),
        reasoning: v4.z.string().nullish().optional(),
        reasoning_details: ReasoningDetailArraySchema.nullish(),
        finish_reason: v4.z.string().nullish(),
        index: v4.z.number().nullish(),
        logprobs: v4.z.object({
          tokens: v4.z.array(v4.z.string()),
          token_logprobs: v4.z.array(v4.z.number()),
          top_logprobs: v4.z.array(v4.z.record(v4.z.string(), v4.z.number())).nullable()
        }).passthrough().nullable().optional()
      }).passthrough()
    ),
    usage: v4.z.object({
      prompt_tokens: v4.z.number(),
      prompt_tokens_details: v4.z.object({
        cached_tokens: v4.z.number()
      }).passthrough().nullish(),
      completion_tokens: v4.z.number(),
      completion_tokens_details: v4.z.object({
        reasoning_tokens: v4.z.number()
      }).passthrough().nullish(),
      total_tokens: v4.z.number(),
      cost: v4.z.number().optional(),
      cost_details: v4.z.object({
        upstream_inference_cost: v4.z.number().nullish()
      }).passthrough().nullish()
    }).passthrough().nullish()
  }).passthrough(),
  OpenRouterErrorResponseSchema
]);
var OpenRouterCompletionLanguageModel = class {
  constructor(modelId, settings, config) {
    this.specificationVersion = "v2";
    this.provider = "openrouter";
    this.supportsImageUrls = true;
    this.supportedUrls = {
      "image/*": [
        /^data:image\/[a-zA-Z]+;base64,/,
        /^https?:\/\/.+\.(jpg|jpeg|png|gif|webp)$/i
      ],
      "text/*": [/^data:text\//, /^https?:\/\/.+$/],
      "application/*": [/^data:application\//, /^https?:\/\/.+$/]
    };
    this.defaultObjectGenerationMode = void 0;
    this.modelId = modelId;
    this.settings = settings;
    this.config = config;
  }
  getArgs({
    prompt,
    maxOutputTokens,
    temperature,
    topP,
    frequencyPenalty,
    presencePenalty,
    seed,
    responseFormat,
    topK,
    stopSequences,
    tools,
    toolChoice
  }) {
    const { prompt: completionPrompt } = convertToOpenRouterCompletionPrompt({
      prompt,
      inputFormat: "prompt"
    });
    if (tools == null ? void 0 : tools.length) {
      throw new UnsupportedFunctionalityError3({
        functionality: "tools"
      });
    }
    if (toolChoice) {
      throw new UnsupportedFunctionalityError3({
        functionality: "toolChoice"
      });
    }
    return __spreadValues(__spreadValues({
      // model id:
      model: this.modelId,
      models: this.settings.models,
      // model specific settings:
      logit_bias: this.settings.logitBias,
      logprobs: typeof this.settings.logprobs === "number" ? this.settings.logprobs : typeof this.settings.logprobs === "boolean" ? this.settings.logprobs ? 0 : void 0 : void 0,
      suffix: this.settings.suffix,
      user: this.settings.user,
      // standardized settings:
      max_tokens: maxOutputTokens,
      temperature,
      top_p: topP,
      frequency_penalty: frequencyPenalty,
      presence_penalty: presencePenalty,
      seed,
      stop: stopSequences,
      response_format: responseFormat,
      top_k: topK,
      // prompt:
      prompt: completionPrompt,
      // OpenRouter specific settings:
      include_reasoning: this.settings.includeReasoning,
      reasoning: this.settings.reasoning
    }, this.config.extraBody), this.settings.extraBody);
  }
  async doGenerate(options) {
    var _a15, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o;
    const providerOptions = options.providerOptions || {};
    const openrouterOptions = providerOptions.openrouter || {};
    const args = __spreadValues(__spreadValues({}, this.getArgs(options)), openrouterOptions);
    const { value: response, responseHeaders } = await postJsonToApi3({
      url: this.config.url({
        path: "/completions",
        modelId: this.modelId
      }),
      headers: combineHeaders3(this.config.headers(), options.headers),
      body: args,
      failedResponseHandler: openrouterFailedResponseHandler,
      successfulResponseHandler: createJsonResponseHandler3(
        OpenRouterCompletionChunkSchema
      ),
      abortSignal: options.abortSignal,
      fetch: this.config.fetch
    });
    if ("error" in response) {
      const errorData = response.error;
      throw new APICallError2({
        message: errorData.message,
        url: this.config.url({
          path: "/completions",
          modelId: this.modelId
        }),
        requestBodyValues: args,
        statusCode: 200,
        responseHeaders,
        data: errorData
      });
    }
    const choice = response.choices[0];
    if (!choice) {
      throw new NoContentGeneratedError({
        message: "No choice in OpenRouter completion response"
      });
    }
    return {
      content: [
        {
          type: "text",
          text: (_a15 = choice.text) != null ? _a15 : ""
        }
      ],
      finishReason: mapOpenRouterFinishReason(choice.finish_reason),
      usage: {
        inputTokens: (_c = (_b = response.usage) == null ? void 0 : _b.prompt_tokens) != null ? _c : 0,
        outputTokens: (_e = (_d = response.usage) == null ? void 0 : _d.completion_tokens) != null ? _e : 0,
        totalTokens: ((_g = (_f = response.usage) == null ? void 0 : _f.prompt_tokens) != null ? _g : 0) + ((_i = (_h = response.usage) == null ? void 0 : _h.completion_tokens) != null ? _i : 0),
        reasoningTokens: (_l = (_k = (_j = response.usage) == null ? void 0 : _j.completion_tokens_details) == null ? void 0 : _k.reasoning_tokens) != null ? _l : 0,
        cachedInputTokens: (_o = (_n = (_m = response.usage) == null ? void 0 : _m.prompt_tokens_details) == null ? void 0 : _n.cached_tokens) != null ? _o : 0
      },
      warnings: [],
      response: {
        headers: responseHeaders
      }
    };
  }
  async doStream(options) {
    const providerOptions = options.providerOptions || {};
    const openrouterOptions = providerOptions.openrouter || {};
    const args = __spreadValues(__spreadValues({}, this.getArgs(options)), openrouterOptions);
    const { value: response, responseHeaders } = await postJsonToApi3({
      url: this.config.url({
        path: "/completions",
        modelId: this.modelId
      }),
      headers: combineHeaders3(this.config.headers(), options.headers),
      body: __spreadProps(__spreadValues({}, args), {
        stream: true,
        // only include stream_options when in strict compatibility mode:
        stream_options: this.config.compatibility === "strict" ? { include_usage: true } : void 0
      }),
      failedResponseHandler: openrouterFailedResponseHandler,
      successfulResponseHandler: createEventSourceResponseHandler3(
        OpenRouterCompletionChunkSchema
      ),
      abortSignal: options.abortSignal,
      fetch: this.config.fetch
    });
    let finishReason = "other";
    const usage = {
      inputTokens: Number.NaN,
      outputTokens: Number.NaN,
      totalTokens: Number.NaN,
      reasoningTokens: Number.NaN,
      cachedInputTokens: Number.NaN
    };
    const openrouterUsage = {};
    return {
      stream: response.pipeThrough(
        new TransformStream({
          transform(chunk, controller) {
            var _a15, _b, _c;
            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 (value.usage != null) {
              usage.inputTokens = value.usage.prompt_tokens;
              usage.outputTokens = value.usage.completion_tokens;
              usage.totalTokens = value.usage.prompt_tokens + value.usage.completion_tokens;
              openrouterUsage.promptTokens = value.usage.prompt_tokens;
              if (value.usage.prompt_tokens_details) {
                const cachedInputTokens = (_a15 = value.usage.prompt_tokens_details.cached_tokens) != null ? _a15 : 0;
                usage.cachedInputTokens = cachedInputTokens;
                openrouterUsage.promptTokensDetails = {
                  cachedTokens: cachedInputTokens
                };
              }
              openrouterUsage.completionTokens = value.usage.completion_tokens;
              if (value.usage.completion_tokens_details) {
                const reasoningTokens = (_b = value.usage.completion_tokens_details.reasoning_tokens) != null ? _b : 0;
                usage.reasoningTokens = reasoningTokens;
                openrouterUsage.completionTokensDetails = {
                  reasoningTokens
                };
              }
              openrouterUsage.cost = value.usage.cost;
              openrouterUsage.totalTokens = value.usage.total_tokens;
              const upstreamInferenceCost = (_c = value.usage.cost_details) == null ? void 0 : _c.upstream_inference_cost;
              if (upstreamInferenceCost != null) {
                openrouterUsage.costDetails = {
                  upstreamInferenceCost
                };
              }
            }
            const choice = value.choices[0];
            if ((choice == null ? void 0 : choice.finish_reason) != null) {
              finishReason = mapOpenRouterFinishReason(choice.finish_reason);
            }
            if ((choice == null ? void 0 : choice.text) != null) {
              controller.enqueue({
                type: "text-delta",
                delta: choice.text,
                id: generateId3()
              });
            }
          },
          flush(controller) {
            controller.enqueue({
              type: "finish",
              finishReason,
              usage,
              providerMetadata: {
                openrouter: {
                  usage: openrouterUsage
                }
              }
            });
          }
        })
      ),
      response: {
        headers: responseHeaders
      }
    };
  }
};
var openrouterEmbeddingUsageSchema = v4.z.object({
  prompt_tokens: v4.z.number(),
  total_tokens: v4.z.number(),
  cost: v4.z.number().optional()
});
var openrouterEmbeddingDataSchema = v4.z.object({
  object: v4.z.literal("embedding"),
  embedding: v4.z.array(v4.z.number()),
  index: v4.z.number().optional()
});
var OpenRouterEmbeddingResponseSchema = v4.z.object({
  id: v4.z.string().optional(),
  object: v4.z.literal("list"),
  data: v4.z.array(openrouterEmbeddingDataSchema),
  model: v4.z.string(),
  usage: openrouterEmbeddingUsageSchema.optional()
});
var OpenRouterEmbeddingModel = class {
  constructor(modelId, settings, config) {
    this.specificationVersion = "v2";
    this.provider = "openrouter";
    this.maxEmbeddingsPerCall = void 0;
    this.supportsParallelCalls = true;
    this.modelId = modelId;
    this.settings = settings;
    this.config = config;
  }
  async doEmbed(options) {
    var _a15;
    const { values, abortSignal, headers } = options;
    const args = __spreadValues(__spreadValues({
      model: this.modelId,
      input: values,
      user: this.settings.user,
      provider: this.settings.provider
    }, this.config.extraBody), this.settings.extraBody);
    const { value: responseValue, responseHeaders } = await postJsonToApi3({
      url: this.config.url({
        path: "/embeddings",
        modelId: this.modelId
      }),
      headers: combineHeaders3(this.config.headers(), headers),
      body: args,
      failedResponseHandler: openrouterFailedResponseHandler,
      successfulResponseHandler: createJsonResponseHandler3(
        OpenRouterEmbeddingResponseSchema
      ),
      abortSignal,
      fetch: this.config.fetch
    });
    return {
      embeddings: responseValue.data.map((item) => item.embedding),
      usage: responseValue.usage ? { tokens: responseValue.usage.prompt_tokens } : void 0,
      providerMetadata: ((_a15 = responseValue.usage) == null ? void 0 : _a15.cost) ? {
        openrouter: {
          usage: {
            cost: responseValue.usage.cost
          }
        }
      } : void 0,
      response: {
        headers: responseHeaders,
        body: responseValue
      }
    };
  }
};
function removeUndefinedEntries2(record) {
  return Object.fromEntries(
    Object.entries(record).filter(([, value]) => value !== null)
  );
}
function withUserAgentSuffix3(headers, ...userAgentSuffixParts) {
  const cleanedHeaders = removeUndefinedEntries2(
    headers != null ? headers : {}
  );
  const currentUserAgentHeader = cleanedHeaders["user-agent"] || "";
  const newUserAgent = [currentUserAgentHeader, ...userAgentSuffixParts].filter(Boolean).join(" ");
  return __spreadProps(__spreadValues({}, cleanedHeaders), {
    "user-agent": newUserAgent
  });
}
var VERSION10 = "1.5.4";
function createOpenRouter(options = {}) {
  var _a15, _b, _c;
  const baseURL = (_b = withoutTrailingSlash3((_a15 = options.baseURL) != null ? _a15 : options.baseUrl)) != null ? _b : "https://openrouter.ai/api/v1";
  const compatibility = (_c = options.compatibility) != null ? _c : "compatible";
  const getHeaders = () => withUserAgentSuffix3(
    __spreadValues(__spreadValues({
      Authorization: `Bearer ${loadApiKey3({
        apiKey: options.apiKey,
        environmentVariableName: "OPENROUTER_API_KEY",
        description: "OpenRouter"
      })}`
    }, options.headers), options.api_keys && Object.keys(options.api_keys).length > 0 && {
      "X-Provider-API-Keys": JSON.stringify(options.api_keys)
    }),
    `ai-sdk/openrouter/${VERSION10}`
  );
  const createChatModel = (modelId, settings = {}) => new OpenRouterChatLanguageModel(modelId, settings, {
    provider: "openrouter.chat",
    url: ({ path }) => `${baseURL}${path}`,
    headers: getHeaders,
    compatibility,
    fetch: options.fetch,
    extraBody: options.extraBody
  });
  const createCompletionModel = (modelId, settings = {}) => new OpenRouterCompletionLanguageModel(modelId, settings, {
    provider: "openrouter.completion",
    url: ({ path }) => `${baseURL}${path}`,
    headers: getHeaders,
    compatibility,
    fetch: options.fetch,
    extraBody: options.extraBody
  });
  const createEmbeddingModel = (modelId, settings = {}) => new OpenRouterEmbeddingModel(modelId, settings, {
    provider: "openrouter.embedding",
    url: ({ path }) => `${baseURL}${path}`,
    headers: getHeaders,
    fetch: options.fetch,
    extraBody: options.extraBody
  });
  const createLanguageModel = (modelId, settings) => {
    if (new.target) {
      throw new Error(
        "The OpenRouter model function cannot be called with the new keyword."
      );
    }
    if (modelId === "openai/gpt-3.5-turbo-instruct") {
      return createCompletionModel(
        modelId,
        settings
      );
    }
    return createChatModel(modelId, settings);
  };
  const provider = (modelId, settings) => createLanguageModel(modelId, settings);
  provider.languageModel = createLanguageModel;
  provider.chat = createChatModel;
  provider.completion = createCompletionModel;
  provider.textEmbeddingModel = createEmbeddingModel;
  provider.embedding = createEmbeddingModel;
  return provider;
}
createOpenRouter({
  compatibility: "strict"
  // strict for OpenRouter API
});

// src/llm/model/gateway-resolver.ts
function parseModelRouterId(routerId, gatewayPrefix) {
  if (gatewayPrefix && !routerId.startsWith(`${gatewayPrefix}/`)) {
    throw new Error(`Expected ${gatewayPrefix}/ in model router ID ${routerId}`);
  }
  const idParts = routerId.split("/");
  if (gatewayPrefix === "azure-openai") {
    if (idParts.length < 2) {
      throw new Error(`Expected format azure-openai/deployment-name, but got ${routerId}`);
    }
    return {
      providerId: "azure-openai",
      modelId: idParts.slice(1).join("/")
      // Deployment name
    };
  }
  if (gatewayPrefix && idParts.length < 3) {
    throw new Error(
      `Expected atleast 3 id parts ${gatewayPrefix}/provider/model, but only saw ${idParts.length} in ${routerId}`
    );
  }
  const providerId = idParts.at(gatewayPrefix ? 1 : 0);
  const modelId = idParts.slice(gatewayPrefix ? 2 : 1).join(`/`);
  if (!routerId.includes(`/`) || !providerId || !modelId) {
    throw new Error(
      `Attempted to parse provider/model from ${routerId} but this ID doesn't appear to contain a provider`
    );
  }
  return {
    providerId,
    modelId
  };
}

// src/llm/model/gateways/models-dev.ts
function selectApiKeyEnvVar({ envVars, providerId }) {
  const fallbackEnvVar = `${providerId.toUpperCase().replace(/-/g, "_")}_API_KEY`;
  if (!envVars?.length) return fallbackEnvVar;
  const suffixPreferences = ["_API_TOKEN", "_API_KEY", "_TOKEN", "_KEY", "_PAT"];
  for (const suffix of suffixPreferences) {
    const preferredEnvVar = envVars.find((envVar) => envVar.endsWith(suffix));
    if (preferredEnvVar) return preferredEnvVar;
  }
  return envVars[0] || fallbackEnvVar;
}
function interpolateUrlTemplate(url, envVars) {
  return url.replace(/\$\{([^}]+)\}/g, (_match, envVarName) => {
    const key = envVarName.trim();
    const value = envVars?.[key] ?? process.env[key];
    if (value === void 0 || value === null) {
      throw new Error(`Missing environment variable ${envVarName} required to build provider URL`);
    }
    return value;
  });
}
function resolveApiKeyFromEnv(apiKeyEnvVar) {
  const envVars = Array.isArray(apiKeyEnvVar) ? apiKeyEnvVar : [apiKeyEnvVar];
  for (const envVar of envVars) {
    const apiKey = process.env[envVar];
    if (apiKey) return apiKey;
  }
}
var PROVIDER_OVERRIDES = {
  google: {
    apiKeyEnvVar: ["GOOGLE_API_KEY", "GOOGLE_GENERATIVE_AI_API_KEY"]
  },
  mistral: {
    url: "https://api.mistral.ai/v1"
  },
  groq: {
    url: "https://api.groq.com/openai/v1"
  },
  // moonshotai uses Anthropic-compatible API, not OpenAI-compatible
  moonshotai: {
    url: "https://api.moonshot.ai/anthropic/v1",
    npm: "@ai-sdk/anthropic"
  },
  // moonshotai-cn (China version) also uses Anthropic-compatible API
  "moonshotai-cn": {
    url: "https://api.moonshot.cn/anthropic/v1",
    npm: "@ai-sdk/anthropic"
  }
};
var ModelsDevGateway = class extends chunkOCS2GTEN_cjs.MastraModelGateway {
  id = "models.dev";
  name = "models.dev";
  providerConfigs = {};
  attachmentCapabilities = {};
  constructor(providerConfigs) {
    super();
    if (providerConfigs) this.providerConfigs = providerConfigs;
  }
  async fetchProviders() {
    const response = await fetch("https://models.dev/api.json");
    if (!response.ok) {
      throw new Error(`Failed to fetch from models.dev: ${response.statusText}`);
    }
    const data = await response.json();
    const providerConfigs = {};
    for (const [providerId, providerInfo] of Object.entries(data)) {
      if (chunkOCS2GTEN_cjs.EXCLUDED_PROVIDERS.includes(providerId)) continue;
      if (!providerInfo || typeof providerInfo !== "object" || !providerInfo.models) continue;
      const normalizedId = providerId;
      const isOpenAICompatible = providerInfo.npm === "@ai-sdk/openai-compatible" || providerInfo.npm === "@ai-sdk/gateway" || // Vercel AI Gateway is OpenAI-compatible
      normalizedId in PROVIDER_OVERRIDES;
      const hasInstalledPackage = chunkOCS2GTEN_cjs.PROVIDERS_WITH_INSTALLED_PACKAGES.includes(providerId);
      const hasApiAndEnv = providerInfo.api && providerInfo.env && providerInfo.env.length > 0;
      if (isOpenAICompatible || hasInstalledPackage || hasApiAndEnv) {
        const activeModels = Object.entries(providerInfo.models).filter(
          ([, modelInfo]) => modelInfo?.status !== "deprecated"
        );
        const modelIds = activeModels.map(([modelId]) => modelId).sort();
        const attachmentModels = activeModels.filter(([, modelInfo]) => modelInfo?.attachment === true).map(([modelId]) => modelId).sort();
        const url = PROVIDER_OVERRIDES[normalizedId]?.url || providerInfo.api;
        if (!hasInstalledPackage && !url) {
          continue;
        }
        const apiKeyEnvVar = PROVIDER_OVERRIDES[normalizedId]?.apiKeyEnvVar || selectApiKeyEnvVar({
          envVars: providerInfo.env,
          providerId: normalizedId
        });
        const apiKeyHeader = !hasInstalledPackage ? PROVIDER_OVERRIDES[normalizedId]?.apiKeyHeader || "Authorization" : void 0;
        providerConfigs[normalizedId] = {
          url,
          apiKeyEnvVar,
          apiKeyHeader,
          name: providerInfo.name || providerId.charAt(0).toUpperCase() + providerId.slice(1),
          models: modelIds,
          docUrl: providerInfo.doc,
          // Include documentation URL if available
          gateway: `models.dev`,
          // Only store npm when it's a non-default SDK (not openai-compatible/gateway) to keep the registry small
          // Overrides take priority (e.g., moonshotai uses @ai-sdk/anthropic, not the openai-compatible listed in models.dev)
          npm: PROVIDER_OVERRIDES[normalizedId]?.npm || (providerInfo.npm && providerInfo.npm !== "@ai-sdk/openai-compatible" && providerInfo.npm !== "@ai-sdk/gateway" ? providerInfo.npm : void 0)
        };
        if (attachmentModels.length > 0) {
          this.attachmentCapabilities[normalizedId] = attachmentModels;
        }
      }
    }
    this.providerConfigs = providerConfigs;
    return providerConfigs;
  }
  /**
   * Return attachment capabilities collected during the last `fetchProviders()` call.
   * Maps provider ID → list of model IDs that support attachments.
   */
  getAttachmentCapabilities() {
    return this.attachmentCapabilities;
  }
  buildUrl(routerId, envVars) {
    const { providerId } = parseModelRouterId(routerId);
    const config = this.providerConfigs[providerId];
    if (!config?.url) {
      return;
    }
    const baseUrlEnvVar = `${providerId.toUpperCase().replace(/-/g, "_")}_BASE_URL`;
    const customBaseUrl = envVars?.[baseUrlEnvVar] || process.env[baseUrlEnvVar];
    return customBaseUrl || interpolateUrlTemplate(config.url, envVars);
  }
  getApiKey(modelId) {
    const [provider, model] = modelId.split("/");
    if (!provider || !model) {
      throw new Error(`Could not identify provider from model id ${modelId}`);
    }
    const config = this.providerConfigs[provider];
    if (!config) {
      throw new Error(`Could not find config for provider ${provider} with model id ${modelId}`);
    }
    const apiKey = resolveApiKeyFromEnv(config.apiKeyEnvVar);
    if (!apiKey) {
      const envVarDisplay = Array.isArray(config.apiKeyEnvVar) ? config.apiKeyEnvVar.join(" or ") : config.apiKeyEnvVar;
      throw new Error(`Could not find API key process.env.${envVarDisplay} for model id ${modelId}`);
    }
    return Promise.resolve(apiKey);
  }
  async resolveLanguageModel({
    modelId,
    providerId,
    apiKey,
    headers
  }) {
    const baseURL = this.buildUrl(`${providerId}/${modelId}`);
    const mastraHeaders = { "User-Agent": chunkOCS2GTEN_cjs.MASTRA_USER_AGENT, ...headers };
    switch (providerId) {
      case "openai":
        return chunkOCS2GTEN_cjs.createOpenAI({ apiKey, baseURL, headers: mastraHeaders }).responses(modelId);
      case "gemini":
      case "google":
        return chunkOCS2GTEN_cjs.createGoogleGenerativeAI({ apiKey, baseURL, headers: mastraHeaders }).chat(modelId);
      case "anthropic":
        return chunkOCS2GTEN_cjs.createAnthropic({ apiKey, baseURL, headers: mastraHeaders })(modelId);
      case "mistral":
        return createMistral({ apiKey, baseURL, headers: mastraHeaders })(modelId);
      case "groq":
        return createGroq({ apiKey, baseURL, headers: mastraHeaders })(modelId);
      case "openrouter":
        return createOpenRouter({ apiKey, baseURL, headers: mastraHeaders })(
          modelId
        );
      case "xai":
        return createXai({ apiKey, baseURL, headers: mastraHeaders })(modelId);
      case "deepseek":
        return createDeepSeek({ apiKey, baseURL, headers: mastraHeaders })(modelId);
      case "perplexity":
        return createPerplexity({ apiKey, baseURL, headers: mastraHeaders })(modelId);
      case "cerebras":
        return createCerebras({ apiKey, baseURL, headers: mastraHeaders })(modelId);
      case "togetherai":
        return createTogetherAI({ apiKey, baseURL, headers: mastraHeaders })(modelId);
      case "deepinfra":
        return createDeepInfra({ apiKey, baseURL, headers: mastraHeaders })(modelId);
      case "vercel":
        return chunk4SCYX53T_cjs.createGatewayProvider({ apiKey, baseURL, headers: mastraHeaders })(modelId);
      case "moonshotai":
      case "moonshotai-cn": {
        if (!baseURL) throw new Error(`No API URL found for ${providerId}/${modelId}`);
        return chunkOCS2GTEN_cjs.createAnthropic({ apiKey, baseURL, headers: mastraHeaders })(modelId);
      }
      default: {
        const config = this.providerConfigs[providerId];
        const npm = config?.npm;
        if (providerId.includes("alibaba")) {
          if (!baseURL) throw new Error(`No API URL found for ${providerId}/${modelId}`);
          return createAlibaba({ apiKey, baseURL, headers: mastraHeaders })(modelId);
        }
        if (npm === "@ai-sdk/anthropic") {
          if (!baseURL) throw new Error(`No API URL found for ${providerId}/${modelId}`);
          return chunkOCS2GTEN_cjs.createAnthropic({ apiKey, baseURL, headers: mastraHeaders })(modelId);
        }
        if (npm === "@ai-sdk/openai") {
          if (!baseURL) throw new Error(`No API URL found for ${providerId}/${modelId}`);
          return chunkOCS2GTEN_cjs.createOpenAI({ apiKey, baseURL, headers: mastraHeaders }).chat(modelId);
        }
        if (npm === "@ai-sdk/google") {
          if (!baseURL) throw new Error(`No API URL found for ${providerId}/${modelId}`);
          return chunkOCS2GTEN_cjs.createGoogleGenerativeAI({ apiKey, baseURL, headers: mastraHeaders }).chat(modelId);
        }
        if (npm === "@ai-sdk/mistral") {
          if (!baseURL) throw new Error(`No API URL found for ${providerId}/${modelId}`);
          return createMistral({ apiKey, baseURL, headers: mastraHeaders })(modelId);
        }
        if (!baseURL) throw new Error(`No API URL found for ${providerId}/${modelId}`);
        return chunkOCS2GTEN_cjs.createOpenAICompatible({
          name: providerId,
          apiKey,
          baseURL,
          headers: mastraHeaders,
          supportsStructuredOutputs: true
        }).chatModel(modelId);
      }
    }
  }
};

exports.ModelsDevGateway = ModelsDevGateway;
exports.createOpenRouter = createOpenRouter;
exports.parseModelRouterId = parseModelRouterId;
//# sourceMappingURL=chunk-DBTKQ3U2.cjs.map
//# sourceMappingURL=chunk-DBTKQ3U2.cjs.map