ai/dist/index.js

AI SDK by Vercel - build apps like ChatGPT, Claude, Gemini, and more with a single interface for any model using the Vercel AI Gateway or go direct to OpenAI, Anthropic, Google, or any other model provider.

var __defProp = Object.defineProperty;
var __export = (target, all) => {
  for (var name22 in all)
    __defProp(target, name22, { get: all[name22], enumerable: true });
};

// src/index.ts
import { createGateway, gateway as gateway2 } from "@ai-sdk/gateway";
import {
  asSchema as asSchema8,
  createIdGenerator as createIdGenerator9,
  dynamicTool,
  generateId,
  jsonSchema,
  parseJsonEventStream as parseJsonEventStream3,
  tool,
  zodSchema as zodSchema3
} from "@ai-sdk/provider-utils";

// src/agent/tool-loop-agent.ts
import {
  validateTypes as validateTypes3,
  withUserAgentSuffix as withUserAgentSuffix3
} from "@ai-sdk/provider-utils";

// src/generate-text/generate-text.ts
import {
  asArray as asArray5,
  createIdGenerator,
  getErrorMessage as getErrorMessage4,
  withUserAgentSuffix as withUserAgentSuffix2
} from "@ai-sdk/provider-utils";

// src/error/index.ts
import {
  AISDKError as AISDKError22,
  APICallError,
  EmptyResponseBodyError,
  InvalidPromptError,
  InvalidResponseDataError,
  JSONParseError,
  LoadAPIKeyError,
  LoadSettingError,
  NoContentGeneratedError,
  NoSuchModelError,
  NoSuchProviderReferenceError,
  TooManyEmbeddingValuesForCallError,
  TypeValidationError,
  UnsupportedFunctionalityError
} from "@ai-sdk/provider";

// src/error/invalid-argument-error.ts
import { AISDKError } from "@ai-sdk/provider";
var name = "AI_InvalidArgumentError";
var marker = `vercel.ai.error.${name}`;
var symbol = Symbol.for(marker);
var _a;
var InvalidArgumentError = class extends AISDKError {
  constructor({
    parameter,
    value,
    message
  }) {
    super({
      name,
      message: `Invalid argument for parameter ${parameter}: ${message}`
    });
    this[_a] = true;
    this.parameter = parameter;
    this.value = value;
  }
  static isInstance(error) {
    return AISDKError.hasMarker(error, marker);
  }
};
_a = symbol;

// src/error/invalid-stream-part-error.ts
import { AISDKError as AISDKError2 } from "@ai-sdk/provider";
var name2 = "AI_InvalidStreamPartError";
var marker2 = `vercel.ai.error.${name2}`;
var symbol2 = Symbol.for(marker2);
var _a2;
var InvalidStreamPartError = class extends AISDKError2 {
  constructor({
    chunk,
    message
  }) {
    super({ name: name2, message });
    this[_a2] = true;
    this.chunk = chunk;
  }
  static isInstance(error) {
    return AISDKError2.hasMarker(error, marker2);
  }
};
_a2 = symbol2;

// src/error/invalid-tool-approval-error.ts
import { AISDKError as AISDKError3 } from "@ai-sdk/provider";
var name3 = "AI_InvalidToolApprovalError";
var marker3 = `vercel.ai.error.${name3}`;
var symbol3 = Symbol.for(marker3);
var _a3;
var InvalidToolApprovalError = class extends AISDKError3 {
  constructor({ approvalId }) {
    super({
      name: name3,
      message: `Tool approval response references unknown approvalId: "${approvalId}". No matching tool-approval-request found in message history.`
    });
    this[_a3] = true;
    this.approvalId = approvalId;
  }
  static isInstance(error) {
    return AISDKError3.hasMarker(error, marker3);
  }
};
_a3 = symbol3;

// src/error/invalid-tool-approval-signature-error.ts
import { AISDKError as AISDKError4 } from "@ai-sdk/provider";
var name4 = "AI_InvalidToolApprovalSignatureError";
var marker4 = `vercel.ai.error.${name4}`;
var symbol4 = Symbol.for(marker4);
var _a4;
var InvalidToolApprovalSignatureError = class extends AISDKError4 {
  constructor({
    approvalId,
    toolCallId,
    reason
  }) {
    super({
      name: name4,
      message: `Tool approval signature verification failed for approval "${approvalId}" (tool call "${toolCallId}"): ${reason}`
    });
    this[_a4] = true;
    this.approvalId = approvalId;
    this.toolCallId = toolCallId;
  }
  static isInstance(error) {
    return AISDKError4.hasMarker(error, marker4);
  }
};
_a4 = symbol4;

// src/error/invalid-tool-input-error.ts
import { AISDKError as AISDKError5, getErrorMessage } from "@ai-sdk/provider";
var name5 = "AI_InvalidToolInputError";
var marker5 = `vercel.ai.error.${name5}`;
var symbol5 = Symbol.for(marker5);
var _a5;
var InvalidToolInputError = class extends AISDKError5 {
  constructor({
    toolInput,
    toolName,
    cause,
    message = `Invalid input for tool ${toolName}: ${getErrorMessage(cause)}`
  }) {
    super({ name: name5, message, cause });
    this[_a5] = true;
    this.toolInput = toolInput;
    this.toolName = toolName;
  }
  static isInstance(error) {
    return AISDKError5.hasMarker(error, marker5);
  }
};
_a5 = symbol5;

// src/error/tool-call-not-found-for-approval-error.ts
import { AISDKError as AISDKError6 } from "@ai-sdk/provider";
var name6 = "AI_ToolCallNotFoundForApprovalError";
var marker6 = `vercel.ai.error.${name6}`;
var symbol6 = Symbol.for(marker6);
var _a6;
var ToolCallNotFoundForApprovalError = class extends AISDKError6 {
  constructor({
    toolCallId,
    approvalId
  }) {
    super({
      name: name6,
      message: `Tool call "${toolCallId}" not found for approval request "${approvalId}".`
    });
    this[_a6] = true;
    this.toolCallId = toolCallId;
    this.approvalId = approvalId;
  }
  static isInstance(error) {
    return AISDKError6.hasMarker(error, marker6);
  }
};
_a6 = symbol6;

