zevairouter 1.0.116 → 1.0.118

package/cli/app/.next-cli-build/static/chunks/app/(dashboard)/dashboard/cli-tools/page-c99774d53ed03829.js

@@ -0,0 +1 @@
+(self.webpackChunk_N_E=self.webpackChunk_N_E||[]).push([[2326],{53501:(e,s,l)=>{"use strict";l.d(s,{default:()=>m});var t=l(95155),a=l(12115),r=l(35497),i=l(3534),n=l(43666),o=l(98500),c=l.n(o),d=l(5772);function x({toolId:e,tool:s,status:l}){let a=l?.error?{label:"Unavailable",cls:"bg-red-500/10 text-red-600 dark:text-red-400"}:l?l.installed?l.hasZevai?{label:"Connected",cls:"bg-green-500/10 text-green-600 dark:text-green-400"}:{label:"Not configured",cls:"bg-yellow-500/10 text-yellow-600 dark:text-yellow-400"}:{label:"Not installed",cls:"bg-gray-500/10 text-gray-500"}:{label:"Unknown",cls:"bg-gray-500/10 text-gray-500"};return(0,t.jsx)(c(),{href:`/dashboard/cli-tools/${e}`,className:"block",children:(0,t.jsx)(r.Zp,{padding:"sm",className:"h-full overflow-hidden hover:border-primary/50 transition-colors cursor-pointer",children:(0,t.jsx)("div",{className:"flex h-full flex-col gap-2",children:(0,t.jsxs)("div",{className:"flex items-center gap-3",children:[(0,t.jsx)("div",{className:"size-8 flex items-center justify-center shrink-0",children:s.image?(0,t.jsx)(d.default,{src:s.image,alt:s.name,width:32,height:32,className:"size-8 object-contain rounded-lg",sizes:"32px",onError:e=>{e.target.style.display="none"}}):s.icon?(0,t.jsx)("span",{className:"material-symbols-outlined text-[28px]",style:{color:s.color},children:s.icon}):null}),(0,t.jsxs)("div",{className:"min-w-0 flex-1",children:[(0,t.jsx)("h3",{className:"font-medium text-sm truncate",children:s.name}),(0,t.jsx)("span",{className:`inline-block mt-1 px-1.5 py-0.5 text-[10px] font-medium rounded-full ${a.cls}`,children:a.label})]}),(0,t.jsx)("span",{className:"material-symbols-outlined text-text-muted text-[18px] shrink-0",children:"chevron_right"})]})})})})}function m({machineId:e}){let[s,l]=(0,a.useState)(!0),[o,c]=(0,a.useState)({}),d=(0,a.useCallback)(async e=>{try{let s=await fetch("/api/cli-tools/all-statuses",{signal:e});s.ok&&c(await s.json())}catch(e){"AbortError"!==e.name&&console.log("Error fetching tool statuses:",e)}finally{e.aborted||l(!1)}},[]);if((0,a.useEffect)(()=>{let e=new AbortController;d(e.signal);let s=()=>{e.abort(),d((e=new AbortController).signal)};return window.addEventListener("focus",s),()=>{e.abort(),window.removeEventListener("focus",s)}},[d]),s)return(0,t.jsxs)("div",{className:"grid grid-cols-1 sm:grid-cols-2 lg:grid-cols-3 gap-3 sm:gap-4",children:[(0,t.jsx)(r.Qv,{}),(0,t.jsx)(r.Qv,{}),(0,t.jsx)(r.Qv,{}),(0,t.jsx)(r.Qv,{}),(0,t.jsx)(r.Qv,{}),(0,t.jsx)(r.Qv,{})]});let g=Object.entries(i.dM),h=Object.entries(i.wn);return(0,t.jsxs)("div",{className:"mx-auto flex w-full max-w-5xl flex-col gap-6 px-1 sm:px-0",children:[(0,t.jsx)("div",{className:"grid grid-cols-1 sm:grid-cols-2 lg:grid-cols-3 gap-3 sm:gap-4",children:g.map(([e,s])=>(0,t.jsx)(x,{toolId:e,tool:s,status:o[e]},e))}),(0,t.jsxs)("div",{className:"flex flex-col gap-3 sm:gap-4",children:[(0,t.jsxs)("div",{className:"flex items-center gap-2 px-1",children:[(0,t.jsx)("span",{className:"material-symbols-outlined text-[18px] text-primary",children:"security"}),(0,t.jsx)("h2",{className:"text-sm font-semibold text-text-main",children:"MITM Tools"})]}),(0,t.jsx)("div",{className:"grid grid-cols-1 sm:grid-cols-2 lg:grid-cols-3 gap-3 sm:gap-4",children:h.map(([e,s])=>(0,t.jsx)(n.gY,{tool:s},e))})]})]})}},89734:(e,s,l)=>{Promise.resolve().then(l.bind(l,53501))}},e=>{e.O(0,[2574,3862,4343,3702,5497,6069,8441,3794,7358],()=>e(e.s=89734)),_N_E=e.O()}]);

