@probeo/anymodel 0.3.1 → 0.5.0

package/dist/index.cjs

@@ -39,12 +39,15 @@ __export(src_exports, {
   configureFsIO: () => configureFsIO,
   createAnthropicBatchAdapter: () => createAnthropicBatchAdapter,
   createAnyModelServer: () => createAnyModelServer,
+  createGoogleBatchAdapter: () => createGoogleBatchAdapter,
   createOpenAIBatchAdapter: () => createOpenAIBatchAdapter,
   ensureDir: () => ensureDir,
+  estimateTokenCount: () => estimateTokenCount,
   getFsQueueStatus: () => getFsQueueStatus,
   joinPath: () => joinPath,
   readFileQueued: () => readFileQueued,
   resolveConfig: () => resolveConfig,
+  resolveMaxTokens: () => resolveMaxTokens,
   startServer: () => startServer,
   waitForFsQueuesIdle: () => waitForFsQueuesIdle,
   writeFileFlushedQueued: () => writeFileFlushedQueued,
@@ -534,6 +537,25 @@ var Router = class {
   }
 };
 
+// src/utils/fetch-with-timeout.ts
+var _defaultTimeout = 12e4;
+var _flexTimeout = 6e5;
+function setDefaultTimeout(ms) {
+  _defaultTimeout = ms;
+}
+function getFlexTimeout() {
+  return _flexTimeout;
+}
+function fetchWithTimeout(url, init, timeoutMs) {
+  const ms = timeoutMs ?? _defaultTimeout;
+  const signal = AbortSignal.timeout(ms);
+  if (init?.signal) {
+    const combined = AbortSignal.any([signal, init.signal]);
+    return fetch(url, { ...init, signal: combined });
+  }
+  return fetch(url, { ...init, signal });
+}
+
 // src/providers/openai.ts
 var OPENAI_API_BASE = "https://api.openai.com/v1";
 var SUPPORTED_PARAMS = /* @__PURE__ */ new Set([
@@ -551,19 +573,20 @@ var SUPPORTED_PARAMS = /* @__PURE__ */ new Set([
   "tools",
   "tool_choice",
   "user",
-  "logit_bias"
+  "logit_bias",
+  "service_tier"
 ]);
 function createOpenAIAdapter(apiKey, baseURL) {
   const base = baseURL || OPENAI_API_BASE;
-  async function makeRequest(path2, body, method = "POST") {
-    const res = await fetch(`${base}${path2}`, {
+  async function makeRequest(path2, body, method = "POST", timeoutMs) {
+    const res = await fetchWithTimeout(`${base}${path2}`, {
       method,
       headers: {
         "Content-Type": "application/json",
         "Authorization": `Bearer ${apiKey}`
       },
       body: body ? JSON.stringify(body) : void 0
-    });
+    }, timeoutMs);
     if (!res.ok) {
       let errorBody;
       try {
@@ -611,6 +634,7 @@ function createOpenAIAdapter(apiKey, baseURL) {
     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;
+    if (request.service_tier !== void 0) body.service_tier = request.service_tier;
     return body;
   }
   const adapter = {
@@ -712,13 +736,15 @@ function createOpenAIAdapter(apiKey, baseURL) {
     },
     async sendRequest(request) {
       const body = buildRequestBody(request);
-      const res = await makeRequest("/chat/completions", body);
+      const timeout = request.service_tier === "flex" ? getFlexTimeout() : void 0;
+      const res = await makeRequest("/chat/completions", body, "POST", timeout);
       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);
+      const timeout = request.service_tier === "flex" ? getFlexTimeout() : void 0;
+      const res = await makeRequest("/chat/completions", body, "POST", timeout);
       if (!res.body) {
         throw new AnyModelError(502, "No response body for streaming request", {
           provider_name: "openai"
@@ -765,7 +791,7 @@ var FALLBACK_MODELS = [
 ];
 function createAnthropicAdapter(apiKey) {
   async function makeRequest(path2, body, stream = false) {
-    const res = await fetch(`${ANTHROPIC_API_BASE}${path2}`, {
+    const res = await fetchWithTimeout(`${ANTHROPIC_API_BASE}${path2}`, {
       method: "POST",
       headers: {
         "Content-Type": "application/json",
@@ -1022,7 +1048,7 @@ ${body.system}` : jsonInstruction;
     },
     async listModels() {
       try {
-        const res = await fetch(`${ANTHROPIC_API_BASE}/models`, {
+        const res = await fetchWithTimeout(`${ANTHROPIC_API_BASE}/models`, {
           method: "GET",
           headers: {
             "x-api-key": apiKey,
@@ -1307,7 +1333,7 @@ function createGoogleAdapter(apiKey) {
     },
     async listModels() {
       try {
-        const res = await fetch(`${GEMINI_API_BASE}/models?key=${apiKey}`);
+        const res = await fetchWithTimeout(`${GEMINI_API_BASE}/models?key=${apiKey}`);
         if (!res.ok) return FALLBACK_MODELS2;
         const data = await res.json();
         const models = data.models || [];
@@ -1342,12 +1368,12 @@ function createGoogleAdapter(apiKey) {
       return SUPPORTED_PARAMS3.has(param);
     },
     supportsBatch() {
-      return false;
+      return true;
     },
     async sendRequest(request) {
       const body = translateRequest(request);
       const url = getModelEndpoint(request.model, false);
-      const res = await fetch(url, {
+      const res = await fetchWithTimeout(url, {
         method: "POST",
         headers: { "Content-Type": "application/json" },
         body: JSON.stringify(body)
@@ -1370,7 +1396,7 @@ function createGoogleAdapter(apiKey) {
     async sendStreamingRequest(request) {
       const body = translateRequest(request);
       const url = getModelEndpoint(request.model, true);
-      const res = await fetch(url, {
+      const res = await fetchWithTimeout(url, {
         method: "POST",
         headers: { "Content-Type": "application/json" },
         body: JSON.stringify(body)
@@ -1396,6 +1422,190 @@ function createGoogleAdapter(apiKey) {
   return adapter;
 }
 
+// src/providers/perplexity.ts
+var PERPLEXITY_API_BASE = "https://api.perplexity.ai";
+var SUPPORTED_PARAMS4 = /* @__PURE__ */ new Set([
+  "temperature",
+  "max_tokens",
+  "top_p",
+  "frequency_penalty",
+  "presence_penalty",
+  "stream",
+  "stop",
+  "response_format",
+  "tools",
+  "tool_choice"
+]);
+var MODELS = [
+  { id: "sonar", name: "Sonar", context: 128e3, maxOutput: 4096, modality: "text->text", inputModalities: ["text"] },
+  { id: "sonar-pro", name: "Sonar Pro", context: 2e5, maxOutput: 8192, modality: "text->text", inputModalities: ["text"] },
+  { id: "sonar-reasoning", name: "Sonar Reasoning", context: 128e3, maxOutput: 8192, modality: "text->text", inputModalities: ["text"] },
+  { id: "sonar-reasoning-pro", name: "Sonar Reasoning Pro", context: 128e3, maxOutput: 16384, modality: "text->text", inputModalities: ["text"] },
+  { id: "sonar-deep-research", name: "Sonar Deep Research", context: 128e3, maxOutput: 16384, modality: "text->text", inputModalities: ["text"] },
+  { id: "r1-1776", name: "R1 1776", context: 128e3, maxOutput: 16384, modality: "text->text", inputModalities: ["text"] }
+];
+function createPerplexityAdapter(apiKey) {
+  async function makeRequest(path2, body, method = "POST") {
+    const res = await fetchWithTimeout(`${PERPLEXITY_API_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: "perplexity",
+        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.stop !== void 0) body.stop = request.stop;
+    if (request.stream !== void 0) body.stream = request.stream;
+    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;
+    return body;
+  }
+  const adapter = {
+    name: "perplexity",
+    translateRequest(request) {
+      return buildRequestBody(request);
+    },
+    translateResponse(response) {
+      const r = response;
+      const result = {
+        id: rePrefixId(r.id),
+        object: "chat.completion",
+        created: r.created,
+        model: `perplexity/${r.model}`,
+        choices: r.choices,
+        usage: r.usage
+      };
+      if (r.citations && result.choices?.[0]?.message) {
+        result.citations = r.citations;
+      }
+      return result;
+    },
+    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 = `perplexity/${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 Perplexity error",
+        metadata: { provider_name: "perplexity", raw: error }
+      };
+    },
+    async listModels() {
+      return MODELS.map((m) => ({
+        id: `perplexity/${m.id}`,
+        name: m.name,
+        created: 0,
+        description: "",
+        context_length: m.context,
+        pricing: { prompt: "0", completion: "0" },
+        architecture: {
+          modality: m.modality,
+          input_modalities: m.inputModalities,
+          output_modalities: ["text"],
+          tokenizer: "unknown"
+        },
+        top_provider: {
+          context_length: m.context,
+          max_completion_tokens: m.maxOutput,
+          is_moderated: false
+        },
+        supported_parameters: Array.from(SUPPORTED_PARAMS4)
+      }));
+    },
+    supportsParameter(param) {
+      return SUPPORTED_PARAMS4.has(param);
+    },
+    supportsBatch() {
+      return false;
+    },
+    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: "perplexity"
+        });
+      }
+      return adapter.translateStream(res.body);
+    }
+  };
+  return adapter;
+}
+
 // src/providers/custom.ts
 function createCustomAdapter(name, config) {
   const openaiAdapter = createOpenAIAdapter(config.apiKey || "", config.baseURL);
@@ -2117,6 +2327,54 @@ var BatchManager = class {
   }
 };
 
+// src/utils/token-estimate.ts
+var CHARS_PER_TOKEN2 = 4;
+function estimateTokenCount(text) {
+  return Math.ceil(text.length / CHARS_PER_TOKEN2);
+}
+var MODEL_LIMITS = [
+  // OpenAI
+  { pattern: "gpt-4o-mini", limit: { contextLength: 128e3, maxCompletionTokens: 16384 } },
+  { pattern: "gpt-4o", limit: { contextLength: 128e3, maxCompletionTokens: 16384 } },
+  { pattern: "gpt-4-turbo", limit: { contextLength: 128e3, maxCompletionTokens: 4096 } },
+  { pattern: "gpt-3.5-turbo", limit: { contextLength: 16385, maxCompletionTokens: 4096 } },
+  { pattern: "o1", limit: { contextLength: 2e5, maxCompletionTokens: 1e5 } },
+  { pattern: "o3", limit: { contextLength: 2e5, maxCompletionTokens: 1e5 } },
+  { pattern: "o4-mini", limit: { contextLength: 2e5, maxCompletionTokens: 1e5 } },
+  // Anthropic
+  { pattern: "claude-opus-4", limit: { contextLength: 2e5, maxCompletionTokens: 32768 } },
+  { pattern: "claude-sonnet-4", limit: { contextLength: 2e5, maxCompletionTokens: 16384 } },
+  { pattern: "claude-haiku-4", limit: { contextLength: 2e5, maxCompletionTokens: 8192 } },
+  { pattern: "claude-3.5-sonnet", limit: { contextLength: 2e5, maxCompletionTokens: 8192 } },
+  { pattern: "claude-3-opus", limit: { contextLength: 2e5, maxCompletionTokens: 4096 } },
+  // Google
+  { pattern: "gemini-2.5-pro", limit: { contextLength: 1048576, maxCompletionTokens: 65536 } },
+  { pattern: "gemini-2.5-flash", limit: { contextLength: 1048576, maxCompletionTokens: 65536 } },
+  { pattern: "gemini-2.0-flash", limit: { contextLength: 1048576, maxCompletionTokens: 65536 } },
+  { pattern: "gemini-1.5-pro", limit: { contextLength: 2097152, maxCompletionTokens: 8192 } },
+  { pattern: "gemini-1.5-flash", limit: { contextLength: 1048576, maxCompletionTokens: 8192 } }
+];
+var DEFAULT_LIMIT = { contextLength: 128e3, maxCompletionTokens: 4096 };
+function getModelLimits(model) {
+  const bare = model.includes("/") ? model.slice(model.indexOf("/") + 1) : model;
+  for (const entry of MODEL_LIMITS) {
+    if (bare.startsWith(entry.pattern) || bare.includes(entry.pattern)) {
+      return entry.limit;
+    }
+  }
+  return DEFAULT_LIMIT;
+}
+function resolveMaxTokens(model, messages, userMaxTokens) {
+  if (userMaxTokens !== void 0) return userMaxTokens;
+  const inputChars = JSON.stringify(messages).length;
+  const estimatedInput = Math.ceil(inputChars / CHARS_PER_TOKEN2);
+  const estimatedWithMargin = Math.ceil(estimatedInput * 1.05);
+  const limits = getModelLimits(model);
+  const available = limits.contextLength - estimatedWithMargin;
+  const result = Math.min(limits.maxCompletionTokens, available);
+  return Math.max(1, result);
+}
+
 // src/providers/openai-batch.ts
 var OPENAI_API_BASE2 = "https://api.openai.com/v1";
 function createOpenAIBatchAdapter(apiKey) {
@@ -2131,7 +2389,7 @@ function createOpenAIBatchAdapter(apiKey) {
       headers["Content-Type"] = "application/json";
       fetchBody = JSON.stringify(options.body);
     }
-    const res = await fetch(`${OPENAI_API_BASE2}${path2}`, {
+    const res = await fetchWithTimeout(`${OPENAI_API_BASE2}${path2}`, {
       method: options.method || "GET",
       headers,
       body: fetchBody
@@ -2157,7 +2415,7 @@ function createOpenAIBatchAdapter(apiKey) {
         model,
         messages: req.messages
       };
-      if (req.max_tokens !== void 0) body.max_tokens = req.max_tokens;
+      body.max_tokens = req.max_tokens !== void 0 ? req.max_tokens : resolveMaxTokens(model, req.messages);
       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;
@@ -2316,7 +2574,7 @@ function createAnthropicBatchAdapter(apiKey) {
       "anthropic-version": ANTHROPIC_VERSION2,
       "Content-Type": "application/json"
     };
-    const res = await fetch(`${ANTHROPIC_API_BASE2}${path2}`, {
+    const res = await fetchWithTimeout(`${ANTHROPIC_API_BASE2}${path2}`, {
       method: options.method || "GET",
       headers,
       body: options.body ? JSON.stringify(options.body) : void 0
@@ -2339,7 +2597,7 @@ function createAnthropicBatchAdapter(apiKey) {
   function translateToAnthropicParams(model, req) {
     const params = {
       model,
-      max_tokens: req.max_tokens || DEFAULT_MAX_TOKENS2
+      max_tokens: resolveMaxTokens(model, req.messages, req.max_tokens || DEFAULT_MAX_TOKENS2)
     };
     const systemMessages = req.messages.filter((m) => m.role === "system");
     const nonSystemMessages = req.messages.filter((m) => m.role !== "system");
@@ -2513,6 +2771,284 @@ ${params.system}` : jsonInstruction;
   };
 }
 
+// src/providers/google-batch.ts
+var GEMINI_API_BASE2 = "https://generativelanguage.googleapis.com/v1beta";
+function createGoogleBatchAdapter(apiKey) {
+  async function apiRequest(path2, options = {}) {
+    const headers = {
+      "Content-Type": "application/json",
+      "x-goog-api-key": apiKey
+    };
+    const res = await fetchWithTimeout(`${GEMINI_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: "google",
+        raw: errorBody
+      });
+    }
+    return res;
+  }
+  function translateRequestToGemini(model, req) {
+    const body = {};
+    const systemMessages = req.messages.filter((m) => m.role === "system");
+    const nonSystemMessages = req.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 (req.temperature !== void 0) generationConfig.temperature = req.temperature;
+    generationConfig.maxOutputTokens = req.max_tokens !== void 0 ? req.max_tokens : resolveMaxTokens(model, req.messages);
+    if (req.top_p !== void 0) generationConfig.topP = req.top_p;
+    if (req.top_k !== void 0) generationConfig.topK = req.top_k;
+    if (req.stop !== void 0) {
+      generationConfig.stopSequences = Array.isArray(req.stop) ? req.stop : [req.stop];
+    }
+    if (req.response_format) {
+      if (req.response_format.type === "json_object") {
+        generationConfig.responseMimeType = "application/json";
+      } else if (req.response_format.type === "json_schema") {
+        generationConfig.responseMimeType = "application/json";
+        generationConfig.responseSchema = req.response_format.json_schema?.schema;
+      }
+    }
+    if (Object.keys(generationConfig).length > 0) {
+      body.generationConfig = generationConfig;
+    }
+    if (req.tools && req.tools.length > 0) {
+      body.tools = [{
+        functionDeclarations: req.tools.map((t) => ({
+          name: t.function.name,
+          description: t.function.description || "",
+          parameters: t.function.parameters || {}
+        }))
+      }];
+      if (req.tool_choice) {
+        if (req.tool_choice === "auto") {
+          body.toolConfig = { functionCallingConfig: { mode: "AUTO" } };
+        } else if (req.tool_choice === "required") {
+          body.toolConfig = { functionCallingConfig: { mode: "ANY" } };
+        } else if (req.tool_choice === "none") {
+          body.toolConfig = { functionCallingConfig: { mode: "NONE" } };
+        } else if (typeof req.tool_choice === "object") {
+          body.toolConfig = {
+            functionCallingConfig: {
+              mode: "ANY",
+              allowedFunctionNames: [req.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 translateGeminiResponse(response, model) {
+    const candidate = response.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/${model}`,
+      choices: [{ index: 0, message, finish_reason: finishReason }],
+      usage: {
+        prompt_tokens: response.usageMetadata?.promptTokenCount || 0,
+        completion_tokens: response.usageMetadata?.candidatesTokenCount || 0,
+        total_tokens: response.usageMetadata?.totalTokenCount || 0
+      }
+    };
+  }
+  function mapBatchState(state) {
+    switch (state) {
+      case "JOB_STATE_PENDING":
+        return "pending";
+      case "JOB_STATE_RUNNING":
+        return "processing";
+      case "JOB_STATE_SUCCEEDED":
+        return "completed";
+      case "JOB_STATE_FAILED":
+        return "failed";
+      case "JOB_STATE_CANCELLED":
+        return "cancelled";
+      case "JOB_STATE_EXPIRED":
+        return "failed";
+      default:
+        return "pending";
+    }
+  }
+  return {
+    async createBatch(model, requests, _options) {
+      const batchRequests = requests.map((req) => ({
+        request: translateRequestToGemini(model, req),
+        metadata: { key: req.custom_id }
+      }));
+      const res = await apiRequest(`/models/${model}:batchGenerateContent`, {
+        method: "POST",
+        body: {
+          batch: {
+            display_name: `anymodel-batch-${Date.now()}`,
+            input_config: {
+              requests: {
+                requests: batchRequests
+              }
+            }
+          }
+        }
+      });
+      const data = await res.json();
+      const batchName = data.name || data.batch?.name;
+      if (!batchName) {
+        throw new AnyModelError(502, "No batch name in Google response", {
+          provider_name: "google",
+          raw: data
+        });
+      }
+      return {
+        providerBatchId: batchName,
+        metadata: {
+          model,
+          total_requests: requests.length
+        }
+      };
+    },
+    async pollBatch(providerBatchId) {
+      const res = await apiRequest(`/${providerBatchId}`);
+      const data = await res.json();
+      const state = data.state || "JOB_STATE_PENDING";
+      const status = mapBatchState(state);
+      const totalCount = data.totalCount || data.metadata?.total_requests || 0;
+      const successCount = data.succeededCount || 0;
+      const failedCount = data.failedCount || 0;
+      return {
+        status,
+        total: totalCount || successCount + failedCount,
+        completed: successCount,
+        failed: failedCount
+      };
+    },
+    async getBatchResults(providerBatchId) {
+      const batchRes = await apiRequest(`/${providerBatchId}`);
+      const batchData = await batchRes.json();
+      const results = [];
+      const model = batchData.metadata?.model || "unknown";
+      if (batchData.response?.inlinedResponses) {
+        for (const item of batchData.response.inlinedResponses) {
+          const customId = item.metadata?.key || `request-${results.length}`;
+          if (item.response) {
+            results.push({
+              custom_id: customId,
+              status: "success",
+              response: translateGeminiResponse(item.response, model),
+              error: null
+            });
+          } else if (item.error) {
+            results.push({
+              custom_id: customId,
+              status: "error",
+              response: null,
+              error: {
+                code: item.error.code || 500,
+                message: item.error.message || "Batch item failed"
+              }
+            });
+          }
+        }
+        return results;
+      }
+      const responsesFile = batchData.response?.responsesFileName || batchData.outputConfig?.file_name;
+      if (responsesFile) {
+        const downloadUrl = `${GEMINI_API_BASE2}/${responsesFile}:download?alt=media`;
+        const fileRes = await fetchWithTimeout(downloadUrl, {
+          headers: { "x-goog-api-key": apiKey }
+        });
+        if (!fileRes.ok) {
+          throw new AnyModelError(502, "Failed to download batch results file", {
+            provider_name: "google"
+          });
+        }
+        const text = await fileRes.text();
+        for (const line of text.trim().split("\n")) {
+          if (!line) continue;
+          const item = JSON.parse(line);
+          const customId = item.key || item.metadata?.key || `request-${results.length}`;
+          if (item.response) {
+            results.push({
+              custom_id: customId,
+              status: "success",
+              response: translateGeminiResponse(item.response, model),
+              error: null
+            });
+          } else if (item.error) {
+            results.push({
+              custom_id: customId,
+              status: "error",
+              response: null,
+              error: {
+                code: item.error.code || 500,
+                message: item.error.message || "Batch item failed"
+              }
+            });
+          }
+        }
+      }
+      return results;
+    },
+    async cancelBatch(providerBatchId) {
+      await apiRequest(`/${providerBatchId}:cancel`, { method: "POST" });
+    }
+  };
+}
+
 // src/client.ts
 var AnyModel = class {
   registry;
@@ -2528,6 +3064,7 @@ var AnyModel = class {
   constructor(config = {}) {
     this.config = resolveConfig(config);
     this.registry = new ProviderRegistry();
+    setDefaultTimeout((this.config.defaults?.timeout ?? 120) * 1e3);
     if (this.config.io) {
       configureFsIO(this.config.io);
     }
@@ -2608,14 +3145,17 @@ var AnyModel = class {
     if (googleKey) {
       this.registry.register("google", createGoogleAdapter(googleKey));
     }
+    const perplexityKey = config.perplexity?.apiKey || process.env.PERPLEXITY_API_KEY;
+    if (perplexityKey) {
+      this.registry.register("perplexity", createPerplexityAdapter(perplexityKey));
+    }
     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" }
+      { name: "fireworks", baseURL: "https://api.fireworks.ai/inference/v1", configKey: "fireworks", envVar: "FIREWORKS_API_KEY" }
     ];
     for (const { name, baseURL, configKey, envVar } of builtinProviders) {
       const providerConfig = config[configKey];
@@ -2645,6 +3185,10 @@ var AnyModel = class {
     if (anthropicKey) {
       this.batchManager.registerBatchAdapter("anthropic", createAnthropicBatchAdapter(anthropicKey));
     }
+    const googleKey = config.google?.apiKey || process.env.GOOGLE_API_KEY;
+    if (googleKey) {
+      this.batchManager.registerBatchAdapter("google", createGoogleBatchAdapter(googleKey));
+    }
   }
   applyDefaults(request) {
     const defaults = this.config.defaults;
@@ -2824,12 +3368,15 @@ function startServer(options = {}) {
   configureFsIO,
   createAnthropicBatchAdapter,
   createAnyModelServer,
+  createGoogleBatchAdapter,
   createOpenAIBatchAdapter,
   ensureDir,
+  estimateTokenCount,
   getFsQueueStatus,
   joinPath,
   readFileQueued,
   resolveConfig,
+  resolveMaxTokens,
   startServer,
   waitForFsQueuesIdle,
   writeFileFlushedQueued,