// src/error/missing-tool-result-error.ts
import { AISDKError as AISDKError7 } from "@ai-sdk/provider";
var name7 = "AI_MissingToolResultsError";
var marker7 = `vercel.ai.error.${name7}`;
var symbol7 = Symbol.for(marker7);
var _a7;
var MissingToolResultsError = class extends AISDKError7 {
  constructor({ toolCallIds }) {
    super({
      name: name7,
      message: `Tool result${toolCallIds.length > 1 ? "s are" : " is"} missing for tool call${toolCallIds.length > 1 ? "s" : ""} ${toolCallIds.join(
        ", "
      )}.`
    });
    this[_a7] = true;
    this.toolCallIds = toolCallIds;
  }
  static isInstance(error) {
    return AISDKError7.hasMarker(error, marker7);
  }
};
_a7 = symbol7;

// src/error/no-image-generated-error.ts
import { AISDKError as AISDKError8 } from "@ai-sdk/provider";
var name8 = "AI_NoImageGeneratedError";
var marker8 = `vercel.ai.error.${name8}`;
var symbol8 = Symbol.for(marker8);
var _a8;
var NoImageGeneratedError = class extends AISDKError8 {
  constructor({
    message = "No image generated.",
    cause,
    responses
  }) {
    super({ name: name8, message, cause });
    this[_a8] = true;
    this.responses = responses;
  }
  static isInstance(error) {
    return AISDKError8.hasMarker(error, marker8);
  }
};
_a8 = symbol8;

// src/error/no-object-generated-error.ts
import { AISDKError as AISDKError9 } from "@ai-sdk/provider";
var name9 = "AI_NoObjectGeneratedError";
var marker9 = `vercel.ai.error.${name9}`;
var symbol9 = Symbol.for(marker9);
var _a9;
var NoObjectGeneratedError = class extends AISDKError9 {
  constructor({
    message = "No object generated.",
    cause,
    text: text2,
    response,
    usage,
    finishReason
  }) {
    super({ name: name9, message, cause });
    this[_a9] = true;
    this.text = text2;
    this.response = response;
    this.usage = usage;
    this.finishReason = finishReason;
  }
  static isInstance(error) {
    return AISDKError9.hasMarker(error, marker9);
  }
};
_a9 = symbol9;

// src/error/no-output-generated-error.ts
import { AISDKError as AISDKError10 } from "@ai-sdk/provider";
var name10 = "AI_NoOutputGeneratedError";
var marker10 = `vercel.ai.error.${name10}`;
var symbol10 = Symbol.for(marker10);
var _a10;
var NoOutputGeneratedError = class extends AISDKError10 {
  // used in isInstance
  constructor({
    message = "No output generated.",
    cause
  } = {}) {
    super({ name: name10, message, cause });
    this[_a10] = true;
  }
  static isInstance(error) {
    return AISDKError10.hasMarker(error, marker10);
  }
};
_a10 = symbol10;

// src/error/no-speech-generated-error.ts
import { AISDKError as AISDKError11 } from "@ai-sdk/provider";
var name11 = "AI_NoSpeechGeneratedError";
var marker11 = `vercel.ai.error.${name11}`;
var symbol11 = Symbol.for(marker11);
var _a11;
var NoSpeechGeneratedError = class extends AISDKError11 {
  constructor(options) {
    super({
      name: name11,
      message: "No speech audio generated."
    });
    this[_a11] = true;
    this.responses = options.responses;
  }
  static isInstance(error) {
    return AISDKError11.hasMarker(error, marker11);
  }
};
_a11 = symbol11;

// src/error/no-transcript-generated-error.ts
import { AISDKError as AISDKError12 } from "@ai-sdk/provider";
var name12 = "AI_NoTranscriptGeneratedError";
var marker12 = `vercel.ai.error.${name12}`;
var symbol12 = Symbol.for(marker12);
var _a12;
var NoTranscriptGeneratedError = class extends AISDKError12 {
  constructor(options) {
    super({
      name: name12,
      message: "No transcript generated."
    });
    this[_a12] = true;
    this.responses = options.responses;
  }
  static isInstance(error) {
    return AISDKError12.hasMarker(error, marker12);
  }
};
_a12 = symbol12;

// src/error/no-video-generated-error.ts
import { AISDKError as AISDKError13 } from "@ai-sdk/provider";
var name13 = "AI_NoVideoGeneratedError";
var marker13 = `vercel.ai.error.${name13}`;
var symbol13 = Symbol.for(marker13);
var _a13;
var NoVideoGeneratedError = class extends AISDKError13 {
  constructor({
    message = "No video generated.",
    cause,
    responses
  }) {
    super({ name: name13, message, cause });
    this[_a13] = true;
    this.responses = responses;
  }
  static isInstance(error) {
    return AISDKError13.hasMarker(error, marker13);
  }
  /**
   * @deprecated use `isInstance` instead
   */
  static isNoVideoGeneratedError(error) {
    return error instanceof Error && error.name === name13 && typeof error.responses !== "undefined" ? true : false;
  }
  /**
   * @deprecated Do not use this method. It will be removed in the next major version.
   */
  toJSON() {
    return {
      name: this.name,
      message: this.message,
      stack: this.stack,
      cause: this.cause,
      responses: this.responses
    };
  }
};
_a13 = symbol13;

// src/error/no-such-tool-error.ts
import { AISDKError as AISDKError14 } from "@ai-sdk/provider";
var name14 = "AI_NoSuchToolError";
var marker14 = `vercel.ai.error.${name14}`;
var symbol14 = Symbol.for(marker14);
var _a14;
var NoSuchToolError = class extends AISDKError14 {
  constructor({
    toolName,
    availableTools = void 0,
    message = `Model tried to call unavailable tool '${toolName}'. ${availableTools === void 0 ? "No tools are available." : `Available tools: ${availableTools.join(", ")}.`}`
  }) {
    super({ name: name14, message });
    this[_a14] = true;
    this.toolName = toolName;
    this.availableTools = availableTools;
  }
  static isInstance(error) {
    return AISDKError14.hasMarker(error, marker14);
  }
};
_a14 = symbol14;