package/cli/app/.openclaude/worktrees/agent-a785ba58/src/lib/terminal/ptyBridge.py

@@ -0,0 +1,163 @@
+#!/usr/bin/env python3
+"""
+Minimal PTY bridge for ZevaiRouter web terminal.
+
+stdin  -> PTY master (keystrokes)
+stdout <- PTY master (shell output), raw binary
+stderr  = control / errors (utf-8 text lines)
+
+Optional control on a side channel is not needed: resize arrives as
+OSC-like escape on stdin:  \\x1b]9999;<cols>;<rows>\\x07
+"""
+from __future__ import annotations
+
+import errno
+import fcntl
+import os
+import select
+import signal
+import struct
+import sys
+import termios
+
+
+def set_winsize(fd: int, rows: int, cols: int) -> None:
+    try:
+        packed = struct.pack("HHHH", max(5, rows), max(20, cols), 0, 0)
+        fcntl.ioctl(fd, termios.TIOCSWINSZ, packed)
+    except Exception:
+        pass
+
+
+def main() -> int:
+    cols = int(sys.argv[1]) if len(sys.argv) > 1 else 120
+    rows = int(sys.argv[2]) if len(sys.argv) > 2 else 40
+    shell = os.environ.get("SHELL") or ("/bin/bash" if os.path.exists("/bin/bash") else "/bin/sh")
+    cwd = os.path.expanduser("~")
+
+    pid, master = pty_fork = _fork_pty()
+    if pid == 0:
+        # child
+        try:
+            os.chdir(cwd)
+        except Exception:
+            pass
+        os.environ.setdefault("TERM", "xterm-256color")
+        os.environ.setdefault("COLORTERM", "truecolor")
+        os.environ.setdefault("FORCE_COLOR", "1")
+        try:
+            os.execv(shell, [shell, "-il"])
+        except Exception:
+            os.execv("/bin/sh", ["/bin/sh", "-i"])
+        return 1
+
+    set_winsize(master, rows, cols)
+
+    # Non-blocking master + stdin
+    for fd in (master, sys.stdin.fileno()):
+        fl = fcntl.fcntl(fd, fcntl.F_GETFL)
+        fcntl.fcntl(fd, fcntl.F_SETFL, fl | os.O_NONBLOCK)
+
+    # Binary stdout
+    stdout = sys.stdout.buffer
+    stdin = sys.stdin.buffer
+
+    resize_buf = b""
+
+    def handle_resize_escape(chunk: bytes) -> bytes:
+        """Strip and apply embedded resize escapes, return remaining bytes."""
+        nonlocal resize_buf
+        data = resize_buf + chunk
+        out = bytearray()
+        i = 0
+        while i < len(data):
+            # ESC ] 9999 ; cols ; rows BEL
+            if data[i] == 0x1B and data[i : i + 6] == b"\x1b]9999;":
+                end = data.find(b"\x07", i + 6)
+                if end < 0:
+                    resize_buf = data[i:]
+                    return bytes(out)
+                payload = data[i + 6 : end].decode("ascii", "ignore")
+                try:
+                    c_s, r_s = payload.split(";", 1)
+                    set_winsize(master, int(r_s), int(c_s))
+                except Exception:
+                    pass
+                i = end + 1
+                resize_buf = b""
+                continue
+            out.append(data[i])
+            i += 1
+        resize_buf = b""
+        return bytes(out)
+
+    alive = True
+
+    def on_chld(signum, frame):  # noqa: ARG001
+        nonlocal alive
+        alive = False
+
+    signal.signal(signal.SIGCHLD, on_chld)
+
+    try:
+        while alive:
+            try:
+                r, _, _ = select.select([master, sys.stdin.fileno()], [], [], 0.25)
+            except InterruptedError:
+                continue
+
+            if master in r:
+                try:
+                    data = os.read(master, 8192)
+                except OSError as e:
+                    if e.errno in (errno.EIO, errno.EAGAIN, errno.EWOULDBLOCK):
+                        data = b""
+                    else:
+                        break
+                if not data:
+                    # EIO often means child exited
+                    if not alive:
+                        break
+                else:
+                    stdout.write(data)
+                    stdout.flush()
+
+            if sys.stdin.fileno() in r:
+                try:
+                    data = stdin.read(8192)
+                except Exception:
+                    data = b""
+                if data is None:
+                    data = b""
+                if data == b"" and not alive:
+                    break
+                if data:
+                    cleaned = handle_resize_escape(data)
+                    if cleaned:
+                        try:
+                            os.write(master, cleaned)
+                        except OSError:
+                            break
+    finally:
+        try:
+            os.close(master)
+        except Exception:
+            pass
+        try:
+            os.waitpid(pid, 0)
+        except Exception:
+            pass
+    return 0
+
+
+def _fork_pty():
+    import pty
+
+    return pty.fork()
+
+
+if __name__ == "__main__":
+    try:
+        raise SystemExit(main())
+    except KeyboardInterrupt:
+        raise SystemExit(0)

