@crewai-ts/core 0.1.12 → 0.2.0

package/dist/chunk-HFQTF332.js

@@ -0,0 +1,4455 @@
+import {
+  LLMCallCompletedEvent,
+  LLMCallFailedEvent,
+  LLMCallStartedEvent,
+  LLMCallType,
+  LLMStreamChunkEvent,
+  LLMThinkingChunkEvent,
+  ToolUsageErrorEvent,
+  ToolUsageFinishedEvent,
+  ToolUsageStartedEvent,
+  crewaiEventBus
+} from "./chunk-C43UEMCX.js";
+import {
+  LLMCallHookContext,
+  runAfterLlmCallHooks,
+  runBeforeLlmCallHooks
+} from "./chunk-LWD4QED4.js";
+
+// src/llm.ts
+import { AsyncLocalStorage } from "async_hooks";
+import { randomUUID } from "crypto";
+import { readFileSync as readFileSync2 } from "fs";
+import { basename as basename2 } from "path";
+
+// src/files.ts
+import { createHash } from "crypto";
+import { readFileSync, statSync } from "fs";
+import { basename, extname, resolve } from "path";
+var ResolvedFile = class {
+  contentType;
+  content_type;
+  constructor(contentType) {
+    this.contentType = contentType;
+    this.content_type = contentType;
+  }
+};
+var InlineBase64 = class extends ResolvedFile {
+  data;
+  constructor(options) {
+    super(options.contentType ?? options.content_type ?? "application/octet-stream");
+    this.data = options.data;
+    Object.freeze(this);
+  }
+};
+var InlineBytes = class extends ResolvedFile {
+  data;
+  constructor(options) {
+    super(options.contentType ?? options.content_type ?? "application/octet-stream");
+    this.data = typeof options.data === "string" ? Buffer.from(options.data) : Buffer.from(options.data);
+    Object.freeze(this);
+  }
+};
+var FileReference = class extends ResolvedFile {
+  fileId;
+  file_id;
+  provider;
+  expiresAt;
+  expires_at;
+  fileUri;
+  file_uri;
+  constructor(options) {
+    super(options.contentType ?? options.content_type ?? "application/octet-stream");
+    this.fileId = options.fileId ?? options.file_id ?? "";
+    this.file_id = this.fileId;
+    this.provider = options.provider;
+    this.expiresAt = options.expiresAt ?? options.expires_at ?? null;
+    this.expires_at = this.expiresAt;
+    this.fileUri = options.fileUri ?? options.file_uri ?? null;
+    this.file_uri = this.fileUri;
+    Object.freeze(this);
+  }
+};
+var UrlReference = class extends ResolvedFile {
+  url;
+  constructor(options) {
+    super(options.contentType ?? options.content_type ?? "application/octet-stream");
+    this.url = options.url;
+    Object.freeze(this);
+  }
+};
+var FileHandling = /* @__PURE__ */ ((FileHandling2) => {
+  FileHandling2["STRICT"] = "strict";
+  FileHandling2["AUTO"] = "auto";
+  FileHandling2["WARN"] = "warn";
+  FileHandling2["CHUNK"] = "chunk";
+  return FileHandling2;
+})(FileHandling || {});
+var FileValidationError = class extends Error {
+  fileName;
+  file_name;
+  constructor(message, options = {}) {
+    super(message);
+    this.name = "FileValidationError";
+    this.fileName = options.fileName ?? options.file_name ?? null;
+    this.file_name = this.fileName;
+  }
+};
+var FileTooLargeError = class extends FileValidationError {
+  actualSize;
+  actual_size;
+  maxSize;
+  max_size;
+  constructor(message, options = {}) {
+    super(message, options);
+    this.name = "FileTooLargeError";
+    this.actualSize = options.actualSize ?? options.actual_size ?? null;
+    this.actual_size = this.actualSize;
+    this.maxSize = options.maxSize ?? options.max_size ?? null;
+    this.max_size = this.maxSize;
+  }
+};
+var UnsupportedFileTypeError = class extends FileValidationError {
+  contentType;
+  content_type;
+  constructor(message, options = {}) {
+    super(message, options);
+    this.name = "UnsupportedFileTypeError";
+    this.contentType = options.contentType ?? options.content_type ?? null;
+    this.content_type = this.contentType;
+  }
+};
+var FileProcessingError = class extends FileValidationError {
+  constructor(message, options = {}) {
+    super(message, options);
+    this.name = "FileProcessingError";
+  }
+};
+var ProcessingDependencyError = class extends FileProcessingError {
+  dependency;
+  installCommand;
+  install_command;
+  constructor(message, options = {}) {
+    super(message);
+    this.name = "ProcessingDependencyError";
+    this.dependency = options.dependency ?? null;
+    this.installCommand = options.installCommand ?? options.install_command ?? null;
+    this.install_command = this.installCommand;
+  }
+};
+var DEFAULT_IMAGE_FORMATS = ["image/png", "image/jpeg", "image/gif", "image/webp"];
+var GEMINI_IMAGE_FORMATS = [...DEFAULT_IMAGE_FORMATS, "image/heic", "image/heif"];
+var DEFAULT_AUDIO_FORMATS = ["audio/mp3", "audio/mpeg", "audio/wav", "audio/ogg", "audio/flac", "audio/aac", "audio/m4a"];
+var GEMINI_AUDIO_FORMATS = [...DEFAULT_AUDIO_FORMATS, "audio/opus"];
+var DEFAULT_VIDEO_FORMATS = ["video/mp4", "video/mpeg", "video/webm", "video/quicktime"];
+var GEMINI_VIDEO_FORMATS = [...DEFAULT_VIDEO_FORMATS, "video/x-msvideo", "video/x-flv"];
+var DEFAULT_TEXT_FORMATS = ["text/plain", "text/markdown", "text/csv", "application/json", "text/xml", "text/html"];
+var GEMINI_TEXT_FORMATS = [...DEFAULT_TEXT_FORMATS, "application/xml", "application/x-yaml", "text/yaml"];
+var ImageConstraints = class {
+  maxSizeBytes;
+  max_size_bytes;
+  maxWidth;
+  max_width;
+  maxHeight;
+  max_height;
+  maxImagesPerRequest;
+  max_images_per_request;
+  supportedFormats;
+  supported_formats;
+  constructor(options) {
+    this.maxSizeBytes = options.maxSizeBytes ?? options.max_size_bytes ?? 0;
+    this.max_size_bytes = this.maxSizeBytes;
+    this.maxWidth = options.maxWidth ?? options.max_width ?? null;
+    this.max_width = this.maxWidth;
+    this.maxHeight = options.maxHeight ?? options.max_height ?? null;
+    this.max_height = this.maxHeight;
+    this.maxImagesPerRequest = options.maxImagesPerRequest ?? options.max_images_per_request ?? null;
+    this.max_images_per_request = this.maxImagesPerRequest;
+    this.supportedFormats = options.supportedFormats ?? options.supported_formats ?? DEFAULT_IMAGE_FORMATS;
+    this.supported_formats = this.supportedFormats;
+    Object.freeze(this);
+  }
+};
+var PDFConstraints = class {
+  maxSizeBytes;
+  max_size_bytes;
+  maxPages;
+  max_pages;
+  constructor(options) {
+    this.maxSizeBytes = options.maxSizeBytes ?? options.max_size_bytes ?? 0;
+    this.max_size_bytes = this.maxSizeBytes;
+    this.maxPages = options.maxPages ?? options.max_pages ?? null;
+    this.max_pages = this.maxPages;
+    Object.freeze(this);
+  }
+};
+var AudioConstraints = class {
+  maxSizeBytes;
+  max_size_bytes;
+  maxDurationSeconds;
+  max_duration_seconds;
+  supportedFormats;
+  supported_formats;
+  constructor(options) {
+    this.maxSizeBytes = options.maxSizeBytes ?? options.max_size_bytes ?? 0;
+    this.max_size_bytes = this.maxSizeBytes;
+    this.maxDurationSeconds = options.maxDurationSeconds ?? options.max_duration_seconds ?? null;
+    this.max_duration_seconds = this.maxDurationSeconds;
+    this.supportedFormats = options.supportedFormats ?? options.supported_formats ?? DEFAULT_AUDIO_FORMATS;
+    this.supported_formats = this.supportedFormats;
+    Object.freeze(this);
+  }
+};
+var VideoConstraints = class {
+  maxSizeBytes;
+  max_size_bytes;
+  maxDurationSeconds;
+  max_duration_seconds;
+  supportedFormats;
+  supported_formats;
+  constructor(options) {
+    this.maxSizeBytes = options.maxSizeBytes ?? options.max_size_bytes ?? 0;
+    this.max_size_bytes = this.maxSizeBytes;
+    this.maxDurationSeconds = options.maxDurationSeconds ?? options.max_duration_seconds ?? null;
+    this.max_duration_seconds = this.maxDurationSeconds;
+    this.supportedFormats = options.supportedFormats ?? options.supported_formats ?? DEFAULT_VIDEO_FORMATS;
+    this.supported_formats = this.supportedFormats;
+    Object.freeze(this);
+  }
+};
+var TextConstraints = class {
+  maxSizeBytes;
+  max_size_bytes;
+  supportedFormats;
+  supported_formats;
+  constructor(options) {
+    this.maxSizeBytes = options.maxSizeBytes ?? options.max_size_bytes ?? 0;
+    this.max_size_bytes = this.maxSizeBytes;
+    this.supportedFormats = options.supportedFormats ?? options.supported_formats ?? DEFAULT_TEXT_FORMATS;
+    this.supported_formats = this.supportedFormats;
+    Object.freeze(this);
+  }
+};
+var ProviderConstraints = class {
+  name;
+  image;
+  pdf;
+  audio;
+  video;
+  text;
+  generalMaxSizeBytes;
+  general_max_size_bytes;
+  supportsFileUpload;
+  supports_file_upload;
+  fileUploadThresholdBytes;
+  file_upload_threshold_bytes;
+  supportsUrlReferences;
+  supports_url_references;
+  constructor(options) {
+    this.name = options.name;
+    this.image = options.image ?? null;
+    this.pdf = options.pdf ?? null;
+    this.audio = options.audio ?? null;
+    this.video = options.video ?? null;
+    this.text = options.text ?? null;
+    this.generalMaxSizeBytes = options.generalMaxSizeBytes ?? options.general_max_size_bytes ?? null;
+    this.general_max_size_bytes = this.generalMaxSizeBytes;
+    this.supportsFileUpload = options.supportsFileUpload ?? options.supports_file_upload ?? false;
+    this.supports_file_upload = this.supportsFileUpload;
+    this.fileUploadThresholdBytes = options.fileUploadThresholdBytes ?? options.file_upload_threshold_bytes ?? null;
+    this.file_upload_threshold_bytes = this.fileUploadThresholdBytes;
+    this.supportsUrlReferences = options.supportsUrlReferences ?? options.supports_url_references ?? false;
+    this.supports_url_references = this.supportsUrlReferences;
+    Object.freeze(this);
+  }
+};
+var ANTHROPIC_CONSTRAINTS = new ProviderConstraints({
+  name: "anthropic",
+  image: new ImageConstraints({ maxSizeBytes: 5242880, maxWidth: 8e3, maxHeight: 8e3, maxImagesPerRequest: 100 }),
+  pdf: new PDFConstraints({ maxSizeBytes: 33554432, maxPages: 100 }),
+  supportsFileUpload: true,
+  fileUploadThresholdBytes: 5242880,
+  supportsUrlReferences: true
+});
+var OPENAI_RESPONSES_CONSTRAINTS = new ProviderConstraints({
+  name: "openai_responses",
+  image: new ImageConstraints({ maxSizeBytes: 20971520, maxImagesPerRequest: 10 }),
+  pdf: new PDFConstraints({ maxSizeBytes: 33554432, maxPages: 100 }),
+  audio: new AudioConstraints({ maxSizeBytes: 26214400, maxDurationSeconds: 1500 }),
+  supportsFileUpload: true,
+  fileUploadThresholdBytes: 5242880,
+  supportsUrlReferences: true
+});
+var OPENAI_CONSTRAINTS = new ProviderConstraints({
+  name: "openai",
+  image: new ImageConstraints({ maxSizeBytes: 20971520, maxImagesPerRequest: 10 }),
+  supportsFileUpload: true,
+  fileUploadThresholdBytes: 5242880,
+  supportsUrlReferences: true
+});
+var GEMINI_CONSTRAINTS = new ProviderConstraints({
+  name: "gemini",
+  image: new ImageConstraints({ maxSizeBytes: 104857600, supportedFormats: GEMINI_IMAGE_FORMATS }),
+  pdf: new PDFConstraints({ maxSizeBytes: 52428800 }),
+  audio: new AudioConstraints({ maxSizeBytes: 104857600, maxDurationSeconds: 34200, supportedFormats: GEMINI_AUDIO_FORMATS }),
+  video: new VideoConstraints({ maxSizeBytes: 2147483648, maxDurationSeconds: 3600, supportedFormats: GEMINI_VIDEO_FORMATS }),
+  text: new TextConstraints({ maxSizeBytes: 104857600, supportedFormats: GEMINI_TEXT_FORMATS }),
+  supportsFileUpload: true,
+  fileUploadThresholdBytes: 20971520,
+  supportsUrlReferences: true
+});
+var BEDROCK_CONSTRAINTS = new ProviderConstraints({
+  name: "bedrock",
+  image: new ImageConstraints({ maxSizeBytes: 4608e3, maxWidth: 8e3, maxHeight: 8e3 }),
+  pdf: new PDFConstraints({ maxSizeBytes: 384e4, maxPages: 100 }),
+  supportsUrlReferences: true
+});
+var AZURE_CONSTRAINTS = new ProviderConstraints({
+  name: "azure",
+  image: new ImageConstraints({ maxSizeBytes: 20971520, maxImagesPerRequest: 10 }),
+  audio: new AudioConstraints({ maxSizeBytes: 26214400, maxDurationSeconds: 1500 }),
+  supportsUrlReferences: true
+});
+var PROVIDER_CONSTRAINTS = /* @__PURE__ */ new Map([
+  ["anthropic", ANTHROPIC_CONSTRAINTS],
+  ["openai", OPENAI_CONSTRAINTS],
+  ["openai_responses", OPENAI_RESPONSES_CONSTRAINTS],
+  ["gemini", GEMINI_CONSTRAINTS],
+  ["bedrock", BEDROCK_CONSTRAINTS],
+  ["azure", AZURE_CONSTRAINTS],
+  ["claude", ANTHROPIC_CONSTRAINTS],
+  ["gpt", OPENAI_CONSTRAINTS],
+  ["google", GEMINI_CONSTRAINTS],
+  ["aws", BEDROCK_CONSTRAINTS]
+]);
+function getConstraintsForProvider(provider) {
+  if (provider instanceof ProviderConstraints) {
+    return provider;
+  }
+  const providerLower = provider.toLowerCase();
+  const exact = PROVIDER_CONSTRAINTS.get(providerLower);
+  if (exact) {
+    return exact;
+  }
+  for (const [key, constraints] of PROVIDER_CONSTRAINTS) {
+    if (providerLower.includes(key)) {
+      return constraints;
+    }
+  }
+  return null;
+}
+var get_constraints_for_provider = getConstraintsForProvider;
+function usesOpenAIResponsesApi(provider, api = null) {
+  if (api !== "responses") {
+    return false;
+  }
+  const providerLower = provider.toLowerCase();
+  return providerLower.includes("openai") || providerLower === "gpt" || providerLower.startsWith("gpt-") || providerLower.includes("/gpt-");
+}
+var uses_openai_responses_api = usesOpenAIResponsesApi;
+function getSupportedContentTypes(provider, api = null) {
+  const lookup = usesOpenAIResponsesApi(provider, api) ? "openai_responses" : provider;
+  const constraints = getConstraintsForProvider(lookup);
+  if (!constraints) {
+    return [];
+  }
+  const types = [];
+  if (constraints.image) {
+    types.push("image/");
+  }
+  if (constraints.pdf) {
+    types.push("application/pdf");
+  }
+  if (constraints.audio) {
+    types.push("audio/");
+  }
+  if (constraints.video) {
+    types.push("video/");
+  }
+  if (constraints.text) {
+    types.push("text/");
+  }
+  return types;
+}
+function validateImage(file, constraints, options = {}) {
+  const errors = [];
+  const raiseOnError = options.raiseOnError ?? options.raise_on_error ?? true;
+  const content = file.read();
+  validateSize("Image", file.filename, content.length, constraints.maxSizeBytes, errors, raiseOnError);
+  validateFormat("Image", file.filename, file.contentType, constraints.supportedFormats, errors, raiseOnError);
+  return errors;
+}
+var validate_image = validateImage;
+function validatePDF(file, constraints, options = {}) {
+  const errors = [];
+  const raiseOnError = options.raiseOnError ?? options.raise_on_error ?? true;
+  validateSize("PDF", file.filename, file.read().length, constraints.maxSizeBytes, errors, raiseOnError);
+  return errors;
+}
+var validate_pdf = validatePDF;
+function validateAudio(file, constraints, options = {}) {
+  const errors = [];
+  const raiseOnError = options.raiseOnError ?? options.raise_on_error ?? true;
+  const duration = options.durationSeconds ?? options.duration_seconds ?? null;
+  validateSize("Audio", file.filename, file.read().length, constraints.maxSizeBytes, errors, raiseOnError);
+  validateFormat("Audio", file.filename, file.contentType, constraints.supportedFormats, errors, raiseOnError);
+  if (constraints.maxDurationSeconds !== null && duration !== null && duration > constraints.maxDurationSeconds) {
+    const message = `Audio '${file.filename ?? "null"}' duration (${duration.toFixed(1)}s) exceeds maximum (${String(constraints.maxDurationSeconds)}s)`;
+    errors.push(message);
+    if (raiseOnError) {
+      throw new FileValidationError(message, { fileName: file.filename });
+    }
+  }
+  return errors;
+}
+var validate_audio = validateAudio;
+function validateVideo(file, constraints, options = {}) {
+  const errors = [];
+  const raiseOnError = options.raiseOnError ?? options.raise_on_error ?? true;
+  const duration = options.durationSeconds ?? options.duration_seconds ?? null;
+  validateSize("Video", file.filename, file.read().length, constraints.maxSizeBytes, errors, raiseOnError);
+  validateFormat("Video", file.filename, file.contentType, constraints.supportedFormats, errors, raiseOnError);
+  if (constraints.maxDurationSeconds !== null && duration !== null && duration > constraints.maxDurationSeconds) {
+    const message = `Video '${file.filename ?? "null"}' duration (${duration.toFixed(1)}s) exceeds maximum (${String(constraints.maxDurationSeconds)}s)`;
+    errors.push(message);
+    if (raiseOnError) {
+      throw new FileValidationError(message, { fileName: file.filename });
+    }
+  }
+  return errors;
+}
+var validate_video = validateVideo;
+function validateText(file, constraints, options = {}) {
+  const errors = [];
+  if (constraints.generalMaxSizeBytes === null) {
+    return errors;
+  }
+  validateSize("Text file", file.filename, file.read().length, constraints.generalMaxSizeBytes, errors, options.raiseOnError ?? options.raise_on_error ?? true);
+  return errors;
+}
+var validate_text = validateText;
+function validateFile(file, constraints, options = {}) {
+  const raiseOnError = options.raiseOnError ?? options.raise_on_error ?? true;
+  if (file instanceof ImageFile) {
+    return constraints.image ? validateImage(file, constraints.image, { raiseOnError }) : unsupportedFileType(file, constraints.name, "images", raiseOnError);
+  }
+  if (file instanceof PDFFile) {
+    return constraints.pdf ? validatePDF(file, constraints.pdf, { raiseOnError }) : unsupportedFileType(file, constraints.name, "PDFs", raiseOnError);
+  }
+  if (file instanceof AudioFile) {
+    return constraints.audio ? validateAudio(file, constraints.audio, { raiseOnError }) : unsupportedFileType(file, constraints.name, "audio", raiseOnError);
+  }
+  if (file instanceof VideoFile) {
+    return constraints.video ? validateVideo(file, constraints.video, { raiseOnError }) : unsupportedFileType(file, constraints.name, "video", raiseOnError);
+  }
+  if (file instanceof TextFile) {
+    return validateText(file, constraints, { raiseOnError });
+  }
+  return [];
+}
+var validate_file = validateFile;
+var FileProcessor = class {
+  constraints;
+  constructor(options = {}) {
+    const value = options instanceof ProviderConstraints || typeof options === "string" || options === null ? options : options.constraints ?? null;
+    this.constraints = typeof value === "string" ? getConstraintsForProvider(value) : value;
+  }
+  validate(file) {
+    if (this.constraints === null) {
+      return [];
+    }
+    return validateFile(file, this.constraints, { raiseOnError: this.fileMode(file) === "strict" /* STRICT */ });
+  }
+  process(file) {
+    if (this.constraints === null) {
+      return file;
+    }
+    const mode = this.fileMode(file);
+    const errors = this.validate(file);
+    if (errors.length === 0) {
+      return file;
+    }
+    if (mode === "strict" /* STRICT */) {
+      throw new FileValidationError(errors.join("; "), { fileName: file.filename });
+    }
+    if (mode === "chunk" /* CHUNK */) {
+      return this.chunkProcess(file);
+    }
+    return file;
+  }
+  processFiles(files) {
+    const result = {};
+    for (const [name, file] of Object.entries(files)) {
+      const processed = this.process(file);
+      if (Array.isArray(processed)) {
+        processed.forEach((chunk, index) => {
+          result[`${name}_chunk_${String(index)}`] = chunk;
+        });
+      } else {
+        result[name] = processed;
+      }
+    }
+    return result;
+  }
+  process_files(files) {
+    return this.processFiles(files);
+  }
+  aprocessFiles(files) {
+    return Promise.resolve(this.processFiles(files));
+  }
+  aprocess_files(files) {
+    return this.aprocessFiles(files);
+  }
+  fileMode(file) {
+    return Object.values(FileHandling).includes(file.mode) ? file.mode : "auto" /* AUTO */;
+  }
+  chunkProcess(file) {
+    if (this.constraints === null) {
+      return file;
+    }
+    if (file instanceof TextFile && this.constraints.generalMaxSizeBytes !== null) {
+      return chunkText(file, this.constraints.generalMaxSizeBytes);
+    }
+    return file;
+  }
+};
+function chunkText(file, maxChars, options = {}) {
+  const overlapChars = Math.max(0, options.overlapChars ?? options.overlap_chars ?? 200);
+  const splitOnNewlines = options.splitOnNewlines ?? options.split_on_newlines ?? true;
+  const text = Buffer.from(file.read()).toString("utf8");
+  if (text.length <= maxChars) {
+    return [file];
+  }
+  const filename = file.filename ?? "text.txt";
+  const dotIndex = filename.lastIndexOf(".");
+  const base = dotIndex >= 0 ? filename.slice(0, dotIndex) : filename;
+  const extension = dotIndex >= 0 ? filename.slice(dotIndex + 1) : "txt";
+  const chunks = [];
+  let start = 0;
+  while (start < text.length) {
+    let end = Math.min(start + maxChars, text.length);
+    if (end < text.length && splitOnNewlines) {
+      const lastNewline = text.lastIndexOf("\n", end - 1);
+      if (lastNewline > start + Math.floor(maxChars / 2)) {
+        end = lastNewline + 1;
+      }
+    }
+    chunks.push(new TextFile({
+      source: new FileBytes({
+        data: Buffer.from(text.slice(start, end), "utf8"),
+        filename: `${base}_chunk_${String(chunks.length)}.${extension}`
+      })
+    }));
+    start = end < text.length ? Math.max(start + 1, end - overlapChars) : text.length;
+  }
+  return chunks;
+}
+var chunk_text = chunkText;
+function chunkPDF(_file, _maxPages) {
+  void _file;
+  void _maxPages;
+  throw new ProcessingDependencyError("pypdf is required for PDF chunking", { dependency: "pypdf", installCommand: "pip install pypdf" });
+}
+var chunk_pdf = chunkPDF;
+function resizeImage(_file, _maxWidth, _maxHeight) {
+  void _file;
+  void _maxWidth;
+  void _maxHeight;
+  throw new ProcessingDependencyError("Pillow is required for image resizing", { dependency: "Pillow", installCommand: "pip install Pillow" });
+}
+var resize_image = resizeImage;
+function optimizeImage(_file, _targetSizeBytes) {
+  void _file;
+  void _targetSizeBytes;
+  throw new ProcessingDependencyError("Pillow is required for image optimization", { dependency: "Pillow", installCommand: "pip install Pillow" });
+}
+var optimize_image = optimizeImage;
+var CachedUpload = class {
+  fileId;
+  file_id;
+  provider;
+  fileUri;
+  file_uri;
+  contentType;
+  content_type;
+  uploadedAt;
+  uploaded_at;
+  expiresAt;
+  expires_at;
+  constructor(options) {
+    this.fileId = options.fileId ?? options.file_id ?? "";
+    this.file_id = this.fileId;
+    this.provider = options.provider;
+    this.fileUri = options.fileUri ?? options.file_uri ?? null;
+    this.file_uri = this.fileUri;
+    this.contentType = options.contentType ?? options.content_type ?? "application/octet-stream";
+    this.content_type = this.contentType;
+    this.uploadedAt = options.uploadedAt ?? options.uploaded_at ?? /* @__PURE__ */ new Date();
+    this.uploaded_at = this.uploadedAt;
+    this.expiresAt = options.expiresAt ?? options.expires_at ?? null;
+    this.expires_at = this.expiresAt;
+  }
+  isExpired(now = /* @__PURE__ */ new Date()) {
+    return this.expiresAt !== null && now.getTime() >= this.expiresAt.getTime();
+  }
+  is_expired(now = /* @__PURE__ */ new Date()) {
+    return this.isExpired(now);
+  }
+};
+var UploadCache = class {
+  ttl;
+  namespace;
+  maxEntries;
+  max_entries;
+  entries = /* @__PURE__ */ new Map();
+  providerKeys = /* @__PURE__ */ new Map();
+  accessOrder = [];
+  constructor(options = {}) {
+    this.ttl = options.ttl ?? 24 * 60 * 60;
+    this.namespace = options.namespace ?? "crewai_uploads";
+    this.maxEntries = options.maxEntries ?? options.max_entries ?? 1e3;
+    this.max_entries = this.maxEntries;
+  }
+  get size() {
+    return this.entries.size;
+  }
+  get length() {
+    return this.size;
+  }
+  get(file, provider) {
+    return this.getByHash(computeFileHash(file), provider);
+  }
+  get_by_hash(fileHash, provider) {
+    return this.getByHash(fileHash, provider);
+  }
+  getByHash(fileHash, provider) {
+    const key = uploadCacheKey(fileHash, provider);
+    const cached = this.entries.get(key) ?? null;
+    if (cached === null) {
+      return null;
+    }
+    if (cached.isExpired()) {
+      this.entries.delete(key);
+      this.untrackKey(provider, key);
+      return null;
+    }
+    this.trackKey(provider, key);
+    return cached;
+  }
+  aget(file, provider) {
+    return Promise.resolve(this.get(file, provider));
+  }
+  aget_by_hash(fileHash, provider) {
+    return Promise.resolve(this.getByHash(fileHash, provider));
+  }
+  agetByHash(fileHash, provider) {
+    return Promise.resolve(this.getByHash(fileHash, provider));
+  }
+  set(file, provider, fileIdOrOptions, fileUri = null, expiresAt = null) {
+    const fileId = typeof fileIdOrOptions === "string" ? fileIdOrOptions : fileIdOrOptions.fileId ?? fileIdOrOptions.file_id ?? "";
+    const resolvedUri = typeof fileIdOrOptions === "string" ? fileUri : fileIdOrOptions.fileUri ?? fileIdOrOptions.file_uri ?? null;
+    const resolvedExpiry = typeof fileIdOrOptions === "string" ? expiresAt : fileIdOrOptions.expiresAt ?? fileIdOrOptions.expires_at ?? null;
+    return this.setByHash(computeFileHash(file), file.contentType, provider, fileId, resolvedUri, resolvedExpiry);
+  }
+  set_by_hash(fileHash, contentType, provider, fileId, fileUri = null, expiresAt = null) {
+    return this.setByHash(fileHash, contentType, provider, fileId, fileUri, expiresAt);
+  }
+  setByHash(fileHash, contentType, provider, fileId, fileUri = null, expiresAt = null) {
+    this.evictIfNeeded();
+    const key = uploadCacheKey(fileHash, provider);
+    const cached = new CachedUpload({
+      fileId,
+      provider,
+      fileUri,
+      contentType,
+      uploadedAt: /* @__PURE__ */ new Date(),
+      expiresAt
+    });
+    this.entries.set(key, cached);
+    this.trackKey(provider, key);
+    return cached;
+  }
+  aset(file, provider, fileId, fileUri = null, expiresAt = null) {
+    return Promise.resolve(this.set(file, provider, fileId, fileUri, expiresAt));
+  }
+  aset_by_hash(fileHash, contentType, provider, fileId, fileUri = null, expiresAt = null) {
+    return Promise.resolve(this.setByHash(fileHash, contentType, provider, fileId, fileUri, expiresAt));
+  }
+  asetByHash(fileHash, contentType, provider, fileId, fileUri = null, expiresAt = null) {
+    return Promise.resolve(this.setByHash(fileHash, contentType, provider, fileId, fileUri, expiresAt));
+  }
+  remove(file, provider) {
+    const key = uploadCacheKey(computeFileHash(file), provider);
+    const removed = this.entries.delete(key);
+    if (removed) {
+      this.untrackKey(provider, key);
+    }
+    return removed;
+  }
+  aremove(file, provider) {
+    return Promise.resolve(this.remove(file, provider));
+  }
+  removeByFileId(fileId, provider) {
+    for (const key of [...this.providerKeys.get(provider) ?? []]) {
+      if (this.entries.get(key)?.fileId === fileId) {
+        this.entries.delete(key);
+        this.untrackKey(provider, key);
+        return true;
+      }
+    }
+    return false;
+  }
+  remove_by_file_id(fileId, provider) {
+    return this.removeByFileId(fileId, provider);
+  }
+  aremove_by_file_id(fileId, provider) {
+    return Promise.resolve(this.removeByFileId(fileId, provider));
+  }
+  clearExpired() {
+    let removed = 0;
+    for (const [key, cached] of [...this.entries]) {
+      if (cached.isExpired()) {
+        this.entries.delete(key);
+        this.untrackKey(cached.provider, key);
+        removed += 1;
+      }
+    }
+    return removed;
+  }
+  clear_expired() {
+    return this.clearExpired();
+  }
+  aclear_expired() {
+    return Promise.resolve(this.clearExpired());
+  }
+  clear() {
+    const count = this.entries.size;
+    this.entries.clear();
+    this.providerKeys.clear();
+    this.accessOrder.length = 0;
+    return count;
+  }
+  aclear() {
+    return Promise.resolve(this.clear());
+  }
+  getAllForProvider(provider) {
+    return [...this.providerKeys.get(provider) ?? []].map((key) => this.getCachedByKey(key, provider)).filter((cached) => cached !== null);
+  }
+  get_all_for_provider(provider) {
+    return this.getAllForProvider(provider);
+  }
+  aget_all_for_provider(provider) {
+    return Promise.resolve(this.getAllForProvider(provider));
+  }
+  getProviders() {
+    return new Set(this.providerKeys.keys());
+  }
+  get_providers() {
+    return this.getProviders();
+  }
+  getCachedByKey(key, provider) {
+    const cached = this.entries.get(key) ?? null;
+    if (cached === null) {
+      this.untrackKey(provider, key);
+      return null;
+    }
+    if (cached.isExpired()) {
+      this.entries.delete(key);
+      this.untrackKey(provider, key);
+      return null;
+    }
+    return cached;
+  }
+  trackKey(provider, key) {
+    const keys = this.providerKeys.get(provider) ?? /* @__PURE__ */ new Set();
+    keys.add(key);
+    this.providerKeys.set(provider, keys);
+    const index = this.accessOrder.indexOf(key);
+    if (index >= 0) {
+      this.accessOrder.splice(index, 1);
+    }
+    this.accessOrder.push(key);
+  }
+  untrackKey(provider, key) {
+    this.providerKeys.get(provider)?.delete(key);
+    if (this.providerKeys.get(provider)?.size === 0) {
+      this.providerKeys.delete(provider);
+    }
+    const index = this.accessOrder.indexOf(key);
+    if (index >= 0) {
+      this.accessOrder.splice(index, 1);
+    }
+  }
+  evictIfNeeded() {
+    if (this.maxEntries === null || this.entries.size < this.maxEntries) {
+      return;
+    }
+    const count = Math.max(1, Math.floor(this.maxEntries / 10));
+    for (const key of this.accessOrder.slice(0, count)) {
+      const cached = this.entries.get(key);
+      this.entries.delete(key);
+      if (cached) {
+        this.untrackKey(cached.provider, key);
+      }
+    }
+  }
+};
+var defaultUploadCache = null;
+function getUploadCache(options = {}) {
+  defaultUploadCache ??= new UploadCache(options);
+  return defaultUploadCache;
+}
+var get_upload_cache = getUploadCache;
+function resetUploadCache() {
+  defaultUploadCache?.clear();
+  defaultUploadCache = null;
+}
+var reset_upload_cache = resetUploadCache;
+var FileSource = class {
+  get content_type() {
+    return this.contentType;
+  }
+  aread() {
+    return Promise.resolve(this.read());
+  }
+  *readChunks(chunkSize = 65536) {
+    const data = this.read();
+    for (let index = 0; index < data.length; index += chunkSize) {
+      yield data.subarray(index, index + chunkSize);
+    }
+  }
+  read_chunks(chunkSize = 65536) {
+    return this.readChunks(chunkSize);
+  }
+};
+var FilePath = class extends FileSource {
+  path;
+  maxSizeBytes;
+  max_size_bytes;
+  contentType;
+  content = null;
+  constructor(options) {
+    super();
+    this.path = options.path;
+    this.maxSizeBytes = options.maxSizeBytes ?? options.max_size_bytes ?? 100 * 1024 * 1024;
+    this.max_size_bytes = this.maxSizeBytes;
+    if (this.path.includes("..")) {
+      throw new Error(`Path traversal not allowed: ${this.path}`);
+    }
+    const stats = statSync(this.path, { throwIfNoEntry: false });
+    if (!stats) {
+      throw new Error(`File not found: ${this.path}`);
+    }
+    if (!stats.isFile()) {
+      throw new Error(`Path is not a file: ${this.path}`);
+    }
+    if (stats.size > this.maxSizeBytes) {
+      throw new Error(`File exceeds max size (${String(stats.size)} > ${String(this.maxSizeBytes)})`);
+    }
+    this.contentType = detectContentType(readFileSync(this.path).subarray(0, 2048), this.filename);
+  }
+  get filename() {
+    return basename(this.path);
+  }
+  read() {
+    this.content ??= readFileSync(this.path);
+    return this.content;
+  }
+};
+var FileBytes = class extends FileSource {
+  data;
+  filename;
+  contentType;
+  constructor(options) {
+    super();
+    this.data = typeof options.data === "string" ? Buffer.from(options.data) : Buffer.from(options.data);
+    this.filename = options.filename ?? null;
+    this.contentType = detectContentType(this.data, this.filename);
+  }
+  read() {
+    return this.data;
+  }
+};
+var FileStream = class extends FileSource {
+  stream;
+  filename;
+  contentType;
+  content = null;
+  constructor(options) {
+    super();
+    this.stream = options.stream;
+    this.filename = options.filename ?? (options.stream.name ? basename(options.stream.name) : null);
+    const position = typeof options.stream.tell === "function" ? options.stream.tell() : null;
+    options.stream.seek?.(0);
+    const header = Buffer.from(options.stream.read(2048));
+    if (position !== null) {
+      options.stream.seek?.(position);
+    }
+    this.contentType = detectContentType(header, this.filename);
+  }
+  read() {
+    if (this.content === null) {
+      const position = typeof this.stream.tell === "function" ? this.stream.tell() : null;
+      this.stream.seek?.(0);
+      this.content = Buffer.from(this.stream.read());
+      if (position !== null) {
+        this.stream.seek?.(position);
+      }
+    }
+    return this.content;
+  }
+  close() {
+    this.stream.close?.();
+  }
+};
+var FileUrl = class extends FileSource {
+  url;
+  filename;
+  detectedContentType = null;
+  content = null;
+  fetcher;
+  constructor(options) {
+    super();
+    if (!options.url.startsWith("http://") && !options.url.startsWith("https://")) {
+      throw new Error(`Invalid URL scheme: ${options.url}`);
+    }
+    this.url = options.url;
+    this.filename = options.filename ?? null;
+    this.fetcher = options.fetcher ?? null;
+  }
+  get contentType() {
+    this.detectedContentType ??= contentTypeFromFilename(this.filename ?? urlPathname(this.url)) ?? "application/octet-stream";
+    return this.detectedContentType;
+  }
+  read() {
+    if (this.content !== null) {
+      return this.content;
+    }
+    if (!this.fetcher) {
+      throw new Error("FileUrl.read requires an injected fetcher in this deterministic TypeScript shim. Use aread() with a fetcher or resolve URL-capable providers as UrlReference.");
+    }
+    const fetched = this.fetcher(this.url);
+    if (isPromiseLike(fetched)) {
+      throw new Error("FileUrl.read requires a synchronous injected fetcher in this deterministic TypeScript shim. Use aread() with async fetchers.");
+    }
+    return this.applyFetchedContent(fetched);
+  }
+  async aread() {
+    if (this.content !== null) {
+      return this.content;
+    }
+    if (!this.fetcher) {
+      throw new Error("FileUrl.aread requires an injected fetcher in this deterministic TypeScript shim.");
+    }
+    const fetched = await this.fetcher(this.url);
+    return this.applyFetchedContent(fetched);
+  }
+  applyFetchedContent(fetched) {
+    this.content = typeof fetched.content === "string" ? Buffer.from(fetched.content) : Buffer.from(fetched.content);
+    if (fetched.contentType) {
+      this.detectedContentType = fetched.contentType.split(";")[0] ?? fetched.contentType;
+    }
+    return this.content;
+  }
+};
+var BaseFile = class {
+  source;
+  mode;
+  constructor(options) {
+    const source = isFileOptions(options) ? options.source : options;
+    this.source = coerceFileSource(source);
+    this.mode = isFileOptions(options) ? options.mode ?? "auto" : "auto";
+  }
+  get filename() {
+    return this.source.filename;
+  }
+  get contentType() {
+    return this.source.contentType;
+  }
+  get content_type() {
+    return this.contentType;
+  }
+  read() {
+    return this.source.read();
+  }
+  async aread() {
+    return await this.source.aread();
+  }
+  readText(encoding = "utf8") {
+    return Buffer.from(this.read()).toString(encoding);
+  }
+  read_text(encoding = "utf8") {
+    return this.readText(encoding);
+  }
+  keys() {
+    return [this.unpackKey()];
+  }
+  getItem(key) {
+    if (key !== this.unpackKey()) {
+      throw new Error(key);
+    }
+    return this;
+  }
+  __getitem__(key) {
+    return this.getItem(key);
+  }
+  unpackKey() {
+    const name = this.filename;
+    return name ? name.replace(/\.[^.]*$/, "") : "file";
+  }
+};
+var ImageFile = class extends BaseFile {
+};
+var PDFFile = class extends BaseFile {
+};
+var TextFile = class extends BaseFile {
+};
+var AudioFile = class extends BaseFile {
+};
+var VideoFile = class extends BaseFile {
+};
+var File = class extends BaseFile {
+};
+function detectContentType(data, filename) {
+  const bytes = typeof data === "string" ? Buffer.from(data) : Buffer.from(data);
+  if (bytes.subarray(0, 8).equals(Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]))) {
+    return "image/png";
+  }
+  if (bytes[0] === 255 && bytes[1] === 216 && bytes[2] === 255) {
+    return "image/jpeg";
+  }
+  if (bytes.subarray(0, 4).toString("ascii") === "%PDF") {
+    return "application/pdf";
+  }
+  const byExtension = contentTypeFromFilename(filename);
+  if (byExtension && byExtension !== "application/octet-stream") {
+    return byExtension;
+  }
+  const text = bytes.toString("utf8").trim();
+  if (text) {
+    try {
+      JSON.parse(text);
+      return "application/json";
+    } catch {
+    }
+  }
+  return isLikelyText(bytes) ? "text/plain" : "application/octet-stream";
+}
+var detect_content_type = detectContentType;
+function wrapFileSource(source) {
+  if (source.contentType.startsWith("image/")) {
+    return new ImageFile({ source });
+  }
+  if (source.contentType.startsWith("audio/")) {
+    return new AudioFile({ source });
+  }
+  if (source.contentType.startsWith("video/")) {
+    return new VideoFile({ source });
+  }
+  if (source.contentType === "application/pdf") {
+    return new PDFFile({ source });
+  }
+  return new TextFile({ source });
+}
+var wrap_file_source = wrapFileSource;
+function normalizeInputFiles(inputFiles) {
+  const result = {};
+  inputFiles.forEach((item, index) => {
+    if (item instanceof BaseFile) {
+      const filename2 = item.filename ?? `file_${String(index)}`;
+      result[filename2.replace(/\.[^.]*$/, "")] = item;
+      return;
+    }
+    const source = coerceFileSource(item);
+    const filename = source.filename ?? `file_${String(index)}`;
+    result[filename] = wrapFileSource(source);
+  });
+  return result;
+}
+var normalize_input_files = normalizeInputFiles;
+var FileResolverConfig = class {
+  preferUpload;
+  prefer_upload;
+  uploadThresholdBytes;
+  upload_threshold_bytes;
+  useBytesForBedrock;
+  use_bytes_for_bedrock;
+  constructor(options = {}) {
+    this.preferUpload = options.preferUpload ?? options.prefer_upload ?? false;
+    this.prefer_upload = this.preferUpload;
+    this.uploadThresholdBytes = options.uploadThresholdBytes ?? options.upload_threshold_bytes ?? null;
+    this.upload_threshold_bytes = this.uploadThresholdBytes;
+    this.useBytesForBedrock = options.useBytesForBedrock ?? options.use_bytes_for_bedrock ?? true;
+    this.use_bytes_for_bedrock = this.useBytesForBedrock;
+  }
+};
+var FileResolver = class {
+  config;
+  uploadCache;
+  upload_cache;
+  constructor(options = {}) {
+    this.config = options.config instanceof FileResolverConfig ? options.config : new FileResolverConfig(options.config);
+    this.uploadCache = options.uploadCache ?? options.upload_cache ?? null;
+    this.upload_cache = this.uploadCache;
+  }
+  resolve(file, provider) {
+    const source = file.source;
+    if (source instanceof FileUrl && supportsUrlReferences(provider)) {
+      return new UrlReference({ contentType: file.contentType, url: source.url });
+    }
+    const content = file.read();
+    const cached = this.resolveCachedUpload(file, provider, content);
+    if (cached) {
+      return cached;
+    }
+    if (provider.toLowerCase() === "bedrock" && this.config.useBytesForBedrock) {
+      return new InlineBytes({ contentType: file.contentType, data: content });
+    }
+    return new InlineBase64({ contentType: file.contentType, data: Buffer.from(content).toString("base64") });
+  }
+  async aresolve(file, provider) {
+    const source = file.source;
+    if (source instanceof FileUrl && supportsUrlReferences(provider)) {
+      return new UrlReference({ contentType: file.contentType, url: source.url });
+    }
+    const content = await file.aread();
+    const cached = this.resolveCachedUpload(file, provider, content);
+    if (cached) {
+      return cached;
+    }
+    if (provider.toLowerCase() === "bedrock" && this.config.useBytesForBedrock) {
+      return new InlineBytes({ contentType: file.contentType, data: content });
+    }
+    return new InlineBase64({ contentType: file.contentType, data: Buffer.from(content).toString("base64") });
+  }
+  resolveFiles(files, provider) {
+    return Object.fromEntries(Object.entries(files).map(([name, file]) => [name, this.resolve(file, provider)]));
+  }
+  resolve_files(files, provider) {
+    return this.resolveFiles(files, provider);
+  }
+  async aresolveFiles(files, provider, maxConcurrency = 10) {
+    const entries = Object.entries(files);
+    const output = {};
+    let nextIndex = 0;
+    const workerCount = Math.max(1, Math.min(maxConcurrency, entries.length));
+    await Promise.all(Array.from({ length: workerCount }, async () => {
+      while (nextIndex < entries.length) {
+        const entry = entries[nextIndex];
+        nextIndex += 1;
+        if (!entry) {
+          continue;
+        }
+        const [name, file] = entry;
+        try {
+          output[name] = await this.aresolve(file, provider);
+        } catch {
+        }
+      }
+    }));
+    return output;
+  }
+  async aresolve_files(files, provider, max_concurrency = 10) {
+    return await this.aresolveFiles(files, provider, max_concurrency);
+  }
+  getCachedUploads(provider) {
+    return this.uploadCache?.getAllForProvider(provider) ?? [];
+  }
+  get_cached_uploads(provider) {
+    return this.getCachedUploads(provider);
+  }
+  clearCache() {
+    this.uploadCache?.clear();
+  }
+  clear_cache() {
+    this.clearCache();
+  }
+  resolveCachedUpload(file, provider, content) {
+    if (!this.uploadCache || !this.shouldUseUpload(file, provider, content.length)) {
+      return null;
+    }
+    const cached = this.uploadCache.getByHash(createHash("sha256").update(content).digest("hex"), provider);
+    if (!cached) {
+      return null;
+    }
+    return new FileReference({
+      contentType: cached.contentType,
+      fileId: cached.fileId,
+      provider: cached.provider,
+      expiresAt: cached.expiresAt,
+      fileUri: cached.fileUri
+    });
+  }
+  shouldUseUpload(file, provider, sizeBytes) {
+    const constraints = getConstraintsForProvider(provider);
+    if (!constraints?.supportsFileUpload) {
+      return false;
+    }
+    if (this.config.preferUpload) {
+      return true;
+    }
+    const typeConstraint = getFileTypeConstraint(file, constraints);
+    if (typeConstraint && sizeBytes > typeConstraint.maxSizeBytes) {
+      return true;
+    }
+    return this.config.uploadThresholdBytes !== null && sizeBytes > this.config.uploadThresholdBytes;
+  }
+};
+function createResolver(options = {}) {
+  const uploadThresholdBytes = options instanceof FileResolverConfig ? null : options.uploadThresholdBytes ?? options.upload_threshold_bytes ?? (options.provider ? getConstraintsForProvider(options.provider)?.fileUploadThresholdBytes : void 0);
+  const config = options instanceof FileResolverConfig ? options : new FileResolverConfig({
+    ...options,
+    ...uploadThresholdBytes === void 0 ? {} : { uploadThresholdBytes }
+  });
+  const enableCache = options instanceof FileResolverConfig ? true : options.enableCache ?? options.enable_cache ?? true;
+  return new FileResolver({ config, uploadCache: enableCache ? new UploadCache() : null });
+}
+var create_resolver = createResolver;
+function formatMultimodalContent(files, provider, options = {}) {
+  const api = typeof options === "string" ? options : options.api ?? "completions";
+  const text = typeof options === "string" ? null : options.text ?? null;
+  const normalizedProvider = provider.toLowerCase();
+  const result = [];
+  if (text) {
+    result.push(formatTextBlockForProvider(text, normalizedProvider, api));
+  }
+  for (const [name, file] of Object.entries(files)) {
+    if (!isOpenAIProvider(normalizedProvider) && !isGeminiProvider(normalizedProvider) && !isAnthropicProvider(normalizedProvider) && !isBedrockProvider(normalizedProvider)) {
+      continue;
+    }
+    const bytes = Buffer.from(file.read());
+    const encoded = bytes.toString("base64");
+    if (isAnthropicProvider(normalizedProvider) && file instanceof ImageFile) {
+      result.push({
+        type: "image",
+        source: {
+          type: "base64",
+          media_type: file.contentType,
+          data: encoded
+        }
+      });
+    } else if (isAnthropicProvider(normalizedProvider) && file instanceof PDFFile) {
+      result.push({
+        type: "document",
+        source: {
+          type: "base64",
+          media_type: file.contentType,
+          data: encoded
+        }
+      });
+    } else if (isBedrockProvider(normalizedProvider) && file instanceof ImageFile) {
+      result.push({
+        image: {
+          format: bedrockImageFormat(file.contentType, file.filename),
+          source: { bytes }
+        }
+      });
+    } else if (isBedrockProvider(normalizedProvider) && file instanceof PDFFile) {
+      result.push({
+        document: {
+          name: bedrockDocumentName(file.filename ?? name),
+          format: "pdf",
+          source: { bytes }
+        }
+      });
+    } else if (isGeminiProvider(normalizedProvider) && file instanceof ImageFile) {
+      result.push({
+        inlineData: {
+          mimeType: file.contentType,
+          data: encoded
+        }
+      });
+    } else if (isGeminiProvider(normalizedProvider) && (file instanceof TextFile || file instanceof AudioFile || file instanceof VideoFile || file instanceof PDFFile)) {
+      result.push({
+        inlineData: {
+          mimeType: file.contentType,
+          data: encoded
+        }
+      });
+    } else if (file instanceof PDFFile && api === "responses") {
+      result.push({
+        type: "input_file",
+        filename: file.filename ?? `${name}.pdf`,
+        file_data: `data:application/pdf;base64,${encoded}`
+      });
+    } else if (file instanceof ImageFile) {
+      result.push({
+        type: api === "responses" ? "input_image" : "image_url",
+        image_url: { url: `data:${file.contentType};base64,${encoded}` }
+      });
+    }
+  }
+  return result;
+}
+function format_multimodal_content(files, provider, options = {}) {
+  return formatMultimodalContent(files, provider, options);
+}
+function isFileOptions(value) {
+  return Boolean(value && typeof value === "object" && "source" in value);
+}
+function coerceFileSource(value) {
+  if (value instanceof FileSource) {
+    return value;
+  }
+  if (typeof value === "string") {
+    if (value.startsWith("http://") || value.startsWith("https://")) {
+      return new FileUrl({ url: value });
+    }
+    return new FilePath({ path: resolve(value) });
+  }
+  if (Buffer.isBuffer(value) || value instanceof Uint8Array) {
+    return new FileBytes({ data: value });
+  }
+  return new FileStream({ stream: value });
+}
+function supportsUrlReferences(provider) {
+  if (["bedrock", "aws"].includes(provider.toLowerCase())) {
+    return false;
+  }
+  return getConstraintsForProvider(provider)?.supportsUrlReferences ?? false;
+}
+function isOpenAIProvider(provider) {
+  return provider === "openai" || provider === "azure" || provider.startsWith("openai/") || provider.startsWith("azure/") || provider.startsWith("gpt-") || provider.startsWith("gpt-35-") || provider.startsWith("o1") || provider.startsWith("o3") || provider.startsWith("o4");
+}
+function isGeminiProvider(provider) {
+  return provider === "gemini" || provider === "google" || provider.startsWith("gemini/") || provider.startsWith("google/");
+}
+function isAnthropicProvider(provider) {
+  return provider === "anthropic" || provider === "claude" || provider.startsWith("anthropic/") || provider.startsWith("claude");
+}
+function isBedrockProvider(provider) {
+  return provider === "bedrock" || provider === "aws" || provider.startsWith("bedrock/") || provider.startsWith("aws/");
+}
+function formatTextBlockForProvider(text, provider, api) {
+  if (api === "responses") {
+    return { type: "input_text", text };
+  }
+  if (isGeminiProvider(provider) || isBedrockProvider(provider)) {
+    return { text };
+  }
+  return { type: "text", text };
+}
+function bedrockImageFormat(contentType, filename) {
+  const mediaType = contentType.split("/").at(-1)?.toLowerCase();
+  if (mediaType === "jpg") {
+    return "jpeg";
+  }
+  if (mediaType) {
+    return mediaType;
+  }
+  const extension = filename?.split(".").at(-1)?.toLowerCase();
+  return extension === "jpg" ? "jpeg" : extension || "png";
+}
+function bedrockDocumentName(filename) {
+  const name = filename.replace(/\.[^.]+$/u, "");
+  const sanitized = name.replace(/[^\p{L}\p{N}\s\-()[\]]/gu, " ").replace(/\s+/gu, " ").trim();
+  return sanitized || "document";
+}
+function isPromiseLike(value) {
+  return (typeof value === "object" || typeof value === "function") && value !== null && "then" in value && typeof value.then === "function";
+}
+function validateSize(fileType, filename, fileSize, maxSize, errors, raiseOnError) {
+  if (fileSize <= maxSize) {
+    return;
+  }
+  const message = `${fileType} '${filename ?? "null"}' size (${formatSize(fileSize)}) exceeds maximum (${formatSize(maxSize)})`;
+  errors.push(message);
+  if (raiseOnError) {
+    throw new FileTooLargeError(message, { fileName: filename, actualSize: fileSize, maxSize });
+  }
+}
+function validateFormat(fileType, filename, contentType, supportedFormats, errors, raiseOnError) {
+  if (supportedFormats.includes(contentType)) {
+    return;
+  }
+  const message = `${fileType} format '${contentType}' is not supported. Supported: ${supportedFormats.join(", ")}`;
+  errors.push(message);
+  if (raiseOnError) {
+    throw new UnsupportedFileTypeError(message, { fileName: filename, contentType });
+  }
+}
+function unsupportedFileType(file, providerName, typeName, raiseOnError) {
+  const message = `Provider '${providerName}' does not support ${typeName}`;
+  if (raiseOnError) {
+    throw new UnsupportedFileTypeError(message, { fileName: file.filename, contentType: file.contentType });
+  }
+  return [message];
+}
+function getFileTypeConstraint(file, constraints) {
+  if (file instanceof ImageFile) {
+    return constraints.image;
+  }
+  if (file instanceof PDFFile) {
+    return constraints.pdf;
+  }
+  if (file instanceof AudioFile) {
+    return constraints.audio;
+  }
+  if (file instanceof VideoFile) {
+    return constraints.video;
+  }
+  if (file instanceof TextFile) {
+    return constraints.text;
+  }
+  return null;
+}
+function formatSize(sizeBytes) {
+  if (sizeBytes >= 1024 * 1024 * 1024) {
+    return `${(sizeBytes / (1024 * 1024 * 1024)).toFixed(1)}GB`;
+  }
+  if (sizeBytes >= 1024 * 1024) {
+    return `${(sizeBytes / (1024 * 1024)).toFixed(1)}MB`;
+  }
+  if (sizeBytes >= 1024) {
+    return `${(sizeBytes / 1024).toFixed(1)}KB`;
+  }
+  return `${String(sizeBytes)}B`;
+}
+function computeFileHash(file) {
+  return createHash("sha256").update(file.read()).digest("hex");
+}
+function uploadCacheKey(fileHash, provider) {
+  return `upload:${provider}:${fileHash}`;
+}
+function contentTypeFromFilename(filename) {
+  switch (extname((filename ?? "").split("?")[0] ?? "").toLowerCase()) {
+    case ".txt":
+    case ".log":
+      return "text/plain";
+    case ".md":
+    case ".markdown":
+      return "text/markdown";
+    case ".csv":
+      return "text/csv";
+    case ".json":
+      return "application/json";
+    case ".xml":
+      return "application/xml";
+    case ".yaml":
+    case ".yml":
+      return "application/x-yaml";
+    case ".html":
+    case ".htm":
+      return "text/html";
+    case ".png":
+      return "image/png";
+    case ".jpg":
+    case ".jpeg":
+      return "image/jpeg";
+    case ".gif":
+      return "image/gif";
+    case ".webp":
+      return "image/webp";
+    case ".pdf":
+      return "application/pdf";
+    case ".wav":
+      return "audio/wav";
+    case ".mp3":
+      return "audio/mpeg";
+    case ".mp4":
+      return "video/mp4";
+    default:
+      return null;
+  }
+}
+function urlPathname(url) {
+  try {
+    return new URL(url).pathname;
+  } catch {
+    return url;
+  }
+}
+function isLikelyText(bytes) {
+  if (bytes.length === 0) {
+    return true;
+  }
+  let printable = 0;
+  for (const byte of bytes) {
+    if (byte === 9 || byte === 10 || byte === 13 || byte >= 32 && byte <= 126) {
+      printable += 1;
+    }
+  }
+  return printable / bytes.length > 0.9;
+}
+
+// src/llm.ts
+var JsonResponseFormat = Object.freeze({ kind: "JsonResponseFormat" });
+var CACHE_BREAKPOINT_KEY = "cache_breakpoint";
+var UsageMetrics = class UsageMetricsValue {
+  totalTokens;
+  total_tokens;
+  promptTokens;
+  prompt_tokens;
+  cachedPromptTokens;
+  cached_prompt_tokens;
+  completionTokens;
+  completion_tokens;
+  reasoningTokens;
+  reasoning_tokens;
+  cacheCreationTokens;
+  cache_creation_tokens;
+  successfulRequests;
+  successful_requests;
+  constructor(options = {}) {
+    this.totalTokens = options.totalTokens ?? options.total_tokens ?? 0;
+    this.total_tokens = this.totalTokens;
+    this.promptTokens = options.promptTokens ?? options.prompt_tokens ?? 0;
+    this.prompt_tokens = this.promptTokens;
+    this.cachedPromptTokens = options.cachedPromptTokens ?? options.cached_prompt_tokens ?? 0;
+    this.cached_prompt_tokens = this.cachedPromptTokens;
+    this.completionTokens = options.completionTokens ?? options.completion_tokens ?? 0;
+    this.completion_tokens = this.completionTokens;
+    this.reasoningTokens = options.reasoningTokens ?? options.reasoning_tokens ?? 0;
+    this.reasoning_tokens = this.reasoningTokens;
+    this.cacheCreationTokens = options.cacheCreationTokens ?? options.cache_creation_tokens ?? 0;
+    this.cache_creation_tokens = this.cacheCreationTokens;
+    this.successfulRequests = options.successfulRequests ?? options.successful_requests ?? 0;
+    this.successful_requests = this.successfulRequests;
+    defineUsageMetricAliases(this);
+  }
+  addUsageMetrics(usageMetrics) {
+    const next = addUsageMetrics(this, normalizeUsageMetrics(usageMetrics));
+    this.assign(next);
+  }
+  add_usage_metrics(usageMetrics) {
+    this.addUsageMetrics(usageMetrics);
+  }
+  assign(metrics) {
+    this.totalTokens = metrics.totalTokens;
+    this.total_tokens = metrics.totalTokens;
+    this.promptTokens = metrics.promptTokens;
+    this.prompt_tokens = metrics.promptTokens;
+    this.cachedPromptTokens = metrics.cachedPromptTokens;
+    this.cached_prompt_tokens = metrics.cachedPromptTokens;
+    this.completionTokens = metrics.completionTokens;
+    this.completion_tokens = metrics.completionTokens;
+    this.reasoningTokens = metrics.reasoningTokens;
+    this.reasoning_tokens = metrics.reasoningTokens;
+    this.cacheCreationTokens = metrics.cacheCreationTokens;
+    this.cache_creation_tokens = metrics.cacheCreationTokens;
+    this.successfulRequests = metrics.successfulRequests;
+    this.successful_requests = metrics.successfulRequests;
+  }
+  modelDump() {
+    return {
+      total_tokens: this.totalTokens,
+      prompt_tokens: this.promptTokens,
+      cached_prompt_tokens: this.cachedPromptTokens,
+      completion_tokens: this.completionTokens,
+      reasoning_tokens: this.reasoningTokens,
+      cache_creation_tokens: this.cacheCreationTokens,
+      successful_requests: this.successfulRequests
+    };
+  }
+  model_dump() {
+    return this.modelDump();
+  }
+};
+var LocalFileUploader = class {
+  provider;
+  options;
+  uploads = [];
+  constructor(provider, options = {}) {
+    this.provider = provider;
+    this.options = { ...options };
+  }
+  upload(name, file) {
+    const rendered = renderLLMInputFile(name, file);
+    const upload = {
+      id: `${this.provider}-file-${String(this.uploads.length + 1)}`,
+      provider: this.provider,
+      name,
+      filename: rendered.filename,
+      contentType: rendered.contentType,
+      content: rendered.content,
+      size: rendered.content.length
+    };
+    this.uploads.push(upload);
+    return upload;
+  }
+  upload_file(name, file) {
+    return this.upload(name, file);
+  }
+};
+var DEFAULT_CONTEXT_WINDOW_SIZE = 4096;
+var DEFAULT_SUPPORTS_STOP_WORDS = true;
+var DEFAULT_LLM_MODEL = "gpt-4.1-mini";
+var JSON_URL = "https://raw.githubusercontent.com/BerriAI/litellm/main/model_prices_and_context_window.json";
+var LITELLM_PARAMS = ["api_key", "api_base", "api_version"];
+var UNACCEPTED_LLM_ENV_ATTRIBUTES = [
+  "AWS_ACCESS_KEY_ID",
+  "AWS_SECRET_ACCESS_KEY",
+  "AWS_DEFAULT_REGION"
+];
+var LLM_ENV_VARS = {
+  openai: [{ key_name: "OPENAI_API_KEY" }],
+  anthropic: [{ key_name: "ANTHROPIC_API_KEY" }],
+  gemini: [{ key_name: "GEMINI_API_KEY" }],
+  nvidia_nim: [{ key_name: "NVIDIA_NIM_API_KEY" }, { key_name: "NVIDIA_API_KEY" }],
+  groq: [{ key_name: "GROQ_API_KEY" }],
+  huggingface: [{ key_name: "HF_TOKEN" }],
+  sambanova: [{ key_name: "SAMBANOVA_API_KEY" }],
+  watson: [
+    { key_name: "WATSONX_URL" },
+    { key_name: "WATSONX_APIKEY" },
+    { key_name: "WATSONX_PROJECT_ID" }
+  ],
+  ollama: [{ default: true, API_BASE: "http://localhost:11434" }],
+  bedrock: [
+    { key_name: "AWS_ACCESS_KEY_ID" },
+    { key_name: "AWS_SECRET_ACCESS_KEY" },
+    { key_name: "AWS_DEFAULT_REGION" }
+  ],
+  azure: [
+    { key_name: "model" },
+    { key_name: "AZURE_API_KEY" },
+    { key_name: "AZURE_API_BASE" },
+    { key_name: "AZURE_API_VERSION" }
+  ],
+  cerebras: [
+    { key_name: "model" },
+    { key_name: "CEREBRAS_API_KEY" }
+  ]
+};
+var ENV_VARS = LLM_ENV_VARS;
+var SUPPORTED_NATIVE_PROVIDERS = ["openai", "anthropic", "azure", "bedrock", "gemini", "snowflake"];
+var LLM_PROVIDER_ALIASES = {
+  openai: "openai",
+  anthropic: "anthropic",
+  claude: "anthropic",
+  azure: "azure",
+  azure_openai: "azure",
+  google: "gemini",
+  gemini: "gemini",
+  bedrock: "bedrock",
+  aws: "bedrock",
+  openrouter: "openrouter",
+  deepseek: "deepseek",
+  ollama: "ollama",
+  ollama_chat: "ollama_chat",
+  hosted_vllm: "hosted_vllm",
+  cerebras: "cerebras",
+  dashscope: "dashscope"
+};
+var PROVIDERS = Object.freeze([
+  "openai",
+  "anthropic",
+  "gemini",
+  "nvidia_nim",
+  "groq",
+  "huggingface",
+  "ollama",
+  "watson",
+  "bedrock",
+  "azure",
+  "cerebras",
+  "sambanova"
+]);
+var OPENAI_MODELS = [
+  "gpt-3.5-turbo",
+  "gpt-3.5-turbo-0125",
+  "gpt-3.5-turbo-0301",
+  "gpt-3.5-turbo-0613",
+  "gpt-3.5-turbo-1106",
+  "gpt-3.5-turbo-16k",
+  "gpt-3.5-turbo-16k-0613",
+  "gpt-3.5-turbo-instruct",
+  "gpt-3.5-turbo-instruct-0914",
+  "gpt-4",
+  "gpt-4-0125-preview",
+  "gpt-4-0314",
+  "gpt-4-0613",
+  "gpt-4-1106-preview",
+  "gpt-4-32k",
+  "gpt-4-32k-0314",
+  "gpt-4-32k-0613",
+  "gpt-4-turbo",
+  "gpt-4-turbo-2024-04-09",
+  "gpt-4-turbo-preview",
+  "gpt-4-vision-preview",
+  "gpt-4.1",
+  "gpt-4.1-2025-04-14",
+  "gpt-4.1-mini",
+  "gpt-4.1-mini-2025-04-14",
+  "gpt-4.1-nano",
+  "gpt-4.1-nano-2025-04-14",
+  "gpt-4o",
+  "gpt-4o-2024-05-13",
+  "gpt-4o-2024-08-06",
+  "gpt-4o-2024-11-20",
+  "gpt-4o-audio-preview",
+  "gpt-4o-audio-preview-2024-10-01",
+  "gpt-4o-audio-preview-2024-12-17",
+  "gpt-4o-audio-preview-2025-06-03",
+  "gpt-4o-mini",
+  "gpt-4o-mini-2024-07-18",
+  "gpt-4o-mini-audio-preview",
+  "gpt-4o-mini-audio-preview-2024-12-17",
+  "gpt-4o-mini-realtime-preview",
+  "gpt-4o-mini-realtime-preview-2024-12-17",
+  "gpt-4o-mini-search-preview",
+  "gpt-4o-mini-search-preview-2025-03-11",
+  "gpt-4o-mini-transcribe",
+  "gpt-4o-mini-tts",
+  "gpt-4o-realtime-preview",
+  "gpt-4o-realtime-preview-2024-10-01",
+  "gpt-4o-realtime-preview-2024-12-17",
+  "gpt-4o-realtime-preview-2025-06-03",
+  "gpt-4o-search-preview",
+  "gpt-4o-search-preview-2025-03-11",
+  "gpt-4o-transcribe",
+  "gpt-4o-transcribe-diarize",
+  "gpt-5",
+  "gpt-5-2025-08-07",
+  "gpt-5-chat",
+  "gpt-5-chat-latest",
+  "gpt-5-codex",
+  "gpt-5-mini",
+  "gpt-5-mini-2025-08-07",
+  "gpt-5-nano",
+  "gpt-5-nano-2025-08-07",
+  "gpt-5-pro",
+  "gpt-5-pro-2025-10-06",
+  "gpt-5-search-api",
+  "gpt-5-search-api-2025-10-14",
+  "gpt-audio",
+  "gpt-audio-2025-08-28",
+  "gpt-audio-mini",
+  "gpt-audio-mini-2025-10-06",
+  "gpt-image-1",
+  "gpt-image-1-mini",
+  "gpt-realtime",
+  "gpt-realtime-2025-08-28",
+  "gpt-realtime-mini",
+  "gpt-realtime-mini-2025-10-06",
+  "o1",
+  "o1-preview",
+  "o1-2024-12-17",
+  "o1-mini",
+  "o1-mini-2024-09-12",
+  "o1-pro",
+  "o1-pro-2025-03-19",
+  "o3-mini",
+  "o3",
+  "o4-mini",
+  "whisper-1"
+];
+var ANTHROPIC_MODELS = [
+  "claude-opus-4-5-20251101",
+  "claude-opus-4-5",
+  "claude-3-7-sonnet-latest",
+  "claude-3-7-sonnet-20250219",
+  "claude-3-5-haiku-latest",
+  "claude-3-5-haiku-20241022",
+  "claude-haiku-4-5",
+  "claude-haiku-4-5-20251001",
+  "claude-sonnet-4-20250514",
+  "claude-sonnet-4-0",
+  "claude-4-sonnet-20250514",
+  "claude-sonnet-4-5",
+  "claude-sonnet-4-5-20250929",
+  "claude-3-5-sonnet-latest",
+  "claude-3-5-sonnet-20241022",
+  "claude-3-5-sonnet-20240620",
+  "claude-opus-4-0",
+  "claude-opus-4-20250514",
+  "claude-4-opus-20250514",
+  "claude-opus-4-1",
+  "claude-opus-4-1-20250805",
+  "claude-3-opus-latest",
+  "claude-3-opus-20240229",
+  "claude-3-sonnet-20240229",
+  "claude-3-haiku-latest",
+  "claude-3-haiku-20240307"
+];
+var AZURE_MODELS = [
+  "gpt-3.5-turbo",
+  "gpt-3.5-turbo-0301",
+  "gpt-3.5-turbo-0613",
+  "gpt-3.5-turbo-16k",
+  "gpt-3.5-turbo-16k-0613",
+  "gpt-35-turbo",
+  "gpt-35-turbo-0125",
+  "gpt-35-turbo-1106",
+  "gpt-35-turbo-16k-0613",
+  "gpt-35-turbo-instruct-0914",
+  "gpt-4",
+  "gpt-4-0314",
+  "gpt-4-0613",
+  "gpt-4-1106-preview",
+  "gpt-4-0125-preview",
+  "gpt-4-32k",
+  "gpt-4-32k-0314",
+  "gpt-4-32k-0613",
+  "gpt-4-turbo",
+  "gpt-4-turbo-2024-04-09",
+  "gpt-4-vision",
+  "gpt-4o",
+  "gpt-4o-2024-05-13",
+  "gpt-4o-2024-08-06",
+  "gpt-4o-2024-11-20",
+  "gpt-4o-mini",
+  "gpt-5",
+  "o1",
+  "o1-mini",
+  "o1-preview",
+  "o3-mini",
+  "o3",
+  "o4-mini"
+];
+var BEDROCK_MODELS = [
+  "us.anthropic.claude-sonnet-4-5-20250929-v1:0",
+  "us.anthropic.claude-sonnet-4-20250514-v1:0",
+  "us.anthropic.claude-opus-4-5-20251101-v1:0",
+  "us.anthropic.claude-opus-4-20250514-v1:0",
+  "us.anthropic.claude-opus-4-1-20250805-v1:0",
+  "us.anthropic.claude-haiku-4-5-20251001-v1:0",
+  "us.anthropic.claude-sonnet-4-6",
+  "us.anthropic.claude-opus-4-6-v1",
+  "us.anthropic.claude-sonnet-4-5-v1:0",
+  "us.anthropic.claude-opus-4-5-v1:0",
+  "us.anthropic.claude-opus-4-6-v1:0",
+  "us.anthropic.claude-haiku-4-5-v1:0",
+  "eu.anthropic.claude-sonnet-4-5-v1:0",
+  "eu.anthropic.claude-opus-4-5-v1:0",
+  "eu.anthropic.claude-haiku-4-5-v1:0",
+  "apac.anthropic.claude-sonnet-4-5-v1:0",
+  "apac.anthropic.claude-opus-4-5-v1:0",
+  "apac.anthropic.claude-haiku-4-5-v1:0",
+  "global.anthropic.claude-sonnet-4-5-20250929-v1:0",
+  "global.anthropic.claude-sonnet-4-20250514-v1:0",
+  "global.anthropic.claude-opus-4-5-20251101-v1:0",
+  "global.anthropic.claude-opus-4-6-v1",
+  "global.anthropic.claude-haiku-4-5-20251001-v1:0",
+  "global.anthropic.claude-sonnet-4-6",
+  "ai21.jamba-1-5-large-v1:0",
+  "ai21.jamba-1-5-mini-v1:0",
+  "amazon.nova-lite-v1:0",
+  "amazon.nova-lite-v1:0:24k",
+  "amazon.nova-lite-v1:0:300k",
+  "amazon.nova-micro-v1:0",
+  "amazon.nova-micro-v1:0:128k",
+  "amazon.nova-micro-v1:0:24k",
+  "amazon.nova-premier-v1:0",
+  "amazon.nova-premier-v1:0:1000k",
+  "amazon.nova-premier-v1:0:20k",
+  "amazon.nova-premier-v1:0:8k",
+  "amazon.nova-premier-v1:0:mm",
+  "amazon.nova-pro-v1:0",
+  "amazon.nova-pro-v1:0:24k",
+  "amazon.nova-pro-v1:0:300k",
+  "amazon.titan-text-express-v1",
+  "amazon.titan-text-express-v1:0:8k",
+  "amazon.titan-text-lite-v1",
+  "amazon.titan-text-lite-v1:0:4k",
+  "amazon.titan-tg1-large",
+  "anthropic.claude-3-5-haiku-20241022-v1:0",
+  "anthropic.claude-3-5-sonnet-20240620-v1:0",
+  "anthropic.claude-3-5-sonnet-20241022-v2:0",
+  "anthropic.claude-3-7-sonnet-20250219-v1:0",
+  "anthropic.claude-3-haiku-20240307-v1:0",
+  "anthropic.claude-3-haiku-20240307-v1:0:200k",
+  "anthropic.claude-3-haiku-20240307-v1:0:48k",
+  "anthropic.claude-3-opus-20240229-v1:0",
+  "anthropic.claude-3-opus-20240229-v1:0:12k",
+  "anthropic.claude-3-opus-20240229-v1:0:200k",
+  "anthropic.claude-3-opus-20240229-v1:0:28k",
+  "anthropic.claude-3-sonnet-20240229-v1:0",
+  "anthropic.claude-3-sonnet-20240229-v1:0:200k",
+  "anthropic.claude-3-sonnet-20240229-v1:0:28k",
+  "anthropic.claude-haiku-4-5-20251001-v1:0",
+  "anthropic.claude-instant-v1:2:100k",
+  "anthropic.claude-opus-4-5-20251101-v1:0",
+  "anthropic.claude-opus-4-1-20250805-v1:0",
+  "anthropic.claude-opus-4-20250514-v1:0",
+  "anthropic.claude-sonnet-4-20250514-v1:0",
+  "anthropic.claude-sonnet-4-5-20250929-v1:0",
+  "anthropic.claude-v2:0:100k",
+  "anthropic.claude-v2:0:18k",
+  "anthropic.claude-v2:1:18k",
+  "anthropic.claude-v2:1:200k",
+  "cohere.command-r-plus-v1:0",
+  "cohere.command-r-v1:0",
+  "cohere.rerank-v3-5:0",
+  "deepseek.r1-v1:0",
+  "meta.llama3-1-70b-instruct-v1:0",
+  "meta.llama3-1-8b-instruct-v1:0",
+  "meta.llama3-2-11b-instruct-v1:0",
+  "meta.llama3-2-1b-instruct-v1:0",
+  "meta.llama3-2-3b-instruct-v1:0",
+  "meta.llama3-2-90b-instruct-v1:0",
+  "meta.llama3-3-70b-instruct-v1:0",
+  "meta.llama3-70b-instruct-v1:0",
+  "meta.llama3-8b-instruct-v1:0",
+  "meta.llama4-maverick-17b-instruct-v1:0",
+  "meta.llama4-scout-17b-instruct-v1:0",
+  "mistral.mistral-7b-instruct-v0:2",
+  "mistral.mistral-large-2402-v1:0",
+  "mistral.mistral-small-2402-v1:0",
+  "mistral.mixtral-8x7b-instruct-v0:1",
+  "mistral.pixtral-large-2502-v1:0",
+  "openai.gpt-oss-120b-1:0",
+  "openai.gpt-oss-20b-1:0",
+  "qwen.qwen3-32b-v1:0",
+  "qwen.qwen3-coder-30b-a3b-v1:0",
+  "twelvelabs.pegasus-1-2-v1:0"
+];
+var NVIDIA_NIM_MODELS = [
+  "nvidia_nim/nvidia/mistral-nemo-minitron-8b-8k-instruct",
+  "nvidia_nim/nvidia/nemotron-4-mini-hindi-4b-instruct",
+  "nvidia_nim/nvidia/llama-3.1-nemotron-70b-instruct",
+  "nvidia_nim/nvidia/llama3-chatqa-1.5-8b",
+  "nvidia_nim/nvidia/llama3-chatqa-1.5-70b",
+  "nvidia_nim/nvidia/vila",
+  "nvidia_nim/nvidia/neva-22",
+  "nvidia_nim/nvidia/nemotron-mini-4b-instruct",
+  "nvidia_nim/nvidia/usdcode-llama3-70b-instruct",
+  "nvidia_nim/nvidia/nemotron-4-340b-instruct",
+  "nvidia_nim/nvidia/nvidia-nemotron-3-ultra-550b-a55b",
+  "nvidia_nim/meta/codellama-70b",
+  "nvidia_nim/meta/llama2-70b",
+  "nvidia_nim/meta/llama3-8b-instruct",
+  "nvidia_nim/meta/llama3-70b-instruct",
+  "nvidia_nim/meta/llama-3.1-8b-instruct",
+  "nvidia_nim/meta/llama-3.1-70b-instruct",
+  "nvidia_nim/meta/llama-3.1-405b-instruct",
+  "nvidia_nim/meta/llama-3.2-1b-instruct",
+  "nvidia_nim/meta/llama-3.2-3b-instruct",
+  "nvidia_nim/meta/llama-3.2-11b-vision-instruct",
+  "nvidia_nim/meta/llama-3.2-90b-vision-instruct",
+  "nvidia_nim/meta/llama-3.1-70b-instruct",
+  "nvidia_nim/google/gemma-7b",
+  "nvidia_nim/google/gemma-2b",
+  "nvidia_nim/google/codegemma-7b",
+  "nvidia_nim/google/codegemma-1.1-7b",
+  "nvidia_nim/google/recurrentgemma-2b",
+  "nvidia_nim/google/gemma-2-9b-it",
+  "nvidia_nim/google/gemma-2-27b-it",
+  "nvidia_nim/google/gemma-2-2b-it",
+  "nvidia_nim/google/deplot",
+  "nvidia_nim/google/paligemma",
+  "nvidia_nim/mistralai/mistral-7b-instruct-v0.2",
+  "nvidia_nim/mistralai/mixtral-8x7b-instruct-v0.1",
+  "nvidia_nim/mistralai/mistral-large",
+  "nvidia_nim/mistralai/mixtral-8x22b-instruct-v0.1",
+  "nvidia_nim/mistralai/mistral-7b-instruct-v0.3",
+  "nvidia_nim/nv-mistralai/mistral-nemo-12b-instruct",
+  "nvidia_nim/mistralai/mamba-codestral-7b-v0.1",
+  "nvidia_nim/microsoft/phi-3-mini-128k-instruct",
+  "nvidia_nim/microsoft/phi-3-mini-4k-instruct",
+  "nvidia_nim/microsoft/phi-3-small-8k-instruct",
+  "nvidia_nim/microsoft/phi-3-small-128k-instruct",
+  "nvidia_nim/microsoft/phi-3-medium-4k-instruct",
+  "nvidia_nim/microsoft/phi-3-medium-128k-instruct",
+  "nvidia_nim/microsoft/phi-3.5-mini-instruct",
+  "nvidia_nim/microsoft/phi-3.5-moe-instruct",
+  "nvidia_nim/microsoft/kosmos-2",
+  "nvidia_nim/microsoft/phi-3-vision-128k-instruct",
+  "nvidia_nim/microsoft/phi-3.5-vision-instruct",
+  "nvidia_nim/databricks/dbrx-instruct",
+  "nvidia_nim/snowflake/arctic",
+  "nvidia_nim/aisingapore/sea-lion-7b-instruct",
+  "nvidia_nim/ibm/granite-8b-code-instruct",
+  "nvidia_nim/ibm/granite-34b-code-instruct",
+  "nvidia_nim/ibm/granite-3.0-8b-instruct",
+  "nvidia_nim/ibm/granite-3.0-3b-a800m-instruct",
+  "nvidia_nim/mediatek/breeze-7b-instruct",
+  "nvidia_nim/upstage/solar-10.7b-instruct",
+  "nvidia_nim/writer/palmyra-med-70b-32k",
+  "nvidia_nim/writer/palmyra-med-70b",
+  "nvidia_nim/writer/palmyra-fin-70b-32k",
+  "nvidia_nim/01-ai/yi-large",
+  "nvidia_nim/deepseek-ai/deepseek-coder-6.7b-instruct",
+  "nvidia_nim/rakuten/rakutenai-7b-instruct",
+  "nvidia_nim/rakuten/rakutenai-7b-chat",
+  "nvidia_nim/baichuan-inc/baichuan2-13b-chat"
+];
+var GROQ_MODELS = [
+  "groq/llama-3.1-8b-instant",
+  "groq/llama-3.1-70b-versatile",
+  "groq/llama-3.1-405b-reasoning",
+  "groq/gemma2-9b-it",
+  "groq/gemma-7b-it"
+];
+var OLLAMA_MODELS = [
+  "ollama/llama3.1",
+  "ollama/mixtral"
+];
+var WATSON_MODELS = [
+  "watsonx/meta-llama/llama-3-1-70b-instruct",
+  "watsonx/meta-llama/llama-3-1-8b-instruct",
+  "watsonx/meta-llama/llama-3-2-11b-vision-instruct",
+  "watsonx/meta-llama/llama-3-2-1b-instruct",
+  "watsonx/meta-llama/llama-3-2-90b-vision-instruct",
+  "watsonx/meta-llama/llama-3-405b-instruct",
+  "watsonx/mistral/mistral-large",
+  "watsonx/ibm/granite-3-8b-instruct"
+];
+var HUGGINGFACE_MODELS = [
+  "huggingface/meta-llama/Meta-Llama-3.1-8B-Instruct",
+  "huggingface/mistralai/Mixtral-8x7B-Instruct-v0.1",
+  "huggingface/tiiuae/falcon-180B-chat",
+  "huggingface/google/gemma-7b-it"
+];
+var SAMBANOVA_MODELS = [
+  "sambanova/Meta-Llama-3.3-70B-Instruct",
+  "sambanova/QwQ-32B-Preview",
+  "sambanova/Qwen2.5-72B-Instruct",
+  "sambanova/Qwen2.5-Coder-32B-Instruct",
+  "sambanova/Meta-Llama-3.1-405B-Instruct",
+  "sambanova/Meta-Llama-3.1-70B-Instruct",
+  "sambanova/Meta-Llama-3.1-8B-Instruct",
+  "sambanova/Llama-3.2-90B-Vision-Instruct",
+  "sambanova/Llama-3.2-11B-Vision-Instruct",
+  "sambanova/Meta-Llama-3.2-3B-Instruct",
+  "sambanova/Meta-Llama-3.2-1B-Instruct"
+];
+var OpenAIModels = OPENAI_MODELS;
+var AnthropicModels = ANTHROPIC_MODELS;
+var AzureModels = AZURE_MODELS;
+var BedrockModels = BEDROCK_MODELS;
+var NvidiaNimModels = NVIDIA_NIM_MODELS;
+var GroqModels = GROQ_MODELS;
+var OllamaModels = OLLAMA_MODELS;
+var WatsonModels = WATSON_MODELS;
+var HuggingFaceModels = HUGGINGFACE_MODELS;
+var SambanovaModels = SAMBANOVA_MODELS;
+var MODELS = Object.freeze({
+  openai: OPENAI_MODELS,
+  anthropic: ANTHROPIC_MODELS,
+  nvidia_nim: NVIDIA_NIM_MODELS,
+  groq: GROQ_MODELS,
+  ollama: OLLAMA_MODELS,
+  watson: WATSON_MODELS,
+  azure: AZURE_MODELS,
+  bedrock: BEDROCK_MODELS,
+  huggingface: HUGGINGFACE_MODELS,
+  sambanova: SAMBANOVA_MODELS
+});
+var CONTEXT_WINDOW_USAGE_RATIO = 0.85;
+var MIN_CONTEXT_WINDOW_SIZE = 1024;
+var MAX_CONTEXT_WINDOW_SIZE = 2097152;
+var MIN_CONTEXT = MIN_CONTEXT_WINDOW_SIZE;
+var MAX_CONTEXT = MAX_CONTEXT_WINDOW_SIZE;
+var ANTHROPIC_PREFIXES = Object.freeze(["anthropic/", "claude-", "claude/"]);
+var Delta = Object.freeze({ kind: "Delta" });
+var StreamingChoices = Object.freeze({ kind: "StreamingChoices" });
+var FunctionArgs = class {
+  name;
+  arguments;
+  constructor(options = {}) {
+    this.name = options.name ?? "";
+    this.arguments = options.arguments ?? "";
+  }
+};
+var AccumulatedToolArgs = class _AccumulatedToolArgs {
+  id;
+  index;
+  type;
+  function;
+  constructor(options = {}) {
+    this.id = options.id ?? null;
+    this.index = options.index ?? 0;
+    this.type = options.type ?? "function";
+    this.function = options.function instanceof FunctionArgs ? options.function : new FunctionArgs(options.function);
+  }
+  accumulate(delta) {
+    const record = readLLMRecord(delta);
+    const deltaIndex = numberValue(record.index);
+    if (deltaIndex !== null) {
+      this.index = deltaIndex;
+    }
+    if (typeof record.id === "string" && !this.id) {
+      this.id = record.id;
+    }
+    if (typeof record.type === "string") {
+      this.type = record.type;
+    }
+    const functionDelta = readLLMRecord(record.function);
+    if (typeof functionDelta.name === "string" && functionDelta.name.length > 0) {
+      this.function.name = functionDelta.name;
+    }
+    if (typeof functionDelta.arguments === "string" && functionDelta.arguments.length > 0) {
+      this.function.arguments += functionDelta.arguments;
+    }
+    return this;
+  }
+  toToolCall() {
+    return {
+      id: this.id,
+      type: this.type,
+      index: this.index,
+      function: {
+        name: this.function.name,
+        arguments: this.function.arguments
+      }
+    };
+  }
+  to_tool_call() {
+    return this.toToolCall();
+  }
+  static toToolCalls(toolCalls) {
+    return Object.entries(toolCalls).map(([key, value]) => {
+      const accumulator = value instanceof _AccumulatedToolArgs ? value : new _AccumulatedToolArgs(value);
+      if (accumulator.index === 0) {
+        const keyIndex = Number(key);
+        if (Number.isInteger(keyIndex)) {
+          accumulator.index = keyIndex;
+        }
+      }
+      return accumulator;
+    }).sort((left, right) => left.index - right.index).map((entry) => entry.toToolCall());
+  }
+  static to_tool_calls(toolCalls) {
+    return _AccumulatedToolArgs.toToolCalls(toolCalls);
+  }
+  static fromStreamingChunks(chunks) {
+    const accumulators = {};
+    for (const chunk of chunks) {
+      for (const toolCall of extractStreamingToolCallDeltas(chunk)) {
+        const index = numberValue(readLLMRecord(toolCall).index) ?? 0;
+        accumulators[index] ??= new _AccumulatedToolArgs({ index });
+        accumulators[index].accumulate(toolCall);
+      }
+    }
+    return _AccumulatedToolArgs.toToolCalls(accumulators);
+  }
+  static from_streaming_chunks(chunks) {
+    return _AccumulatedToolArgs.fromStreamingChunks(chunks);
+  }
+};
+function extractStreamingToolCallDeltas(chunk) {
+  const record = readLLMRecord(chunk);
+  const direct = readLLMRecord(record.delta).tool_calls ?? record.tool_calls;
+  if (Array.isArray(direct)) {
+    return direct;
+  }
+  const choices = Array.isArray(record.choices) ? record.choices : [];
+  const deltas = [];
+  for (const choice of choices) {
+    const toolCalls = readLLMRecord(readLLMRecord(choice).delta).tool_calls;
+    if (Array.isArray(toolCalls)) {
+      for (const toolCall of toolCalls) {
+        deltas.push(toolCall);
+      }
+    }
+  }
+  return deltas;
+}
+function readLLMRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function numberValue(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+var LLM_CONTEXT_WINDOW_SIZES = {
+  "gpt-4": 8192,
+  "gpt-4o": 128e3,
+  "gpt-4o-mini": 2e5,
+  "gpt-4-turbo": 128e3,
+  "gpt-4.1": 1047576,
+  "gpt-4.1-mini-2025-04-14": 1047576,
+  "gpt-4.1-nano-2025-04-14": 1047576,
+  "o1-preview": 128e3,
+  "o1-mini": 128e3,
+  "o3-mini": 2e5,
+  "o4-mini": 2e5,
+  "deepseek-chat": 128e3,
+  "llama-3.1-70b-versatile": 131072,
+  "llama-3.1-8b-instant": 131072,
+  "llama-3.3-70b-versatile": 128e3,
+  "mixtral-8x7b-32768": 32768,
+  "anthropic.claude-v2": 1e5,
+  "anthropic.claude-v2:1": 2e5,
+  "anthropic.claude-instant-v1": 1e5,
+  "anthropic.claude-3-haiku-20240307-v1:0": 2e5,
+  "anthropic.claude-3-sonnet-20240229-v1:0": 2e5,
+  "anthropic.claude-3-opus-20240229-v1:0": 2e5,
+  "anthropic.claude-3-5-sonnet-20240620-v1:0": 2e5,
+  "anthropic.claude-3-5-haiku-20241022-v1:0": 2e5,
+  "anthropic.claude-3-7-sonnet-20250219-v1:0": 2e5,
+  "anthropic.claude-sonnet-4-20250514-v1:0": 2e5,
+  "anthropic.claude-opus-4-20250514-v1:0": 2e5,
+  "anthropic.claude-sonnet-4-5-20250929-v1:0": 2e5,
+  "anthropic.claude-opus-4-5-20251101-v1:0": 2e5,
+  "anthropic.claude-haiku-4-5-20251001-v1:0": 2e5,
+  "anthropic.claude-opus-4-7": 1e6,
+  "anthropic.claude-sonnet-4-6": 1e6,
+  "amazon.nova-pro-v1:0": 3e5,
+  "amazon.nova-lite-v1:0": 3e5,
+  "amazon.nova-micro-v1:0": 128e3,
+  "meta.llama3-1-8b-instruct-v1:0": 128e3,
+  "meta.llama3-1-70b-instruct-v1:0": 128e3,
+  "meta.llama3-1-405b-instruct-v1:0": 128e3,
+  "mistral-tiny": 32768,
+  "mistral-small-latest": 32768,
+  "mistral-medium-latest": 32768,
+  "mistral-large-latest": 32768
+};
+var currentCallIdStore = new AsyncLocalStorage();
+var callStopOverrideStore = new AsyncLocalStorage();
+var configuredCallbacks = [];
+var configuredSuccessCallbacks = [];
+var configuredFailureCallbacks = [];
+var registeredProviders = /* @__PURE__ */ new Map();
+var registeredProviderFactories = /* @__PURE__ */ new Map();
+var openAIModelSet = new Set(OPENAI_MODELS);
+var anthropicModelSet = new Set(ANTHROPIC_MODELS);
+var azureModelSet = new Set(AZURE_MODELS);
+var bedrockModelSet = new Set(BEDROCK_MODELS);
+var nativeProviderSet = new Set(SUPPORTED_NATIVE_PROVIDERS);
+async function llmCallContext(callback) {
+  const callId = randomUUID();
+  return await currentCallIdStore.run(callId, async () => await callback(callId));
+}
+var llm_call_context = llmCallContext;
+function validate_function_name(name, provider = "LLM") {
+  if (!name) {
+    throw new Error(`${provider} function name cannot be empty`);
+  }
+  if (!/^[A-Za-z_]/.test(name)) {
+    throw new Error(`${provider} function name '${name}' must start with a letter or underscore`);
+  }
+  if (name.length > 64) {
+    throw new Error(`${provider} function name '${name}' exceeds 64 character limit`);
+  }
+  if (!/^[a-z_][a-z0-9_]*$/.test(name)) {
+    throw new Error(`${provider} function name '${name}' contains invalid characters. Only lowercase letters, numbers, and underscores allowed`);
+  }
+  return name;
+}
+function sanitize_function_name(name) {
+  const normalized = name.trim().toLowerCase().replace(/[^a-z0-9_]/g, "_").replace(/_+/g, "_").slice(0, 64);
+  return /^[a-z_]/.test(normalized) ? normalized : `_${normalized}`;
+}
+function extract_tool_info(tool) {
+  if (!recordOrNull(tool)) {
+    throw new Error("Tool must be a dictionary");
+  }
+  let source = tool;
+  if ("function" in tool) {
+    const functionInfo = recordOrNull(tool.function);
+    if (!functionInfo) {
+      throw new Error("Tool function must be a dictionary");
+    }
+    source = functionInfo;
+  }
+  const name = stringOrEmpty(source.name);
+  const description = stringOrEmpty(source.description);
+  const parameters = recordOrNull(source.parameters) ?? argsSchemaParameters(source.args_schema) ?? {};
+  return [name, description, parameters];
+}
+function log_tool_conversion(tool, provider) {
+  void extract_tool_info(tool);
+  void provider;
+}
+function safe_tool_conversion(tool, provider) {
+  log_tool_conversion(tool, provider);
+  const [name, description, parameters] = extract_tool_info(tool);
+  return [validate_function_name(sanitize_function_name(name), provider), description, parameters];
+}
+function getCurrentCallId() {
+  return currentCallIdStore.getStore() ?? randomUUID();
+}
+var get_current_call_id = getCurrentCallId;
+async function callStopOverride(llm, stop, callback) {
+  const current = callStopOverrideStore.getStore();
+  const overrides = new Map(current ?? []);
+  if (stop === null) {
+    overrides.delete(llm);
+  } else {
+    overrides.set(llm, normalizeStopSequences(stop));
+  }
+  return await callStopOverrideStore.run(overrides, async () => await callback());
+}
+var call_stop_override = callStopOverride;
+function callStopOverrideSync(llm, stop, callback) {
+  const current = callStopOverrideStore.getStore();
+  const overrides = new Map(current ?? []);
+  if (stop === null) {
+    overrides.delete(llm);
+  } else {
+    overrides.set(llm, normalizeStopSequences(stop));
+  }
+  return callStopOverrideStore.run(overrides, callback);
+}
+var call_stop_override_sync = callStopOverrideSync;
+var FunctionLLM = class {
+  constructor(fn) {
+    this.fn = fn;
+  }
+  fn;
+  usageMetrics = emptyUsageMetrics();
+  async call(messages, options) {
+    const response = await this.fn(messages, options);
+    this.usageMetrics = addUsageMetrics(
+      this.usageMetrics,
+      estimateUsageMetrics(messages, response)
+    );
+    return response;
+  }
+  getUsageMetrics() {
+    return { ...this.usageMetrics };
+  }
+  getTokenUsageSummary() {
+    return this.getUsageMetrics();
+  }
+  resetUsageMetrics() {
+    this.usageMetrics = emptyUsageMetrics();
+  }
+};
+function createLLM(llmValue = null, env = process.env) {
+  if (llmValue == null) {
+    return llmViaEnvironmentOrFallback(env);
+  }
+  if (typeof llmValue === "string") {
+    const spec2 = resolveLLMModelSpec(llmValue);
+    const usesProviderFactory2 = registeredProviderFactories.has(spec2.provider);
+    return createConfiguredLLM({
+      model: usesProviderFactory2 ? spec2.model : llmValue,
+      provider: spec2.provider,
+      is_litellm: !spec2.useNative && !usesProviderFactory2
+    });
+  }
+  if (typeof llmValue === "function" || isLLMClient(llmValue)) {
+    return createLLMClient(llmValue);
+  }
+  const model = stringProperty(llmValue, "model") ?? stringProperty(llmValue, "model_name") ?? stringProperty(llmValue, "deployment_name") ?? stringifyLLMValue(llmValue);
+  const spec = resolveLLMModelSpec(model, stringProperty(llmValue, "provider"));
+  const usesProviderFactory = registeredProviderFactories.has(spec.provider);
+  const apiKey = stringProperty(llmValue, "api_key");
+  const baseUrl = stringProperty(llmValue, "base_url");
+  const apiBase = stringProperty(llmValue, "api_base");
+  const usesOpenAICompatibleEndpoint = spec.provider === "openai" && (baseUrl !== void 0 || apiBase !== void 0);
+  const options = {
+    model: usesProviderFactory || usesOpenAICompatibleEndpoint ? spec.model : model,
+    provider: spec.provider,
+    is_litellm: !spec.useNative && !usesProviderFactory && !usesOpenAICompatibleEndpoint,
+    temperature: numberProperty(llmValue, "temperature"),
+    max_tokens: numberProperty(llmValue, "max_tokens"),
+    max_completion_tokens: numberProperty(llmValue, "max_completion_tokens"),
+    top_p: numberProperty(llmValue, "top_p"),
+    presence_penalty: numberProperty(llmValue, "presence_penalty"),
+    frequency_penalty: numberProperty(llmValue, "frequency_penalty"),
+    seed: numberProperty(llmValue, "seed"),
+    logprobs: booleanOrNumberProperty(llmValue, "logprobs"),
+    top_logprobs: numberProperty(llmValue, "top_logprobs"),
+    timeout: numberProperty(llmValue, "timeout")
+  };
+  const stop = llmValue["stop"];
+  if (typeof stop === "string" || Array.isArray(stop)) {
+    options.stop = stop;
+  }
+  const responseFormat = llmValue["response_format"] ?? llmValue["responseFormat"];
+  if (responseFormat !== void 0) {
+    options.response_format = responseFormat;
+  }
+  if (apiKey !== void 0) {
+    options.api_key = apiKey;
+  }
+  if (baseUrl !== void 0) {
+    options.base_url = baseUrl;
+  }
+  if (apiBase !== void 0) {
+    options.api_base = apiBase;
+  }
+  const providerOptions = options;
+  const llmOptions = llmValue;
+  for (const key of [
+    "api",
+    "instructions",
+    "store",
+    "previousResponseId",
+    "previous_response_id",
+    "include",
+    "builtinTools",
+    "builtin_tools",
+    "parseToolOutputs",
+    "parse_tool_outputs",
+    "autoChain",
+    "auto_chain",
+    "autoChainReasoning",
+    "auto_chain_reasoning"
+  ]) {
+    if (llmOptions[key] !== void 0) {
+      providerOptions[key] = llmOptions[key];
+    }
+  }
+  return createConfiguredLLM(options);
+}
+var create_llm = createLLM;
+function llmViaEnvironmentOrFallback(env = process.env) {
+  const model = env.MODEL ?? env.MODEL_NAME ?? env.OPENAI_MODEL_NAME ?? DEFAULT_LLM_MODEL;
+  let baseUrl = env.BASE_URL ?? env.OPENAI_API_BASE ?? env.OPENAI_BASE_URL;
+  let apiBase = env.API_BASE ?? env.AZURE_API_BASE;
+  if (baseUrl !== void 0 && apiBase === void 0) {
+    apiBase = baseUrl;
+  } else if (apiBase !== void 0 && baseUrl === void 0) {
+    baseUrl = apiBase;
+  }
+  const spec = resolveLLMModelSpec(model);
+  const usesProviderFactory = registeredProviderFactories.has(spec.provider);
+  const options = {
+    model: usesProviderFactory ? spec.model : model,
+    provider: spec.provider,
+    is_litellm: !spec.useNative && !usesProviderFactory,
+    ...baseUrl === void 0 ? {} : { base_url: baseUrl },
+    ...apiBase === void 0 ? {} : { api_base: apiBase }
+  };
+  applyLLMEnvVars(options, spec.provider, env);
+  return createConfiguredLLM(options);
+}
+var llm_via_environment_or_fallback = llmViaEnvironmentOrFallback;
+var _llm_via_environment_or_fallback = llmViaEnvironmentOrFallback;
+function normalizeLLMEnvKeyName(keyName) {
+  for (const pattern of LITELLM_PARAMS) {
+    if (keyName.includes(pattern)) {
+      return pattern;
+    }
+  }
+  return keyName;
+}
+var normalize_llm_env_key_name = normalizeLLMEnvKeyName;
+var _normalize_key_name = normalizeLLMEnvKeyName;
+var BASE_LLM_OPTION_FIELDS = /* @__PURE__ */ new Set([
+  "model",
+  "temperature",
+  "apiKey",
+  "api_key",
+  "baseUrl",
+  "base_url",
+  "provider",
+  "preferUpload",
+  "prefer_upload",
+  "isLitellm",
+  "is_litellm",
+  "stop",
+  "stopSequences",
+  "stop_sequences",
+  "additionalParams",
+  "additional_params",
+  "responseFormat",
+  "response_format",
+  "contextWindowSize",
+  "context_window_size"
+]);
+var BaseLLM = class _BaseLLM {
+  llmType = "base";
+  llm_type = "base";
+  model;
+  temperature;
+  apiKey;
+  api_key;
+  baseUrl;
+  base_url;
+  provider;
+  preferUpload;
+  prefer_upload;
+  isLitellm;
+  is_litellm;
+  additionalParams;
+  additional_params;
+  responseFormat;
+  response_format;
+  contextWindowSize;
+  stopValues;
+  tokenUsage = emptyUsageMetrics();
+  constructor(options) {
+    if (!options.model) {
+      throw new Error("Model name is required and cannot be empty.");
+    }
+    this.model = options.model;
+    this.temperature = options.temperature ?? null;
+    this.apiKey = options.apiKey ?? options.api_key ?? null;
+    this.api_key = this.apiKey;
+    this.baseUrl = options.baseUrl ?? options.base_url ?? null;
+    this.base_url = this.baseUrl;
+    this.provider = options.provider || "openai";
+    this.preferUpload = options.preferUpload ?? options.prefer_upload ?? false;
+    this.prefer_upload = this.preferUpload;
+    this.isLitellm = options.isLitellm ?? options.is_litellm ?? false;
+    this.is_litellm = this.isLitellm;
+    this.stopValues = normalizeStopSequences(options.stopSequences ?? options.stop_sequences ?? options.stop ?? []);
+    this.additionalParams = { ...options.additionalParams ?? {}, ...options.additional_params ?? {} };
+    this.additional_params = this.additionalParams;
+    this.responseFormat = options.responseFormat ?? options.response_format ?? null;
+    this.response_format = this.responseFormat;
+    this.contextWindowSize = options.contextWindowSize ?? options.context_window_size ?? 0;
+  }
+  async acall(messages, options) {
+    return await this.call(this.formatMessages(messages), options);
+  }
+  get stop() {
+    return [...this.stopValues];
+  }
+  set stop(value) {
+    this.stopValues = normalizeStopSequences(value);
+  }
+  get stopSequences() {
+    const override = callStopOverrideStore.getStore()?.get(this);
+    if (override) {
+      return override;
+    }
+    return this.stopValues;
+  }
+  get stop_sequences() {
+    return this.stopSequences;
+  }
+  setStopSequences(stop) {
+    this.stopValues = normalizeStopSequences(stop);
+  }
+  set_stop_sequences(stop) {
+    this.setStopSequences(stop);
+  }
+  supportsStopWords() {
+    if (this.model.toLowerCase().includes("gpt-5")) {
+      return false;
+    }
+    return DEFAULT_SUPPORTS_STOP_WORDS;
+  }
+  supports_stop_words() {
+    return this.supportsStopWords();
+  }
+  supportsFunctionCalling() {
+    return true;
+  }
+  supports_function_calling() {
+    return this.supportsFunctionCalling();
+  }
+  supportsStopWordsImplementation() {
+    return this.stopSequences.length > 0;
+  }
+  _supports_stop_words_implementation() {
+    return this.supportsStopWordsImplementation();
+  }
+  applyStopWords(content) {
+    if (this.stopSequences.length === 0 || content.length === 0) {
+      return content;
+    }
+    let earliest = content.length;
+    for (const stop of this.stopSequences) {
+      const index = content.indexOf(stop);
+      if (index !== -1 && index < earliest) {
+        earliest = index;
+      }
+    }
+    return earliest === content.length ? content : content.slice(0, earliest).trim();
+  }
+  _apply_stop_words(content) {
+    return this.applyStopWords(content);
+  }
+  getContextWindowSize() {
+    if (this.contextWindowSize !== 0) {
+      return this.contextWindowSize;
+    }
+    this.contextWindowSize = knownContextWindowSizeForModel(this.model) ?? DEFAULT_CONTEXT_WINDOW_SIZE;
+    return this.contextWindowSize;
+  }
+  get_context_window_size() {
+    return this.getContextWindowSize();
+  }
+  supportsMultimodal() {
+    return false;
+  }
+  supports_multimodal() {
+    return this.supportsMultimodal();
+  }
+  formatTextContent(text) {
+    return { type: "text", text };
+  }
+  format_text_content(text) {
+    return this.formatTextContent(text);
+  }
+  getFileUploader() {
+    return null;
+  }
+  get_file_uploader() {
+    return this.getFileUploader();
+  }
+  get lastResponseId() {
+    return null;
+  }
+  get last_response_id() {
+    return this.lastResponseId;
+  }
+  get lastReasoningItems() {
+    return null;
+  }
+  get last_reasoning_items() {
+    return this.lastReasoningItems;
+  }
+  resetChain() {
+  }
+  reset_chain() {
+    this.resetChain();
+  }
+  resetReasoningChain() {
+  }
+  reset_reasoning_chain() {
+    this.resetReasoningChain();
+  }
+  emitCallStartedEvent(options) {
+    crewaiEventBus.emit(this, new LLMCallStartedEvent({
+      call_id: getCurrentCallId(),
+      from_task: options.fromTask ?? options.from_task,
+      from_agent: options.fromAgent ?? options.from_agent,
+      model: this.model,
+      messages: serializeLLMEventMessages(options.messages),
+      tools: options.tools ?? null,
+      callbacks: options.callbacks ?? null,
+      available_functions: options.availableFunctions ?? options.available_functions ?? null
+    }));
+  }
+  _emit_call_started_event(options) {
+    this.emitCallStartedEvent(options);
+  }
+  emitCallCompletedEvent(options) {
+    crewaiEventBus.emit(this, new LLMCallCompletedEvent({
+      call_id: getCurrentCallId(),
+      from_task: options.fromTask ?? options.from_task,
+      from_agent: options.fromAgent ?? options.from_agent,
+      model: this.model,
+      messages: options.messages === void 0 || options.messages === null ? null : serializeLLMEventMessages(options.messages),
+      response: options.response,
+      call_type: options.callType ?? options.call_type ?? LLMCallType.LLM_CALL,
+      usage: _BaseLLM.usageToDict(options.usage)
+    }));
+  }
+  _emit_call_completed_event(options) {
+    this.emitCallCompletedEvent(options);
+  }
+  handleEmitCallEvents(responseOrOptions, callType = LLMCallType.LLM_CALL, fromTask = null, fromAgent = null, messages = null, usage = null) {
+    const options = isRecord(responseOrOptions) && ("response" in responseOrOptions || "call_type" in responseOrOptions || "callType" in responseOrOptions) ? responseOrOptions : {
+      response: responseOrOptions,
+      callType,
+      fromTask,
+      fromAgent,
+      messages,
+      usage
+    };
+    this.emitCallCompletedEvent(options);
+  }
+  _handle_emit_call_events(responseOrOptions, callType = LLMCallType.LLM_CALL, fromTask = null, fromAgent = null, messages = null, usage = null) {
+    this.handleEmitCallEvents(responseOrOptions, callType, fromTask, fromAgent, messages, usage);
+  }
+  emitCallFailedEvent(options) {
+    crewaiEventBus.emit(this, new LLMCallFailedEvent({
+      call_id: getCurrentCallId(),
+      from_task: options.fromTask ?? options.from_task,
+      from_agent: options.fromAgent ?? options.from_agent,
+      model: this.model,
+      error: options.error
+    }));
+  }
+  _emit_call_failed_event(options) {
+    this.emitCallFailedEvent(options);
+  }
+  emitStreamChunkEvent(options) {
+    crewaiEventBus.emit(this, new LLMStreamChunkEvent({
+      call_id: getCurrentCallId(),
+      from_task: options.fromTask ?? options.from_task,
+      from_agent: options.fromAgent ?? options.from_agent,
+      model: this.model,
+      chunk: options.chunk,
+      tool_call: options.toolCall ?? options.tool_call ?? null,
+      call_type: options.callType ?? options.call_type ?? null,
+      response_id: options.responseId ?? options.response_id ?? null
+    }));
+  }
+  _emit_stream_chunk_event(options) {
+    this.emitStreamChunkEvent(options);
+  }
+  emitThinkingChunkEvent(options) {
+    crewaiEventBus.emit(this, new LLMThinkingChunkEvent({
+      call_id: getCurrentCallId(),
+      from_task: options.fromTask ?? options.from_task,
+      from_agent: options.fromAgent ?? options.from_agent,
+      model: this.model,
+      chunk: options.chunk,
+      response_id: options.responseId ?? options.response_id ?? null
+    }));
+  }
+  _emit_thinking_chunk_event(options) {
+    this.emitThinkingChunkEvent(options);
+  }
+  async handleToolExecution(options) {
+    const functionName = options.functionName ?? options.function_name;
+    const functionArgs = options.functionArgs ?? options.function_args ?? {};
+    const availableFunctions = options.availableFunctions ?? options.available_functions ?? {};
+    if (!functionName) {
+      return null;
+    }
+    const fn = availableFunctions[functionName];
+    if (!fn) {
+      return null;
+    }
+    const startedAt = /* @__PURE__ */ new Date();
+    try {
+      crewaiEventBus.emit(this, new ToolUsageStartedEvent({
+        toolName: functionName,
+        toolArgs: functionArgs,
+        toolClass: "BaseLLM"
+      }));
+      const result = await invokeAvailableFunction(fn, functionArgs);
+      crewaiEventBus.emit(this, new ToolUsageFinishedEvent({
+        toolName: functionName,
+        toolArgs: functionArgs,
+        toolClass: "BaseLLM",
+        startedAt,
+        output: result
+      }));
+      this.emitCallCompletedEvent({
+        response: result,
+        callType: LLMCallType.TOOL_CALL,
+        from_task: options.fromTask ?? options.from_task,
+        from_agent: options.fromAgent ?? options.from_agent
+      });
+      return stringifyToolExecutionResult(result);
+    } catch (error) {
+      const errorMessage = `Error executing function '${functionName}': ${error instanceof Error ? error.message : String(error)}`;
+      crewaiEventBus.emit(this, new ToolUsageErrorEvent({
+        toolName: functionName,
+        toolArgs: functionArgs,
+        toolClass: "BaseLLM",
+        error: errorMessage
+      }));
+      this.emitCallFailedEvent({
+        error: errorMessage,
+        from_task: options.fromTask ?? options.from_task,
+        from_agent: options.fromAgent ?? options.from_agent
+      });
+      return null;
+    }
+  }
+  async _handle_tool_execution(options) {
+    return await this.handleToolExecution(options);
+  }
+  async handleToolCall(toolCalls, availableFunctions = null, fromTask = null, fromAgent = null) {
+    const calls = Array.isArray(toolCalls) ? toolCalls : [toolCalls];
+    const available = availableFunctions ?? {};
+    if (calls.length === 0 || Object.keys(available).length === 0) {
+      return null;
+    }
+    const parsed = parseLLMToolCall(calls[0]);
+    if (!parsed) {
+      return null;
+    }
+    return await this.handleToolExecution({
+      functionName: parsed.name,
+      functionArgs: parsed.args,
+      availableFunctions: available,
+      fromTask,
+      fromAgent
+    });
+  }
+  async _handle_tool_call(toolCalls, availableFunctions = null, fromTask = null, fromAgent = null) {
+    return await this.handleToolCall(toolCalls, availableFunctions, fromTask, fromAgent);
+  }
+  convertToolsForInterference(tools) {
+    return tools;
+  }
+  _convert_tools_for_interference(tools) {
+    return this.convertToolsForInterference(tools);
+  }
+  formatMessages(messages) {
+    if (typeof messages === "string") {
+      return [{ role: "user", content: messages }];
+    }
+    const cleaned = messages.map((message, index) => {
+      if (Array.isArray(message)) {
+        throw new Error(`Message at index ${String(index)} must be a dictionary.`);
+      }
+      if (!isLLMRole(message.role) || typeof message.content !== "string") {
+        throw new Error(`Message at index ${String(index)} must have 'role' and 'content' keys.`);
+      }
+      const copy = { ...message };
+      stripCacheBreakpoint(copy);
+      return copy;
+    });
+    return this.processMessageFiles(cleaned);
+  }
+  _format_messages(messages) {
+    return this.formatMessages(messages);
+  }
+  formatMessagesForProvider(messages) {
+    for (const message of messages) {
+      if (!isLLMRole(message.role) || typeof message.content !== "string") {
+        throw new TypeError("Invalid message format. Each message must be a dict with 'role' and 'content' keys");
+      }
+    }
+    const model = this.model.toLowerCase();
+    if (model.includes("o1")) {
+      return messages.map((message) => message.role === "system" ? { ...message, role: "assistant" } : { ...message });
+    }
+    if ((model.includes("mistral") || model.includes("ollama")) && messages.at(-1)?.role === "assistant") {
+      return [...messages.map((message) => ({ ...message })), { role: "user", content: model.includes("mistral") ? "Please continue." : "" }];
+    }
+    if (!_BaseLLM.isAnthropicModel(this.model)) {
+      return messages.map((message) => ({ ...message }));
+    }
+    if (messages.length === 0 || messages[0]?.role === "system") {
+      return [{ role: "user", content: "." }, ...messages.map((message) => ({ ...message }))];
+    }
+    return messages.map((message) => ({ ...message }));
+  }
+  _format_messages_for_provider(messages) {
+    return this.formatMessagesForProvider(messages);
+  }
+  prepareCompletionParams(messages, ...args) {
+    const tools = Array.isArray(args[0]) ? args[0] : null;
+    const skipFileProcessing = typeof args[1] === "boolean" ? args[1] : false;
+    const normalizedMessages = typeof messages === "string" ? [{ role: "user", content: messages }] : messages.map((message, index) => {
+      if (Array.isArray(message)) {
+        throw new Error(`Message at index ${String(index)} must be a dictionary.`);
+      }
+      if (!isLLMRole(message.role) || typeof message.content !== "string") {
+        throw new Error(`Message at index ${String(index)} must have 'role' and 'content' keys.`);
+      }
+      const copy = { ...message };
+      stripCacheBreakpoint(copy);
+      return copy;
+    });
+    const processedMessages = skipFileProcessing ? normalizedMessages : this.processMessageFiles(normalizedMessages);
+    const params = removeUndefinedValues({
+      model: this.model,
+      messages: this.formatMessagesForProvider(processedMessages),
+      temperature: this.temperature,
+      stop: this.supportsStopWords() && this.stopSequences.length > 0 ? [...this.stopSequences] : null,
+      response_format: this.responseFormat === null ? null : this.serializeResponseFormat(this.responseFormat),
+      api_key: this.apiKey,
+      base_url: this.baseUrl,
+      provider: this.provider,
+      stream: booleanOrNull(this.additionalParams.stream),
+      tools,
+      ...this.additionalParams
+    });
+    return params;
+  }
+  _prepare_completion_params(messages, ...args) {
+    return this.prepareCompletionParams(messages, ...args);
+  }
+  processMessageFiles(messages) {
+    if (!this.supportsMultimodal() && messages.some((message) => message.files && Object.keys(message.files).length > 0)) {
+      throw new Error(`Model '${this.model}' does not support multimodal input, but files were provided via 'input_files'.`);
+    }
+    if (!this.supportsMultimodal()) {
+      return messages.map((message) => ({ ...message }));
+    }
+    const uploader = this.preferUpload ? this.getFileUploader() : null;
+    return messages.map((message) => {
+      if (!message.files || Object.keys(message.files).length === 0) {
+        return { ...message };
+      }
+      const typedFiles = typedMultimodalFiles(message.files);
+      if (!uploader && typedFiles) {
+        const api = llmApiMode(this);
+        const text = typeof message.content === "string" && message.content.length > 0 ? message.content : null;
+        const formattedBlocks = formatMultimodalContent(
+          typedFiles,
+          this.provider || this.model,
+          api === void 0 ? { text } : { api, text }
+        );
+        const { files: _files2, ...rest2 } = message;
+        void _files2;
+        if (formattedBlocks.length === 0) {
+          return { ...rest2 };
+        }
+        return {
+          ...rest2,
+          content: formattedBlocks
+        };
+      }
+      const contentBlocks = [];
+      if (typeof message.content === "string" && message.content.length > 0) {
+        contentBlocks.push(this.formatTextContent(message.content));
+      }
+      for (const [name, file] of Object.entries(message.files)) {
+        contentBlocks.push(uploader ? formatUploadedFileContentBlock(name, uploader.upload(name, file)) : formatInlineFileContentBlock(name, file));
+      }
+      const { files: _files, ...rest } = message;
+      void _files;
+      const formattedMessage = {
+        ...rest,
+        content: contentBlocks
+      };
+      return formattedMessage;
+    });
+  }
+  _process_message_files(messages) {
+    return this.processMessageFiles(messages);
+  }
+  async aprocessMessageFiles(messages) {
+    return await Promise.resolve(this.processMessageFiles(messages));
+  }
+  async _aprocess_message_files(messages) {
+    return await this.aprocessMessageFiles(messages);
+  }
+  async handleStreamingResponse(params, callbacks = null, availableFunctions = null, fromTask = null, fromAgent = null, responseModel = null) {
+    void responseModel;
+    const chunks = streamingChunksFromParams(params);
+    let fullResponse = "";
+    let lastChunk = null;
+    let usageInfo = null;
+    const collectedChunks = [];
+    for await (const chunk of chunks) {
+      lastChunk = chunk;
+      collectedChunks.push(chunk);
+      usageInfo = usageRecordFromChunk(chunk) ?? usageInfo;
+      const content = streamingChunkContent(chunk);
+      if (content !== null) {
+        fullResponse += content;
+        this.emitStreamChunkEvent({
+          chunk: content,
+          callType: LLMCallType.LLM_CALL,
+          responseId: stringPropertyFromRecord(chunk, "id"),
+          fromTask,
+          fromAgent
+        });
+      }
+      await this.invokeStreamingCallbacks(callbacks, chunk);
+    }
+    if (usageInfo) {
+      this.trackTokenUsageInternal(usageInfo);
+    }
+    this.handleStreamingCallbacks(callbacks, usageInfo, lastChunk);
+    const toolCalls = AccumulatedToolArgs.fromStreamingChunks(collectedChunks);
+    if (toolCalls.length > 0) {
+      if (availableFunctions && Object.keys(availableFunctions).length > 0) {
+        const toolResult = await this.handleToolCall(toolCalls, availableFunctions, fromTask, fromAgent);
+        if (toolResult !== null) {
+          return toolResult;
+        }
+      } else if (fullResponse.length === 0) {
+        return toolCalls;
+      }
+    }
+    if (!fullResponse.trim() && collectedChunks.length === 0) {
+      return await this.handleNonStreamingResponse({ ...params, stream: false }, callbacks, availableFunctions, fromTask, fromAgent, responseModel);
+    }
+    this.handleEmitCallEvents({
+      response: fullResponse,
+      callType: LLMCallType.LLM_CALL,
+      fromTask,
+      fromAgent,
+      messages: messagesFromParams(params),
+      usage: usageInfo ? _BaseLLM.usageToDict(usageInfo) : null
+    });
+    return fullResponse;
+  }
+  async _handle_streaming_response(params, callbacks = null, availableFunctions = null, fromTask = null, fromAgent = null, responseModel = null) {
+    return await this.handleStreamingResponse(params, callbacks, availableFunctions, fromTask, fromAgent, responseModel);
+  }
+  async handleStreamingToolCalls(toolCalls, accumulatedToolArgs = null, availableFunctions = null, fromTask = null, fromAgent = null, responseId = null) {
+    const deltas = Array.isArray(toolCalls) ? toolCalls : [toolCalls];
+    const accumulators = accumulatedToolArgs ?? {};
+    for (const toolCall of deltas) {
+      const record = readLLMRecord(toolCall);
+      const index = numberValue(record.index) ?? 0;
+      accumulators[index] ??= new AccumulatedToolArgs({ index });
+      accumulators[index].accumulate(toolCall);
+      this.emitStreamChunkEvent({
+        chunk: stringPropertyFromRecord(readLLMRecord(record.function), "arguments") ?? "",
+        toolCall: accumulators[index].toToolCall(),
+        callType: LLMCallType.TOOL_CALL,
+        responseId,
+        fromTask,
+        fromAgent
+      });
+    }
+    const completeToolCalls = AccumulatedToolArgs.toToolCalls(accumulators);
+    if (!availableFunctions || Object.keys(availableFunctions).length === 0) {
+      return null;
+    }
+    return await this.handleToolCall(completeToolCalls, availableFunctions, fromTask, fromAgent);
+  }
+  async _handle_streaming_tool_calls(toolCalls, accumulatedToolArgs = null, availableFunctions = null, fromTask = null, fromAgent = null, responseId = null) {
+    return await this.handleStreamingToolCalls(toolCalls, accumulatedToolArgs, availableFunctions, fromTask, fromAgent, responseId);
+  }
+  handleStreamingCallbacks(callbacks = null, usageInfo = null, lastChunk = null) {
+    if (!callbacks || callbacks.length === 0) {
+      return;
+    }
+    const usage = usageInfo ?? usageRecordFromChunk(lastChunk);
+    if (!usage) {
+      return;
+    }
+    for (const callback of callbacks) {
+      invokeUsageCallback(callback, usage);
+    }
+  }
+  _handle_streaming_callbacks(callbacks = null, usageInfo = null, lastChunk = null) {
+    this.handleStreamingCallbacks(callbacks, usageInfo, lastChunk);
+  }
+  async invokeStreamingCallbacks(callbacks, chunk) {
+    if (!callbacks) {
+      return;
+    }
+    for (const callback of callbacks) {
+      if (typeof callback === "function") {
+        await callback(chunk);
+      }
+    }
+  }
+  handleNonStreamingResponse(params, callbacks = null, availableFunctions = null, fromTask = null, fromAgent = null, responseModel = null) {
+    void responseModel;
+    const response = params.response ?? params.rawResponse ?? params.raw_response ?? params;
+    const usage = usageRecordFromChunk(response) ?? usageRecordFromChunk(params);
+    if (usage) {
+      this.trackTokenUsageInternal(usage);
+      this.handleStreamingCallbacks(callbacks, usage, response);
+    }
+    const toolCalls = extractToolCallsFromResponse(response);
+    if (toolCalls.length > 0) {
+      if (!availableFunctions || Object.keys(availableFunctions).length === 0) {
+        return toolCalls;
+      }
+      return this.handleToolCall(toolCalls, availableFunctions, fromTask, fromAgent);
+    }
+    const textResponse = extractResponseText(response);
+    this.handleEmitCallEvents({
+      response: textResponse,
+      callType: LLMCallType.LLM_CALL,
+      fromTask,
+      fromAgent,
+      messages: messagesFromParams(params),
+      usage: usage ? _BaseLLM.usageToDict(usage) : null
+    });
+    return textResponse;
+  }
+  _handle_non_streaming_response(params, callbacks = null, availableFunctions = null, fromTask = null, fromAgent = null, responseModel = null) {
+    return this.handleNonStreamingResponse(params, callbacks, availableFunctions, fromTask, fromAgent, responseModel);
+  }
+  async ahandleNonStreamingResponse(params, callbacks = null, availableFunctions = null, fromTask = null, fromAgent = null, responseModel = null) {
+    return await Promise.resolve(this.handleNonStreamingResponse(params, callbacks, availableFunctions, fromTask, fromAgent, responseModel));
+  }
+  async _ahandle_non_streaming_response(params, callbacks = null, availableFunctions = null, fromTask = null, fromAgent = null, responseModel = null) {
+    return await this.ahandleNonStreamingResponse(params, callbacks, availableFunctions, fromTask, fromAgent, responseModel);
+  }
+  async ahandleStreamingResponse(params, callbacks = null, availableFunctions = null, fromTask = null, fromAgent = null, responseModel = null) {
+    return await this.handleStreamingResponse(params, callbacks, availableFunctions, fromTask, fromAgent, responseModel);
+  }
+  async _ahandle_streaming_response(params, callbacks = null, availableFunctions = null, fromTask = null, fromAgent = null, responseModel = null) {
+    return await this.ahandleStreamingResponse(params, callbacks, availableFunctions, fromTask, fromAgent, responseModel);
+  }
+  getCustomLlmProvider() {
+    const index = this.model.indexOf("/");
+    return index === -1 ? null : this.model.slice(0, index);
+  }
+  _get_custom_llm_provider() {
+    return this.getCustomLlmProvider();
+  }
+  validateCallParams() {
+    if (this.responseFormat === null) {
+      return;
+    }
+    if (!isJsonResponseFormat(this.responseFormat) && !isStructuredOutputValidator(this.responseFormat)) {
+      throw new Error(`The model ${this.model} received an unsupported response_format value.`);
+    }
+  }
+  _validate_call_params() {
+    this.validateCallParams();
+  }
+  toConfigDict() {
+    return {
+      model: this.model,
+      temperature: this.temperature,
+      api_key: this.apiKey,
+      base_url: this.baseUrl,
+      provider: this.provider,
+      prefer_upload: this.preferUpload,
+      is_litellm: this.isLitellm,
+      stop: [...this.stop],
+      additional_params: { ...this.additionalParams },
+      ...this.responseFormat === null ? {} : { response_format: serializeResponseFormat(this.responseFormat) }
+    };
+  }
+  to_config_dict() {
+    return this.toConfigDict();
+  }
+  serializeResponseFormat(value) {
+    if (value === null || value === void 0) {
+      return value;
+    }
+    if (isJsonResponseFormat(value) || isStructuredOutputValidator(value)) {
+      return serializeResponseFormat(value);
+    }
+    return value;
+  }
+  _serialize_response_format(value) {
+    return this.serializeResponseFormat(value);
+  }
+  async invokeBeforeLlmCallHooks(messages, fromAgent = null) {
+    if (fromAgent !== null && fromAgent !== void 0) {
+      return true;
+    }
+    const context = new LLMCallHookContext({
+      messages,
+      llm: this,
+      agent: null,
+      task: null,
+      crew: null
+    });
+    try {
+      await runBeforeLlmCallHooks(context);
+      return true;
+    } catch (error) {
+      if (error instanceof Error && error.message.includes("blocked by before_llm_call hook")) {
+        return false;
+      }
+      return true;
+    }
+  }
+  async _invoke_before_llm_call_hooks(messages, from_agent = null) {
+    return await this.invokeBeforeLlmCallHooks(messages, from_agent);
+  }
+  async invokeAfterLlmCallHooks(messages, response, fromAgent = null) {
+    if (fromAgent !== null && fromAgent !== void 0 || typeof response !== "string") {
+      return response;
+    }
+    const context = new LLMCallHookContext({
+      messages,
+      llm: this,
+      agent: null,
+      task: null,
+      crew: null,
+      response
+    });
+    try {
+      const result = await runAfterLlmCallHooks(context);
+      return typeof result === "string" ? result : response;
+    } catch {
+      return response;
+    }
+  }
+  async _invoke_after_llm_call_hooks(messages, response, from_agent = null) {
+    return await this.invokeAfterLlmCallHooks(messages, response, from_agent);
+  }
+  trackTokenUsageInternal(usageData) {
+    const promptTokens = numberFromUsage(usageData, "prompt_tokens", "prompt_token_count", "input_tokens");
+    const completionTokens = numberFromUsage(usageData, "completion_tokens", "candidates_token_count", "output_tokens");
+    const cachedTokens = numberFromUsage(usageData, "cached_tokens", "cached_prompt_tokens", "cache_read_input_tokens") || nestedNumberFromUsage(usageData, "prompt_tokens_details", "cached_tokens");
+    this.tokenUsage = addUsageMetrics(this.tokenUsage, {
+      ...emptyUsageMetrics(),
+      totalTokens: promptTokens + completionTokens,
+      promptTokens,
+      completionTokens,
+      cachedPromptTokens: cachedTokens,
+      reasoningTokens: numberFromUsage(usageData, "reasoning_tokens"),
+      cacheCreationTokens: numberFromUsage(usageData, "cache_creation_tokens"),
+      successfulRequests: 1
+    });
+  }
+  _track_token_usage_internal(usageData) {
+    this.trackTokenUsageInternal(usageData);
+  }
+  getUsageMetrics() {
+    return { ...this.tokenUsage };
+  }
+  getTokenUsageSummary() {
+    return this.getUsageMetrics();
+  }
+  get_token_usage_summary() {
+    return this.getTokenUsageSummary();
+  }
+  resetUsageMetrics() {
+    this.tokenUsage = emptyUsageMetrics();
+  }
+  reset_usage_metrics() {
+    this.resetUsageMetrics();
+  }
+  validateStructuredOutput(response, responseFormat = null) {
+    return validateStructuredOutput(response, responseFormat);
+  }
+  _validate_structured_output(response, responseFormat = null) {
+    return this.validateStructuredOutput(response, responseFormat);
+  }
+  static validateStructuredOutput(response, responseFormat = null) {
+    return validateStructuredOutput(response, responseFormat);
+  }
+  static _validate_structured_output(response, responseFormat = null) {
+    return validateStructuredOutput(response, responseFormat);
+  }
+  static validateInitFields(data) {
+    if (!isRecord(data)) {
+      return data;
+    }
+    const normalized = {};
+    const extras = {};
+    for (const [key, value] of Object.entries(data)) {
+      if (BASE_LLM_OPTION_FIELDS.has(key)) {
+        normalized[key] = value;
+      } else {
+        extras[key] = value;
+      }
+    }
+    if (!normalized.model) {
+      throw new Error("Model name is required and cannot be empty.");
+    }
+    const stopSequences = normalized.stop_sequences ?? normalized.stopSequences;
+    const stop = stopSequences ?? normalized.stop;
+    if (stop === null || stop === void 0) {
+      normalized.stop = [];
+    } else if (typeof stop === "string") {
+      normalized.stop = [stop];
+    } else if (Array.isArray(stop)) {
+      normalized.stop = stop;
+    } else if (isIterable(stop)) {
+      normalized.stop = [...stop];
+    }
+    if (!normalized.provider) {
+      normalized.provider = "openai";
+    }
+    normalized.additional_params = {
+      ...isRecord(normalized.additionalParams) ? normalized.additionalParams : {},
+      ...isRecord(normalized.additional_params) ? normalized.additional_params : {},
+      ...extras
+    };
+    return normalized;
+  }
+  static _validate_init_fields(data) {
+    return this.validateInitFields(data);
+  }
+  static validateLLMFields(data) {
+    if (!isRecord(data)) {
+      return data;
+    }
+    const model = typeof data.model === "string" ? data.model : "";
+    return { ...data, is_anthropic: this.isAnthropicModel(model) };
+  }
+  static _validate_llm_fields(data) {
+    return this.validateLLMFields(data);
+  }
+  initLitellm() {
+    this.isLitellm = true;
+    this.is_litellm = true;
+    return this;
+  }
+  _init_litellm() {
+    return this.initLitellm();
+  }
+  static isAnthropicModel(model) {
+    const normalized = model.toLowerCase();
+    return ANTHROPIC_PREFIXES.some((prefix) => normalized.includes(prefix));
+  }
+  static _is_anthropic_model(model) {
+    return this.isAnthropicModel(model);
+  }
+  isAnthropicModel(model = this.model) {
+    return _BaseLLM.isAnthropicModel(model);
+  }
+  _is_anthropic_model(model = this.model) {
+    return this.isAnthropicModel(model);
+  }
+  static getNativeProvider(provider) {
+    const normalized = canonicalLLMProvider(provider);
+    if (normalized === "openai" || normalized === "anthropic" || normalized === "azure" || normalized === "bedrock" || normalized === "gemini" || normalized === "snowflake") {
+      return normalized;
+    }
+    if (["openrouter", "deepseek", "ollama", "ollama_chat", "hosted_vllm", "cerebras", "dashscope"].includes(normalized)) {
+      return "openai_compatible";
+    }
+    return null;
+  }
+  static _get_native_provider(provider) {
+    return this.getNativeProvider(provider);
+  }
+  static usageToDict(usage) {
+    if (usage === null || usage === void 0) {
+      return null;
+    }
+    if (isRecord(usage)) {
+      const modelDump = usage.model_dump ?? usage.modelDump;
+      if (typeof modelDump === "function") {
+        const dumped = modelDump();
+        return isRecord(dumped) ? normalizeUsageDict(dumped) : null;
+      }
+      const result = {};
+      for (const [key, value] of Object.entries(usage)) {
+        if (!key.startsWith("_")) {
+          result[key] = value;
+        }
+      }
+      return normalizeUsageDict(result);
+    }
+    return null;
+  }
+  static _usage_to_dict(usage) {
+    return this.usageToDict(usage);
+  }
+  usageToDict(usage) {
+    return _BaseLLM.usageToDict(usage);
+  }
+  _usage_to_dict(usage) {
+    return this.usageToDict(usage);
+  }
+  static extractProvider(model) {
+    return extractProvider(model);
+  }
+  static _extract_provider(model) {
+    return extractProvider(model);
+  }
+  static canonicalLLMProvider(provider) {
+    return canonicalLLMProvider(provider);
+  }
+  static canonical_llm_provider(provider) {
+    return canonicalLLMProvider(provider);
+  }
+  static matchesProviderPattern(model, provider) {
+    return matchesProviderPattern(model, provider);
+  }
+  static _matches_provider_pattern(model, provider) {
+    return matchesProviderPattern(model, provider);
+  }
+  static validateModelInConstants(model, provider) {
+    return validateModelInConstants(model, provider);
+  }
+  static _validate_model_in_constants(model, provider) {
+    return validateModelInConstants(model, provider);
+  }
+  static inferProviderFromModel(model) {
+    return inferProviderFromModel(model);
+  }
+  static _infer_provider_from_model(model) {
+    return inferProviderFromModel(model);
+  }
+  static resolveLLMModelSpec(model, explicitProvider) {
+    return resolveLLMModelSpec(model, explicitProvider);
+  }
+  static resolve_llm_model_spec(model, explicitProvider) {
+    return resolveLLMModelSpec(model, explicitProvider);
+  }
+  static setCallbacks(callbacks) {
+    const callbackTypes = new Set(
+      callbacks.filter((callback) => typeof callback === "object" || typeof callback === "function").map((callback) => callback?.constructor)
+    );
+    configuredSuccessCallbacks = configuredSuccessCallbacks.filter((callback) => !callbackTypes.has(callback?.constructor));
+    configuredCallbacks = [...callbacks];
+  }
+  static set_callbacks(callbacks) {
+    this.setCallbacks(callbacks);
+  }
+  static setEnvCallbacks(env = process.env) {
+    const successCallbacks = parseCallbackNames(env.LITELLM_SUCCESS_CALLBACKS);
+    const failureCallbacks = parseCallbackNames(env.LITELLM_FAILURE_CALLBACKS);
+    if (successCallbacks.length > 0 || failureCallbacks.length > 0) {
+      configuredSuccessCallbacks = successCallbacks;
+      configuredFailureCallbacks = failureCallbacks;
+    }
+  }
+  static set_env_callbacks(env = process.env) {
+    this.setEnvCallbacks(env);
+  }
+  static get callbacks() {
+    return configuredCallbacks;
+  }
+  static get successCallbacks() {
+    return configuredSuccessCallbacks;
+  }
+  static get success_callbacks() {
+    return configuredSuccessCallbacks;
+  }
+  static get failureCallbacks() {
+    return configuredFailureCallbacks;
+  }
+  static get failure_callbacks() {
+    return configuredFailureCallbacks;
+  }
+};
+var ConfiguredLLM = class extends BaseLLM {
+  timeout;
+  maxTokens;
+  max_tokens;
+  maxCompletionTokens;
+  max_completion_tokens;
+  topP;
+  top_p;
+  presencePenalty;
+  presence_penalty;
+  frequencyPenalty;
+  frequency_penalty;
+  seed;
+  logprobs;
+  topLogprobs;
+  top_logprobs;
+  apiBase;
+  api_base;
+  constructor(options) {
+    super(options);
+    this.timeout = options.timeout ?? null;
+    this.maxTokens = options.maxTokens ?? options.max_tokens ?? null;
+    this.max_tokens = this.maxTokens;
+    this.maxCompletionTokens = options.maxCompletionTokens ?? options.max_completion_tokens ?? null;
+    this.max_completion_tokens = this.maxCompletionTokens;
+    this.topP = options.topP ?? options.top_p ?? null;
+    this.top_p = this.topP;
+    this.presencePenalty = options.presencePenalty ?? options.presence_penalty ?? null;
+    this.presence_penalty = this.presencePenalty;
+    this.frequencyPenalty = options.frequencyPenalty ?? options.frequency_penalty ?? null;
+    this.frequency_penalty = this.frequencyPenalty;
+    this.seed = options.seed ?? null;
+    this.logprobs = options.logprobs ?? null;
+    this.topLogprobs = options.topLogprobs ?? options.top_logprobs ?? null;
+    this.top_logprobs = this.topLogprobs;
+    this.apiBase = options.apiBase ?? options.api_base ?? this.baseUrl;
+    this.api_base = this.apiBase;
+  }
+  async call(messages, options) {
+    const provider = resolveLLMProvider(this.model);
+    if (!provider || provider === this) {
+      throw new Error(`No LLM provider registered for model '${this.model}'.`);
+    }
+    return await provider.call(messages, options);
+  }
+  supportsMultimodal() {
+    const model = this.model.toLowerCase();
+    const textOnlyModels = ["o3-mini", "o1-mini"];
+    if (textOnlyModels.some((name) => model.startsWith(name) || model.includes(`/${name}`))) {
+      return false;
+    }
+    return [
+      "gpt-4o",
+      "gpt-4-turbo",
+      "gpt-4-vision",
+      "gpt-4.1",
+      "gpt-5",
+      "o1",
+      "o3",
+      "o4-mini",
+      "o4",
+      "claude-3",
+      "claude-4",
+      "claude-sonnet-4",
+      "claude-opus-4",
+      "claude-haiku-4",
+      "gemini",
+      "grok",
+      "pixtral",
+      "llava",
+      "qwen-vl",
+      "qwen2-vl",
+      "qwen3-vl"
+    ].some((prefix) => model.startsWith(prefix) || model.includes(`/${prefix}`));
+  }
+  supports_multimodal() {
+    return this.supportsMultimodal();
+  }
+  toConfigDict() {
+    return {
+      ...super.toConfigDict(),
+      ...this.timeout === null ? {} : { timeout: this.timeout },
+      ...this.maxTokens === null ? {} : { max_tokens: this.maxTokens },
+      ...this.maxCompletionTokens === null ? {} : { max_completion_tokens: this.maxCompletionTokens },
+      ...this.topP === null ? {} : { top_p: this.topP },
+      ...this.presencePenalty === null ? {} : { presence_penalty: this.presencePenalty },
+      ...this.frequencyPenalty === null ? {} : { frequency_penalty: this.frequencyPenalty },
+      ...this.seed === null ? {} : { seed: this.seed },
+      ...this.logprobs === null ? {} : { logprobs: this.logprobs },
+      ...this.topLogprobs === null ? {} : { top_logprobs: this.topLogprobs },
+      ...this.apiBase === null ? {} : { api_base: this.apiBase }
+    };
+  }
+};
+function createLLMClient(provider) {
+  return typeof provider === "function" ? new FunctionLLM(provider) : provider;
+}
+function registerLLMProvider(model, provider) {
+  registeredProviders.set(model, createLLMClient(provider));
+}
+function registerLLMProviderFactory(provider, factory) {
+  registeredProviderFactories.set(canonicalLLMProvider(provider), factory);
+}
+function unregisterLLMProviderFactory(provider) {
+  registeredProviderFactories.delete(canonicalLLMProvider(provider));
+}
+function unregisterLLMProvider(model) {
+  registeredProviders.delete(model);
+}
+function clearLLMProviders() {
+  registeredProviders.clear();
+}
+function resolveLLMProvider(model) {
+  return registeredProviders.get(model) ?? null;
+}
+function createConfiguredLLM(options) {
+  const provider = typeof options.provider === "string" ? canonicalLLMProvider(options.provider) : null;
+  const factory = provider ? registeredProviderFactories.get(provider) : void 0;
+  if (!factory) {
+    return new ConfiguredLLM(options);
+  }
+  try {
+    return factory(options);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`Error importing native provider '${provider ?? "unknown"}': ${message}`, { cause: error });
+  }
+}
+async function callLLM(client, messages, options = {}) {
+  return await llmCallContext(async (callId) => {
+    const mutableMessages = messages;
+    const model = typeof options.metadata?.model === "string" ? options.metadata.model : null;
+    crewaiEventBus.emit(client, new LLMCallStartedEvent({
+      call_id: callId,
+      from_agent: options.metadata?.agent,
+      from_task: options.metadata?.task,
+      model,
+      messages: serializeLLMMessages(mutableMessages),
+      tools: serializeLLMTools(options.tools),
+      available_functions: options.availableFunctions ?? options.available_functions ?? null
+    }));
+    const context = new LLMCallHookContext({
+      messages: mutableMessages,
+      llm: client,
+      agent: options.metadata?.agent,
+      task: options.metadata?.task,
+      crew: options.metadata?.crew,
+      iterations: typeof options.metadata?.iterations === "number" ? options.metadata.iterations : 0
+    });
+    try {
+      await runBeforeLlmCallHooks(context);
+      const response = await client.call(mutableMessages, options);
+      context.response = response;
+      const finalResponse = await runAfterLlmCallHooks(context);
+      crewaiEventBus.emit(client, new LLMCallCompletedEvent({
+        call_id: callId,
+        from_agent: options.metadata?.agent,
+        from_task: options.metadata?.task,
+        model,
+        messages: serializeLLMMessages(mutableMessages),
+        response: finalResponse,
+        call_type: isToolCallingResponse(finalResponse) ? LLMCallType.TOOL_CALL : LLMCallType.LLM_CALL,
+        usage: client.getUsageMetrics?.() ?? client.getTokenUsageSummary?.() ?? client.get_token_usage_summary?.() ?? null
+      }));
+      return finalResponse;
+    } catch (error) {
+      crewaiEventBus.emit(client, new LLMCallFailedEvent({
+        call_id: callId,
+        from_agent: options.metadata?.agent,
+        from_task: options.metadata?.task,
+        model,
+        error
+      }));
+      throw error;
+    }
+  });
+}
+function getLLMUsageMetrics(client) {
+  if (client.getUsageMetrics) {
+    return normalizeUsageMetrics(client.getUsageMetrics());
+  }
+  if (client.getTokenUsageSummary) {
+    return normalizeUsageMetrics(client.getTokenUsageSummary());
+  }
+  if (client.get_token_usage_summary) {
+    return normalizeUsageMetrics(client.get_token_usage_summary());
+  }
+  return emptyUsageMetrics();
+}
+function hasLLMUsageMetrics(client) {
+  return "getUsageMetrics" in client || "getTokenUsageSummary" in client || "get_token_usage_summary" in client;
+}
+function markCacheBreakpoint(message) {
+  return { ...message, cache_breakpoint: true };
+}
+var mark_cache_breakpoint = markCacheBreakpoint;
+function stripCacheBreakpoint(message) {
+  delete message.cache_breakpoint;
+}
+var strip_cache_breakpoint = stripCacheBreakpoint;
+function emptyUsageMetrics() {
+  return new UsageMetrics();
+}
+function addUsageMetrics(left, right) {
+  return new UsageMetrics({
+    totalTokens: left.totalTokens + right.totalTokens,
+    promptTokens: left.promptTokens + right.promptTokens,
+    cachedPromptTokens: left.cachedPromptTokens + right.cachedPromptTokens,
+    completionTokens: left.completionTokens + right.completionTokens,
+    reasoningTokens: left.reasoningTokens + right.reasoningTokens,
+    cacheCreationTokens: left.cacheCreationTokens + right.cacheCreationTokens,
+    successfulRequests: left.successfulRequests + right.successfulRequests
+  });
+}
+function subtractUsageMetrics(left, right) {
+  return new UsageMetrics({
+    totalTokens: Math.max(0, left.totalTokens - right.totalTokens),
+    promptTokens: Math.max(0, left.promptTokens - right.promptTokens),
+    cachedPromptTokens: Math.max(0, left.cachedPromptTokens - right.cachedPromptTokens),
+    completionTokens: Math.max(0, left.completionTokens - right.completionTokens),
+    reasoningTokens: Math.max(0, left.reasoningTokens - right.reasoningTokens),
+    cacheCreationTokens: Math.max(0, left.cacheCreationTokens - right.cacheCreationTokens),
+    successfulRequests: Math.max(0, left.successfulRequests - right.successfulRequests)
+  });
+}
+function isEmptyUsageMetrics(metrics) {
+  return Object.values(metrics).every((value) => value === 0);
+}
+function estimateUsageMetrics(messages, response) {
+  const promptTokens = messages.reduce(
+    (total, message) => total + estimateTokens(message.content),
+    0
+  );
+  const completionText = typeof response === "string" ? response : JSON.stringify(response);
+  const completionTokens = estimateTokens(completionText);
+  return {
+    ...emptyUsageMetrics(),
+    totalTokens: promptTokens + completionTokens,
+    promptTokens,
+    completionTokens,
+    successfulRequests: 1
+  };
+}
+function estimateTokens(value) {
+  const trimmed = value.trim();
+  if (!trimmed) {
+    return 0;
+  }
+  return Math.max(1, Math.ceil(trimmed.length / 4));
+}
+function validateStructuredOutput(response, responseFormat = null) {
+  if (responseFormat === null) {
+    return response;
+  }
+  const data = parseStructuredOutputJson(response, validatorName(responseFormat));
+  if (typeof responseFormat.modelValidate === "function") {
+    return responseFormat.modelValidate(data);
+  }
+  if (typeof responseFormat.model_validate === "function") {
+    return responseFormat.model_validate(data);
+  }
+  if (typeof responseFormat.parse === "function") {
+    return responseFormat.parse(data);
+  }
+  if (typeof responseFormat.validate === "function") {
+    return responseFormat.validate(data);
+  }
+  return data;
+}
+var validate_structured_output = validateStructuredOutput;
+function extractProvider(model) {
+  const index = model.indexOf("/");
+  return index === -1 ? "openai" : model.slice(0, index);
+}
+var extract_provider = extractProvider;
+function canonicalLLMProvider(provider) {
+  return LLM_PROVIDER_ALIASES[provider.toLowerCase()] ?? provider.toLowerCase();
+}
+var canonical_llm_provider = canonicalLLMProvider;
+function matchesProviderPattern(model, provider) {
+  const modelLower = model.toLowerCase();
+  const canonicalProvider = canonicalLLMProvider(provider);
+  if (canonicalProvider === "openai") {
+    return ["gpt-", "o1", "o3", "o4", "whisper-"].some((prefix) => modelLower.startsWith(prefix));
+  }
+  if (canonicalProvider === "anthropic") {
+    return ["claude-", "anthropic."].some((prefix) => modelLower.startsWith(prefix));
+  }
+  if (canonicalProvider === "gemini") {
+    return ["gemini-", "gemma-", "learnlm-"].some((prefix) => modelLower.startsWith(prefix));
+  }
+  if (canonicalProvider === "bedrock") {
+    return modelLower.includes(".");
+  }
+  if (canonicalProvider === "azure") {
+    return ["gpt-", "gpt-35-", "o1", "o3", "o4", "azure-"].some((prefix) => modelLower.startsWith(prefix));
+  }
+  if (canonicalProvider === "deepseek") {
+    return modelLower.startsWith("deepseek");
+  }
+  if (canonicalProvider === "dashscope") {
+    return modelLower.startsWith("qwen");
+  }
+  return ["ollama", "ollama_chat", "hosted_vllm", "cerebras", "openrouter"].includes(canonicalProvider);
+}
+var matches_provider_pattern = matchesProviderPattern;
+function validateModelInConstants(model, provider) {
+  const canonicalProvider = canonicalLLMProvider(provider);
+  if (canonicalProvider === "openai" && openAIModelSet.has(model)) {
+    return true;
+  }
+  if (canonicalProvider === "anthropic" && anthropicModelSet.has(model)) {
+    return true;
+  }
+  if (canonicalProvider === "bedrock" && bedrockModelSet.has(model)) {
+    return true;
+  }
+  if (canonicalProvider === "azure") {
+    return true;
+  }
+  if (canonicalProvider === "snowflake") {
+    return true;
+  }
+  return matchesProviderPattern(model, canonicalProvider);
+}
+var validate_model_in_constants = validateModelInConstants;
+function inferProviderFromModel(model) {
+  if (openAIModelSet.has(model)) {
+    return "openai";
+  }
+  if (anthropicModelSet.has(model)) {
+    return "anthropic";
+  }
+  if (matchesProviderPattern(model, "gemini")) {
+    return "gemini";
+  }
+  if (bedrockModelSet.has(model)) {
+    return "bedrock";
+  }
+  if (azureModelSet.has(model)) {
+    return "azure";
+  }
+  return "openai";
+}
+var infer_provider_from_model = inferProviderFromModel;
+function resolveLLMModelSpec(model, explicitProvider) {
+  if (!model) {
+    throw new Error("Model must be a non-empty string.");
+  }
+  if (explicitProvider) {
+    return {
+      provider: canonicalLLMProvider(explicitProvider),
+      model,
+      originalModel: model,
+      useNative: true
+    };
+  }
+  const separatorIndex = model.indexOf("/");
+  if (separatorIndex !== -1) {
+    const prefix = model.slice(0, separatorIndex);
+    const modelPart = model.slice(separatorIndex + 1);
+    const canonicalProvider = canonicalLLMProvider(prefix);
+    const hasNativeProvider = nativeProviderSet.has(canonicalProvider);
+    const useNative = hasNativeProvider && validateModelInConstants(modelPart, canonicalProvider);
+    return {
+      provider: useNative ? canonicalProvider : prefix,
+      model: modelPart,
+      originalModel: model,
+      useNative
+    };
+  }
+  return {
+    provider: inferProviderFromModel(model),
+    model,
+    originalModel: model,
+    useNative: true
+  };
+}
+var resolve_llm_model_spec = resolveLLMModelSpec;
+function contextWindowSizeForModel(model) {
+  validateContextWindowSizes(LLM_CONTEXT_WINDOW_SIZES);
+  return knownContextWindowSizeForModel(model) ?? Math.trunc(DEFAULT_CONTEXT_WINDOW_SIZE * CONTEXT_WINDOW_USAGE_RATIO);
+}
+var context_window_size_for_model = contextWindowSizeForModel;
+function validateContextWindowSizes(sizes) {
+  for (const [model, size] of Object.entries(sizes)) {
+    if (size < MIN_CONTEXT_WINDOW_SIZE || size > MAX_CONTEXT_WINDOW_SIZE) {
+      throw new Error(`Context window for ${model} must be between ${String(MIN_CONTEXT_WINDOW_SIZE)} and ${String(MAX_CONTEXT_WINDOW_SIZE)}.`);
+    }
+  }
+}
+var validate_context_window_sizes = validateContextWindowSizes;
+function knownContextWindowSizeForModel(model) {
+  const match = Object.entries(LLM_CONTEXT_WINDOW_SIZES).sort(([left], [right]) => right.length - left.length).find(([prefix]) => model.startsWith(prefix));
+  return match ? Math.trunc(match[1] * CONTEXT_WINDOW_USAGE_RATIO) : null;
+}
+function normalizeUsageMetrics(metrics) {
+  return new UsageMetrics({
+    totalTokens: metrics.totalTokens ?? metrics.total_tokens ?? 0,
+    promptTokens: metrics.promptTokens ?? metrics.prompt_tokens ?? 0,
+    cachedPromptTokens: metrics.cachedPromptTokens ?? metrics.cached_prompt_tokens ?? 0,
+    completionTokens: metrics.completionTokens ?? metrics.completion_tokens ?? 0,
+    reasoningTokens: metrics.reasoningTokens ?? metrics.reasoning_tokens ?? 0,
+    cacheCreationTokens: metrics.cacheCreationTokens ?? metrics.cache_creation_tokens ?? 0,
+    successfulRequests: metrics.successfulRequests ?? metrics.successful_requests ?? 0
+  });
+}
+function normalizeUsageDict(usage) {
+  const result = { ...usage };
+  const promptDetails = isRecord(result.prompt_tokens_details) ? result.prompt_tokens_details : null;
+  const completionDetails = isRecord(result.completion_tokens_details) ? result.completion_tokens_details : null;
+  const cachedPromptTokens = firstDefined(
+    result.cached_tokens,
+    result.cached_prompt_tokens,
+    result.cache_read_input_tokens,
+    promptDetails?.cached_tokens
+  );
+  if (cachedPromptTokens !== void 0) {
+    result.cached_prompt_tokens = cachedPromptTokens;
+  }
+  const reasoningTokens = firstDefined(result.reasoning_tokens, completionDetails?.reasoning_tokens);
+  if (reasoningTokens !== void 0) {
+    result.reasoning_tokens = reasoningTokens;
+  }
+  const cacheCreationTokens = firstDefined(result.cache_creation_tokens, result.cache_creation_input_tokens);
+  if (cacheCreationTokens !== void 0) {
+    result.cache_creation_tokens = cacheCreationTokens;
+  }
+  return result;
+}
+function firstDefined(...values) {
+  return values.find((value) => value !== null && value !== void 0);
+}
+function defineUsageMetricAliases(metrics) {
+  Object.defineProperties(metrics, {
+    total_tokens: usageMetricAlias("totalTokens"),
+    prompt_tokens: usageMetricAlias("promptTokens"),
+    cached_prompt_tokens: usageMetricAlias("cachedPromptTokens"),
+    completion_tokens: usageMetricAlias("completionTokens"),
+    reasoning_tokens: usageMetricAlias("reasoningTokens"),
+    cache_creation_tokens: usageMetricAlias("cacheCreationTokens"),
+    successful_requests: usageMetricAlias("successfulRequests")
+  });
+}
+function usageMetricAlias(key) {
+  return {
+    enumerable: false,
+    configurable: true,
+    get() {
+      return this[key];
+    },
+    set(value) {
+      this[key] = value;
+    }
+  };
+}
+function parseStructuredOutputJson(response, responseFormatName) {
+  const trimmed = response.trim();
+  try {
+    if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
+      return JSON.parse(trimmed);
+    }
+    const match = /\{.*\}/s.exec(response);
+    if (match) {
+      return JSON.parse(match[0]);
+    }
+    throw new Error("No JSON found in response");
+  } catch (error) {
+    const detail = error instanceof Error ? error.message : String(error);
+    throw new Error(`Failed to parse response into ${responseFormatName}: ${detail}`, { cause: error });
+  }
+}
+function validatorName(validator) {
+  return validator.name ?? "response_format";
+}
+function removeUndefinedValues(record) {
+  return Object.fromEntries(Object.entries(record).filter(([, value]) => value !== null && value !== void 0));
+}
+function booleanOrNull(value) {
+  return typeof value === "boolean" ? value : null;
+}
+async function* streamingChunksFromParams(params) {
+  const source = params.chunks ?? params.stream ?? params.response;
+  if (isAsyncIterable(source)) {
+    for await (const chunk of source) {
+      yield chunk;
+    }
+    return;
+  }
+  if (isIterable(source) && typeof source !== "string") {
+    for (const chunk of source) {
+      yield chunk;
+    }
+    return;
+  }
+  if (source !== void 0 && source !== null && source !== true && source !== false) {
+    yield source;
+  }
+}
+function isAsyncIterable(value) {
+  return value !== null && value !== void 0 && typeof value[Symbol.asyncIterator] === "function";
+}
+function streamingChunkContent(chunk) {
+  const direct = stringPropertyFromRecord(chunk, "content") ?? stringPropertyFromRecord(chunk, "text");
+  if (direct !== null) {
+    return direct;
+  }
+  const record = readLLMRecord(chunk);
+  const deltaContent = stringPropertyFromRecord(record.delta, "content");
+  if (deltaContent !== null) {
+    return deltaContent;
+  }
+  const choices = Array.isArray(record.choices) ? record.choices : [];
+  for (const choice of choices) {
+    const choiceRecord = readLLMRecord(choice);
+    const content = stringPropertyFromRecord(choiceRecord.delta, "content") ?? stringPropertyFromRecord(choiceRecord.message, "content");
+    if (content !== null) {
+      return content;
+    }
+  }
+  return null;
+}
+function extractResponseText(response) {
+  if (typeof response === "string") {
+    return response;
+  }
+  const direct = stringPropertyFromRecord(response, "content") ?? stringPropertyFromRecord(response, "text");
+  if (direct !== null) {
+    return direct;
+  }
+  const record = readLLMRecord(response);
+  const choices = Array.isArray(record.choices) ? record.choices : [];
+  for (const choice of choices) {
+    const content = stringPropertyFromRecord(readLLMRecord(choice).message, "content") ?? stringPropertyFromRecord(readLLMRecord(choice).delta, "content") ?? stringPropertyFromRecord(choice, "text");
+    if (content !== null) {
+      return content;
+    }
+  }
+  return "";
+}
+function extractToolCallsFromResponse(response) {
+  const record = readLLMRecord(response);
+  const direct = record.tool_calls ?? readLLMRecord(record.message).tool_calls;
+  if (Array.isArray(direct)) {
+    return direct;
+  }
+  const choices = Array.isArray(record.choices) ? record.choices : [];
+  const calls = [];
+  for (const choice of choices) {
+    const messageCalls = readLLMRecord(readLLMRecord(choice).message).tool_calls;
+    const deltaCalls = readLLMRecord(readLLMRecord(choice).delta).tool_calls;
+    for (const candidate of [messageCalls, deltaCalls]) {
+      if (Array.isArray(candidate)) {
+        calls.push(...candidate);
+      }
+    }
+  }
+  return calls;
+}
+function parseLLMToolCall(toolCall) {
+  const record = readLLMRecord(toolCall);
+  const functionRecord = readLLMRecord(record.function);
+  const name = stringPropertyFromRecord(functionRecord, "name") ?? stringPropertyFromRecord(record, "name");
+  if (name === null || name.length === 0) {
+    return null;
+  }
+  return {
+    name,
+    args: parseToolArguments(functionRecord.arguments ?? record.arguments ?? record.args)
+  };
+}
+function parseToolArguments(value) {
+  if (isRecord(value)) {
+    return value;
+  }
+  if (typeof value !== "string" || value.trim().length === 0) {
+    return {};
+  }
+  try {
+    const parsed = JSON.parse(value);
+    return isRecord(parsed) ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+function usageRecordFromChunk(chunk) {
+  const record = readLLMRecord(chunk);
+  const usage = record.usage ?? readLLMRecord(record.model_extra).usage;
+  return isRecord(usage) ? usage : null;
+}
+function messagesFromParams(params) {
+  const messages = params.messages;
+  if (!Array.isArray(messages)) {
+    return null;
+  }
+  const normalized = [];
+  for (const message of messages) {
+    const record = readLLMRecord(message);
+    if (isLLMRole(record.role) && typeof record.content === "string") {
+      normalized.push({ role: record.role, content: record.content });
+    }
+  }
+  return normalized;
+}
+function stringPropertyFromRecord(value, key) {
+  const record = readLLMRecord(value);
+  const property = record[key];
+  return typeof property === "string" ? property : null;
+}
+function invokeUsageCallback(callback, usage) {
+  if (typeof callback === "function") {
+    return;
+  }
+  if (typeof callback.logSuccessEvent === "function") {
+    void Promise.resolve(callback.logSuccessEvent({
+      kwargs: {},
+      responseObj: { usage },
+      startTime: 0,
+      endTime: 0
+    }));
+  }
+  if (typeof callback.log_success_event === "function") {
+    void Promise.resolve(callback.log_success_event({}, { usage }, 0, 0));
+  }
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isIterable(value) {
+  return typeof value[Symbol.iterator] === "function";
+}
+function isJsonResponseFormat(value) {
+  return isRecord(value) && value.type === "json_object";
+}
+function isStructuredOutputValidator(value) {
+  return isRecord(value) && (typeof value.name === "string" || typeof value.modelValidate === "function" || typeof value.model_validate === "function" || typeof value.parse === "function" || typeof value.validate === "function");
+}
+function serializeResponseFormat(responseFormat) {
+  if ("type" in responseFormat) {
+    return { type: "json_object" };
+  }
+  return responseFormat.name ?? "response_format";
+}
+function normalizeStopSequences(value) {
+  if (value === null || value === void 0) {
+    return [];
+  }
+  return typeof value === "string" ? [value] : [...value];
+}
+function numberFromUsage(data, ...keys) {
+  for (const key of keys) {
+    const value = data[key];
+    if (typeof value === "number") {
+      return value;
+    }
+  }
+  return 0;
+}
+function nestedNumberFromUsage(data, objectKey, valueKey) {
+  const nested = data[objectKey];
+  if (!nested || typeof nested !== "object" || Array.isArray(nested)) {
+    return 0;
+  }
+  const value = nested[valueKey];
+  return typeof value === "number" ? value : 0;
+}
+function serializeLLMMessages(messages) {
+  return messages.map((message) => ({
+    role: message.role,
+    content: message.content,
+    ...message.files === void 0 ? {} : { files: message.files },
+    ...message.cache_breakpoint === void 0 ? {} : { cache_breakpoint: message.cache_breakpoint }
+  }));
+}
+function formatInlineFileContentBlock(name, file) {
+  const rendered = renderLLMInputFile(name, file);
+  return {
+    type: "file",
+    source: "inline",
+    name,
+    filename: rendered.filename,
+    content_type: rendered.contentType,
+    content: rendered.content
+  };
+}
+function formatUploadedFileContentBlock(name, upload) {
+  return {
+    type: "file",
+    source: "upload",
+    name,
+    filename: upload.filename,
+    file_id: upload.id,
+    content_type: upload.contentType
+  };
+}
+function typedMultimodalFiles(files) {
+  const entries = Object.entries(files);
+  if (entries.length === 0) {
+    return null;
+  }
+  const result = {};
+  for (const [name, file] of entries) {
+    if (!isCrewAIFileInput(file)) {
+      return null;
+    }
+    result[name] = file;
+  }
+  return result;
+}
+function isCrewAIFileInput(file) {
+  return file instanceof AudioFile || file instanceof File || file instanceof ImageFile || file instanceof PDFFile || file instanceof TextFile || file instanceof VideoFile;
+}
+function llmApiMode(llm) {
+  const api = llm.api;
+  return api === "responses" || api === "completions" ? api : void 0;
+}
+function renderLLMInputFile(name, file) {
+  if (typeof file === "string") {
+    return {
+      filename: basename2(file) || name,
+      contentType: guessLLMFileContentType(file),
+      content: readFileSync2(file, "utf8")
+    };
+  }
+  if (hasLLMTextContent(file)) {
+    return {
+      filename: file.filename ?? (file.path ? basename2(file.path) : name),
+      contentType: file.contentType ?? guessLLMFileContentType(file.filename ?? file.path ?? name),
+      content: file.content
+    };
+  }
+  if (isLLMReadableInputFile(file)) {
+    const content = file.read();
+    return {
+      filename: file.filename ?? name,
+      contentType: file.contentType ?? file.content_type ?? guessLLMFileContentType(file.filename ?? name),
+      content: typeof content === "string" ? content : Buffer.from(content).toString("base64")
+    };
+  }
+  if (hasLLMFilePath(file)) {
+    return {
+      filename: file.filename ?? (basename2(file.path) || name),
+      contentType: file.contentType ?? guessLLMFileContentType(file.path),
+      content: readFileSync2(file.path, "utf8")
+    };
+  }
+  throw new Error(`Input file '${name}' requires either a path or text content.`);
+}
+function hasLLMTextContent(file) {
+  return "content" in file && typeof file.content === "string";
+}
+function hasLLMFilePath(file) {
+  return "path" in file && typeof file.path === "string";
+}
+function isLLMReadableInputFile(file) {
+  return "read" in file && typeof file.read === "function";
+}
+function guessLLMFileContentType(path) {
+  const lower = path.toLowerCase();
+  if (lower.endsWith(".json")) {
+    return "application/json";
+  }
+  if (lower.endsWith(".csv")) {
+    return "text/csv";
+  }
+  if (lower.endsWith(".md") || lower.endsWith(".markdown")) {
+    return "text/markdown";
+  }
+  if (lower.endsWith(".txt") || lower.endsWith(".log")) {
+    return "text/plain";
+  }
+  if (lower.endsWith(".png")) {
+    return "image/png";
+  }
+  if (lower.endsWith(".jpg") || lower.endsWith(".jpeg")) {
+    return "image/jpeg";
+  }
+  if (lower.endsWith(".webp")) {
+    return "image/webp";
+  }
+  return null;
+}
+function serializeLLMEventMessages(messages) {
+  return typeof messages === "string" ? messages : serializeLLMMessages(messages);
+}
+function isLLMRole(value) {
+  return value === "system" || value === "user" || value === "assistant" || value === "tool";
+}
+function isLLMClient(value) {
+  if (!value || typeof value !== "object" || !("call" in value)) {
+    return false;
+  }
+  return typeof value.call === "function";
+}
+function parseCallbackNames(value) {
+  if (!value) {
+    return [];
+  }
+  return value.split(",").map((callback) => callback.trim()).filter((callback) => callback.length > 0);
+}
+function stringProperty(value, key) {
+  const property = value[key];
+  return typeof property === "string" ? property : void 0;
+}
+function stringifyLLMValue(value) {
+  const toString = value["toString"];
+  const rendered = typeof toString === "function" && toString !== Object.prototype.toString ? toString.call(value) : Object.prototype.toString.call(value);
+  return typeof rendered === "string" ? rendered : Object.prototype.toString.call(value);
+}
+function numberProperty(value, key) {
+  const property = value[key];
+  return typeof property === "number" ? property : null;
+}
+function booleanOrNumberProperty(value, key) {
+  const property = value[key];
+  return typeof property === "boolean" || typeof property === "number" ? property : null;
+}
+function recordOrNull(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function stringOrEmpty(value) {
+  return typeof value === "string" ? value : "";
+}
+function argsSchemaParameters(value) {
+  const schemaProvider = value;
+  const schema = schemaProvider?.model_json_schema?.() ?? schemaProvider?.modelJsonSchema?.();
+  return recordOrNull(schema);
+}
+function applyLLMEnvVars(options, provider, env) {
+  for (const spec of LLM_ENV_VARS[provider] ?? []) {
+    const keyName = spec.key_name;
+    if (typeof keyName === "string" && !UNACCEPTED_LLM_ENV_ATTRIBUTES.includes(keyName)) {
+      const value = env[keyName];
+      if (value) {
+        const paramKey = normalizeLLMEnvKeyName(keyName.toLowerCase());
+        assignLLMConfigParam(options, paramKey, value);
+      }
+      continue;
+    }
+    if (spec.default === true) {
+      for (const [key, value] of Object.entries(spec)) {
+        if (key !== "prompt" && key !== "key_name" && key !== "default" && typeof value === "string") {
+          assignLLMConfigParam(options, key.toLowerCase(), value);
+        }
+      }
+    }
+  }
+}
+function assignLLMConfigParam(options, key, value) {
+  if (key === "model") {
+    options.model = value;
+  } else if (key === "api_key") {
+    options.api_key = value;
+  } else if (key === "api_base") {
+    options.api_base = value;
+    options.base_url ??= value;
+  } else if (key === "api_version") {
+    options.additional_params = { ...options.additional_params ?? {}, api_version: value };
+  } else if (key === "watsonx_url") {
+    options.base_url = value;
+  } else {
+    options.additional_params = { ...options.additional_params ?? {}, [key]: value };
+  }
+}
+async function invokeAvailableFunction(fn, args) {
+  return typeof fn === "function" ? await fn(args) : await fn.run(args);
+}
+function stringifyToolExecutionResult(value) {
+  if (typeof value === "string") {
+    return value;
+  }
+  if (value === void 0) {
+    return "undefined";
+  }
+  if (typeof value === "number" || typeof value === "boolean" || typeof value === "bigint") {
+    return value.toString();
+  }
+  if (typeof value === "symbol") {
+    return value.description ?? "Symbol()";
+  }
+  if (typeof value === "function") {
+    return `[function ${value.name || "anonymous"}]`;
+  }
+  return JSON.stringify(value);
+}
+function serializeLLMTools(tools) {
+  if (!tools || tools.length === 0) {
+    return null;
+  }
+  return tools.map((tool) => {
+    if (isToolLike(tool)) {
+      return {
+        name: tool.name,
+        description: tool.description ?? null,
+        resultAsAnswer: tool.resultAsAnswer ?? false
+      };
+    }
+    return recordOrNull(tool) ?? { value: String(tool) };
+  });
+}
+function isToolLike(value) {
+  const record = recordOrNull(value);
+  return record !== null && typeof record.name === "string" && "run" in record;
+}
+function isToolCallingResponse(response) {
+  return typeof response === "object" && "toolName" in response;
+}
+
+export {
+  ResolvedFile,
+  InlineBase64,
+  InlineBytes,
+  FileReference,
+  UrlReference,
+  FileHandling,
+  FileValidationError,
+  FileTooLargeError,
+  UnsupportedFileTypeError,
+  FileProcessingError,
+  ProcessingDependencyError,
+  ImageConstraints,
+  PDFConstraints,
+  AudioConstraints,
+  VideoConstraints,
+  TextConstraints,
+  ProviderConstraints,
+  ANTHROPIC_CONSTRAINTS,
+  OPENAI_RESPONSES_CONSTRAINTS,
+  OPENAI_CONSTRAINTS,
+  GEMINI_CONSTRAINTS,
+  BEDROCK_CONSTRAINTS,
+  AZURE_CONSTRAINTS,
+  getConstraintsForProvider,
+  get_constraints_for_provider,
+  usesOpenAIResponsesApi,
+  uses_openai_responses_api,
+  getSupportedContentTypes,
+  validateImage,
+  validate_image,
+  validatePDF,
+  validate_pdf,
+  validateAudio,
+  validate_audio,
+  validateVideo,
+  validate_video,
+  validateText,
+  validate_text,
+  validateFile,
+  validate_file,
+  FileProcessor,
+  chunkText,
+  chunk_text,
+  chunkPDF,
+  chunk_pdf,
+  resizeImage,
+  resize_image,
+  optimizeImage,
+  optimize_image,
+  CachedUpload,
+  UploadCache,
+  getUploadCache,
+  get_upload_cache,
+  resetUploadCache,
+  reset_upload_cache,
+  FileSource,
+  FilePath,
+  FileBytes,
+  FileStream,
+  FileUrl,
+  BaseFile,
+  ImageFile,
+  PDFFile,
+  TextFile,
+  AudioFile,
+  VideoFile,
+  File,
+  detectContentType,
+  detect_content_type,
+  wrapFileSource,
+  wrap_file_source,
+  normalizeInputFiles,
+  normalize_input_files,
+  FileResolverConfig,
+  FileResolver,
+  createResolver,
+  create_resolver,
+  formatMultimodalContent,
+  format_multimodal_content,
+  JsonResponseFormat,
+  CACHE_BREAKPOINT_KEY,
+  UsageMetrics,
+  LocalFileUploader,
+  DEFAULT_CONTEXT_WINDOW_SIZE,
+  DEFAULT_SUPPORTS_STOP_WORDS,
+  DEFAULT_LLM_MODEL,
+  JSON_URL,
+  LITELLM_PARAMS,
+  UNACCEPTED_LLM_ENV_ATTRIBUTES,
+  LLM_ENV_VARS,
+  ENV_VARS,
+  SUPPORTED_NATIVE_PROVIDERS,
+  LLM_PROVIDER_ALIASES,
+  PROVIDERS,
+  OPENAI_MODELS,
+  ANTHROPIC_MODELS,
+  AZURE_MODELS,
+  BEDROCK_MODELS,
+  NVIDIA_NIM_MODELS,
+  GROQ_MODELS,
+  OLLAMA_MODELS,
+  WATSON_MODELS,
+  HUGGINGFACE_MODELS,
+  SAMBANOVA_MODELS,
+  OpenAIModels,
+  AnthropicModels,
+  AzureModels,
+  BedrockModels,
+  NvidiaNimModels,
+  GroqModels,
+  OllamaModels,
+  WatsonModels,
+  HuggingFaceModels,
+  SambanovaModels,
+  MODELS,
+  CONTEXT_WINDOW_USAGE_RATIO,
+  MIN_CONTEXT_WINDOW_SIZE,
+  MAX_CONTEXT_WINDOW_SIZE,
+  MIN_CONTEXT,
+  MAX_CONTEXT,
+  ANTHROPIC_PREFIXES,
+  Delta,
+  StreamingChoices,
+  FunctionArgs,
+  AccumulatedToolArgs,
+  LLM_CONTEXT_WINDOW_SIZES,
+  llmCallContext,
+  llm_call_context,
+  validate_function_name,
+  sanitize_function_name,
+  extract_tool_info,
+  log_tool_conversion,
+  safe_tool_conversion,
+  getCurrentCallId,
+  get_current_call_id,
+  callStopOverride,
+  call_stop_override,
+  callStopOverrideSync,
+  call_stop_override_sync,
+  FunctionLLM,
+  createLLM,
+  create_llm,
+  llmViaEnvironmentOrFallback,
+  llm_via_environment_or_fallback,
+  _llm_via_environment_or_fallback,
+  normalizeLLMEnvKeyName,
+  normalize_llm_env_key_name,
+  _normalize_key_name,
+  BaseLLM,
+  ConfiguredLLM,
+  createLLMClient,
+  registerLLMProvider,
+  registerLLMProviderFactory,
+  unregisterLLMProviderFactory,
+  unregisterLLMProvider,
+  clearLLMProviders,
+  resolveLLMProvider,
+  callLLM,
+  getLLMUsageMetrics,
+  hasLLMUsageMetrics,
+  markCacheBreakpoint,
+  mark_cache_breakpoint,
+  stripCacheBreakpoint,
+  strip_cache_breakpoint,
+  emptyUsageMetrics,
+  addUsageMetrics,
+  subtractUsageMetrics,
+  isEmptyUsageMetrics,
+  estimateUsageMetrics,
+  estimateTokens,
+  validateStructuredOutput,
+  validate_structured_output,
+  extractProvider,
+  extract_provider,
+  canonicalLLMProvider,
+  canonical_llm_provider,
+  matchesProviderPattern,
+  matches_provider_pattern,
+  validateModelInConstants,
+  validate_model_in_constants,
+  inferProviderFromModel,
+  infer_provider_from_model,
+  resolveLLMModelSpec,
+  resolve_llm_model_spec,
+  contextWindowSizeForModel,
+  context_window_size_for_model,
+  validateContextWindowSizes,
+  validate_context_window_sizes
+};