// src/error/tool-call-repair-error.ts
import { AISDKError as AISDKError15, getErrorMessage as getErrorMessage2 } from "@ai-sdk/provider";
var name15 = "AI_ToolCallRepairError";
var marker15 = `vercel.ai.error.${name15}`;
var symbol15 = Symbol.for(marker15);
var _a15;
var ToolCallRepairError = class extends AISDKError15 {
  constructor({
    cause,
    originalError,
    message = `Error repairing tool call: ${getErrorMessage2(cause)}`
  }) {
    super({ name: name15, message, cause });
    this[_a15] = true;
    this.originalError = originalError;
  }
  static isInstance(error) {
    return AISDKError15.hasMarker(error, marker15);
  }
};
_a15 = symbol15;

// src/error/unsupported-model-version-error.ts
import { AISDKError as AISDKError16 } from "@ai-sdk/provider";
var UnsupportedModelVersionError = class extends AISDKError16 {
  constructor(options) {
    super({
      name: "AI_UnsupportedModelVersionError",
      message: `Unsupported model version ${options.version} for provider "${options.provider}" and model "${options.modelId}". AI SDK 5 only supports models that implement specification version "v2".`
    });
    this.version = options.version;
    this.provider = options.provider;
    this.modelId = options.modelId;
  }
};

// src/error/ui-message-stream-error.ts
import { AISDKError as AISDKError17 } from "@ai-sdk/provider";
var name16 = "AI_UIMessageStreamError";
var marker16 = `vercel.ai.error.${name16}`;
var symbol16 = Symbol.for(marker16);
var _a16;
var UIMessageStreamError = class extends AISDKError17 {
  constructor({
    chunkType,
    chunkId,
    message
  }) {
    super({ name: name16, message });
    this[_a16] = true;
    this.chunkType = chunkType;
    this.chunkId = chunkId;
  }
  static isInstance(error) {
    return AISDKError17.hasMarker(error, marker16);
  }
};
_a16 = symbol16;

// src/prompt/invalid-data-content-error.ts
import { AISDKError as AISDKError18 } from "@ai-sdk/provider";
var name17 = "AI_InvalidDataContentError";
var marker17 = `vercel.ai.error.${name17}`;
var symbol17 = Symbol.for(marker17);
var _a17;
var InvalidDataContentError = class extends AISDKError18 {
  constructor({
    content,
    cause,
    message = `Invalid data content. Expected a base64 string, Uint8Array, ArrayBuffer, or Buffer, but got ${typeof content}.`
  }) {
    super({ name: name17, message, cause });
    this[_a17] = true;
    this.content = content;
  }
  static isInstance(error) {
    return AISDKError18.hasMarker(error, marker17);
  }
};
_a17 = symbol17;

// src/prompt/invalid-message-role-error.ts
import { AISDKError as AISDKError19 } from "@ai-sdk/provider";
var name18 = "AI_InvalidMessageRoleError";
var marker18 = `vercel.ai.error.${name18}`;
var symbol18 = Symbol.for(marker18);
var _a18;
var InvalidMessageRoleError = class extends AISDKError19 {
  constructor({
    role,
    message = `Invalid message role: '${role}'. Must be one of: "system", "user", "assistant", "tool".`
  }) {
    super({ name: name18, message });
    this[_a18] = true;
    this.role = role;
  }
  static isInstance(error) {
    return AISDKError19.hasMarker(error, marker18);
  }
};
_a18 = symbol18;

// src/prompt/message-conversion-error.ts
import { AISDKError as AISDKError20 } from "@ai-sdk/provider";
var name19 = "AI_MessageConversionError";
var marker19 = `vercel.ai.error.${name19}`;
var symbol19 = Symbol.for(marker19);
var _a19;
var MessageConversionError = class extends AISDKError20 {
  constructor({
    originalMessage,
    message
  }) {
    super({ name: name19, message });
    this[_a19] = true;
    this.originalMessage = originalMessage;
  }
  static isInstance(error) {
    return AISDKError20.hasMarker(error, marker19);
  }
};
_a19 = symbol19;

// src/error/index.ts
import { DownloadError } from "@ai-sdk/provider-utils";

// src/util/retry-error.ts
import { AISDKError as AISDKError21 } from "@ai-sdk/provider";
var name20 = "AI_RetryError";
var marker20 = `vercel.ai.error.${name20}`;
var symbol20 = Symbol.for(marker20);
var _a20;
var RetryError = class extends AISDKError21 {
  constructor({
    message,
    reason,
    errors
  }) {
    super({ name: name20, message });
    this[_a20] = true;
    this.reason = reason;
    this.errors = errors;
    this.lastError = errors[errors.length - 1];
  }
  static isInstance(error) {
    return AISDKError21.hasMarker(error, marker20);
  }
};
_a20 = symbol20;

// src/logger/log-warnings.ts
function formatWarning({
  warning,
  provider,
  model
}) {
  const scope = provider != null && model != null ? ` (${provider} / ${model})` : "";
  const prefix = `AI SDK Warning${scope}:`;
  switch (warning.type) {
    case "unsupported": {
      let message = `${prefix} The feature "${warning.feature}" is not supported.`;
      if (warning.details) {
        message += ` ${warning.details}`;
      }
      return message;
    }
    case "compatibility": {
      let message = `${prefix} The feature "${warning.feature}" is used in a compatibility mode.`;
      if (warning.details) {
        message += ` ${warning.details}`;
      }
      return message;
    }
    case "deprecated": {
      return `${prefix} Deprecated: "${warning.setting}". ${warning.message}`;
    }
    case "other": {
      return `${prefix} ${warning.message}`;
    }
    default: {
      return `${prefix} ${JSON.stringify(warning, null, 2)}`;
    }
  }
}
var FIRST_WARNING_INFO_MESSAGE = "AI SDK Warning System: To turn off warning logging, set the AI_SDK_LOG_WARNINGS global to false.";
var hasLoggedBefore = false;
var logWarnings = (options) => {
  if (options.warnings.length === 0) {
    return;
  }
  const logger = globalThis.AI_SDK_LOG_WARNINGS;
  if (logger === false) {
    return;
  }
  if (typeof logger === "function") {
    logger(options);
    return;
  }
  if (!hasLoggedBefore) {
    hasLoggedBefore = true;
    console.info(FIRST_WARNING_INFO_MESSAGE);
  }
  for (const warning of options.warnings) {
    const message = formatWarning({
      warning,
      provider: options.provider,
      model: options.model
    });
    if (typeof process !== "undefined" && typeof process.emitWarning === "function") {
      process.emitWarning(message, {
        type: warning.type === "deprecated" ? "DeprecationWarning" : "Warning"
      });
    } else {
      console.warn(message);
    }
  }
};