package/cli/app/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zevairouter",
-  "version": "1.0.116",
+  "version": "1.0.118",
   "description": "Self-hosted AI router: many providers, one OpenAI-compatible /v1 endpoint and dashboard",
   "bin": {
     "zevai": "./cli/cli.js"

package/cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zevairouter-cli",
-  "version": "1.0.116",
+  "version": "1.0.118",
   "description": "ZevaiRouter CLI - Start and manage ZevaiRouter server",
   "bin": {
     "zevai": "./cli.js"

package/open-sse/config/errorConfig.js

@@ -77,6 +77,8 @@ export const ERROR_RULES = [
   { status: 402, cooldownMs: COOLDOWN.long },
   { status: 403, cooldownMs: COOLDOWN.long },
   { status: 404, cooldownMs: COOLDOWN.long },
+  { status: 408, cooldownMs: COOLDOWN.short },
+  { status: 409, cooldownMs: COOLDOWN.short },
   { status: 429, backoff: true },
 ];
 

package/open-sse/executors/base.js

@@ -4,6 +4,41 @@ import { shouldRefreshCredentials } from "../services/oauthCredentialManager.js"
 import { proxyAwareFetch } from "../utils/proxyFetch.js";
 import { dbg } from "../utils/debugLog.js";
 
+export function withBodyTimeout(response, timeoutMs, abortController, signal) {
+  if (!response.body || !timeoutMs) return response;
+  const reader = response.body.getReader();
+  const body = new ReadableStream({
+    async pull(controller) {
+      if (signal?.aborted) throw signal.reason;
+      let timer;
+      try {
+        const timeout = new Promise((_, reject) => {
+          timer = setTimeout(() => {
+            const error = new Error("response body timeout");
+            reject(error);
+            queueMicrotask(() => {
+              abortController.abort(error);
+              reader.cancel(error).catch(() => {});
+            });
+          }, timeoutMs);
+        });
+        const { done, value } = await Promise.race([reader.read(), timeout]);
+        if (signal?.aborted) throw signal.reason;
+        if (done) controller.close();
+        else controller.enqueue(value);
+      } catch (error) {
+        controller.error(error);
+      } finally {
+        clearTimeout(timer);
+      }
+    },
+    cancel(reason) {
+      return reader.cancel(reason);
+    },
+  });
+  return new Response(body, response);
+}
+
 /**
  * BaseExecutor - Base class for provider executors
  */
@@ -159,7 +194,7 @@ export class BaseExecutor {
           continue;
         }
 
-        return { response, url, headers, transformedBody };
+        return { response: withBodyTimeout(response, this.config?.responseTimeoutMs || timeoutMs, connectCtrl, signal), url, headers, transformedBody };
       } catch (error) {
         clearTimeout(connectTimer);
         lastError = error;

package/open-sse/services/accountFallback.js

@@ -68,7 +68,12 @@ export function checkFallbackError(status, errorText, backoffLevel = 0) {
     }
   }
 
-  // Default: transient cooldown for any unmatched error
+  // Unmatched request-caused client errors belong to the request, not the account.
+  if (status >= 400 && status < 500) {
+    return { shouldFallback: false, cooldownMs: 0 };
+  }
+
+  // Default: transient cooldown for unknown server/network errors
   return { shouldFallback: true, cooldownMs: TRANSIENT_COOLDOWN_MS };
 }
 

