@probeo/anymodel 0.3.0 → 0.3.1

package/dist/index.js

@@ -1,16 +1,2783 @@
-// Client
-export { AnyModel } from './client.js';
-export { AnyModelError } from './types.js';
-// Config
-export { resolveConfig } from './config.js';
-// Generation stats
-export { GenerationStatsStore } from './utils/generation-stats.js';
-// Batch
-export { BatchManager, BatchStore } from './batch/index.js';
-// Server
-export { createAnyModelServer, startServer } from './server.js';
-// Filesystem IO (queued, high-volume)
-export { readFileQueued, writeFileQueued, writeFileFlushedQueued, appendFileQueued, ensureDir, joinPath, getFsQueueStatus, waitForFsQueuesIdle, } from './utils/fs-io.js';
-export { createOpenAIBatchAdapter } from './providers/openai-batch.js';
-export { createAnthropicBatchAdapter } from './providers/anthropic-batch.js';
+// src/types.ts
+var AnyModelError = class extends Error {
+  code;
+  metadata;
+  constructor(code, message, metadata = {}) {
+    super(message);
+    this.name = "AnyModelError";
+    this.code = code;
+    this.metadata = metadata;
+  }
+  toJSON() {
+    return {
+      error: {
+        code: this.code,
+        message: this.message,
+        metadata: this.metadata
+      }
+    };
+  }
+};
+
+// src/providers/registry.ts
+var ProviderRegistry = class {
+  adapters = /* @__PURE__ */ new Map();
+  register(slug, adapter) {
+    if (this.adapters.has(slug)) {
+      throw new AnyModelError(500, `Provider '${slug}' is already registered`);
+    }
+    this.adapters.set(slug, adapter);
+  }
+  get(slug) {
+    const adapter = this.adapters.get(slug);
+    if (!adapter) {
+      throw new AnyModelError(400, `Provider '${slug}' not configured`);
+    }
+    return adapter;
+  }
+  has(slug) {
+    return this.adapters.has(slug);
+  }
+  list() {
+    return Array.from(this.adapters.keys());
+  }
+  all() {
+    return Array.from(this.adapters.values());
+  }
+};
+
+// src/utils/model-parser.ts
+function parseModelString(model, aliases) {
+  if (aliases && model in aliases) {
+    model = aliases[model];
+  }
+  const slashIndex = model.indexOf("/");
+  if (slashIndex === -1) {
+    throw new AnyModelError(
+      400,
+      `Model must be in provider/model format or be a valid alias. Got: '${model}'`
+    );
+  }
+  const provider = model.substring(0, slashIndex);
+  const modelId = model.substring(slashIndex + 1);
+  if (!provider) {
+    throw new AnyModelError(400, `Invalid model string: missing provider in '${model}'`);
+  }
+  if (!modelId) {
+    throw new AnyModelError(400, `Invalid model string: missing model ID in '${model}'`);
+  }
+  return { provider, model: modelId };
+}
+
+// src/utils/validate.ts
+function validateRequest(request) {
+  if (!request.model && !request.models?.length) {
+    throw new AnyModelError(400, "Missing required field: model");
+  }
+  if (!request.messages || !Array.isArray(request.messages) || request.messages.length === 0) {
+    throw new AnyModelError(400, "Missing or empty required field: messages");
+  }
+  if (request.temperature !== void 0 && (request.temperature < 0 || request.temperature > 2)) {
+    throw new AnyModelError(400, "temperature must be between 0.0 and 2.0");
+  }
+  if (request.top_p !== void 0 && (request.top_p < 0 || request.top_p > 1)) {
+    throw new AnyModelError(400, "top_p must be between 0.0 and 1.0");
+  }
+  if (request.top_logprobs !== void 0 && !request.logprobs) {
+    throw new AnyModelError(400, "top_logprobs requires logprobs: true");
+  }
+  if (request.top_logprobs !== void 0 && (request.top_logprobs < 0 || request.top_logprobs > 20)) {
+    throw new AnyModelError(400, "top_logprobs must be between 0 and 20");
+  }
+  if (request.stop !== void 0) {
+    const stops = Array.isArray(request.stop) ? request.stop : [request.stop];
+    if (stops.length > 4) {
+      throw new AnyModelError(400, "stop may have at most 4 sequences");
+    }
+  }
+  if (request.models && request.models.length > 0 && request.route && request.route !== "fallback") {
+    throw new AnyModelError(400, `Invalid route: '${request.route}'. Only 'fallback' is supported.`);
+  }
+}
+
+// src/utils/retry.ts
+var DEFAULT_RETRY = {
+  maxRetries: 2,
+  baseDelay: 500,
+  maxDelay: 1e4
+};
+var RETRYABLE_CODES = /* @__PURE__ */ new Set([429, 502, 503, 529]);
+function isRetryable(error) {
+  if (error instanceof AnyModelError) {
+    return RETRYABLE_CODES.has(error.code);
+  }
+  return false;
+}
+function getRetryAfter(error) {
+  if (error instanceof AnyModelError && error.metadata.raw) {
+    const raw = error.metadata.raw;
+    if (raw?.retry_after) return Number(raw.retry_after) * 1e3;
+    if (raw?.headers?.["retry-after"]) return Number(raw.headers["retry-after"]) * 1e3;
+  }
+  return null;
+}
+function computeDelay(attempt, options, error) {
+  const retryAfter = getRetryAfter(error);
+  if (retryAfter && retryAfter > 0) {
+    return Math.min(retryAfter, options.maxDelay);
+  }
+  const exponential = options.baseDelay * Math.pow(2, attempt);
+  const jitter = exponential * 0.2 * Math.random();
+  return Math.min(exponential + jitter, options.maxDelay);
+}
+async function withRetry(fn, options = {}) {
+  const opts = { ...DEFAULT_RETRY, ...options };
+  let lastError;
+  for (let attempt = 0; attempt <= opts.maxRetries; attempt++) {
+    try {
+      return await fn();
+    } catch (error) {
+      lastError = error;
+      if (attempt >= opts.maxRetries || !isRetryable(error)) {
+        throw error;
+      }
+      const delay = computeDelay(attempt, opts, error);
+      await new Promise((resolve2) => setTimeout(resolve2, delay));
+    }
+  }
+  throw lastError;
+}
+
+// src/utils/rate-limiter.ts
+var RateLimitTracker = class {
+  state = /* @__PURE__ */ new Map();
+  /**
+   * Update rate limit state from response headers.
+   */
+  updateFromHeaders(provider, headers) {
+    const state = this.getOrCreate(provider);
+    const remaining = headers["x-ratelimit-remaining"] || headers["x-ratelimit-remaining-requests"];
+    if (remaining !== void 0) {
+      state.remaining = parseInt(remaining, 10);
+    }
+    const reset = headers["x-ratelimit-reset"] || headers["x-ratelimit-reset-requests"];
+    if (reset !== void 0) {
+      const parsed = Number(reset);
+      state.resetAt = parsed > 1e12 ? parsed : parsed * 1e3;
+    }
+    const retryAfter = headers["retry-after"];
+    if (retryAfter !== void 0) {
+      state.retryAfter = Number(retryAfter) * 1e3;
+    }
+    state.lastUpdated = Date.now();
+  }
+  /**
+   * Record a 429 for a provider.
+   */
+  recordRateLimit(provider, retryAfterMs) {
+    const state = this.getOrCreate(provider);
+    state.remaining = 0;
+    if (retryAfterMs) {
+      state.retryAfter = retryAfterMs;
+      state.resetAt = Date.now() + retryAfterMs;
+    }
+    state.lastUpdated = Date.now();
+  }
+  /**
+   * Check if a provider is currently rate-limited.
+   */
+  isRateLimited(provider) {
+    const state = this.state.get(provider);
+    if (!state) return false;
+    if (state.remaining === 0 && state.resetAt) {
+      return Date.now() < state.resetAt;
+    }
+    return false;
+  }
+  /**
+   * Get ms until rate limit resets for a provider.
+   */
+  getWaitTime(provider) {
+    const state = this.state.get(provider);
+    if (!state?.resetAt) return 0;
+    const wait = state.resetAt - Date.now();
+    return Math.max(0, wait);
+  }
+  /**
+   * Get state for a provider.
+   */
+  getState(provider) {
+    return this.state.get(provider);
+  }
+  getOrCreate(provider) {
+    let state = this.state.get(provider);
+    if (!state) {
+      state = {
+        provider,
+        remaining: null,
+        resetAt: null,
+        retryAfter: null,
+        lastUpdated: Date.now()
+      };
+      this.state.set(provider, state);
+    }
+    return state;
+  }
+};
+
+// src/utils/transforms.ts
+var CHARS_PER_TOKEN = 4;
+function middleOut(messages, maxTokens) {
+  if (messages.length <= 2) return messages;
+  const maxChars = maxTokens * CHARS_PER_TOKEN;
+  function messageLength(msg) {
+    const content = typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content);
+    return content.length + 20;
+  }
+  const totalChars = messages.reduce((sum, m) => sum + messageLength(m), 0);
+  if (totalChars <= maxChars) return messages;
+  const systemMessages = messages.filter((m) => m.role === "system");
+  const conversationMessages = messages.filter((m) => m.role !== "system");
+  if (conversationMessages.length <= 2) return messages;
+  const systemChars = systemMessages.reduce((sum, m) => sum + messageLength(m), 0);
+  const budgetForConversation = maxChars - systemChars;
+  if (budgetForConversation <= 0) return [...systemMessages, conversationMessages[conversationMessages.length - 1]];
+  const kept = [];
+  let usedChars = 0;
+  const tail = [];
+  let tailChars = 0;
+  for (let i = conversationMessages.length - 1; i >= 0; i--) {
+    const len = messageLength(conversationMessages[i]);
+    if (tailChars + len > budgetForConversation * 0.7) break;
+    tail.unshift(conversationMessages[i]);
+    tailChars += len;
+  }
+  const headBudget = budgetForConversation - tailChars;
+  const headEnd = conversationMessages.length - tail.length;
+  for (let i = 0; i < headEnd; i++) {
+    const len = messageLength(conversationMessages[i]);
+    if (usedChars + len > headBudget) break;
+    kept.push(conversationMessages[i]);
+    usedChars += len;
+  }
+  return [...systemMessages, ...kept, ...tail];
+}
+function applyTransform(name, messages, contextLength) {
+  if (name === "middle-out") {
+    return middleOut(messages, contextLength);
+  }
+  return messages;
+}
+
+// src/router.ts
+var STRIPPABLE_PARAMS = [
+  "temperature",
+  "max_tokens",
+  "top_p",
+  "top_k",
+  "frequency_penalty",
+  "presence_penalty",
+  "repetition_penalty",
+  "seed",
+  "stop",
+  "logprobs",
+  "top_logprobs",
+  "response_format",
+  "tools",
+  "tool_choice",
+  "user"
+];
+var Router = class {
+  constructor(registry, aliases, config) {
+    this.registry = registry;
+    this.aliases = aliases;
+    this.config = config;
+  }
+  rateLimiter = new RateLimitTracker();
+  /**
+   * Strip parameters that the target provider doesn't support.
+   */
+  stripUnsupported(request, adapter) {
+    const cleaned = { ...request };
+    for (const param of STRIPPABLE_PARAMS) {
+      if (cleaned[param] !== void 0 && !adapter.supportsParameter(param)) {
+        delete cleaned[param];
+      }
+    }
+    return cleaned;
+  }
+  /**
+   * Apply transforms (e.g., middle-out) to the request messages.
+   */
+  applyTransforms(request) {
+    const transforms = request.transforms || this.config?.defaults?.transforms;
+    if (!transforms || transforms.length === 0) return request;
+    let messages = [...request.messages];
+    const contextLength = 128e3;
+    for (const transform of transforms) {
+      messages = applyTransform(transform, messages, contextLength);
+    }
+    return { ...request, messages };
+  }
+  /**
+   * Order models based on provider preferences.
+   */
+  applyProviderPreferences(models, prefs) {
+    if (!prefs) return models;
+    let filtered = [...models];
+    if (prefs.only && prefs.only.length > 0) {
+      const onlySet = new Set(prefs.only);
+      filtered = filtered.filter((m) => {
+        const { provider } = parseModelString(m, this.aliases);
+        return onlySet.has(provider);
+      });
+    }
+    if (prefs.ignore && prefs.ignore.length > 0) {
+      const ignoreSet = new Set(prefs.ignore);
+      filtered = filtered.filter((m) => {
+        const { provider } = parseModelString(m, this.aliases);
+        return !ignoreSet.has(provider);
+      });
+    }
+    if (prefs.order && prefs.order.length > 0) {
+      const orderMap = new Map(prefs.order.map((p, i) => [p, i]));
+      filtered.sort((a, b) => {
+        const aProvider = parseModelString(a, this.aliases).provider;
+        const bProvider = parseModelString(b, this.aliases).provider;
+        const aOrder = orderMap.get(aProvider) ?? Infinity;
+        const bOrder = orderMap.get(bProvider) ?? Infinity;
+        return aOrder - bOrder;
+      });
+    }
+    if (prefs.require_parameters) {
+      filtered = filtered.filter((m) => {
+        try {
+          const { provider } = parseModelString(m, this.aliases);
+          const adapter = this.registry.get(provider);
+          return adapter !== void 0;
+        } catch {
+          return false;
+        }
+      });
+    }
+    filtered = filtered.filter((m) => {
+      const { provider } = parseModelString(m, this.aliases);
+      return !this.rateLimiter.isRateLimited(provider);
+    });
+    return filtered;
+  }
+  getRetryOptions() {
+    return {
+      maxRetries: this.config?.defaults?.retries ?? 2
+    };
+  }
+  async complete(request) {
+    validateRequest(request);
+    const transformed = this.applyTransforms(request);
+    if (transformed.models && transformed.models.length > 0 && transformed.route === "fallback") {
+      return this.completeWithFallback(transformed);
+    }
+    const { provider, model } = parseModelString(transformed.model, this.aliases);
+    const adapter = this.registry.get(provider);
+    const resolvedRequest = this.stripUnsupported({ ...transformed, model }, adapter);
+    return withRetry(
+      () => adapter.sendRequest(resolvedRequest),
+      this.getRetryOptions()
+    );
+  }
+  async stream(request) {
+    validateRequest(request);
+    const transformed = this.applyTransforms(request);
+    if (transformed.models && transformed.models.length > 0 && transformed.route === "fallback") {
+      return this.streamWithFallback(transformed);
+    }
+    const { provider, model } = parseModelString(transformed.model, this.aliases);
+    const adapter = this.registry.get(provider);
+    const resolvedRequest = this.stripUnsupported({ ...transformed, model, stream: true }, adapter);
+    return withRetry(
+      () => adapter.sendStreamingRequest(resolvedRequest),
+      this.getRetryOptions()
+    );
+  }
+  async completeWithFallback(request) {
+    let models = request.models;
+    const errors = [];
+    models = this.applyProviderPreferences(models, request.provider);
+    for (const modelStr of models) {
+      try {
+        const { provider, model } = parseModelString(modelStr, this.aliases);
+        const adapter = this.registry.get(provider);
+        const resolvedRequest = this.stripUnsupported(
+          { ...request, model, models: void 0, route: void 0 },
+          adapter
+        );
+        const response = await withRetry(
+          () => adapter.sendRequest(resolvedRequest),
+          this.getRetryOptions()
+        );
+        response.model = modelStr;
+        return response;
+      } catch (err) {
+        const error = err instanceof AnyModelError ? err : new AnyModelError(500, String(err));
+        if (error.code === 429) {
+          const { provider } = parseModelString(modelStr, this.aliases);
+          this.rateLimiter.recordRateLimit(provider);
+        }
+        errors.push({ model: modelStr, error });
+      }
+    }
+    const lastError = errors[errors.length - 1];
+    throw new AnyModelError(lastError.error.code, lastError.error.message, {
+      ...lastError.error.metadata,
+      raw: {
+        attempts: errors.map((e) => ({
+          model: e.model,
+          code: e.error.code,
+          message: e.error.message
+        }))
+      }
+    });
+  }
+  async streamWithFallback(request) {
+    let models = request.models;
+    const errors = [];
+    models = this.applyProviderPreferences(models, request.provider);
+    for (const modelStr of models) {
+      try {
+        const { provider, model } = parseModelString(modelStr, this.aliases);
+        const adapter = this.registry.get(provider);
+        const resolvedRequest = this.stripUnsupported(
+          { ...request, model, models: void 0, route: void 0, stream: true },
+          adapter
+        );
+        return await withRetry(
+          () => adapter.sendStreamingRequest(resolvedRequest),
+          this.getRetryOptions()
+        );
+      } catch (err) {
+        const error = err instanceof AnyModelError ? err : new AnyModelError(500, String(err));
+        if (error.code === 429) {
+          const { provider } = parseModelString(modelStr, this.aliases);
+          this.rateLimiter.recordRateLimit(provider);
+        }
+        errors.push({ model: modelStr, error });
+      }
+    }
+    const lastError = errors[errors.length - 1];
+    throw new AnyModelError(lastError.error.code, lastError.error.message, {
+      ...lastError.error.metadata,
+      raw: {
+        attempts: errors.map((e) => ({
+          model: e.model,
+          code: e.error.code,
+          message: e.error.message
+        }))
+      }
+    });
+  }
+  getRateLimiter() {
+    return this.rateLimiter;
+  }
+};
+
+// src/providers/openai.ts
+var OPENAI_API_BASE = "https://api.openai.com/v1";
+var SUPPORTED_PARAMS = /* @__PURE__ */ new Set([
+  "temperature",
+  "max_tokens",
+  "top_p",
+  "frequency_penalty",
+  "presence_penalty",
+  "seed",
+  "stop",
+  "stream",
+  "logprobs",
+  "top_logprobs",
+  "response_format",
+  "tools",
+  "tool_choice",
+  "user",
+  "logit_bias"
+]);
+function createOpenAIAdapter(apiKey, baseURL) {
+  const base = baseURL || OPENAI_API_BASE;
+  async function makeRequest(path2, body, method = "POST") {
+    const res = await fetch(`${base}${path2}`, {
+      method,
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${apiKey}`
+      },
+      body: body ? JSON.stringify(body) : void 0
+    });
+    if (!res.ok) {
+      let errorBody;
+      try {
+        errorBody = await res.json();
+      } catch {
+        errorBody = { message: res.statusText };
+      }
+      const msg = errorBody?.error?.message || errorBody?.message || res.statusText;
+      throw new AnyModelError(mapErrorCode(res.status), msg, {
+        provider_name: "openai",
+        raw: errorBody
+      });
+    }
+    return res;
+  }
+  function mapErrorCode(status) {
+    if (status === 401 || status === 403) return 401;
+    if (status === 429) return 429;
+    if (status === 400 || status === 422) return 400;
+    if (status >= 500) return 502;
+    return status;
+  }
+  function rePrefixId(id) {
+    if (id && id.startsWith("chatcmpl-")) {
+      return `gen-${id.substring(9)}`;
+    }
+    return id.startsWith("gen-") ? id : `gen-${id}`;
+  }
+  function buildRequestBody(request) {
+    const body = {
+      model: request.model,
+      messages: request.messages
+    };
+    if (request.temperature !== void 0) body.temperature = request.temperature;
+    if (request.max_tokens !== void 0) body.max_tokens = request.max_tokens;
+    if (request.top_p !== void 0) body.top_p = request.top_p;
+    if (request.frequency_penalty !== void 0) body.frequency_penalty = request.frequency_penalty;
+    if (request.presence_penalty !== void 0) body.presence_penalty = request.presence_penalty;
+    if (request.seed !== void 0) body.seed = request.seed;
+    if (request.stop !== void 0) body.stop = request.stop;
+    if (request.stream !== void 0) body.stream = request.stream;
+    if (request.logprobs !== void 0) body.logprobs = request.logprobs;
+    if (request.top_logprobs !== void 0) body.top_logprobs = request.top_logprobs;
+    if (request.response_format !== void 0) body.response_format = request.response_format;
+    if (request.tools !== void 0) body.tools = request.tools;
+    if (request.tool_choice !== void 0) body.tool_choice = request.tool_choice;
+    if (request.user !== void 0) body.user = request.user;
+    return body;
+  }
+  const adapter = {
+    name: "openai",
+    translateRequest(request) {
+      return buildRequestBody(request);
+    },
+    translateResponse(response) {
+      const r = response;
+      return {
+        id: rePrefixId(r.id),
+        object: "chat.completion",
+        created: r.created,
+        model: `openai/${r.model}`,
+        choices: r.choices,
+        usage: r.usage
+      };
+    },
+    async *translateStream(stream) {
+      const reader = stream.getReader();
+      const decoder = new TextDecoder();
+      let buffer = "";
+      try {
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done) break;
+          buffer += decoder.decode(value, { stream: true });
+          const lines = buffer.split("\n");
+          buffer = lines.pop() || "";
+          for (const line of lines) {
+            const trimmed = line.trim();
+            if (!trimmed || trimmed.startsWith(":")) continue;
+            if (trimmed === "data: [DONE]") return;
+            if (trimmed.startsWith("data: ")) {
+              const json = JSON.parse(trimmed.substring(6));
+              json.id = rePrefixId(json.id);
+              json.model = `openai/${json.model}`;
+              yield json;
+            }
+          }
+        }
+      } finally {
+        reader.releaseLock();
+      }
+    },
+    translateError(error) {
+      if (error instanceof AnyModelError) {
+        return { code: error.code, message: error.message, metadata: error.metadata };
+      }
+      const err = error;
+      const status = err?.status || err?.code || 500;
+      return {
+        code: mapErrorCode(status),
+        message: err?.message || "Unknown OpenAI error",
+        metadata: { provider_name: "openai", raw: error }
+      };
+    },
+    async listModels() {
+      const res = await makeRequest("/models", void 0, "GET");
+      const data = await res.json();
+      return (data.data || []).filter((m) => {
+        const id = m.id;
+        if (id.includes("embedding")) return false;
+        if (id.includes("whisper")) return false;
+        if (id.includes("tts")) return false;
+        if (id.includes("dall-e")) return false;
+        if (id.includes("davinci")) return false;
+        if (id.includes("babbage")) return false;
+        if (id.includes("moderation")) return false;
+        if (id.includes("realtime")) return false;
+        if (id.startsWith("ft:")) return false;
+        return id.startsWith("gpt-") || id.startsWith("o1") || id.startsWith("o3") || id.startsWith("o4") || id.startsWith("chatgpt-");
+      }).map((m) => ({
+        id: `openai/${m.id}`,
+        name: m.id,
+        created: m.created,
+        description: "",
+        context_length: 128e3,
+        pricing: { prompt: "0", completion: "0" },
+        architecture: {
+          modality: "text+image->text",
+          input_modalities: ["text", "image"],
+          output_modalities: ["text"],
+          tokenizer: "o200k_base"
+        },
+        top_provider: {
+          context_length: 128e3,
+          max_completion_tokens: 16384,
+          is_moderated: true
+        },
+        supported_parameters: Array.from(SUPPORTED_PARAMS)
+      }));
+    },
+    supportsParameter(param) {
+      return SUPPORTED_PARAMS.has(param);
+    },
+    supportsBatch() {
+      return true;
+    },
+    async sendRequest(request) {
+      const body = buildRequestBody(request);
+      const res = await makeRequest("/chat/completions", body);
+      const json = await res.json();
+      return adapter.translateResponse(json);
+    },
+    async sendStreamingRequest(request) {
+      const body = buildRequestBody({ ...request, stream: true });
+      const res = await makeRequest("/chat/completions", body);
+      if (!res.body) {
+        throw new AnyModelError(502, "No response body for streaming request", {
+          provider_name: "openai"
+        });
+      }
+      return adapter.translateStream(res.body);
+    }
+  };
+  return adapter;
+}
+
+// src/utils/id.ts
+import { randomBytes } from "crypto";
+function generateId(prefix = "gen") {
+  const random = randomBytes(12).toString("base64url");
+  return `${prefix}-${random}`;
+}
+
+// src/providers/anthropic.ts
+var ANTHROPIC_API_BASE = "https://api.anthropic.com/v1";
+var ANTHROPIC_VERSION = "2023-06-01";
+var DEFAULT_MAX_TOKENS = 4096;
+var SUPPORTED_PARAMS2 = /* @__PURE__ */ new Set([
+  "temperature",
+  "max_tokens",
+  "top_p",
+  "top_k",
+  "stop",
+  "stream",
+  "tools",
+  "tool_choice",
+  "response_format"
+]);
+var FALLBACK_MODELS = [
+  // Claude 4.6
+  { id: "anthropic/claude-opus-4-6", name: "Claude Opus 4.6", created: 0, description: "Most capable model", context_length: 2e5, pricing: { prompt: "0.000015", completion: "0.000075" }, architecture: { modality: "text+image->text", input_modalities: ["text", "image"], output_modalities: ["text"], tokenizer: "claude" }, top_provider: { context_length: 2e5, max_completion_tokens: 32768, is_moderated: false }, supported_parameters: Array.from(SUPPORTED_PARAMS2) },
+  { id: "anthropic/claude-sonnet-4-6", name: "Claude Sonnet 4.6", created: 0, description: "Best balance of speed and capability", context_length: 2e5, pricing: { prompt: "0.000003", completion: "0.000015" }, architecture: { modality: "text+image->text", input_modalities: ["text", "image"], output_modalities: ["text"], tokenizer: "claude" }, top_provider: { context_length: 2e5, max_completion_tokens: 16384, is_moderated: false }, supported_parameters: Array.from(SUPPORTED_PARAMS2) },
+  // Claude 4.5
+  { id: "anthropic/claude-sonnet-4-5-20251022", name: "Claude Sonnet 4.5", created: 0, description: "Previous generation balanced model", context_length: 2e5, pricing: { prompt: "0.000003", completion: "0.000015" }, architecture: { modality: "text+image->text", input_modalities: ["text", "image"], output_modalities: ["text"], tokenizer: "claude" }, top_provider: { context_length: 2e5, max_completion_tokens: 16384, is_moderated: false }, supported_parameters: Array.from(SUPPORTED_PARAMS2) },
+  { id: "anthropic/claude-haiku-4-5", name: "Claude Haiku 4.5", created: 0, description: "Fast and compact", context_length: 2e5, pricing: { prompt: "0.000001", completion: "0.000005" }, architecture: { modality: "text+image->text", input_modalities: ["text", "image"], output_modalities: ["text"], tokenizer: "claude" }, top_provider: { context_length: 2e5, max_completion_tokens: 8192, is_moderated: false }, supported_parameters: Array.from(SUPPORTED_PARAMS2) },
+  // Claude 3.5
+  { id: "anthropic/claude-3-5-sonnet-20241022", name: "Claude 3.5 Sonnet", created: 0, description: "Legacy balanced model", context_length: 2e5, pricing: { prompt: "0.000003", completion: "0.000015" }, architecture: { modality: "text+image->text", input_modalities: ["text", "image"], output_modalities: ["text"], tokenizer: "claude" }, top_provider: { context_length: 2e5, max_completion_tokens: 8192, is_moderated: false }, supported_parameters: Array.from(SUPPORTED_PARAMS2) },
+  { id: "anthropic/claude-3-5-haiku-20241022", name: "Claude 3.5 Haiku", created: 0, description: "Legacy fast model", context_length: 2e5, pricing: { prompt: "0.0000008", completion: "0.000004" }, architecture: { modality: "text+image->text", input_modalities: ["text", "image"], output_modalities: ["text"], tokenizer: "claude" }, top_provider: { context_length: 2e5, max_completion_tokens: 8192, is_moderated: false }, supported_parameters: Array.from(SUPPORTED_PARAMS2) }
+];
+function createAnthropicAdapter(apiKey) {
+  async function makeRequest(path2, body, stream = false) {
+    const res = await fetch(`${ANTHROPIC_API_BASE}${path2}`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "x-api-key": apiKey,
+        "anthropic-version": ANTHROPIC_VERSION
+      },
+      body: JSON.stringify(body)
+    });
+    if (!res.ok) {
+      let errorBody;
+      try {
+        errorBody = await res.json();
+      } catch {
+        errorBody = { message: res.statusText };
+      }
+      const msg = errorBody?.error?.message || errorBody?.message || res.statusText;
+      throw new AnyModelError(mapErrorCode(res.status), msg, {
+        provider_name: "anthropic",
+        raw: errorBody
+      });
+    }
+    return res;
+  }
+  function mapErrorCode(status) {
+    if (status === 401 || status === 403) return 401;
+    if (status === 429) return 429;
+    if (status === 400 || status === 422) return 400;
+    if (status === 529) return 502;
+    if (status >= 500) return 502;
+    return status;
+  }
+  function translateRequest(request) {
+    const body = {
+      model: request.model,
+      max_tokens: request.max_tokens || DEFAULT_MAX_TOKENS
+    };
+    const systemMessages = request.messages.filter((m) => m.role === "system");
+    const nonSystemMessages = request.messages.filter((m) => m.role !== "system");
+    if (systemMessages.length > 0) {
+      body.system = systemMessages.map((m) => typeof m.content === "string" ? m.content : "").join("\n");
+    }
+    body.messages = nonSystemMessages.map((m) => ({
+      role: m.role === "tool" ? "user" : m.role,
+      content: m.tool_call_id ? [{ type: "tool_result", tool_use_id: m.tool_call_id, content: typeof m.content === "string" ? m.content : "" }] : m.content
+    }));
+    if (request.temperature !== void 0) body.temperature = request.temperature;
+    if (request.top_p !== void 0) body.top_p = request.top_p;
+    if (request.top_k !== void 0) body.top_k = request.top_k;
+    if (request.stop !== void 0) body.stop_sequences = Array.isArray(request.stop) ? request.stop : [request.stop];
+    if (request.stream) body.stream = true;
+    if (request.tools && request.tools.length > 0) {
+      body.tools = request.tools.map((t) => ({
+        name: t.function.name,
+        description: t.function.description || "",
+        input_schema: t.function.parameters || { type: "object", properties: {} }
+      }));
+      if (request.tool_choice) {
+        if (request.tool_choice === "auto") {
+          body.tool_choice = { type: "auto" };
+        } else if (request.tool_choice === "required") {
+          body.tool_choice = { type: "any" };
+        } else if (request.tool_choice === "none") {
+          delete body.tools;
+        } else if (typeof request.tool_choice === "object") {
+          body.tool_choice = { type: "tool", name: request.tool_choice.function.name };
+        }
+      }
+    }
+    if (request.response_format) {
+      if (request.response_format.type === "json_object" || request.response_format.type === "json_schema") {
+        const jsonInstruction = "Respond with valid JSON only. Do not include any text outside the JSON object.";
+        body.system = body.system ? `${jsonInstruction}
+
+${body.system}` : jsonInstruction;
+      }
+    }
+    return body;
+  }
+  function mapStopReason(reason) {
+    switch (reason) {
+      case "end_turn":
+        return "stop";
+      case "max_tokens":
+        return "length";
+      case "tool_use":
+        return "tool_calls";
+      case "stop_sequence":
+        return "stop";
+      default:
+        return "stop";
+    }
+  }
+  function translateResponse(response) {
+    const r = response;
+    let content = "";
+    const toolCalls = [];
+    for (const block of r.content || []) {
+      if (block.type === "text") {
+        content += block.text;
+      } else if (block.type === "tool_use") {
+        toolCalls.push({
+          id: block.id,
+          type: "function",
+          function: {
+            name: block.name,
+            arguments: JSON.stringify(block.input)
+          }
+        });
+      }
+    }
+    const message = {
+      role: "assistant",
+      content
+    };
+    if (toolCalls.length > 0) {
+      message.tool_calls = toolCalls;
+    }
+    return {
+      id: generateId(),
+      object: "chat.completion",
+      created: Math.floor(Date.now() / 1e3),
+      model: `anthropic/${r.model}`,
+      choices: [{
+        index: 0,
+        message,
+        finish_reason: mapStopReason(r.stop_reason)
+      }],
+      usage: {
+        prompt_tokens: r.usage?.input_tokens || 0,
+        completion_tokens: r.usage?.output_tokens || 0,
+        total_tokens: (r.usage?.input_tokens || 0) + (r.usage?.output_tokens || 0)
+      }
+    };
+  }
+  const adapter = {
+    name: "anthropic",
+    translateRequest,
+    translateResponse,
+    async *translateStream(stream) {
+      const reader = stream.getReader();
+      const decoder = new TextDecoder();
+      let buffer = "";
+      const id = generateId();
+      const created = Math.floor(Date.now() / 1e3);
+      let model = "";
+      let usage = null;
+      try {
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done) break;
+          buffer += decoder.decode(value, { stream: true });
+          const lines = buffer.split("\n");
+          buffer = lines.pop() || "";
+          for (const line of lines) {
+            const trimmed = line.trim();
+            if (!trimmed || trimmed.startsWith(":")) continue;
+            if (trimmed.startsWith("data: ")) {
+              const data = JSON.parse(trimmed.substring(6));
+              if (data.type === "message_start") {
+                model = `anthropic/${data.message.model}`;
+                usage = data.message.usage;
+                yield {
+                  id,
+                  object: "chat.completion.chunk",
+                  created,
+                  model,
+                  choices: [{ index: 0, delta: { role: "assistant" }, finish_reason: null }]
+                };
+              } else if (data.type === "content_block_delta") {
+                if (data.delta?.type === "text_delta") {
+                  yield {
+                    id,
+                    object: "chat.completion.chunk",
+                    created,
+                    model,
+                    choices: [{ index: 0, delta: { content: data.delta.text }, finish_reason: null }]
+                  };
+                } else if (data.delta?.type === "input_json_delta") {
+                  yield {
+                    id,
+                    object: "chat.completion.chunk",
+                    created,
+                    model,
+                    choices: [{
+                      index: 0,
+                      delta: {
+                        tool_calls: [{
+                          id: data.content_block?.id || "",
+                          type: "function",
+                          function: { name: "", arguments: data.delta.partial_json }
+                        }]
+                      },
+                      finish_reason: null
+                    }]
+                  };
+                }
+              } else if (data.type === "content_block_start") {
+                if (data.content_block?.type === "tool_use") {
+                  yield {
+                    id,
+                    object: "chat.completion.chunk",
+                    created,
+                    model,
+                    choices: [{
+                      index: 0,
+                      delta: {
+                        tool_calls: [{
+                          id: data.content_block.id,
+                          type: "function",
+                          function: { name: data.content_block.name, arguments: "" }
+                        }]
+                      },
+                      finish_reason: null
+                    }]
+                  };
+                }
+              } else if (data.type === "message_delta") {
+                const finalUsage = usage ? {
+                  prompt_tokens: usage.input_tokens || 0,
+                  completion_tokens: data.usage?.output_tokens || 0,
+                  total_tokens: (usage.input_tokens || 0) + (data.usage?.output_tokens || 0)
+                } : void 0;
+                yield {
+                  id,
+                  object: "chat.completion.chunk",
+                  created,
+                  model,
+                  choices: [{
+                    index: 0,
+                    delta: {},
+                    finish_reason: mapStopReason(data.delta?.stop_reason || "end_turn")
+                  }],
+                  usage: finalUsage
+                };
+              }
+            }
+          }
+        }
+      } finally {
+        reader.releaseLock();
+      }
+    },
+    translateError(error) {
+      if (error instanceof AnyModelError) {
+        return { code: error.code, message: error.message, metadata: error.metadata };
+      }
+      const err = error;
+      const status = err?.status || err?.code || 500;
+      return {
+        code: mapErrorCode(status),
+        message: err?.message || "Unknown Anthropic error",
+        metadata: { provider_name: "anthropic", raw: error }
+      };
+    },
+    async listModels() {
+      try {
+        const res = await fetch(`${ANTHROPIC_API_BASE}/models`, {
+          method: "GET",
+          headers: {
+            "x-api-key": apiKey,
+            "anthropic-version": ANTHROPIC_VERSION
+          }
+        });
+        if (!res.ok) return FALLBACK_MODELS;
+        const data = await res.json();
+        const models = data.data || [];
+        return models.filter((m) => m.type === "model").map((m) => ({
+          id: `anthropic/${m.id}`,
+          name: m.display_name || m.id,
+          created: m.created_at ? new Date(m.created_at).getTime() / 1e3 : 0,
+          description: m.display_name || "",
+          context_length: 2e5,
+          pricing: { prompt: "0", completion: "0" },
+          architecture: {
+            modality: "text+image->text",
+            input_modalities: ["text", "image"],
+            output_modalities: ["text"],
+            tokenizer: "claude"
+          },
+          top_provider: {
+            context_length: 2e5,
+            max_completion_tokens: 16384,
+            is_moderated: false
+          },
+          supported_parameters: Array.from(SUPPORTED_PARAMS2)
+        }));
+      } catch {
+        return FALLBACK_MODELS;
+      }
+    },
+    supportsParameter(param) {
+      return SUPPORTED_PARAMS2.has(param);
+    },
+    supportsBatch() {
+      return true;
+    },
+    async sendRequest(request) {
+      const body = translateRequest(request);
+      const res = await makeRequest("/messages", body);
+      const json = await res.json();
+      return translateResponse(json);
+    },
+    async sendStreamingRequest(request) {
+      const body = translateRequest({ ...request, stream: true });
+      const res = await makeRequest("/messages", body, true);
+      if (!res.body) {
+        throw new AnyModelError(502, "No response body for streaming request", {
+          provider_name: "anthropic"
+        });
+      }
+      return adapter.translateStream(res.body);
+    }
+  };
+  return adapter;
+}
+
+// src/providers/google.ts
+var GEMINI_API_BASE = "https://generativelanguage.googleapis.com/v1beta";
+var SUPPORTED_PARAMS3 = /* @__PURE__ */ new Set([
+  "temperature",
+  "max_tokens",
+  "top_p",
+  "top_k",
+  "stop",
+  "stream",
+  "tools",
+  "tool_choice",
+  "response_format"
+]);
+var FALLBACK_MODELS2 = [
+  // Gemini 2.5
+  { id: "google/gemini-2.5-pro", name: "Gemini 2.5 Pro", created: 0, description: "Most capable Gemini model", context_length: 1048576, pricing: { prompt: "0.00000125", completion: "0.000005" }, architecture: { modality: "text+image->text", input_modalities: ["text", "image", "video", "audio"], output_modalities: ["text"], tokenizer: "gemini" }, top_provider: { context_length: 1048576, max_completion_tokens: 65536, is_moderated: false }, supported_parameters: Array.from(SUPPORTED_PARAMS3) },
+  { id: "google/gemini-2.5-flash", name: "Gemini 2.5 Flash", created: 0, description: "Fast and efficient", context_length: 1048576, pricing: { prompt: "0.00000015", completion: "0.0000006" }, architecture: { modality: "text+image->text", input_modalities: ["text", "image", "video", "audio"], output_modalities: ["text"], tokenizer: "gemini" }, top_provider: { context_length: 1048576, max_completion_tokens: 65536, is_moderated: false }, supported_parameters: Array.from(SUPPORTED_PARAMS3) },
+  // Gemini 2.0
+  { id: "google/gemini-2.0-flash", name: "Gemini 2.0 Flash", created: 0, description: "Fast multimodal model", context_length: 1048576, pricing: { prompt: "0.0000001", completion: "0.0000004" }, architecture: { modality: "text+image->text", input_modalities: ["text", "image", "video", "audio"], output_modalities: ["text"], tokenizer: "gemini" }, top_provider: { context_length: 1048576, max_completion_tokens: 65536, is_moderated: false }, supported_parameters: Array.from(SUPPORTED_PARAMS3) },
+  { id: "google/gemini-2.0-flash-lite", name: "Gemini 2.0 Flash Lite", created: 0, description: "Lightweight and fast", context_length: 1048576, pricing: { prompt: "0.00000005", completion: "0.0000002" }, architecture: { modality: "text+image->text", input_modalities: ["text", "image", "video", "audio"], output_modalities: ["text"], tokenizer: "gemini" }, top_provider: { context_length: 1048576, max_completion_tokens: 65536, is_moderated: false }, supported_parameters: Array.from(SUPPORTED_PARAMS3) },
+  // Gemini 1.5
+  { id: "google/gemini-1.5-pro", name: "Gemini 1.5 Pro", created: 0, description: "Previous generation pro model", context_length: 2097152, pricing: { prompt: "0.00000125", completion: "0.000005" }, architecture: { modality: "text+image->text", input_modalities: ["text", "image", "video", "audio"], output_modalities: ["text"], tokenizer: "gemini" }, top_provider: { context_length: 2097152, max_completion_tokens: 8192, is_moderated: false }, supported_parameters: Array.from(SUPPORTED_PARAMS3) },
+  { id: "google/gemini-1.5-flash", name: "Gemini 1.5 Flash", created: 0, description: "Previous generation flash model", context_length: 1048576, pricing: { prompt: "0.000000075", completion: "0.0000003" }, architecture: { modality: "text+image->text", input_modalities: ["text", "image", "video", "audio"], output_modalities: ["text"], tokenizer: "gemini" }, top_provider: { context_length: 1048576, max_completion_tokens: 8192, is_moderated: false }, supported_parameters: Array.from(SUPPORTED_PARAMS3) }
+];
+function createGoogleAdapter(apiKey) {
+  function getModelEndpoint(model, stream) {
+    const action = stream ? "streamGenerateContent" : "generateContent";
+    return `${GEMINI_API_BASE}/models/${model}:${action}?key=${apiKey}${stream ? "&alt=sse" : ""}`;
+  }
+  function mapErrorCode(status) {
+    if (status === 401 || status === 403) return 401;
+    if (status === 429) return 429;
+    if (status === 400) return 400;
+    if (status >= 500) return 502;
+    return status;
+  }
+  function translateRequest(request) {
+    const body = {};
+    const systemMessages = request.messages.filter((m) => m.role === "system");
+    const nonSystemMessages = request.messages.filter((m) => m.role !== "system");
+    if (systemMessages.length > 0) {
+      body.systemInstruction = {
+        parts: [{ text: systemMessages.map((m) => typeof m.content === "string" ? m.content : "").join("\n") }]
+      };
+    }
+    body.contents = nonSystemMessages.map((m) => ({
+      role: m.role === "assistant" ? "model" : "user",
+      parts: typeof m.content === "string" ? [{ text: m.content }] : Array.isArray(m.content) ? m.content.map((p) => p.type === "text" ? { text: p.text } : { text: "" }) : [{ text: "" }]
+    }));
+    const generationConfig = {};
+    if (request.temperature !== void 0) generationConfig.temperature = request.temperature;
+    if (request.max_tokens !== void 0) generationConfig.maxOutputTokens = request.max_tokens;
+    if (request.top_p !== void 0) generationConfig.topP = request.top_p;
+    if (request.top_k !== void 0) generationConfig.topK = request.top_k;
+    if (request.stop !== void 0) {
+      generationConfig.stopSequences = Array.isArray(request.stop) ? request.stop : [request.stop];
+    }
+    if (request.response_format) {
+      if (request.response_format.type === "json_object") {
+        generationConfig.responseMimeType = "application/json";
+      } else if (request.response_format.type === "json_schema") {
+        generationConfig.responseMimeType = "application/json";
+        generationConfig.responseSchema = request.response_format.json_schema.schema;
+      }
+    }
+    if (Object.keys(generationConfig).length > 0) {
+      body.generationConfig = generationConfig;
+    }
+    if (request.tools && request.tools.length > 0) {
+      body.tools = [{
+        functionDeclarations: request.tools.map((t) => ({
+          name: t.function.name,
+          description: t.function.description || "",
+          parameters: t.function.parameters || {}
+        }))
+      }];
+      if (request.tool_choice) {
+        if (request.tool_choice === "auto") {
+          body.toolConfig = { functionCallingConfig: { mode: "AUTO" } };
+        } else if (request.tool_choice === "required") {
+          body.toolConfig = { functionCallingConfig: { mode: "ANY" } };
+        } else if (request.tool_choice === "none") {
+          body.toolConfig = { functionCallingConfig: { mode: "NONE" } };
+        } else if (typeof request.tool_choice === "object") {
+          body.toolConfig = {
+            functionCallingConfig: {
+              mode: "ANY",
+              allowedFunctionNames: [request.tool_choice.function.name]
+            }
+          };
+        }
+      }
+    }
+    return body;
+  }
+  function mapFinishReason(reason) {
+    switch (reason) {
+      case "STOP":
+        return "stop";
+      case "MAX_TOKENS":
+        return "length";
+      case "SAFETY":
+        return "content_filter";
+      case "RECITATION":
+        return "content_filter";
+      default:
+        return "stop";
+    }
+  }
+  function translateResponse(response) {
+    const r = response;
+    const candidate = r.candidates?.[0];
+    let content = "";
+    const toolCalls = [];
+    for (const part of candidate?.content?.parts || []) {
+      if (part.text) {
+        content += part.text;
+      } else if (part.functionCall) {
+        toolCalls.push({
+          id: generateId("call"),
+          type: "function",
+          function: {
+            name: part.functionCall.name,
+            arguments: JSON.stringify(part.functionCall.args || {})
+          }
+        });
+      }
+    }
+    const message = { role: "assistant", content };
+    if (toolCalls.length > 0) {
+      message.tool_calls = toolCalls;
+    }
+    const finishReason = toolCalls.length > 0 ? "tool_calls" : mapFinishReason(candidate?.finishReason || "STOP");
+    return {
+      id: generateId(),
+      object: "chat.completion",
+      created: Math.floor(Date.now() / 1e3),
+      model: `google/${r.modelVersion || "unknown"}`,
+      choices: [{ index: 0, message, finish_reason: finishReason }],
+      usage: {
+        prompt_tokens: r.usageMetadata?.promptTokenCount || 0,
+        completion_tokens: r.usageMetadata?.candidatesTokenCount || 0,
+        total_tokens: r.usageMetadata?.totalTokenCount || 0
+      }
+    };
+  }
+  const adapter = {
+    name: "google",
+    translateRequest,
+    translateResponse,
+    async *translateStream(stream) {
+      const reader = stream.getReader();
+      const decoder = new TextDecoder();
+      let buffer = "";
+      const id = generateId();
+      const created = Math.floor(Date.now() / 1e3);
+      let emittedRole = false;
+      try {
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done) break;
+          buffer += decoder.decode(value, { stream: true });
+          const lines = buffer.split("\n");
+          buffer = lines.pop() || "";
+          for (const line of lines) {
+            const trimmed = line.trim();
+            if (!trimmed || trimmed.startsWith(":")) continue;
+            if (trimmed === "data: [DONE]") return;
+            if (trimmed.startsWith("data: ")) {
+              const data = JSON.parse(trimmed.substring(6));
+              const candidate = data.candidates?.[0];
+              if (!candidate) continue;
+              const parts = candidate.content?.parts || [];
+              for (const part of parts) {
+                if (part.text !== void 0) {
+                  const chunk = {
+                    id,
+                    object: "chat.completion.chunk",
+                    created,
+                    model: `google/${data.modelVersion || "unknown"}`,
+                    choices: [{
+                      index: 0,
+                      delta: emittedRole ? { content: part.text } : { role: "assistant", content: part.text },
+                      finish_reason: null
+                    }]
+                  };
+                  emittedRole = true;
+                  yield chunk;
+                }
+              }
+              if (candidate.finishReason) {
+                yield {
+                  id,
+                  object: "chat.completion.chunk",
+                  created,
+                  model: `google/${data.modelVersion || "unknown"}`,
+                  choices: [{ index: 0, delta: {}, finish_reason: mapFinishReason(candidate.finishReason) }],
+                  usage: data.usageMetadata ? {
+                    prompt_tokens: data.usageMetadata.promptTokenCount || 0,
+                    completion_tokens: data.usageMetadata.candidatesTokenCount || 0,
+                    total_tokens: data.usageMetadata.totalTokenCount || 0
+                  } : void 0
+                };
+              }
+            }
+          }
+        }
+      } finally {
+        reader.releaseLock();
+      }
+    },
+    translateError(error) {
+      if (error instanceof AnyModelError) {
+        return { code: error.code, message: error.message, metadata: error.metadata };
+      }
+      const err = error;
+      const status = err?.status || err?.code || 500;
+      return {
+        code: mapErrorCode(status),
+        message: err?.message || "Unknown Google error",
+        metadata: { provider_name: "google", raw: error }
+      };
+    },
+    async listModels() {
+      try {
+        const res = await fetch(`${GEMINI_API_BASE}/models?key=${apiKey}`);
+        if (!res.ok) return FALLBACK_MODELS2;
+        const data = await res.json();
+        const models = data.models || [];
+        return models.filter((m) => m.name?.startsWith("models/gemini-") && m.supportedGenerationMethods?.includes("generateContent")).map((m) => {
+          const modelId = m.name.replace("models/", "");
+          return {
+            id: `google/${modelId}`,
+            name: m.displayName || modelId,
+            created: 0,
+            description: m.description || "",
+            context_length: m.inputTokenLimit || 1048576,
+            pricing: { prompt: "0", completion: "0" },
+            architecture: {
+              modality: "text+image->text",
+              input_modalities: ["text", "image", "video", "audio"],
+              output_modalities: ["text"],
+              tokenizer: "gemini"
+            },
+            top_provider: {
+              context_length: m.inputTokenLimit || 1048576,
+              max_completion_tokens: m.outputTokenLimit || 65536,
+              is_moderated: false
+            },
+            supported_parameters: Array.from(SUPPORTED_PARAMS3)
+          };
+        });
+      } catch {
+        return FALLBACK_MODELS2;
+      }
+    },
+    supportsParameter(param) {
+      return SUPPORTED_PARAMS3.has(param);
+    },
+    supportsBatch() {
+      return false;
+    },
+    async sendRequest(request) {
+      const body = translateRequest(request);
+      const url = getModelEndpoint(request.model, false);
+      const res = await fetch(url, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(body)
+      });
+      if (!res.ok) {
+        let errorBody;
+        try {
+          errorBody = await res.json();
+        } catch {
+          errorBody = { message: res.statusText };
+        }
+        throw new AnyModelError(mapErrorCode(res.status), errorBody?.error?.message || res.statusText, {
+          provider_name: "google",
+          raw: errorBody
+        });
+      }
+      const json = await res.json();
+      return translateResponse(json);
+    },
+    async sendStreamingRequest(request) {
+      const body = translateRequest(request);
+      const url = getModelEndpoint(request.model, true);
+      const res = await fetch(url, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(body)
+      });
+      if (!res.ok) {
+        let errorBody;
+        try {
+          errorBody = await res.json();
+        } catch {
+          errorBody = { message: res.statusText };
+        }
+        throw new AnyModelError(mapErrorCode(res.status), errorBody?.error?.message || res.statusText, {
+          provider_name: "google",
+          raw: errorBody
+        });
+      }
+      if (!res.body) {
+        throw new AnyModelError(502, "No response body for streaming request", { provider_name: "google" });
+      }
+      return adapter.translateStream(res.body);
+    }
+  };
+  return adapter;
+}
+
+// src/providers/custom.ts
+function createCustomAdapter(name, config) {
+  const openaiAdapter = createOpenAIAdapter(config.apiKey || "", config.baseURL);
+  return {
+    ...openaiAdapter,
+    name,
+    supportsBatch() {
+      return false;
+    },
+    async listModels() {
+      if (config.models && config.models.length > 0) {
+        return config.models.map((modelId) => ({
+          id: `${name}/${modelId}`,
+          name: modelId,
+          created: 0,
+          description: `Custom model via ${name}`,
+          context_length: 128e3,
+          pricing: { prompt: "0", completion: "0" },
+          architecture: {
+            modality: "text->text",
+            input_modalities: ["text"],
+            output_modalities: ["text"],
+            tokenizer: "unknown"
+          },
+          top_provider: {
+            context_length: 128e3,
+            max_completion_tokens: 16384,
+            is_moderated: false
+          },
+          supported_parameters: ["temperature", "max_tokens", "top_p", "stop", "stream", "tools", "tool_choice"]
+        }));
+      }
+      try {
+        const models = await openaiAdapter.listModels();
+        return models.map((m) => ({
+          ...m,
+          id: `${name}/${m.name}`
+        }));
+      } catch {
+        return [];
+      }
+    },
+    translateResponse(response) {
+      const translated = openaiAdapter.translateResponse(response);
+      if (translated.model.startsWith("openai/")) {
+        translated.model = `${name}/${translated.model.substring(7)}`;
+      }
+      return translated;
+    }
+  };
+}
+
+// src/config.ts
+import { readFileSync, existsSync } from "fs";
+import { resolve, join } from "path";
+import { homedir } from "os";
+var LOCAL_CONFIG_NAMES = ["anymodel.config.json"];
+var GLOBAL_CONFIG_DIR = join(homedir(), ".anymodel");
+var GLOBAL_CONFIG_FILE = join(GLOBAL_CONFIG_DIR, "config.json");
+function interpolateEnvVars(value) {
+  return value.replace(/\$\{([^}]+)\}/g, (_, name) => process.env[name] || "");
+}
+function interpolateDeep(obj) {
+  if (typeof obj === "string") return interpolateEnvVars(obj);
+  if (Array.isArray(obj)) return obj.map(interpolateDeep);
+  if (obj !== null && typeof obj === "object") {
+    const result = {};
+    for (const [key, val] of Object.entries(obj)) {
+      result[key] = interpolateDeep(val);
+    }
+    return result;
+  }
+  return obj;
+}
+function loadJsonFile(path2) {
+  if (!existsSync(path2)) return null;
+  try {
+    const raw = readFileSync(path2, "utf-8");
+    const parsed = JSON.parse(raw);
+    return interpolateDeep(parsed);
+  } catch {
+    return null;
+  }
+}
+function findLocalConfig(cwd) {
+  const dir = cwd || process.cwd();
+  for (const name of LOCAL_CONFIG_NAMES) {
+    const config = loadJsonFile(resolve(dir, name));
+    if (config) return config;
+  }
+  return null;
+}
+function findGlobalConfig() {
+  return loadJsonFile(GLOBAL_CONFIG_FILE);
+}
+function deepMerge(target, source) {
+  const result = { ...target };
+  for (const [key, value] of Object.entries(source)) {
+    if (value === void 0) continue;
+    const existing = target[key];
+    if (existing !== null && typeof existing === "object" && !Array.isArray(existing) && value !== null && typeof value === "object" && !Array.isArray(value)) {
+      result[key] = deepMerge(existing, value);
+    } else {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+function envConfig() {
+  const config = {};
+  const envMap = [
+    ["openai", "OPENAI_API_KEY"],
+    ["anthropic", "ANTHROPIC_API_KEY"],
+    ["google", "GOOGLE_API_KEY"],
+    ["mistral", "MISTRAL_API_KEY"],
+    ["groq", "GROQ_API_KEY"],
+    ["deepseek", "DEEPSEEK_API_KEY"],
+    ["xai", "XAI_API_KEY"],
+    ["together", "TOGETHER_API_KEY"],
+    ["fireworks", "FIREWORKS_API_KEY"],
+    ["perplexity", "PERPLEXITY_API_KEY"]
+  ];
+  for (const [key, envVar] of envMap) {
+    if (process.env[envVar]) {
+      config[key] = { apiKey: process.env[envVar] };
+    }
+  }
+  return config;
+}
+function resolveConfig(programmatic = {}, cwd) {
+  const env = envConfig();
+  const global = findGlobalConfig() || {};
+  const local = findLocalConfig(cwd) || {};
+  let config = deepMerge(env, global);
+  config = deepMerge(config, local);
+  config = deepMerge(config, programmatic);
+  return config;
+}
+
+// src/utils/generation-stats.ts
+var GenerationStatsStore = class {
+  records = /* @__PURE__ */ new Map();
+  maxRecords;
+  constructor(maxRecords = 1e3) {
+    this.maxRecords = maxRecords;
+  }
+  record(entry) {
+    if (this.records.size >= this.maxRecords) {
+      const oldest = this.records.keys().next().value;
+      if (oldest) this.records.delete(oldest);
+    }
+    this.records.set(entry.id, entry);
+  }
+  get(id) {
+    const rec = this.records.get(id);
+    if (!rec) return void 0;
+    const latency = rec.endTime - rec.startTime;
+    return {
+      id: rec.id,
+      model: rec.model,
+      provider_name: rec.providerName,
+      total_cost: 0,
+      // Cost calculation requires pricing data
+      tokens_prompt: rec.promptTokens,
+      tokens_completion: rec.completionTokens,
+      latency,
+      generation_time: latency,
+      created_at: new Date(rec.startTime).toISOString(),
+      finish_reason: rec.finishReason,
+      streamed: rec.streamed
+    };
+  }
+  list(limit = 50) {
+    const entries = Array.from(this.records.values()).slice(-limit).reverse();
+    return entries.map((rec) => this.get(rec.id));
+  }
+};
+
+// src/utils/fs-io.ts
+import { mkdir, open, readFile as fsReadFile, rename, writeFile as fsWriteFile, readdir as fsReaddir, stat as fsStat } from "fs/promises";
+import { createWriteStream } from "fs";
+import path from "path";
+import PQueue from "p-queue";
+var writeQueue = new PQueue({ concurrency: 10 });
+var readQueue = new PQueue({ concurrency: 20 });
+function configureFsIO(options) {
+  if (options.readConcurrency !== void 0) {
+    readQueue.concurrency = options.readConcurrency;
+  }
+  if (options.writeConcurrency !== void 0) {
+    writeQueue.concurrency = options.writeConcurrency;
+  }
+}
+var ensuredDirs = /* @__PURE__ */ new Set();
+var joinPathCache = /* @__PURE__ */ new Map();
+var dirnameCache = /* @__PURE__ */ new Map();
+var resolvePathCache = /* @__PURE__ */ new Map();
+async function ensureDir(dir) {
+  if (!dir) return;
+  if (ensuredDirs.has(dir)) return;
+  await mkdir(dir, { recursive: true });
+  ensuredDirs.add(dir);
+}
+async function readFileQueued(filePath, encoding = "utf8") {
+  return readQueue.add(async () => {
+    return fsReadFile(filePath, encoding);
+  });
+}
+async function readJsonQueued(filePath) {
+  const raw = await readFileQueued(filePath, "utf8");
+  return JSON.parse(raw);
+}
+async function readDirQueued(dirPath) {
+  return readQueue.add(async () => {
+    return fsReaddir(dirPath, { withFileTypes: true });
+  });
+}
+async function pathExistsQueued(p) {
+  return readQueue.add(async () => {
+    try {
+      await fsStat(p);
+      return true;
+    } catch {
+      return false;
+    }
+  });
+}
+async function fileExistsQueued(filePath) {
+  return readQueue.add(async () => {
+    try {
+      const s = await fsStat(filePath);
+      return s.isFile();
+    } catch {
+      return false;
+    }
+  });
+}
+async function writeFileQueued(filePath, data) {
+  await writeQueue.add(async () => {
+    const dir = dirnameOf(filePath);
+    await ensureDir(dir);
+    await fsWriteFile(filePath, data);
+  });
+}
+async function appendFileQueued(filePath, data) {
+  await writeQueue.add(async () => {
+    const dir = dirnameOf(filePath);
+    await ensureDir(dir);
+    await fsWriteFile(filePath, data, { flag: "a" });
+  });
+}
+async function writeFileFlushedQueued(filePath, data) {
+  await writeQueue.add(async () => {
+    const dir = dirnameOf(filePath);
+    await ensureDir(dir);
+    const tmpPath = joinPath(
+      dir,
+      `.${path.basename(filePath)}.${Date.now()}.${Math.random().toString(16).slice(2)}.tmp`
+    );
+    const fh = await open(tmpPath, "w");
+    try {
+      await fh.writeFile(data);
+      await fh.sync();
+    } finally {
+      await fh.close();
+    }
+    await rename(tmpPath, filePath);
+    try {
+      const dh = await open(dir, "r");
+      try {
+        await dh.sync();
+      } finally {
+        await dh.close();
+      }
+    } catch {
+    }
+  });
+}
+function joinPath(...segments) {
+  const key = segments.join("\0");
+  const cached = joinPathCache.get(key);
+  if (cached !== void 0) return cached;
+  const out = path.join(...segments);
+  joinPathCache.set(key, out);
+  return out;
+}
+function dirnameOf(p) {
+  const cached = dirnameCache.get(p);
+  if (cached !== void 0) return cached;
+  const out = path.dirname(p);
+  dirnameCache.set(p, out);
+  return out;
+}
+function resolvePath(...segments) {
+  const key = segments.join("\0");
+  const cached = resolvePathCache.get(key);
+  if (cached !== void 0) return cached;
+  const out = path.resolve(...segments);
+  resolvePathCache.set(key, out);
+  return out;
+}
+function getFsQueueStatus() {
+  return {
+    read: { size: readQueue.size, pending: readQueue.pending },
+    write: { size: writeQueue.size, pending: writeQueue.pending }
+  };
+}
+async function waitForFsQueuesIdle() {
+  await Promise.all([writeQueue.onIdle(), readQueue.onIdle()]);
+}
+
+// src/batch/store.ts
+var DEFAULT_BATCH_DIR = joinPath(process.cwd(), ".anymodel", "batches");
+var BatchStore = class {
+  dir;
+  initialized = false;
+  constructor(dir) {
+    this.dir = resolvePath(dir || DEFAULT_BATCH_DIR);
+  }
+  async init() {
+    if (this.initialized) return;
+    await ensureDir(this.dir);
+    this.initialized = true;
+  }
+  batchDir(id) {
+    return joinPath(this.dir, id);
+  }
+  /**
+   * Create a new batch directory and save initial metadata.
+   */
+  async create(batch) {
+    await this.init();
+    const dir = this.batchDir(batch.id);
+    await ensureDir(dir);
+    await writeFileFlushedQueued(joinPath(dir, "meta.json"), JSON.stringify(batch, null, 2));
+  }
+  /**
+   * Update batch metadata (atomic write).
+   */
+  async updateMeta(batch) {
+    await writeFileFlushedQueued(
+      joinPath(this.batchDir(batch.id), "meta.json"),
+      JSON.stringify(batch, null, 2)
+    );
+  }
+  /**
+   * Save requests as JSONL.
+   */
+  async saveRequests(id, requests) {
+    const lines = requests.map((r) => JSON.stringify(r)).join("\n") + "\n";
+    await writeFileQueued(joinPath(this.batchDir(id), "requests.jsonl"), lines);
+  }
+  /**
+   * Append a result to results.jsonl.
+   */
+  async appendResult(id, result) {
+    await appendFileQueued(
+      joinPath(this.batchDir(id), "results.jsonl"),
+      JSON.stringify(result) + "\n"
+    );
+  }
+  /**
+   * Save provider-specific state (e.g., provider batch ID).
+   */
+  async saveProviderState(id, state) {
+    await writeFileFlushedQueued(
+      joinPath(this.batchDir(id), "provider.json"),
+      JSON.stringify(state, null, 2)
+    );
+  }
+  /**
+   * Load provider state.
+   */
+  async loadProviderState(id) {
+    const p = joinPath(this.batchDir(id), "provider.json");
+    if (!await fileExistsQueued(p)) return null;
+    return readJsonQueued(p);
+  }
+  /**
+   * Get batch metadata.
+   */
+  async getMeta(id) {
+    const p = joinPath(this.batchDir(id), "meta.json");
+    if (!await fileExistsQueued(p)) return null;
+    return readJsonQueued(p);
+  }
+  /**
+   * Get all results for a batch.
+   */
+  async getResults(id) {
+    const p = joinPath(this.batchDir(id), "results.jsonl");
+    if (!await fileExistsQueued(p)) return [];
+    const raw = await readFileQueued(p, "utf8");
+    return raw.trim().split("\n").filter(Boolean).map((line) => JSON.parse(line));
+  }
+  /**
+   * List all batch IDs.
+   */
+  async listBatches() {
+    await this.init();
+    if (!await pathExistsQueued(this.dir)) return [];
+    const entries = await readDirQueued(this.dir);
+    return entries.filter((d) => d.isDirectory()).map((d) => d.name).sort();
+  }
+  /**
+   * Check if a batch exists.
+   */
+  async exists(id) {
+    return fileExistsQueued(joinPath(this.batchDir(id), "meta.json"));
+  }
+};
+
+// src/batch/manager.ts
+var BatchManager = class {
+  store;
+  router;
+  concurrencyLimit;
+  defaultPollInterval;
+  batchAdapters = /* @__PURE__ */ new Map();
+  constructor(router, options) {
+    this.store = new BatchStore(options?.dir);
+    this.router = router;
+    this.concurrencyLimit = options?.concurrency ?? 5;
+    this.defaultPollInterval = options?.pollInterval ?? 5e3;
+  }
+  /**
+   * Register a native batch adapter for a provider.
+   */
+  registerBatchAdapter(providerName, adapter) {
+    this.batchAdapters.set(providerName, adapter);
+  }
+  /**
+   * Check if a provider has native batch support.
+   */
+  getNativeBatchAdapter(model) {
+    const providerName = model.split("/")[0];
+    const adapter = this.batchAdapters.get(providerName);
+    return adapter ? { adapter, providerName } : null;
+  }
+  /**
+   * Create a batch and return immediately (no polling).
+   */
+  async create(request) {
+    const id = generateId("batch");
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const providerName = request.model.split("/")[0] || "unknown";
+    const native = this.getNativeBatchAdapter(request.model);
+    const batchMode = native ? "native" : "concurrent";
+    const batch = {
+      id,
+      object: "batch",
+      status: "pending",
+      model: request.model,
+      provider_name: providerName,
+      batch_mode: batchMode,
+      total: request.requests.length,
+      completed: 0,
+      failed: 0,
+      created_at: now,
+      completed_at: null,
+      expires_at: null
+    };
+    await this.store.create(batch);
+    await this.store.saveRequests(id, request.requests);
+    if (native) {
+      this.processNativeBatch(id, request, native.adapter).catch(() => {
+      });
+    } else {
+      this.processConcurrentBatch(id, request).catch(() => {
+      });
+    }
+    return batch;
+  }
+  /**
+   * Create a batch and poll until completion.
+   */
+  async createAndPoll(request, options = {}) {
+    const batch = await this.create(request);
+    return this.poll(batch.id, options);
+  }
+  /**
+   * Poll an existing batch until completion.
+   */
+  async poll(id, options = {}) {
+    const interval = options.interval ?? this.defaultPollInterval;
+    const timeout = options.timeout ?? 0;
+    const startTime = Date.now();
+    while (true) {
+      let batch = await this.store.getMeta(id);
+      if (!batch) {
+        throw new AnyModelError(404, `Batch ${id} not found`);
+      }
+      if (batch.batch_mode === "native" && batch.status === "processing") {
+        await this.syncNativeBatchStatus(id);
+        batch = await this.store.getMeta(id);
+        if (!batch) throw new AnyModelError(404, `Batch ${id} not found`);
+      }
+      if (options.onProgress) {
+        options.onProgress(batch);
+      }
+      if (batch.status === "completed" || batch.status === "failed" || batch.status === "cancelled") {
+        return this.getResults(id);
+      }
+      if (timeout > 0 && Date.now() - startTime > timeout) {
+        throw new AnyModelError(408, `Batch ${id} timed out after ${timeout}ms`);
+      }
+      await new Promise((resolve2) => setTimeout(resolve2, interval));
+    }
+  }
+  /**
+   * Get the current status of a batch.
+   */
+  async get(id) {
+    return this.store.getMeta(id);
+  }
+  /**
+   * Get results for a completed batch.
+   */
+  async getResults(id) {
+    const batch = await this.store.getMeta(id);
+    if (!batch) {
+      throw new AnyModelError(404, `Batch ${id} not found`);
+    }
+    const results = await this.store.getResults(id);
+    const usage = {
+      total_prompt_tokens: 0,
+      total_completion_tokens: 0,
+      estimated_cost: 0
+    };
+    for (const result of results) {
+      if (result.response) {
+        usage.total_prompt_tokens += result.response.usage.prompt_tokens;
+        usage.total_completion_tokens += result.response.usage.completion_tokens;
+      }
+    }
+    return {
+      id: batch.id,
+      status: batch.status,
+      results,
+      usage_summary: usage
+    };
+  }
+  /**
+   * List all batches.
+   */
+  async list() {
+    const ids = await this.store.listBatches();
+    const batches = [];
+    for (const id of ids) {
+      const meta = await this.store.getMeta(id);
+      if (meta) batches.push(meta);
+    }
+    return batches;
+  }
+  /**
+   * Cancel a batch.
+   */
+  async cancel(id) {
+    const batch = await this.store.getMeta(id);
+    if (!batch) {
+      throw new AnyModelError(404, `Batch ${id} not found`);
+    }
+    if (batch.status === "completed" || batch.status === "cancelled") {
+      return batch;
+    }
+    if (batch.batch_mode === "native") {
+      const providerState = await this.store.loadProviderState(id);
+      const adapter = this.batchAdapters.get(batch.provider_name);
+      if (adapter && providerState?.providerBatchId) {
+        try {
+          await adapter.cancelBatch(providerState.providerBatchId);
+        } catch {
+        }
+      }
+    }
+    batch.status = "cancelled";
+    batch.completed_at = (/* @__PURE__ */ new Date()).toISOString();
+    await this.store.updateMeta(batch);
+    return batch;
+  }
+  /**
+   * Process batch via native provider batch API.
+   */
+  async processNativeBatch(batchId, request, adapter) {
+    const batch = await this.store.getMeta(batchId);
+    if (!batch) return;
+    try {
+      const model = request.model.includes("/") ? request.model.split("/").slice(1).join("/") : request.model;
+      const { providerBatchId, metadata } = await adapter.createBatch(
+        model,
+        request.requests,
+        request.options
+      );
+      await this.store.saveProviderState(batchId, {
+        providerBatchId,
+        providerName: batch.provider_name,
+        ...metadata
+      });
+      batch.status = "processing";
+      await this.store.updateMeta(batch);
+    } catch (err) {
+      batch.status = "failed";
+      batch.completed_at = (/* @__PURE__ */ new Date()).toISOString();
+      await this.store.updateMeta(batch);
+      throw err;
+    }
+  }
+  /**
+   * Sync native batch status from provider.
+   */
+  async syncNativeBatchStatus(batchId) {
+    const batch = await this.store.getMeta(batchId);
+    if (!batch) return;
+    const providerState = await this.store.loadProviderState(batchId);
+    if (!providerState?.providerBatchId) return;
+    const adapter = this.batchAdapters.get(batch.provider_name);
+    if (!adapter) return;
+    try {
+      const status = await adapter.pollBatch(providerState.providerBatchId);
+      batch.total = status.total || batch.total;
+      batch.completed = status.completed;
+      batch.failed = status.failed;
+      if (status.status === "completed" || status.status === "failed" || status.status === "cancelled") {
+        batch.status = status.status;
+        batch.completed_at = (/* @__PURE__ */ new Date()).toISOString();
+        if (status.status === "completed" || status.status === "failed") {
+          try {
+            const results = await adapter.getBatchResults(providerState.providerBatchId);
+            for (const result of results) {
+              await this.store.appendResult(batchId, result);
+            }
+            batch.completed = results.filter((r) => r.status === "success").length;
+            batch.failed = results.filter((r) => r.status === "error").length;
+          } catch {
+            if (batch.status !== "failed") {
+              batch.status = "failed";
+            }
+          }
+        }
+      } else {
+        batch.status = "processing";
+      }
+      await this.store.updateMeta(batch);
+    } catch {
+    }
+  }
+  /**
+   * Process batch requests concurrently (fallback path).
+   */
+  async processConcurrentBatch(batchId, request) {
+    const batch = await this.store.getMeta(batchId);
+    if (!batch) return;
+    batch.status = "processing";
+    await this.store.updateMeta(batch);
+    const items = request.requests;
+    const active = /* @__PURE__ */ new Set();
+    const processItem = async (item) => {
+      const current = await this.store.getMeta(batchId);
+      if (current?.status === "cancelled") return;
+      const chatRequest = {
+        model: request.model,
+        messages: item.messages,
+        max_tokens: item.max_tokens ?? request.options?.max_tokens,
+        temperature: item.temperature ?? request.options?.temperature,
+        top_p: item.top_p ?? request.options?.top_p,
+        top_k: item.top_k ?? request.options?.top_k,
+        stop: item.stop ?? request.options?.stop,
+        response_format: item.response_format ?? request.options?.response_format,
+        tools: item.tools ?? request.options?.tools,
+        tool_choice: item.tool_choice ?? request.options?.tool_choice
+      };
+      let result;
+      try {
+        const response = await this.router.complete(chatRequest);
+        result = {
+          custom_id: item.custom_id,
+          status: "success",
+          response,
+          error: null
+        };
+      } catch (err) {
+        const error = err instanceof AnyModelError ? err : new AnyModelError(500, String(err));
+        result = {
+          custom_id: item.custom_id,
+          status: "error",
+          response: null,
+          error: { code: error.code, message: error.message }
+        };
+      }
+      await this.store.appendResult(batchId, result);
+      const meta = await this.store.getMeta(batchId);
+      if (meta) {
+        if (result.status === "success") {
+          meta.completed++;
+        } else {
+          meta.failed++;
+        }
+        await this.store.updateMeta(meta);
+      }
+    };
+    for (const item of items) {
+      const current = await this.store.getMeta(batchId);
+      if (current?.status === "cancelled") break;
+      if (active.size >= this.concurrencyLimit) {
+        await Promise.race(active);
+      }
+      const promise = processItem(item).then(() => {
+        active.delete(promise);
+      });
+      active.add(promise);
+    }
+    await Promise.all(active);
+    const finalMeta = await this.store.getMeta(batchId);
+    if (finalMeta && finalMeta.status !== "cancelled") {
+      finalMeta.status = finalMeta.failed === finalMeta.total ? "failed" : "completed";
+      finalMeta.completed_at = (/* @__PURE__ */ new Date()).toISOString();
+      await this.store.updateMeta(finalMeta);
+    }
+  }
+};
+
+// src/providers/openai-batch.ts
+var OPENAI_API_BASE2 = "https://api.openai.com/v1";
+function createOpenAIBatchAdapter(apiKey) {
+  async function apiRequest(path2, options = {}) {
+    const headers = {
+      "Authorization": `Bearer ${apiKey}`
+    };
+    let fetchBody;
+    if (options.formData) {
+      fetchBody = options.formData;
+    } else if (options.body) {
+      headers["Content-Type"] = "application/json";
+      fetchBody = JSON.stringify(options.body);
+    }
+    const res = await fetch(`${OPENAI_API_BASE2}${path2}`, {
+      method: options.method || "GET",
+      headers,
+      body: fetchBody
+    });
+    if (!res.ok) {
+      let errorBody;
+      try {
+        errorBody = await res.json();
+      } catch {
+        errorBody = { message: res.statusText };
+      }
+      const msg = errorBody?.error?.message || errorBody?.message || res.statusText;
+      throw new AnyModelError(res.status >= 500 ? 502 : res.status, msg, {
+        provider_name: "openai",
+        raw: errorBody
+      });
+    }
+    return res;
+  }
+  function buildJSONL(model, requests) {
+    return requests.map((req) => {
+      const body = {
+        model,
+        messages: req.messages
+      };
+      if (req.max_tokens !== void 0) body.max_tokens = req.max_tokens;
+      if (req.temperature !== void 0) body.temperature = req.temperature;
+      if (req.top_p !== void 0) body.top_p = req.top_p;
+      if (req.stop !== void 0) body.stop = req.stop;
+      if (req.response_format !== void 0) body.response_format = req.response_format;
+      if (req.tools !== void 0) body.tools = req.tools;
+      if (req.tool_choice !== void 0) body.tool_choice = req.tool_choice;
+      return JSON.stringify({
+        custom_id: req.custom_id,
+        method: "POST",
+        url: "/v1/chat/completions",
+        body
+      });
+    }).join("\n");
+  }
+  function rePrefixId(id) {
+    if (id && id.startsWith("chatcmpl-")) {
+      return `gen-${id.substring(9)}`;
+    }
+    return id.startsWith("gen-") ? id : `gen-${id}`;
+  }
+  function translateOpenAIResponse(body) {
+    return {
+      id: rePrefixId(body.id || generateId()),
+      object: "chat.completion",
+      created: body.created || Math.floor(Date.now() / 1e3),
+      model: `openai/${body.model}`,
+      choices: body.choices,
+      usage: body.usage
+    };
+  }
+  function mapStatus(openaiStatus) {
+    switch (openaiStatus) {
+      case "validating":
+      case "finalizing":
+        return "processing";
+      case "in_progress":
+        return "processing";
+      case "completed":
+        return "completed";
+      case "failed":
+        return "failed";
+      case "expired":
+        return "failed";
+      case "cancelled":
+      case "cancelling":
+        return "cancelled";
+      default:
+        return "pending";
+    }
+  }
+  return {
+    async createBatch(model, requests, options) {
+      const jsonlContent = buildJSONL(model, requests);
+      const blob = new Blob([jsonlContent], { type: "application/jsonl" });
+      const formData = new FormData();
+      formData.append("purpose", "batch");
+      formData.append("file", blob, "batch_input.jsonl");
+      const uploadRes = await apiRequest("/files", { method: "POST", formData });
+      const fileData = await uploadRes.json();
+      const inputFileId = fileData.id;
+      const batchRes = await apiRequest("/batches", {
+        method: "POST",
+        body: {
+          input_file_id: inputFileId,
+          endpoint: "/v1/chat/completions",
+          completion_window: "24h",
+          metadata: options?.metadata
+        }
+      });
+      const batchData = await batchRes.json();
+      return {
+        providerBatchId: batchData.id,
+        metadata: {
+          input_file_id: inputFileId,
+          openai_status: batchData.status
+        }
+      };
+    },
+    async pollBatch(providerBatchId) {
+      const res = await apiRequest(`/batches/${providerBatchId}`);
+      const data = await res.json();
+      const requestCounts = data.request_counts || {};
+      return {
+        status: mapStatus(data.status),
+        total: requestCounts.total || 0,
+        completed: requestCounts.completed || 0,
+        failed: requestCounts.failed || 0
+      };
+    },
+    async getBatchResults(providerBatchId) {
+      const batchRes = await apiRequest(`/batches/${providerBatchId}`);
+      const batchData = await batchRes.json();
+      const results = [];
+      if (batchData.output_file_id) {
+        const outputRes = await apiRequest(`/files/${batchData.output_file_id}/content`);
+        const outputText = await outputRes.text();
+        for (const line of outputText.trim().split("\n")) {
+          if (!line) continue;
+          const item = JSON.parse(line);
+          if (item.response?.status_code === 200) {
+            results.push({
+              custom_id: item.custom_id,
+              status: "success",
+              response: translateOpenAIResponse(item.response.body),
+              error: null
+            });
+          } else {
+            results.push({
+              custom_id: item.custom_id,
+              status: "error",
+              response: null,
+              error: {
+                code: item.response?.status_code || 500,
+                message: item.error?.message || item.response?.body?.error?.message || "Unknown error"
+              }
+            });
+          }
+        }
+      }
+      if (batchData.error_file_id) {
+        const errorRes = await apiRequest(`/files/${batchData.error_file_id}/content`);
+        const errorText = await errorRes.text();
+        for (const line of errorText.trim().split("\n")) {
+          if (!line) continue;
+          const item = JSON.parse(line);
+          const existing = results.find((r) => r.custom_id === item.custom_id);
+          if (!existing) {
+            results.push({
+              custom_id: item.custom_id,
+              status: "error",
+              response: null,
+              error: {
+                code: item.response?.status_code || 500,
+                message: item.error?.message || "Batch item error"
+              }
+            });
+          }
+        }
+      }
+      return results;
+    },
+    async cancelBatch(providerBatchId) {
+      await apiRequest(`/batches/${providerBatchId}/cancel`, { method: "POST" });
+    }
+  };
+}
+
+// src/providers/anthropic-batch.ts
+var ANTHROPIC_API_BASE2 = "https://api.anthropic.com/v1";
+var ANTHROPIC_VERSION2 = "2023-06-01";
+var DEFAULT_MAX_TOKENS2 = 4096;
+function createAnthropicBatchAdapter(apiKey) {
+  async function apiRequest(path2, options = {}) {
+    const headers = {
+      "x-api-key": apiKey,
+      "anthropic-version": ANTHROPIC_VERSION2,
+      "Content-Type": "application/json"
+    };
+    const res = await fetch(`${ANTHROPIC_API_BASE2}${path2}`, {
+      method: options.method || "GET",
+      headers,
+      body: options.body ? JSON.stringify(options.body) : void 0
+    });
+    if (!res.ok) {
+      let errorBody;
+      try {
+        errorBody = await res.json();
+      } catch {
+        errorBody = { message: res.statusText };
+      }
+      const msg = errorBody?.error?.message || errorBody?.message || res.statusText;
+      throw new AnyModelError(res.status >= 500 ? 502 : res.status, msg, {
+        provider_name: "anthropic",
+        raw: errorBody
+      });
+    }
+    return res;
+  }
+  function translateToAnthropicParams(model, req) {
+    const params = {
+      model,
+      max_tokens: req.max_tokens || DEFAULT_MAX_TOKENS2
+    };
+    const systemMessages = req.messages.filter((m) => m.role === "system");
+    const nonSystemMessages = req.messages.filter((m) => m.role !== "system");
+    if (systemMessages.length > 0) {
+      params.system = systemMessages.map((m) => typeof m.content === "string" ? m.content : "").join("\n");
+    }
+    params.messages = nonSystemMessages.map((m) => ({
+      role: m.role === "tool" ? "user" : m.role,
+      content: m.tool_call_id ? [{ type: "tool_result", tool_use_id: m.tool_call_id, content: typeof m.content === "string" ? m.content : "" }] : m.content
+    }));
+    if (req.temperature !== void 0) params.temperature = req.temperature;
+    if (req.top_p !== void 0) params.top_p = req.top_p;
+    if (req.top_k !== void 0) params.top_k = req.top_k;
+    if (req.stop !== void 0) params.stop_sequences = Array.isArray(req.stop) ? req.stop : [req.stop];
+    if (req.tools && req.tools.length > 0) {
+      params.tools = req.tools.map((t) => ({
+        name: t.function.name,
+        description: t.function.description || "",
+        input_schema: t.function.parameters || { type: "object", properties: {} }
+      }));
+      if (req.tool_choice) {
+        if (req.tool_choice === "auto") {
+          params.tool_choice = { type: "auto" };
+        } else if (req.tool_choice === "required") {
+          params.tool_choice = { type: "any" };
+        } else if (req.tool_choice === "none") {
+          delete params.tools;
+        } else if (typeof req.tool_choice === "object") {
+          params.tool_choice = { type: "tool", name: req.tool_choice.function.name };
+        }
+      }
+    }
+    if (req.response_format) {
+      if (req.response_format.type === "json_object" || req.response_format.type === "json_schema") {
+        const jsonInstruction = "Respond with valid JSON only. Do not include any text outside the JSON object.";
+        params.system = params.system ? `${jsonInstruction}
+
+${params.system}` : jsonInstruction;
+      }
+    }
+    return params;
+  }
+  function mapStopReason(reason) {
+    switch (reason) {
+      case "end_turn":
+        return "stop";
+      case "max_tokens":
+        return "length";
+      case "tool_use":
+        return "tool_calls";
+      case "stop_sequence":
+        return "stop";
+      default:
+        return "stop";
+    }
+  }
+  function translateAnthropicMessage(msg) {
+    let content = "";
+    const toolCalls = [];
+    for (const block of msg.content || []) {
+      if (block.type === "text") {
+        content += block.text;
+      } else if (block.type === "tool_use") {
+        toolCalls.push({
+          id: block.id,
+          type: "function",
+          function: {
+            name: block.name,
+            arguments: JSON.stringify(block.input)
+          }
+        });
+      }
+    }
+    const message = { role: "assistant", content };
+    if (toolCalls.length > 0) {
+      message.tool_calls = toolCalls;
+    }
+    return {
+      id: generateId(),
+      object: "chat.completion",
+      created: Math.floor(Date.now() / 1e3),
+      model: `anthropic/${msg.model}`,
+      choices: [{
+        index: 0,
+        message,
+        finish_reason: mapStopReason(msg.stop_reason)
+      }],
+      usage: {
+        prompt_tokens: msg.usage?.input_tokens || 0,
+        completion_tokens: msg.usage?.output_tokens || 0,
+        total_tokens: (msg.usage?.input_tokens || 0) + (msg.usage?.output_tokens || 0)
+      }
+    };
+  }
+  return {
+    async createBatch(model, requests, _options) {
+      const batchRequests = requests.map((req) => ({
+        custom_id: req.custom_id,
+        params: translateToAnthropicParams(model, req)
+      }));
+      const res = await apiRequest("/messages/batches", {
+        method: "POST",
+        body: { requests: batchRequests }
+      });
+      const data = await res.json();
+      return {
+        providerBatchId: data.id,
+        metadata: {
+          anthropic_type: data.type,
+          created_at: data.created_at
+        }
+      };
+    },
+    async pollBatch(providerBatchId) {
+      const res = await apiRequest(`/messages/batches/${providerBatchId}`);
+      const data = await res.json();
+      const counts = data.request_counts || {};
+      const total = (counts.processing || 0) + (counts.succeeded || 0) + (counts.errored || 0) + (counts.canceled || 0) + (counts.expired || 0);
+      let status;
+      if (data.processing_status === "ended") {
+        if (counts.succeeded === 0 && (counts.errored > 0 || counts.expired > 0 || counts.canceled > 0)) {
+          status = "failed";
+        } else if (data.cancel_initiated_at) {
+          status = "cancelled";
+        } else {
+          status = "completed";
+        }
+      } else {
+        status = "processing";
+      }
+      return {
+        status,
+        total,
+        completed: counts.succeeded || 0,
+        failed: (counts.errored || 0) + (counts.expired || 0) + (counts.canceled || 0)
+      };
+    },
+    async getBatchResults(providerBatchId) {
+      const res = await apiRequest(`/messages/batches/${providerBatchId}/results`);
+      const text = await res.text();
+      const results = [];
+      for (const line of text.trim().split("\n")) {
+        if (!line) continue;
+        const item = JSON.parse(line);
+        if (item.result?.type === "succeeded") {
+          results.push({
+            custom_id: item.custom_id,
+            status: "success",
+            response: translateAnthropicMessage(item.result.message),
+            error: null
+          });
+        } else {
+          const errorType = item.result?.type || "unknown";
+          const errorMsg = item.result?.error?.message || `Batch item ${errorType}`;
+          results.push({
+            custom_id: item.custom_id,
+            status: "error",
+            response: null,
+            error: {
+              code: errorType === "expired" ? 408 : 500,
+              message: errorMsg
+            }
+          });
+        }
+      }
+      return results;
+    },
+    async cancelBatch(providerBatchId) {
+      await apiRequest(`/messages/batches/${providerBatchId}/cancel`, { method: "POST" });
+    }
+  };
+}
+
+// src/client.ts
+var AnyModel = class {
+  registry;
+  router;
+  config;
+  modelCache = null;
+  statsStore = new GenerationStatsStore();
+  batchManager;
+  chat;
+  models;
+  generation;
+  batches;
+  constructor(config = {}) {
+    this.config = resolveConfig(config);
+    this.registry = new ProviderRegistry();
+    if (this.config.io) {
+      configureFsIO(this.config.io);
+    }
+    this.registerProviders();
+    this.router = new Router(this.registry, this.config.aliases, this.config);
+    this.chat = {
+      completions: {
+        create: async (request) => {
+          const merged = this.applyDefaults(request);
+          if (merged.stream) {
+            return this.router.stream(merged);
+          }
+          const startTime = Date.now();
+          const response = await this.router.complete(merged);
+          const endTime = Date.now();
+          const providerName = response.model.includes("/") ? response.model.split("/")[0] : "unknown";
+          this.statsStore.record({
+            id: response.id,
+            model: response.model,
+            providerName,
+            promptTokens: response.usage.prompt_tokens,
+            completionTokens: response.usage.completion_tokens,
+            startTime,
+            endTime,
+            finishReason: response.choices[0]?.finish_reason || "stop",
+            streamed: false
+          });
+          return response;
+        }
+      }
+    };
+    this.models = {
+      list: async (opts) => {
+        if (!this.modelCache) {
+          this.modelCache = await this.fetchModels();
+        }
+        if (opts?.provider) {
+          return this.modelCache.filter((m) => m.id.startsWith(`${opts.provider}/`));
+        }
+        return this.modelCache;
+      },
+      refresh: async () => {
+        this.modelCache = null;
+        return this.models.list();
+      }
+    };
+    this.generation = {
+      get: (id) => this.statsStore.get(id),
+      list: (limit) => this.statsStore.list(limit)
+    };
+    this.batchManager = new BatchManager(this.router, {
+      dir: this.config.batch?.dir,
+      concurrency: this.config.batch?.concurrencyFallback,
+      pollInterval: this.config.batch?.pollInterval
+    });
+    this.registerBatchAdapters();
+    this.batches = {
+      create: (request) => this.batchManager.create(request),
+      createAndPoll: (request, options) => this.batchManager.createAndPoll(request, options),
+      poll: (id, options) => this.batchManager.poll(id, options),
+      get: (id) => this.batchManager.get(id),
+      list: () => this.batchManager.list(),
+      cancel: (id) => this.batchManager.cancel(id),
+      results: (id) => this.batchManager.getResults(id)
+    };
+  }
+  registerProviders() {
+    const config = this.config;
+    const openaiKey = config.openai?.apiKey || process.env.OPENAI_API_KEY;
+    if (openaiKey) {
+      this.registry.register("openai", createOpenAIAdapter(openaiKey));
+    }
+    const anthropicKey = config.anthropic?.apiKey || process.env.ANTHROPIC_API_KEY;
+    if (anthropicKey) {
+      this.registry.register("anthropic", createAnthropicAdapter(anthropicKey));
+    }
+    const googleKey = config.google?.apiKey || process.env.GOOGLE_API_KEY;
+    if (googleKey) {
+      this.registry.register("google", createGoogleAdapter(googleKey));
+    }
+    const builtinProviders = [
+      { name: "mistral", baseURL: "https://api.mistral.ai/v1", configKey: "mistral", envVar: "MISTRAL_API_KEY" },
+      { name: "groq", baseURL: "https://api.groq.com/openai/v1", configKey: "groq", envVar: "GROQ_API_KEY" },
+      { name: "deepseek", baseURL: "https://api.deepseek.com", configKey: "deepseek", envVar: "DEEPSEEK_API_KEY" },
+      { name: "xai", baseURL: "https://api.x.ai/v1", configKey: "xai", envVar: "XAI_API_KEY" },
+      { name: "together", baseURL: "https://api.together.xyz/v1", configKey: "together", envVar: "TOGETHER_API_KEY" },
+      { name: "fireworks", baseURL: "https://api.fireworks.ai/inference/v1", configKey: "fireworks", envVar: "FIREWORKS_API_KEY" },
+      { name: "perplexity", baseURL: "https://api.perplexity.ai", configKey: "perplexity", envVar: "PERPLEXITY_API_KEY" }
+    ];
+    for (const { name, baseURL, configKey, envVar } of builtinProviders) {
+      const providerConfig = config[configKey];
+      const key = providerConfig?.apiKey || process.env[envVar];
+      if (key) {
+        this.registry.register(name, createCustomAdapter(name, { baseURL, apiKey: key }));
+      }
+    }
+    const ollamaConfig = config.ollama;
+    const ollamaURL = ollamaConfig?.baseURL || process.env.OLLAMA_BASE_URL || "http://localhost:11434/v1";
+    if (ollamaConfig || process.env.OLLAMA_BASE_URL) {
+      this.registry.register("ollama", createCustomAdapter("ollama", { baseURL: ollamaURL }));
+    }
+    if (config.custom) {
+      for (const [name, customConfig] of Object.entries(config.custom)) {
+        this.registry.register(name, createCustomAdapter(name, customConfig));
+      }
+    }
+  }
+  registerBatchAdapters() {
+    const config = this.config;
+    const openaiKey = config.openai?.apiKey || process.env.OPENAI_API_KEY;
+    if (openaiKey) {
+      this.batchManager.registerBatchAdapter("openai", createOpenAIBatchAdapter(openaiKey));
+    }
+    const anthropicKey = config.anthropic?.apiKey || process.env.ANTHROPIC_API_KEY;
+    if (anthropicKey) {
+      this.batchManager.registerBatchAdapter("anthropic", createAnthropicBatchAdapter(anthropicKey));
+    }
+  }
+  applyDefaults(request) {
+    const defaults = this.config.defaults;
+    if (!defaults) return request;
+    return {
+      ...request,
+      temperature: request.temperature ?? defaults.temperature,
+      max_tokens: request.max_tokens ?? defaults.max_tokens
+    };
+  }
+  async fetchModels() {
+    const all = [];
+    for (const adapter of this.registry.all()) {
+      try {
+        const models = await adapter.listModels();
+        all.push(...models);
+      } catch {
+      }
+    }
+    return all.sort((a, b) => a.id.localeCompare(b.id));
+  }
+  getRegistry() {
+    return this.registry;
+  }
+};
+
+// src/server.ts
+import { createServer } from "http";
+function parseBody(req) {
+  return new Promise((resolve2, reject) => {
+    const chunks = [];
+    req.on("data", (chunk) => chunks.push(chunk));
+    req.on("end", () => resolve2(Buffer.concat(chunks).toString()));
+    req.on("error", reject);
+  });
+}
+function sendJSON(res, status, body) {
+  res.writeHead(status, { "Content-Type": "application/json" });
+  res.end(JSON.stringify(body));
+}
+function sendError(res, status, message) {
+  sendJSON(res, status, { error: { code: status, message, metadata: {} } });
+}
+async function sendSSE(res, stream) {
+  res.writeHead(200, {
+    "Content-Type": "text/event-stream",
+    "Cache-Control": "no-cache",
+    "Connection": "keep-alive"
+  });
+  for await (const chunk of stream) {
+    res.write(`data: ${JSON.stringify(chunk)}
+
+`);
+  }
+  res.write("data: [DONE]\n\n");
+  res.end();
+}
+function createAnyModelServer(options = {}) {
+  const client = new AnyModel(options.config);
+  const basePath = "/api/v1";
+  const server = createServer(async (req, res) => {
+    const url = new URL(req.url || "/", `http://${req.headers.host}`);
+    const path2 = url.pathname;
+    res.setHeader("Access-Control-Allow-Origin", "*");
+    res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
+    res.setHeader("Access-Control-Allow-Headers", "Content-Type, Authorization");
+    if (req.method === "OPTIONS") {
+      res.writeHead(204);
+      res.end();
+      return;
+    }
+    try {
+      if (path2 === "/health" && req.method === "GET") {
+        sendJSON(res, 200, { status: "ok" });
+        return;
+      }
+      if (path2 === `${basePath}/chat/completions` && req.method === "POST") {
+        const body = JSON.parse(await parseBody(req));
+        if (body.stream) {
+          const stream = await client.chat.completions.create(body);
+          await sendSSE(res, stream);
+        } else {
+          const response = await client.chat.completions.create(body);
+          sendJSON(res, 200, response);
+        }
+        return;
+      }
+      if (path2 === `${basePath}/models` && req.method === "GET") {
+        const provider = url.searchParams.get("provider") || void 0;
+        const models = await client.models.list({ provider });
+        sendJSON(res, 200, { object: "list", data: models });
+        return;
+      }
+      if (path2.startsWith(`${basePath}/generation/`) && req.method === "GET") {
+        const id = path2.substring(`${basePath}/generation/`.length);
+        const stats = client.generation.get(id);
+        if (!stats) {
+          sendError(res, 404, `Generation ${id} not found`);
+          return;
+        }
+        sendJSON(res, 200, stats);
+        return;
+      }
+      if (path2 === `${basePath}/batches` && req.method === "POST") {
+        const body = JSON.parse(await parseBody(req));
+        const batch = await client.batches.create(body);
+        sendJSON(res, 201, batch);
+        return;
+      }
+      if (path2 === `${basePath}/batches` && req.method === "GET") {
+        const batches = await client.batches.list();
+        sendJSON(res, 200, { object: "list", data: batches });
+        return;
+      }
+      if (path2.startsWith(`${basePath}/batches/`) && req.method === "GET") {
+        const parts = path2.substring(`${basePath}/batches/`.length).split("/");
+        const id = parts[0];
+        if (parts[1] === "results") {
+          const results = await client.batches.results(id);
+          sendJSON(res, 200, results);
+          return;
+        }
+        const batch = await client.batches.get(id);
+        if (!batch) {
+          sendError(res, 404, `Batch ${id} not found`);
+          return;
+        }
+        sendJSON(res, 200, batch);
+        return;
+      }
+      if (path2.startsWith(`${basePath}/batches/`) && req.method === "POST") {
+        const parts = path2.substring(`${basePath}/batches/`.length).split("/");
+        const id = parts[0];
+        if (parts[1] === "cancel") {
+          const batch = await client.batches.cancel(id);
+          sendJSON(res, 200, batch);
+          return;
+        }
+      }
+      sendError(res, 404, `Not found: ${path2}`);
+    } catch (err) {
+      const code = err?.code || 500;
+      const message = err?.message || "Internal server error";
+      sendError(res, code, message);
+    }
+  });
+  return server;
+}
+function startServer(options = {}) {
+  const port = options.port ?? 4141;
+  const host = options.host ?? "0.0.0.0";
+  const server = createAnyModelServer(options);
+  server.listen(port, host, () => {
+    console.log(`@probeo/anymodel server running at http://${host}:${port}`);
+    console.log(`API base: http://${host}:${port}/api/v1`);
+    console.log("");
+    console.log("Endpoints:");
+    console.log("  POST /api/v1/chat/completions");
+    console.log("  GET  /api/v1/models");
+    console.log("  GET  /api/v1/generation/:id");
+    console.log("  POST /api/v1/batches");
+    console.log("  GET  /api/v1/batches");
+    console.log("  GET  /api/v1/batches/:id");
+    console.log("  GET  /api/v1/batches/:id/results");
+    console.log("  POST /api/v1/batches/:id/cancel");
+    console.log("  GET  /health");
+  });
+}
+export {
+  AnyModel,
+  AnyModelError,
+  BatchManager,
+  BatchStore,
+  GenerationStatsStore,
+  appendFileQueued,
+  configureFsIO,
+  createAnthropicBatchAdapter,
+  createAnyModelServer,
+  createOpenAIBatchAdapter,
+  ensureDir,
+  getFsQueueStatus,
+  joinPath,
+  readFileQueued,
+  resolveConfig,
+  startServer,
+  waitForFsQueuesIdle,
+  writeFileFlushedQueued,
+  writeFileQueued
+};
 //# sourceMappingURL=index.js.map