// src/model/resolve-model.ts
import { gateway } from "@ai-sdk/gateway";

// src/util/log-v2-compatibility-warning.ts
function logV2CompatibilityWarning({
  provider,
  modelId
}) {
  logWarnings({
    warnings: [
      {
        type: "compatibility",
        feature: "specificationVersion",
        details: `Using v2 specification compatibility mode. Some features may not be available.`
      }
    ],
    provider,
    model: modelId
  });
}

// src/model/as-embedding-model-v3.ts
function asEmbeddingModelV3(model) {
  if (model.specificationVersion === "v3") {
    return model;
  }
  logV2CompatibilityWarning({
    provider: model.provider,
    modelId: model.modelId
  });
  return new Proxy(model, {
    get(target, prop) {
      if (prop === "specificationVersion")
        return "v3";
      return target[prop];
    }
  });
}

// src/model/as-embedding-model-v4.ts
function asEmbeddingModelV4(model) {
  if (model.specificationVersion === "v4") {
    return model;
  }
  const v3Model = model.specificationVersion === "v2" ? asEmbeddingModelV3(model) : model;
  return new Proxy(v3Model, {
    get(target, prop) {
      if (prop === "specificationVersion")
        return "v4";
      return target[prop];
    }
  });
}

// src/model/as-image-model-v3.ts
function asImageModelV3(model) {
  if (model.specificationVersion === "v3") {
    return model;
  }
  logV2CompatibilityWarning({
    provider: model.provider,
    modelId: model.modelId
  });
  return new Proxy(model, {
    get(target, prop) {
      if (prop === "specificationVersion")
        return "v3";
      return target[prop];
    }
  });
}

// src/model/as-image-model-v4.ts
function asImageModelV4(model) {
  if (model.specificationVersion === "v4") {
    return model;
  }
  const v3Model = model.specificationVersion === "v2" ? asImageModelV3(model) : model;
  return new Proxy(v3Model, {
    get(target, prop) {
      if (prop === "specificationVersion")
        return "v4";
      return target[prop];
    }
  });
}

// src/model/as-language-model-v3.ts
function asLanguageModelV3(model) {
  if (model.specificationVersion === "v3") {
    return model;
  }
  logV2CompatibilityWarning({
    provider: model.provider,
    modelId: model.modelId
  });
  return new Proxy(model, {
    get(target, prop) {
      switch (prop) {
        case "specificationVersion":
          return "v3";
        case "doGenerate":
          return async (...args) => {
            const result = await target.doGenerate(...args);
            return {
              ...result,
              finishReason: convertV2FinishReasonToV3(result.finishReason),
              usage: convertV2UsageToV3(result.usage)
            };
          };
        case "doStream":
          return async (...args) => {
            const result = await target.doStream(...args);
            return {
              ...result,
              stream: convertV2StreamToV3(result.stream)
            };
          };
        default:
          return target[prop];
      }
    }
  });
}
function convertV2StreamToV3(stream) {
  return stream.pipeThrough(
    new TransformStream({
      transform(chunk, controller) {
        switch (chunk.type) {
          case "finish":
            controller.enqueue({
              ...chunk,
              finishReason: convertV2FinishReasonToV3(chunk.finishReason),
              usage: convertV2UsageToV3(chunk.usage)
            });
            break;
          default:
            controller.enqueue(chunk);
            break;
        }
      }
    })
  );
}
function convertV2FinishReasonToV3(finishReason) {
  return {
    unified: finishReason === "unknown" ? "other" : finishReason,
    raw: void 0
  };
}
function convertV2UsageToV3(usage) {
  return {
    inputTokens: {
      total: usage.inputTokens,
      noCache: void 0,
      cacheRead: usage.cachedInputTokens,
      cacheWrite: void 0
    },
    outputTokens: {
      total: usage.outputTokens,
      text: void 0,
      reasoning: usage.reasoningTokens
    }
  };
}

// src/model/as-language-model-v4.ts
function asLanguageModelV4(model) {
  if (model.specificationVersion === "v4") {
    return model;
  }
  const v3Model = model.specificationVersion === "v2" ? asLanguageModelV3(model) : model;
  return new Proxy(v3Model, {
    get(target, prop) {
      if (prop === "specificationVersion")
        return "v4";
      return target[prop];
    }
  });
}

// src/model/as-reranking-model-v4.ts
function asRerankingModelV4(model) {
  if (model.specificationVersion === "v4") {
    return model;
  }
  return new Proxy(model, {
    get(target, prop) {
      if (prop === "specificationVersion")
        return "v4";
      return target[prop];
    }
  });
}

// src/model/as-speech-model-v3.ts
function asSpeechModelV3(model) {
  if (model.specificationVersion === "v3") {
    return model;
  }
  logV2CompatibilityWarning({
    provider: model.provider,
    modelId: model.modelId
  });
  return new Proxy(model, {
    get(target, prop) {
      if (prop === "specificationVersion")
        return "v3";
      return target[prop];
    }
  });
}

// src/model/as-speech-model-v4.ts
function asSpeechModelV4(model) {
  if (model.specificationVersion === "v4") {
    return model;
  }
  const v3Model = model.specificationVersion === "v2" ? asSpeechModelV3(model) : model;
  return new Proxy(v3Model, {
    get(target, prop) {
      if (prop === "specificationVersion")
        return "v4";
      return target[prop];
    }
  });
}

// src/model/as-transcription-model-v3.ts
function asTranscriptionModelV3(model) {
  if (model.specificationVersion === "v3") {
    return model;
  }
  logV2CompatibilityWarning({
    provider: model.provider,
    modelId: model.modelId
  });
  return new Proxy(model, {
    get(target, prop) {
      if (prop === "specificationVersion")
        return "v3";
      return target[prop];
    }
  });
}

// src/model/as-transcription-model-v4.ts
function asTranscriptionModelV4(model) {
  if (model.specificationVersion === "v4") {
    return model;
  }
  const v3Model = model.specificationVersion === "v2" ? asTranscriptionModelV3(model) : model;
  return new Proxy(v3Model, {
    get(target, prop) {
      if (prop === "specificationVersion")
        return "v4";
      return target[prop];
    }
  });
}