package/open-sse/services/combo.js

@@ -148,22 +148,13 @@ export async function handleComboChat({ body, models, handleSingleModel, log, co
       }
 
       // Check if should fallback to next model
-      const { shouldFallback, cooldownMs } = checkFallbackError(result.status, errorText);
+      const { shouldFallback } = checkFallbackError(result.status, errorText);
 
       if (!shouldFallback) {
         log.warn("COMBO", `Model ${modelStr} failed (no fallback)`, { status: result.status });
         return result;
       }
 
-      // For transient errors (503/502/504), wait for cooldown before falling through
-      // so a briefly-overloaded provider gets a chance to recover rather than being
-      // skipped immediately (fixes: combo falls through on transient 503)
-      if (cooldownMs && cooldownMs > 0 && cooldownMs <= 5000 &&
-          (result.status === 503 || result.status === 502 || result.status === 504)) {
-        log.info("COMBO", `Model ${modelStr} transient ${result.status}, waiting ${cooldownMs}ms before next`);
-        await new Promise(r => setTimeout(r, cooldownMs));
-      }
-
       // Fallback to next model
       lastError = errorText || String(result.status);
       if (!lastStatus) lastStatus = result.status;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zevairouter",
-  "version": "1.0.116",
+  "version": "1.0.118",
   "description": "Self-hosted AI router: many providers, one OpenAI-compatible /v1 endpoint and dashboard",
   "bin": {
     "zevai": "./cli/cli.js"

package/src/app/(dashboard)/dashboard/cli-tools/CLIToolsPageClient.js

@@ -1,6 +1,6 @@
 "use client";
 
-import { useState, useEffect } from "react";
+import { useState, useEffect, useCallback } from "react";
 import { CardSkeleton } from "@/shared/components";
 import { CLI_TOOLS, MITM_TOOLS } from "@/shared/constants/cliTools";
 import { MitmLinkCard } from "./components";
@@ -12,21 +12,32 @@ export default function CLIToolsPageClient({ machineId }) {
   const [loading, setLoading] = useState(true);
   const [toolStatuses, setToolStatuses] = useState({});
 
-  useEffect(() => {
-    let mounted = true;
-    (async () => {
-      try {
-        const res = await fetch(ALL_STATUSES_URL);
-        if (res.ok && mounted) setToolStatuses(await res.json());
-      } catch (error) {
-        console.log("Error fetching tool statuses:", error);
-      } finally {
-        if (mounted) setLoading(false);
-      }
-    })();
-    return () => { mounted = false; };
+  const fetchStatuses = useCallback(async (signal) => {
+    try {
+      const res = await fetch(ALL_STATUSES_URL, { signal });
+      if (res.ok) setToolStatuses(await res.json());
+    } catch (error) {
+      if (error.name !== "AbortError") console.log("Error fetching tool statuses:", error);
+    } finally {
+      if (!signal.aborted) setLoading(false);
+    }
   }, []);
 
+  useEffect(() => {
+    let controller = new AbortController();
+    fetchStatuses(controller.signal);
+    const onFocus = () => {
+      controller.abort();
+      controller = new AbortController();
+      fetchStatuses(controller.signal);
+    };
+    window.addEventListener("focus", onFocus);
+    return () => {
+      controller.abort();
+      window.removeEventListener("focus", onFocus);
+    };
+  }, [fetchStatuses]);
+
   if (loading) {
     return (
       <div className="grid grid-cols-1 sm:grid-cols-2 lg:grid-cols-3 gap-3 sm:gap-4">

package/src/app/(dashboard)/dashboard/cli-tools/components/ToolSummaryCard.js

@@ -6,6 +6,7 @@ import { Card } from "@/shared/components";
 
 // Derive simple connected/configured/not-installed status from API payload
 function getStatus(status) {
+  if (status?.error) return { label: "Unavailable", cls: "bg-red-500/10 text-red-600 dark:text-red-400" };
   if (!status) return { label: "Unknown", cls: "bg-gray-500/10 text-gray-500" };
   if (!status.installed) return { label: "Not installed", cls: "bg-gray-500/10 text-gray-500" };
   if (status.hasZevai) return { label: "Connected", cls: "bg-green-500/10 text-green-600 dark:text-green-400" };

package/src/app/api/cli-tools/all-statuses/route.js

@@ -37,8 +37,8 @@ export async function GET() {
         const res = await getter();
         const data = await res.json();
         return [toolId, data];
-      } catch {
-        return [toolId, null];
+      } catch (error) {
+        return [toolId, { error: error instanceof Error ? error.message : "Status unavailable" }];
       }
     })
   );

package/src/app/api/v1/messages/count_tokens/route.js

@@ -25,21 +25,28 @@ export async function POST(request) {
     });
   }
 
-  // Estimate token count based on content length
-  const messages = body.messages || [];
-  let totalChars = 0;
-  for (const msg of messages) {
-    if (typeof msg.content === "string") {
-      totalChars += msg.content.length;
-    } else if (Array.isArray(msg.content)) {
-      for (const part of msg.content) {
-        if (part.type === "text" && part.text) {
-          totalChars += part.text.length;
-        }
-      }
-    }
+  if (!body || typeof body !== "object" || Array.isArray(body)) {
+    return new Response(JSON.stringify({ error: "Invalid request body" }), {
+      status: 400,
+      headers: { "Content-Type": "application/json", ...CORS_HEADERS }
+    });
   }
 
+  const textOf = (value) => {
+    if (typeof value === "string") return value;
+    if (value == null) return "";
+    if (Array.isArray(value)) return value.map(textOf).join(" ");
+    if (typeof value === "object") {
+      if (typeof value.text === "string") return value.text;
+      if (typeof value.content === "string") return value.content;
+      return JSON.stringify(value);
+    }
+    return String(value);
+  };
+
+  let totalChars = textOf(body.system).length + textOf(body.tools).length;
+  for (const msg of body.messages || []) totalChars += textOf(msg).length;
+
   // Rough estimate: ~4 chars per token
   const inputTokens = Math.ceil(totalChars / 4);
 

package/src/app/api/v1beta/models/[...path]/route.js

@@ -43,39 +43,24 @@ export async function POST(request, { params }) {
 
   try {
     const { path } = await params;
-    // path = ["provider", "model:action"] or ["model:action"]
-
-    let model;
-    let action; // ":generateContent" | ":streamGenerateContent"
-
-    if (path.length >= 2) {
-      // Format: /v1beta/models/provider/model:generateContent
-      const provider = path[0];
-      const modelAction = path[1];
-      action = modelAction.includes(":streamGenerateContent")
-        ? ":streamGenerateContent"
-        : ":generateContent";
-      const modelName = modelAction
-        .replace(":streamGenerateContent", "")
-        .replace(":generateContent", "");
-      model = provider + "/" + modelName;
-    } else {
-      // Format: /v1beta/models/model:generateContent
-      const modelAction = path[0];
-      action = modelAction.includes(":streamGenerateContent")
-        ? ":streamGenerateContent"
-        : ":generateContent";
-      model = modelAction
-        .replace(":streamGenerateContent", "")
-        .replace(":generateContent", "");
+    if (!Array.isArray(path) || path.length < 1 || path.length > 2) {
+      return Response.json({ error: { message: "Invalid model path", code: 400 } }, { status: 400 });
+    }
+
+    const modelAction = path.at(-1);
+    const match = /^([^:]+):(generateContent|streamGenerateContent)$/.exec(modelAction);
+    if (!match || (path.length === 2 && (!path[0] || path[0].includes(":")))) {
+      return Response.json({ error: { message: "Invalid model action", code: 400 } }, { status: 400 });
     }
+    const model = path.length === 2 ? `${path[0]}/${match[1]}` : match[1];
+    const action = match[2];
 
     const body = await request.json();
 
     // Streaming is determined by URL action suffix:
     //   :streamGenerateContent => stream: true  (SSE)
     //   :generateContent       => stream: false (plain JSON)
-    const stream = action === ":streamGenerateContent";
+    const stream = action === "streamGenerateContent";
 
     // Convert Gemini request format to OpenAI/internal format
     const convertedBody = convertGeminiToInternal(body, model, stream);
@@ -100,9 +85,10 @@ export async function POST(request, { params }) {
     }
   } catch (error) {
     console.log("Error handling Gemini request:", error);
+    const status = error.status || (error instanceof SyntaxError ? 400 : 500);
     return Response.json(
-      { error: { message: error.message, code: 500 } },
-      { status: 500 }
+      { error: { message: error.message, code: status } },
+      { status }
     );
   }
 }
@@ -114,38 +100,86 @@ export async function POST(request, { params }) {
  * @param {string} model       - resolved model string (e.g. "gemini-pro-high")
  * @param {boolean} stream     - whether to stream (from URL action)
  */
-function convertGeminiToInternal(geminiBody, model, stream) {
+export function convertGeminiToInternal(geminiBody, model, stream) {
   const messages = [];
+  const allowedTopLevel = new Set(["contents", "systemInstruction", "generationConfig", "tools", "toolConfig", "safetySettings", "cachedContent"]);
+  const unsupported = Object.keys(geminiBody).filter(key => !allowedTopLevel.has(key));
+  if (unsupported.length || geminiBody.toolConfig || geminiBody.safetySettings || geminiBody.cachedContent) {
+    throw new ClientError(`Unsupported Gemini options: ${unsupported.concat([geminiBody.toolConfig && "toolConfig", geminiBody.safetySettings && "safetySettings", geminiBody.cachedContent && "cachedContent"].filter(Boolean)).join(", ")}`);
+  }
 
-  // Convert system instruction
-  if (geminiBody.systemInstruction) {
-    const systemText = geminiBody.systemInstruction.parts
-      ?.map(p => p.text)
-      .join("\n") || "";
-    if (systemText) {
-      messages.push({ role: "system", content: systemText });
+  const mapParts = (parts = []) => parts.map(part => {
+    if (typeof part.text === "string") return { type: "text", text: part.text };
+    if (part.inlineData?.mimeType && part.inlineData?.data) {
+      return { type: "image_url", image_url: { url: `data:${part.inlineData.mimeType};base64,${part.inlineData.data}` } };
+    }
+    if (part.functionCall?.name) {
+      return { type: "tool_call", id: part.functionCall.id, function: { name: part.functionCall.name, arguments: JSON.stringify(part.functionCall.args || {}) } };
+    }
+    if (part.functionResponse?.name) {
+      return { type: "tool_result", tool_call_id: part.functionResponse.id || part.functionResponse.name, content: JSON.stringify(part.functionResponse.response ?? {}) };
     }
+    throw new ClientError(`Unsupported Gemini content part: ${Object.keys(part).join(", ") || "empty part"}`);
+  });
+
+  if (geminiBody.systemInstruction) {
+    const parts = mapParts(geminiBody.systemInstruction.parts);
+    if (parts.some(part => part.type !== "text")) throw new ClientError("System instruction only supports text parts");
+    messages.push({ role: "system", content: parts.map(part => part.text).join("\n") });
   }
 
-  // Convert contents to messages
-  if (geminiBody.contents) {
-    for (const content of geminiBody.contents) {
-      const role = content.role === "model" ? "assistant" : "user";
-      const text = content.parts?.map(p => p.text).join("\n") || "";
-      messages.push({ role, content: text });
+  for (const content of geminiBody.contents || []) {
+    if (!content || !["user", "model", "function"].includes(content.role) || !Array.isArray(content.parts)) {
+      throw new ClientError("Invalid Gemini content");
+    }
+    const parts = mapParts(content.parts);
+    const role = content.role === "model" ? "assistant" : content.role === "function" ? "tool" : "user";
+    const textAndImages = parts.filter(part => part.type === "text" || part.type === "image_url");
+    const toolCalls = parts.filter(part => part.type === "tool_call");
+    const toolResults = parts.filter(part => part.type === "tool_result");
+    if (toolResults.length) {
+      for (const result of toolResults) messages.push({ role: "tool", tool_call_id: result.tool_call_id, content: result.content });
+    } else {
+      messages.push({
+        role,
+        content: textAndImages.length === 1 && textAndImages[0].type === "text" ? textAndImages[0].text : textAndImages,
+        ...(toolCalls.length ? { tool_calls: toolCalls.map(({ id, function: fn }, index) => ({ id: id || `call_${index}`, type: "function", function: fn })) } : {}),
+      });
     }
   }
 
+  const generationConfig = geminiBody.generationConfig || {};
+  const allowedGeneration = new Set(["maxOutputTokens", "temperature", "topP", "stopSequences", "responseMimeType", "responseSchema"]);
+  const unsupportedGeneration = Object.keys(generationConfig).filter(key => !allowedGeneration.has(key));
+  if (unsupportedGeneration.length) throw new ClientError(`Unsupported generation options: ${unsupportedGeneration.join(", ")}`);
+
+  const tools = (geminiBody.tools || []).flatMap(tool => {
+    if (!Array.isArray(tool.functionDeclarations) || Object.keys(tool).some(key => key !== "functionDeclarations")) {
+      throw new ClientError("Only Gemini function declarations are supported");
+    }
+    return tool.functionDeclarations.map(fn => ({ type: "function", function: { name: fn.name, description: fn.description, parameters: fn.parameters } }));
+  });
+
   return {
     model,
     messages,
     stream,
-    max_tokens: geminiBody.generationConfig?.maxOutputTokens,
-    temperature: geminiBody.generationConfig?.temperature,
-    top_p: geminiBody.generationConfig?.topP,
+    max_tokens: generationConfig.maxOutputTokens,
+    temperature: generationConfig.temperature,
+    top_p: generationConfig.topP,
+    stop: generationConfig.stopSequences,
+    ...(tools.length ? { tools } : {}),
+    ...(generationConfig.responseMimeType === "application/json" ? { response_format: generationConfig.responseSchema ? { type: "json_schema", json_schema: { name: "response", schema: generationConfig.responseSchema } } : { type: "json_object" } } : {}),
   };
 }
 
+class ClientError extends Error {
+  constructor(message) {
+    super(message);
+    this.status = 400;
+  }
+}
+
 /** Map OpenAI finish_reason => Gemini finishReason */
 const FINISH_REASON_MAP = {
   stop: "STOP",
@@ -167,7 +201,7 @@ const FINISH_REASON_MAP = {
  *   data: {"candidates":[{"content":{"role":"model","parts":[{"text":""}]},"finishReason":"STOP","index":0}],"usageMetadata":{...}}
  *   (stream closes — no [DONE])
  */
-function transformOpenAISSEToGeminiSSE(upstreamResponse, model) {
+export function transformOpenAISSEToGeminiSSE(upstreamResponse, model) {
   if (!upstreamResponse.ok || !upstreamResponse.body) {
     return upstreamResponse;
   }
@@ -175,29 +209,38 @@ function transformOpenAISSEToGeminiSSE(upstreamResponse, model) {
   const decoder = new TextDecoder();
   const encoder = new TextEncoder();
 
+  let buffer = "";
   const transformStream = new TransformStream({
     transform(chunk, controller) {
-      const text = decoder.decode(chunk, { stream: true });
-      const lines = text.split("\n");
+      buffer += decoder.decode(chunk, { stream: true });
+      const lines = buffer.split("\n");
+      buffer = lines.pop() || "";
+      for (const line of lines) emitLine(line, controller);
+    },
+    flush(controller) {
+      buffer += decoder.decode();
+      if (buffer) emitLine(buffer, controller);
+    },
+  });
 
-      for (const line of lines) {
-        if (!line.startsWith("data:")) continue;
+  function emitLine(line, controller) {
+        if (!line.startsWith("data:")) return;
 
         const data = line.slice(5).trim();
 
         // Drop empty lines and the OpenAI [DONE] sentinel.
         // Gemini SSE ends by stream close, no sentinel needed.
-        if (!data || data === "[DONE]") continue;
+        if (!data || data === "[DONE]") return;
 
         let parsed;
         try {
           parsed = JSON.parse(data);
         } catch {
-          continue;
+          return;
         }
 
         const choice = parsed.choices?.[0];
-        if (!choice) continue;
+        if (!choice) return;
 
         const delta = choice.delta || {};
 
@@ -210,7 +253,7 @@ function transformOpenAISSEToGeminiSSE(upstreamResponse, model) {
         }
 
         // Skip pure role-only deltas with no content and no finish signal
-        if (parts.length === 0 && !choice.finish_reason) continue;
+        if (parts.length === 0 && !choice.finish_reason) return;
 
         const candidate = {
           content: {
@@ -244,10 +287,7 @@ function transformOpenAISSEToGeminiSSE(upstreamResponse, model) {
         controller.enqueue(
           encoder.encode("data: " + JSON.stringify(geminiChunk) + "\r\n\r\n")
         );
-      }
-    },
-    // No flush() needed: Gemini SSE ends by stream close, not a sentinel
-  });
+  }
 
   return new Response(upstreamResponse.body.pipeThrough(transformStream), {
     status: 200,