@probeo/anymodel 0.2.0 → 0.3.1

package/dist/cli.cjs

@@ -1,5 +1,27 @@
 #!/usr/bin/env node
 "use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 
 // src/server.ts
 var import_node_http = require("http");
@@ -148,7 +170,7 @@ async function withRetry(fn, options = {}) {
         throw error;
       }
       const delay = computeDelay(attempt, opts, error);
-      await new Promise((resolve3) => setTimeout(resolve3, delay));
+      await new Promise((resolve2) => setTimeout(resolve2, delay));
     }
   }
   throw lastError;
@@ -507,8 +529,8 @@ var SUPPORTED_PARAMS = /* @__PURE__ */ new Set([
 ]);
 function createOpenAIAdapter(apiKey, baseURL) {
   const base = baseURL || OPENAI_API_BASE;
-  async function makeRequest(path, body, method = "POST") {
-    const res = await fetch(`${base}${path}`, {
+  async function makeRequest(path2, body, method = "POST") {
+    const res = await fetch(`${base}${path2}`, {
       method,
       headers: {
         "Content-Type": "application/json",
@@ -659,6 +681,9 @@ function createOpenAIAdapter(apiKey, baseURL) {
     supportsParameter(param) {
       return SUPPORTED_PARAMS.has(param);
     },
+    supportsBatch() {
+      return true;
+    },
     async sendRequest(request) {
       const body = buildRequestBody(request);
       const res = await makeRequest("/chat/completions", body);
@@ -713,8 +738,8 @@ var FALLBACK_MODELS = [
   { 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(path, body, stream = false) {
-    const res = await fetch(`${ANTHROPIC_API_BASE}${path}`, {
+  async function makeRequest(path2, body, stream = false) {
+    const res = await fetch(`${ANTHROPIC_API_BASE}${path2}`, {
       method: "POST",
       headers: {
         "Content-Type": "application/json",
@@ -1008,6 +1033,9 @@ ${body.system}` : jsonInstruction;
     supportsParameter(param) {
       return SUPPORTED_PARAMS2.has(param);
     },
+    supportsBatch() {
+      return true;
+    },
     async sendRequest(request) {
       const body = translateRequest(request);
       const res = await makeRequest("/messages", body);
@@ -1287,6 +1315,9 @@ function createGoogleAdapter(apiKey) {
     supportsParameter(param) {
       return SUPPORTED_PARAMS3.has(param);
     },
+    supportsBatch() {
+      return false;
+    },
     async sendRequest(request) {
       const body = translateRequest(request);
       const url = getModelEndpoint(request.model, false);
@@ -1345,6 +1376,9 @@ function createCustomAdapter(name, config) {
   return {
     ...openaiAdapter,
     name,
+    supportsBatch() {
+      return false;
+    },
     async listModels() {
       if (config.models && config.models.length > 0) {
         return config.models.map((modelId) => ({
@@ -1410,10 +1444,10 @@ function interpolateDeep(obj) {
   }
   return obj;
 }
-function loadJsonFile(path) {
-  if (!(0, import_node_fs.existsSync)(path)) return null;
+function loadJsonFile(path2) {
+  if (!(0, import_node_fs.existsSync)(path2)) return null;
   try {
-    const raw = (0, import_node_fs.readFileSync)(path, "utf-8");
+    const raw = (0, import_node_fs.readFileSync)(path2, "utf-8");
     const parsed = JSON.parse(raw);
     return interpolateDeep(parsed);
   } catch {
@@ -1514,93 +1548,228 @@ var GenerationStatsStore = class {
   }
 };
 
-// src/batch/store.ts
+// src/utils/fs-io.ts
+var import_promises = require("fs/promises");
 var import_node_fs2 = require("fs");
-var import_node_path2 = require("path");
-var import_node_os2 = require("os");
-var DEFAULT_BATCH_DIR = (0, import_node_path2.join)((0, import_node_os2.homedir)(), ".anymodel", "batches");
+var import_node_path2 = __toESM(require("path"), 1);
+var import_p_queue = __toESM(require("p-queue"), 1);
+var writeQueue = new import_p_queue.default({ concurrency: 10 });
+var readQueue = new import_p_queue.default({ 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 (0, import_promises.mkdir)(dir, { recursive: true });
+  ensuredDirs.add(dir);
+}
+async function readFileQueued(filePath, encoding = "utf8") {
+  return readQueue.add(async () => {
+    return (0, import_promises.readFile)(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 (0, import_promises.readdir)(dirPath, { withFileTypes: true });
+  });
+}
+async function pathExistsQueued(p) {
+  return readQueue.add(async () => {
+    try {
+      await (0, import_promises.stat)(p);
+      return true;
+    } catch {
+      return false;
+    }
+  });
+}
+async function fileExistsQueued(filePath) {
+  return readQueue.add(async () => {
+    try {
+      const s = await (0, import_promises.stat)(filePath);
+      return s.isFile();
+    } catch {
+      return false;
+    }
+  });
+}
+async function writeFileQueued(filePath, data) {
+  await writeQueue.add(async () => {
+    const dir = dirnameOf(filePath);
+    await ensureDir(dir);
+    await (0, import_promises.writeFile)(filePath, data);
+  });
+}
+async function appendFileQueued(filePath, data) {
+  await writeQueue.add(async () => {
+    const dir = dirnameOf(filePath);
+    await ensureDir(dir);
+    await (0, import_promises.writeFile)(filePath, data, { flag: "a" });
+  });
+}
+async function writeFileFlushedQueued(filePath, data) {
+  await writeQueue.add(async () => {
+    const dir = dirnameOf(filePath);
+    await ensureDir(dir);
+    const tmpPath = joinPath(
+      dir,
+      `.${import_node_path2.default.basename(filePath)}.${Date.now()}.${Math.random().toString(16).slice(2)}.tmp`
+    );
+    const fh = await (0, import_promises.open)(tmpPath, "w");
+    try {
+      await fh.writeFile(data);
+      await fh.sync();
+    } finally {
+      await fh.close();
+    }
+    await (0, import_promises.rename)(tmpPath, filePath);
+    try {
+      const dh = await (0, import_promises.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 = import_node_path2.default.join(...segments);
+  joinPathCache.set(key, out);
+  return out;
+}
+function dirnameOf(p) {
+  const cached = dirnameCache.get(p);
+  if (cached !== void 0) return cached;
+  const out = import_node_path2.default.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 = import_node_path2.default.resolve(...segments);
+  resolvePathCache.set(key, out);
+  return out;
+}
+
+// src/batch/store.ts
+var DEFAULT_BATCH_DIR = joinPath(process.cwd(), ".anymodel", "batches");
 var BatchStore = class {
   dir;
+  initialized = false;
   constructor(dir) {
-    this.dir = (0, import_node_path2.resolve)(dir || DEFAULT_BATCH_DIR);
-    (0, import_node_fs2.mkdirSync)(this.dir, { recursive: true });
+    this.dir = resolvePath(dir || DEFAULT_BATCH_DIR);
+  }
+  async init() {
+    if (this.initialized) return;
+    await ensureDir(this.dir);
+    this.initialized = true;
   }
   batchDir(id) {
-    return (0, import_node_path2.join)(this.dir, id);
+    return joinPath(this.dir, id);
   }
   /**
    * Create a new batch directory and save initial metadata.
    */
-  create(batch) {
+  async create(batch) {
+    await this.init();
     const dir = this.batchDir(batch.id);
-    (0, import_node_fs2.mkdirSync)(dir, { recursive: true });
-    (0, import_node_fs2.writeFileSync)((0, import_node_path2.join)(dir, "meta.json"), JSON.stringify(batch, null, 2));
+    await ensureDir(dir);
+    await writeFileFlushedQueued(joinPath(dir, "meta.json"), JSON.stringify(batch, null, 2));
   }
   /**
-   * Update batch metadata.
+   * Update batch metadata (atomic write).
    */
-  updateMeta(batch) {
-    const dir = this.batchDir(batch.id);
-    (0, import_node_fs2.writeFileSync)((0, import_node_path2.join)(dir, "meta.json"), JSON.stringify(batch, null, 2));
+  async updateMeta(batch) {
+    await writeFileFlushedQueued(
+      joinPath(this.batchDir(batch.id), "meta.json"),
+      JSON.stringify(batch, null, 2)
+    );
   }
   /**
    * Save requests as JSONL.
    */
-  saveRequests(id, requests) {
-    const dir = this.batchDir(id);
+  async saveRequests(id, requests) {
     const lines = requests.map((r) => JSON.stringify(r)).join("\n") + "\n";
-    (0, import_node_fs2.writeFileSync)((0, import_node_path2.join)(dir, "requests.jsonl"), lines);
+    await writeFileQueued(joinPath(this.batchDir(id), "requests.jsonl"), lines);
   }
   /**
    * Append a result to results.jsonl.
    */
-  appendResult(id, result) {
-    const dir = this.batchDir(id);
-    (0, import_node_fs2.appendFileSync)((0, import_node_path2.join)(dir, "results.jsonl"), JSON.stringify(result) + "\n");
+  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).
    */
-  saveProviderState(id, state) {
-    const dir = this.batchDir(id);
-    (0, import_node_fs2.writeFileSync)((0, import_node_path2.join)(dir, "provider.json"), JSON.stringify(state, null, 2));
+  async saveProviderState(id, state) {
+    await writeFileFlushedQueued(
+      joinPath(this.batchDir(id), "provider.json"),
+      JSON.stringify(state, null, 2)
+    );
   }
   /**
    * Load provider state.
    */
-  loadProviderState(id) {
-    const path = (0, import_node_path2.join)(this.batchDir(id), "provider.json");
-    if (!(0, import_node_fs2.existsSync)(path)) return null;
-    return JSON.parse((0, import_node_fs2.readFileSync)(path, "utf-8"));
+  async loadProviderState(id) {
+    const p = joinPath(this.batchDir(id), "provider.json");
+    if (!await fileExistsQueued(p)) return null;
+    return readJsonQueued(p);
   }
   /**
    * Get batch metadata.
    */
-  getMeta(id) {
-    const path = (0, import_node_path2.join)(this.batchDir(id), "meta.json");
-    if (!(0, import_node_fs2.existsSync)(path)) return null;
-    return JSON.parse((0, import_node_fs2.readFileSync)(path, "utf-8"));
+  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.
    */
-  getResults(id) {
-    const path = (0, import_node_path2.join)(this.batchDir(id), "results.jsonl");
-    if (!(0, import_node_fs2.existsSync)(path)) return [];
-    return (0, import_node_fs2.readFileSync)(path, "utf-8").trim().split("\n").filter(Boolean).map((line) => JSON.parse(line));
+  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.
    */
-  listBatches() {
-    if (!(0, import_node_fs2.existsSync)(this.dir)) return [];
-    return (0, import_node_fs2.readdirSync)(this.dir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name).sort();
+  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.
    */
-  exists(id) {
-    return (0, import_node_fs2.existsSync)((0, import_node_path2.join)(this.batchDir(id), "meta.json"));
+  async exists(id) {
+    return fileExistsQueued(joinPath(this.batchDir(id), "meta.json"));
   }
 };
 
@@ -1609,10 +1778,27 @@ 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).
@@ -1620,13 +1806,16 @@ var BatchManager = class {
   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: request.model.split("/")[0] || "unknown",
-      batch_mode: "concurrent",
+      provider_name: providerName,
+      batch_mode: batchMode,
       total: request.requests.length,
       completed: 0,
       failed: 0,
@@ -1634,10 +1823,15 @@ var BatchManager = class {
       completed_at: null,
       expires_at: null
     };
-    this.store.create(batch);
-    this.store.saveRequests(id, request.requests);
-    this.processBatch(id, request).catch(() => {
-    });
+    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;
   }
   /**
@@ -1651,14 +1845,19 @@ var BatchManager = class {
    * Poll an existing batch until completion.
    */
   async poll(id, options = {}) {
-    const interval = options.interval ?? 5e3;
+    const interval = options.interval ?? this.defaultPollInterval;
     const timeout = options.timeout ?? 0;
     const startTime = Date.now();
     while (true) {
-      const batch = this.store.getMeta(id);
+      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);
       }
@@ -1668,24 +1867,24 @@ var BatchManager = class {
       if (timeout > 0 && Date.now() - startTime > timeout) {
         throw new AnyModelError(408, `Batch ${id} timed out after ${timeout}ms`);
       }
-      await new Promise((resolve3) => setTimeout(resolve3, interval));
+      await new Promise((resolve2) => setTimeout(resolve2, interval));
     }
   }
   /**
    * Get the current status of a batch.
    */
-  get(id) {
+  async get(id) {
     return this.store.getMeta(id);
   }
   /**
    * Get results for a completed batch.
    */
-  getResults(id) {
-    const batch = this.store.getMeta(id);
+  async getResults(id) {
+    const batch = await this.store.getMeta(id);
     if (!batch) {
       throw new AnyModelError(404, `Batch ${id} not found`);
     }
-    const results = this.store.getResults(id);
+    const results = await this.store.getResults(id);
     const usage = {
       total_prompt_tokens: 0,
       total_completion_tokens: 0,
@@ -1707,37 +1906,119 @@ var BatchManager = class {
   /**
    * List all batches.
    */
-  list() {
-    return this.store.listBatches().map((id) => this.store.getMeta(id)).filter((b) => b !== null);
+  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.
    */
-  cancel(id) {
-    const batch = this.store.getMeta(id);
+  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();
-    this.store.updateMeta(batch);
+    await this.store.updateMeta(batch);
     return batch;
   }
   /**
-   * Process batch requests concurrently.
+   * Process batch via native provider batch API.
    */
-  async processBatch(batchId, request) {
-    const batch = this.store.getMeta(batchId);
+  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";
-    this.store.updateMeta(batch);
+    await this.store.updateMeta(batch);
     const items = request.requests;
-    const queue = [...items];
     const active = /* @__PURE__ */ new Set();
     const processItem = async (item) => {
-      const current = this.store.getMeta(batchId);
+      const current = await this.store.getMeta(batchId);
       if (current?.status === "cancelled") return;
       const chatRequest = {
         model: request.model,
@@ -1769,17 +2050,19 @@ var BatchManager = class {
           error: { code: error.code, message: error.message }
         };
       }
-      this.store.appendResult(batchId, result);
-      const meta = this.store.getMeta(batchId);
-      if (result.status === "success") {
-        meta.completed++;
-      } else {
-        meta.failed++;
+      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);
       }
-      this.store.updateMeta(meta);
     };
-    for (const item of queue) {
-      const current = this.store.getMeta(batchId);
+    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);
@@ -1790,15 +2073,411 @@ var BatchManager = class {
       active.add(promise);
     }
     await Promise.all(active);
-    const finalMeta = this.store.getMeta(batchId);
-    if (finalMeta.status !== "cancelled") {
+    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();
-      this.store.updateMeta(finalMeta);
+      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;
@@ -1814,6 +2493,9 @@ var AnyModel = class {
   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 = {
@@ -1863,8 +2545,10 @@ var AnyModel = class {
     };
     this.batchManager = new BatchManager(this.router, {
       dir: this.config.batch?.dir,
-      concurrency: this.config.batch?.concurrencyFallback
+      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),
@@ -1916,6 +2600,17 @@ var AnyModel = class {
       }
     }
   }
+  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;
@@ -1943,10 +2638,10 @@ var AnyModel = class {
 
 // src/server.ts
 function parseBody(req) {
-  return new Promise((resolve3, reject) => {
+  return new Promise((resolve2, reject) => {
     const chunks = [];
     req.on("data", (chunk) => chunks.push(chunk));
-    req.on("end", () => resolve3(Buffer.concat(chunks).toString()));
+    req.on("end", () => resolve2(Buffer.concat(chunks).toString()));
     req.on("error", reject);
   });
 }
@@ -1976,7 +2671,7 @@ function createAnyModelServer(options = {}) {
   const basePath = "/api/v1";
   const server = (0, import_node_http.createServer)(async (req, res) => {
     const url = new URL(req.url || "/", `http://${req.headers.host}`);
-    const path = url.pathname;
+    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");
@@ -1986,11 +2681,11 @@ function createAnyModelServer(options = {}) {
       return;
     }
     try {
-      if (path === "/health" && req.method === "GET") {
+      if (path2 === "/health" && req.method === "GET") {
         sendJSON(res, 200, { status: "ok" });
         return;
       }
-      if (path === `${basePath}/chat/completions` && req.method === "POST") {
+      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);
@@ -2001,14 +2696,14 @@ function createAnyModelServer(options = {}) {
         }
         return;
       }
-      if (path === `${basePath}/models` && req.method === "GET") {
+      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 (path.startsWith(`${basePath}/generation/`) && req.method === "GET") {
-        const id = path.substring(`${basePath}/generation/`.length);
+      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`);
@@ -2017,26 +2712,26 @@ function createAnyModelServer(options = {}) {
         sendJSON(res, 200, stats);
         return;
       }
-      if (path === `${basePath}/batches` && req.method === "POST") {
+      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 (path === `${basePath}/batches` && req.method === "GET") {
-        const batches = client.batches.list();
+      if (path2 === `${basePath}/batches` && req.method === "GET") {
+        const batches = await client.batches.list();
         sendJSON(res, 200, { object: "list", data: batches });
         return;
       }
-      if (path.startsWith(`${basePath}/batches/`) && req.method === "GET") {
-        const parts = path.substring(`${basePath}/batches/`.length).split("/");
+      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 = client.batches.results(id);
+          const results = await client.batches.results(id);
           sendJSON(res, 200, results);
           return;
         }
-        const batch = client.batches.get(id);
+        const batch = await client.batches.get(id);
         if (!batch) {
           sendError(res, 404, `Batch ${id} not found`);
           return;
@@ -2044,16 +2739,16 @@ function createAnyModelServer(options = {}) {
         sendJSON(res, 200, batch);
         return;
       }
-      if (path.startsWith(`${basePath}/batches/`) && req.method === "POST") {
-        const parts = path.substring(`${basePath}/batches/`.length).split("/");
+      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 = client.batches.cancel(id);
+          const batch = await client.batches.cancel(id);
           sendJSON(res, 200, batch);
           return;
         }
       }
-      sendError(res, 404, `Not found: ${path}`);
+      sendError(res, 404, `Not found: ${path2}`);
     } catch (err) {
       const code = err?.code || 500;
       const message = err?.message || "Internal server error";