// src/model/as-video-model-v4.ts
function asVideoModelV4(model) {
  if (model.specificationVersion === "v4") {
    return model;
  }
  return new Proxy(model, {
    get(target, prop) {
      if (prop === "specificationVersion")
        return "v4";
      return target[prop];
    }
  });
}

// src/model/as-provider-v3.ts
function asProviderV3(provider) {
  if ("specificationVersion" in provider && provider.specificationVersion === "v3") {
    return provider;
  }
  const v2Provider = provider;
  return {
    specificationVersion: "v3",
    languageModel: (modelId) => asLanguageModelV3(v2Provider.languageModel(modelId)),
    embeddingModel: (modelId) => asEmbeddingModelV3(v2Provider.textEmbeddingModel(modelId)),
    imageModel: (modelId) => asImageModelV3(v2Provider.imageModel(modelId)),
    transcriptionModel: v2Provider.transcriptionModel ? (modelId) => asTranscriptionModelV3(v2Provider.transcriptionModel(modelId)) : void 0,
    speechModel: v2Provider.speechModel ? (modelId) => asSpeechModelV3(v2Provider.speechModel(modelId)) : void 0,
    rerankingModel: void 0
    // v2 providers don't have reranking models
  };
}

// src/model/as-provider-v4.ts
function asProviderV4(provider) {
  if ("specificationVersion" in provider && provider.specificationVersion === "v4") {
    return provider;
  }
  const v3Provider = !("specificationVersion" in provider) || provider.specificationVersion !== "v3" ? asProviderV3(provider) : provider;
  return {
    specificationVersion: "v4",
    languageModel: (modelId) => asLanguageModelV4(v3Provider.languageModel(modelId)),
    embeddingModel: (modelId) => asEmbeddingModelV4(v3Provider.embeddingModel(modelId)),
    imageModel: (modelId) => asImageModelV4(v3Provider.imageModel(modelId)),
    transcriptionModel: v3Provider.transcriptionModel ? (modelId) => asTranscriptionModelV4(v3Provider.transcriptionModel(modelId)) : void 0,
    speechModel: v3Provider.speechModel ? (modelId) => asSpeechModelV4(v3Provider.speechModel(modelId)) : void 0,
    rerankingModel: v3Provider.rerankingModel ? (modelId) => asRerankingModelV4(v3Provider.rerankingModel(modelId)) : void 0
  };
}

// src/model/resolve-model.ts
function resolveLanguageModel(model) {
  if (typeof model === "string") {
    return getGlobalProvider().languageModel(model);
  }
  if (!["v4", "v3", "v2"].includes(model.specificationVersion)) {
    const unsupportedModel = model;
    throw new UnsupportedModelVersionError({
      version: unsupportedModel.specificationVersion,
      provider: unsupportedModel.provider,
      modelId: unsupportedModel.modelId
    });
  }
  return asLanguageModelV4(model);
}
function resolveEmbeddingModel(model) {
  if (typeof model === "string") {
    return getGlobalProvider().embeddingModel(model);
  }
  if (!["v4", "v3", "v2"].includes(model.specificationVersion)) {
    const unsupportedModel = model;
    throw new UnsupportedModelVersionError({
      version: unsupportedModel.specificationVersion,
      provider: unsupportedModel.provider,
      modelId: unsupportedModel.modelId
    });
  }
  return asEmbeddingModelV4(model);
}
function resolveTranscriptionModel(model) {
  var _a22, _b;
  if (typeof model === "string") {
    return (_b = (_a22 = getGlobalProvider()).transcriptionModel) == null ? void 0 : _b.call(_a22, model);
  }
  if (!["v4", "v3", "v2"].includes(model.specificationVersion)) {
    const unsupportedModel = model;
    throw new UnsupportedModelVersionError({
      version: unsupportedModel.specificationVersion,
      provider: unsupportedModel.provider,
      modelId: unsupportedModel.modelId
    });
  }
  return asTranscriptionModelV4(model);
}
function resolveSpeechModel(model) {
  var _a22, _b;
  if (typeof model === "string") {
    return (_b = (_a22 = getGlobalProvider()).speechModel) == null ? void 0 : _b.call(_a22, model);
  }
  if (!["v4", "v3", "v2"].includes(model.specificationVersion)) {
    const unsupportedModel = model;
    throw new UnsupportedModelVersionError({
      version: unsupportedModel.specificationVersion,
      provider: unsupportedModel.provider,
      modelId: unsupportedModel.modelId
    });
  }
  return asSpeechModelV4(model);
}
function resolveImageModel(model) {
  if (typeof model === "string") {
    return getGlobalProvider().imageModel(model);
  }
  if (!["v4", "v3", "v2"].includes(model.specificationVersion)) {
    const unsupportedModel = model;
    throw new UnsupportedModelVersionError({
      version: unsupportedModel.specificationVersion,
      provider: unsupportedModel.provider,
      modelId: unsupportedModel.modelId
    });
  }
  return asImageModelV4(model);
}
function resolveVideoModel(model) {
  var _a22;
  if (typeof model === "string") {
    const provider = (_a22 = globalThis.AI_SDK_DEFAULT_PROVIDER) != null ? _a22 : gateway;
    const videoModel = provider.videoModel;
    if (!videoModel) {
      throw new Error(
        'The default provider does not support video models. Please use a Experimental_VideoModelV4 object from a provider (e.g., vertex.video("model-id")).'
      );
    }
    return videoModel(model);
  }
  if (!["v4", "v3"].includes(model.specificationVersion)) {
    const unsupportedModel = model;
    throw new UnsupportedModelVersionError({
      version: unsupportedModel.specificationVersion,
      provider: unsupportedModel.provider,
      modelId: unsupportedModel.modelId
    });
  }
  return asVideoModelV4(model);
}
function resolveRerankingModel(model) {
  if (typeof model === "string") {
    const provider = getGlobalProvider();
    const rerankingModel = provider.rerankingModel;
    if (!rerankingModel) {
      throw new Error(
        'The default provider does not support reranking models. Please use a RerankingModel object from a provider (e.g., gateway.rerankingModel("model-id")).'
      );
    }
    return rerankingModel(model);
  }
  if (model.specificationVersion !== "v4" && model.specificationVersion !== "v3") {
    const unsupportedModel = model;
    throw new UnsupportedModelVersionError({
      version: unsupportedModel.specificationVersion,
      provider: unsupportedModel.provider,
      modelId: unsupportedModel.modelId
    });
  }
  return asRerankingModelV4(model);
}
function getGlobalProvider() {
  var _a22;
  const provider = (_a22 = globalThis.AI_SDK_DEFAULT_PROVIDER) != null ? _a22 : gateway;
  return asProviderV4(provider);
}

// src/prompt/clone-model-message.ts
function cloneModelMessages(messages) {
  return messages.map((message) => cloneValue(message));
}
function cloneValue(value) {
  if (value instanceof URL) {
    return new URL(value.href);
  }
  if (Array.isArray(value)) {
    return value.map((item) => cloneValue(item));
  }
  if (value instanceof Uint8Array) {
    return new Uint8Array(value);
  }
  if (value instanceof ArrayBuffer) {
    return value.slice(0);
  }
  if (value instanceof Date) {
    return new Date(value);
  }
  if (value != null && typeof value === "object") {
    return Object.fromEntries(
      Object.entries(value).map(([key, value2]) => [key, cloneValue(value2)])
    );
  }
  return value;
}

// src/prompt/convert-to-language-model-prompt.ts
import {
  asArray,
  detectMediaType,
  isFullMediaType,
  isUrlSupported
} from "@ai-sdk/provider-utils";

// src/util/download/download.ts
import {
  cancelResponseBody,
  DownloadError as DownloadError2,
  readResponseWithSizeLimit,
  DEFAULT_MAX_DOWNLOAD_SIZE,
  fetchWithValidatedRedirects,
  withUserAgentSuffix,
  getRuntimeEnvironmentUserAgent
} from "@ai-sdk/provider-utils";

// src/version.ts
var VERSION = true ? "7.0.22" : "0.0.0-test";

// src/util/download/download.ts
var download = async ({
  url,
  maxBytes,
  abortSignal
}) => {
  var _a22;
  const urlText = url.toString();
  try {
    const headers = withUserAgentSuffix(
      {},
      `ai-sdk/${VERSION}`,
      getRuntimeEnvironmentUserAgent()
    );
    const response = await fetchWithValidatedRedirects({
      url: urlText,
      headers,
      abortSignal
    });
    if (!response.ok) {
      await cancelResponseBody(response);
      throw new DownloadError2({
        url: urlText,
        statusCode: response.status,
        statusText: response.statusText
      });
    }
    const data = await readResponseWithSizeLimit({
      response,
      url: urlText,
      maxBytes: maxBytes != null ? maxBytes : DEFAULT_MAX_DOWNLOAD_SIZE
    });
    return {
      data,
      mediaType: (_a22 = response.headers.get("content-type")) != null ? _a22 : void 0
    };
  } catch (error) {
    if (DownloadError2.isInstance(error)) {
      throw error;
    }
    throw new DownloadError2({ url: urlText, cause: error });
  }
};

// src/util/download/download-function.ts
var createDefaultDownloadFunction = (download2 = download) => (requestedDownloads) => Promise.all(
  requestedDownloads.map(
    async (requestedDownload) => requestedDownload.isUrlSupportedByModel ? null : await download2(requestedDownload)
  )
);

// src/prompt/file-part-data.ts
import {
  isBuffer,
  isProviderReference
} from "@ai-sdk/provider-utils";

// src/prompt/split-data-url.ts
function splitDataUrl(dataUrl) {
  try {
    const [header, base64Content] = dataUrl.split(",");
    return {
      mediaType: header.split(";")[0].split(":")[1],
      base64Content
    };
  } catch (e) {
    return {
      mediaType: void 0,
      base64Content: void 0
    };
  }
}

// src/prompt/file-part-data.ts
function isTaggedFileData(value) {
  if (typeof value !== "object" || value === null)
    return false;
  const type = value.type;
  return type === "data" || type === "url" || type === "reference" || type === "text";
}
function convertUrlToFilePartData(url) {
  if (url.protocol === "data:") {
    const { mediaType, base64Content } = splitDataUrl(url.toString());
    if (mediaType == null || base64Content == null) {
      throw new InvalidDataContentError({
        content: url,
        message: `Invalid data URL format in content ${url.toString()}`
      });
    }
    return { data: { type: "data", data: base64Content }, mediaType };
  }
  return { data: { type: "url", url }, mediaType: void 0 };
}
function convertInlineDataToFilePartData(content) {
  if (content instanceof Uint8Array) {
    return { data: { type: "data", data: content }, mediaType: void 0 };
  }
  if (content instanceof ArrayBuffer) {
    return {
      data: { type: "data", data: new Uint8Array(content) },
      mediaType: void 0
    };
  }
  if (isBuffer(content)) {
    return {
      data: { type: "data", data: new Uint8Array(content) },
      mediaType: void 0
    };
  }
  return {
    data: { type: "data", data: content },
    mediaType: void 0
  };
}
function convertToLanguageModelV4FilePart(content) {
  if (isTaggedFileData(content)) {
    switch (content.type) {
      case "data":
        if (typeof content.data === "string" && content.data.startsWith("data:")) {
          throw new InvalidDataContentError({
            content: content.data,
            message: 'Data URLs are not valid inline data. Pass them as { type: "url", url } instead.'
          });
        }
        return convertInlineDataToFilePartData(content.data);
      case "url":
        return convertUrlToFilePartData(content.url);
      case "reference":
        return {
          data: { type: "reference", reference: content.reference },
          mediaType: void 0
        };
      case "text":
        return {
          data: { type: "text", text: content.text },
          mediaType: void 0
        };
    }
  }
  if (content instanceof URL) {
    return convertUrlToFilePartData(content);
  }
  if (typeof content === "string") {
    try {
      return convertUrlToFilePartData(new URL(content));
    } catch (e) {
      return convertInlineDataToFilePartData(content);
    }
  }
  if (isProviderReference(content)) {
    return {
      data: { type: "reference", reference: content },
      mediaType: void 0
    };
  }
  return convertInlineDataToFilePartData(content);
}

// src/prompt/convert-to-language-model-prompt.ts
async function convertToLanguageModelPrompt({
  prompt,
  supportedUrls,
  download: download2 = createDefaultDownloadFunction(),
  // `provider` is only needed here to convert legacy tool output types via `mapToolResultOutput`.
  // TODO: remove in v8 when "file-id" and "image-file-id" types are removed
  provider
}) {
  const downloadedAssets = await downloadAssets(
    prompt.messages,
    download2,
    supportedUrls
  );
  const approvalIdToToolCallId = /* @__PURE__ */ new Map();
  for (const message of prompt.messages) {
    if (message.role === "assistant" && Array.isArray(message.content)) {
      for (const part of message.content) {
        if (part.type === "tool-approval-request" && "approvalId" in part && "toolCallId" in part) {
          approvalIdToToolCallId.set(
            part.approvalId,
            part.toolCallId
          );
        }
      }
    }
  }
  const approvedToolCallIds = /* @__PURE__ */ new Set();
  for (const message of prompt.messages) {
    if (message.role === "tool") {
      for (const part of message.content) {
        if (part.type === "tool-approval-response") {
          const toolCallId = approvalIdToToolCallId.get(part.approvalId);
          if (toolCallId) {
            approvedToolCallIds.add(toolCallId);
          }
        }
      }
    }
  }
  const messages = [
    ...prompt.instructions != null ? typeof prompt.instructions === "string" ? [{ role: "system", content: prompt.instructions }] : asArray(prompt.instructions).map((message) => ({
      role: "system",
      content: message.content,
      providerOptions: message.providerOptions
    })) : [],
    ...prompt.messages.map(
      (message) => convertToLanguageModelMessage({ message, downloadedAssets, provider })
    )
  ];
  const combinedMessages = [];
  for (const message of messages) {
    if (message.role !== "tool") {
      combinedMessages.push(message);
      continue;
    }
    const lastCombinedMessage = combinedMessages.at(-1);
    if ((lastCombinedMessage == null ? void 0 : lastCombinedMessage.role) === "tool") {
      lastCombinedMessage.content.push(...message.content);
    } else {
      combinedMessages.push(message);
    }
  }
  const toolCallIds = /* @__PURE__ */ new Set();
  for (const message of combinedMessages) {
    switch (message.role) {
      case "assistant": {
        for (const content of message.content) {
          if (content.type === "tool-call" && !content.providerExecuted) {
            toolCallIds.add(content.toolCallId);
          }
        }
        break;
      }
      case "tool": {
        for (const content of message.content) {
          if (content.type === "tool-result") {
            toolCallIds.delete(content.toolCallId);
          }
        }
        break;
      }
      case "user":
      case "system":
        for (const id of approvedToolCallIds) {
          toolCallIds.delete(id);
        }
        if (toolCallIds.size > 0) {
          throw new MissingToolResultsError({
            toolCallIds: Array.from(toolCallIds)
          });
        }
        break;
    }
  }
  for (const id of approvedToolCallIds) {
    toolCallIds.delete(id);
  }
  if (toolCallIds.size > 0) {
    throw new MissingToolResultsError({ toolCallIds: Array.from(toolCallIds) });
  }
  return combinedMessages.filter(
    // Filter out empty tool messages (e.g. if they only contained
    // tool-approval-response parts that were removed).
    // This prevents sending invalid empty messages to the provider.
    // Note: provider-executed tool-approval-response parts are preserved.
    (message) => message.role !== "tool" || message.content.length > 0
  );
}
function convertToLanguageModelMessage({
  message,
  downloadedAssets,
  // `provider` is only needed here to convert legacy tool output types via `mapToolResultOutput`.
  // TODO: remove in v8 when "file-id" and "image-file-id" types are removed
  provider
}) {
  const warnings = [];
  const role = message.role;
  switch (role) {
    case "system": {
      return {
        role: "system",
        content: message.content,
        providerOptions: message.providerOptions
      };
    }
    case "user": {
      if (typeof message.content === "string") {
        return {
          role: "user",
          content: [{ type: "text", text: message.content }],
          providerOptions: message.providerOptions
        };
      }
      const converted = {
        role: "user",
        content: message.content.map((part) => {
          if (part.type === "image") {
            warnings.push({
              type: "deprecated",
              setting: '"image" content part',
              message: `The "image" content part type is deprecated. Use a "file" part with mediaType: 'image' (or a more specific image/* subtype) instead.`
            });
          }
          return convertImagePartToFilePart(part);
        }).map((part) => convertPartToLanguageModelPart(part, downloadedAssets)).filter((part) => part.type !== "text" || part.text !== ""),
        providerOptions: message.providerOptions
      };
      if (warnings.length > 0) {
        logWarnings({ warnings });
      }
      return converted;
    }
    case "assistant": {
      if (typeof message.content === "string") {
        return {
          role: "assistant",
          content: [{ type: "text", text: message.content }],
          providerOptions: message.providerOptions
        };
      }
      const converted = {
        role: "assistant",
        content: message.content.filter(
          // remove empty text parts (no text, and no provider options):
          (part) => part.type !== "text" || part.text !== "" || part.providerOptions != null
        ).filter(
          (part) => part.type !== "tool-approval-request"
        ).map((part) => {
          const providerOptions = part.providerOptions;
          switch (part.type) {
            case "custom": {
              return {
                type: "custom",
                kind: part.kind,
                providerOptions
              };
            }
            case "file": {
              const { data, mediaType } = convertToLanguageModelV4FilePart(
                part.data
              );
              return {
                type: "file",
                data,
                filename: part.filename,
                mediaType: mediaType != null ? mediaType : part.mediaType,
                providerOptions
              };
            }
            case "reasoning": {
              return {
                type: "reasoning",
                text: part.text,
                providerOptions
              };
            }
            case "reasoning-file": {
              const { data, mediaType } = convertToLanguageModelV4FilePart(
                part.data
              );
              if (data.type !== "data" && data.type !== "url") {
                throw new Error(
                  `Unsupported reasoning-file data type: ${data.type}`
                );
              }
              return {
                type: "reasoning-file",
                data,
                mediaType: mediaType != null ? mediaType : part.mediaType,
                providerOptions
              };
            }
            case "text": {
              return {
                type: "text",
                text: part.text,
                providerOptions
              };
            }
            case "tool-call": {
              return {
                type: "tool-call",
                toolCallId: part.toolCallId,
                toolName: part.toolName,
                input: part.input,
                providerExecuted: part.providerExecuted,
                providerOptions
              };
            }
            case "tool-result": {
              return {
                type: "tool-result",
                toolCallId: part.toolCallId,
                toolName: part.toolName,
                output: mapToolResultOutput({
                  output: part.output,
                  provider,
                  warnings,
                  downloadedAssets
                }),
                providerOptions
              };
            }
          }
        }),
        providerOptions: message.providerOptions
      };
      if (warnings.length > 0) {
        logWarnings({ warnings });
      }
      return converted;
    }
    case "tool": {
      const converted = {
        role: "tool",
        content: message.content.filter(
          // Only include tool-approval-response for provider-executed tools
          (part) => part.type !== "tool-approval-response" || part.providerExecuted
        ).map((part) => {
          switch (part.type) {
            case "tool-result": {
              return {
                type: "tool-result",
                toolCallId: part.toolCallId,
                toolName: part.toolName,
                output: mapToolResultOutput({
                  output: part.output,
                  provider,
                  warnings,
                  downloadedAssets
                }),
                providerOptions: part.providerOptions
              };
            }
            case "tool-approval-response": {
              return {
                type: "tool-approval-response",
                approvalId: part.approvalId,
                approved: part.approved,
                reason: part.reason
              };
            }
          }
        }),
        providerOptions: message.providerOptions
      };
      if (warnings.length > 0) {
        logWarnings({ warnings });
      }
      return converted;
    }
    default: {
      const _exhaustiveCheck = role;
      throw new InvalidMessageRoleError({ role: _exhaustiveCheck });
    }
  }
}
function convertImagePartToFilePart(part) {
  var _a22;
  if (part.type !== "image") {
    return part;
  }
  return {
    type: "file",
    data: part.image,
    mediaType: (_a22 = part.mediaType) != null ? _a22 : "image",
    providerOptions: part.providerOptions
  };
}
async function downloadAssets(messages, download2, supportedUrls) {
  const downloadableFiles = [];
  for (const message of messages) {
    if (message.role === "user" && Array.isArray(message.content)) {
      for (const part of message.content) {
        const filePart = convertImagePartToFilePart(part);
        if (filePart.type === "file") {
          downloadableFiles.push(filePart);
        }
      }
    }
    if (message.role === "tool") {
      for (const part of message.content) {
        if (part.type !== "tool-result") {
          continue;
        }
        if (part.output.type !== "content") {
          continue;
        }
        for (const contentPart of part.output.value) {
          if (contentPart.type === "file") {
            downloadableFiles.push(contentPart);
          }
        }
      }
    }
    if (message.role === "assistant" && Array.isArray(message.content)) {
      for (const part of message.content) {
        if (part.type !== "tool-result") {
          continue;
        }
        if (part.output.type !== "content") {
          continue;
        }
        for (const contentPart of part.output.value) {
          if (contentPart.type === "file") {
            downloadableFiles.push(contentPart);
          }
        }
      }
    }
  }
  const plannedDownloads = downloadableFiles.map((part) => {
    const mediaType = part.mediaType;
    const { data } = convertToLanguageModelV4FilePart(part.data);
    return { mediaType, data };
  }).filter((part) => part.data.type === "url").map((part) => ({
    url: part.data.url,
    isUrlSupportedByModel: part.mediaType != null && isUrlSupported({
      url: part.data.url.toString(),
      mediaType: part.mediaType,
      supportedUrls
    })
  }));
  const downloadedFiles = await download2(plannedDownloads);
  return Object.fromEntries(
    downloadedFiles.map(
      (file, index) => file == null ? null : [
        plannedDownloads[index].url.toString(),
        { data: file.data, mediaType: file.mediaType }
      ]
    ).filter((file) => file != null)
  );
}
function convertPartToLanguageModelPart(part, downloadedAssets) {
  if (part.type === "text") {
    return {
      type: "text",
      text: part.text,
      providerOptions: part.providerOptions
    };
  }
  const { data: normalizedData, mediaType: dataUrlMediaType } = convertToLanguageModelV4FilePart(part.data);
  let mediaType = dataUrlMediaType != null ? dataUrlMediaType : part.mediaType;
  let data = normalizedData;
  if (data.type === "url") {
    const downloadedFile = downloadedAssets[data.url.toString()];
    if (downloadedFile) {
      data = { type: "data", data: downloadedFile.data };
      if (downloadedFile.mediaType != null && (mediaType == null || !isFullMediaType(mediaType))) {
        mediaType = downloadedFile.mediaType;
      }
    }
  }
  if (data.type === "data" && (data.data instanceof Uint8Array || typeof data.data === "string")) {
    const imageMediaType = detectMediaType({
      data: data.data,
      topLevelType: "image"
    });
    if (imageMediaType != null) {
      mediaType = imageMediaType;
    }
  }
  if (mediaType == null) {
    throw new Error(`Media type is missing for file part`);
  }
  return {
    type: "file",
    mediaType,
    filename: part.filename,
    data,
    providerOptions: part.providerOptions
  };
}
function mapToolResultOutput({
  output,
  // `provider` is only needed here to convert legacy "file-id" and "image-file-id" types to provider references, in case they are using string ID values.
  // TODO: remove in v8 when "file-id" and "image-file-id" types are removed
  provider,
  warnings = [],
  downloadedAssets
}) {
  if (output.type !== "content") {
    return output;
  }
  return {
    type: "content",
    value: output.value.map((item) => {
      var _a22;
      switch (item.type) {
        case "file": {
          const convertedPart = convertPartToLanguageModelPart(
            item,
            downloadedAssets
          );
          if (convertedPart.type !== "file") {
            throw new Error(
              "Expected tool result file content to convert to file."
            );
          }
          return convertedPart;
        }
        case "file-data": {
          warnings.push({
            type: "deprecated",
            setting: '"tool-result" content of type "file-data"',
            message: `The "file-data" type for tool result content is deprecated. Use the "file" type with mediaType and { type: 'data', data } instead.`
          });
          return {
            type: "file",
            data: { type: "data", data: item.data },
            filename: item.filename,
            mediaType: