@elvatis_com/openclaw-cli-bridge-elvatis 2.7.3 → 2.8.1

package/README.md

@@ -2,7 +2,7 @@
 
 > OpenClaw plugin that bridges locally installed AI CLIs (Codex, Gemini, Claude Code, OpenCode, Pi) as model providers — with slash commands for instant model switching, restore, health testing, and model listing.
 
-**Current version:** `2.7.3`
+**Current version:** `2.8.1`
 
 ---
 
@@ -406,6 +406,17 @@ npm run ci          # lint + typecheck + test
 
 ## Changelog
 
+### v2.8.1
+- **fix:** increase Sonnet-4-6 base timeout from 180s to 300s to prevent premature SIGTERM kills causing FailoverError fallback to gpt-5.2-codex
+
+### v2.8.0
+- **feat:** Gemini API provider (`gemini-api/gemini-2.5-flash`, `gemini-api/gemini-2.5-pro`) — direct Google Generative AI SDK integration with native **image generation** support via `responseModalities: ["TEXT", "IMAGE"]`. No CLI subprocess overhead, no browser needed.
+- **feat:** Images returned as base64 data URIs in OpenAI-compatible `content_parts` format — works with OpenClaw multimodal rendering
+- **feat:** Native Gemini tool calling — converts OpenAI tool format to Gemini `functionDeclarations`, parses `functionCall` responses back to `tool_calls`
+- **feat:** Real token usage from Gemini API (no estimation needed)
+- **config:** API key via `GOOGLE_API_KEY` env var or `~/.openclaw/.env`
+- **test:** 17 new tests — message conversion, tool conversion, proxy routing, streaming (278 total)
+
 ### v2.7.3
 - **fix:** Gemini image generation timeouts — Gemini Pro models bumped from 180s → 300s base timeout, Flash models from 90s → 180s. Image generation needs significantly more time than text completion.
 - **tune:** Per-tool timeout bonus increased from 5s → 7s per tool definition (21 tools = 147s instead of 105s)

package/SKILL.md

@@ -68,4 +68,4 @@ On gateway restart, if any session has expired, a **WhatsApp alert** is sent aut
 
 See `README.md` for full configuration reference and architecture diagram.
 
-**Version:** 2.7.3
+**Version:** 2.8.1

package/openclaw.plugin.json

@@ -2,7 +2,7 @@
   "id": "openclaw-cli-bridge-elvatis",
   "slug": "openclaw-cli-bridge-elvatis",
   "name": "OpenClaw CLI Bridge",
-  "version": "2.7.3",
+  "version": "2.8.1",
   "license": "MIT",
   "description": "Phase 1: openai-codex auth bridge. Phase 2: local HTTP proxy routing model calls through gemini/claude CLIs (vllm provider).",
   "providers": [
@@ -44,7 +44,7 @@
         },
         "default": {
           "cli-claude/claude-opus-4-6": 300000,
-          "cli-claude/claude-sonnet-4-6": 180000,
+          "cli-claude/claude-sonnet-4-6": 300000,
           "cli-claude/claude-haiku-4-5": 90000,
           "cli-gemini/gemini-2.5-pro": 300000,
           "cli-gemini/gemini-2.5-flash": 180000,
@@ -52,7 +52,9 @@
           "cli-gemini/gemini-3-flash-preview": 180000,
           "openai-codex/gpt-5.4": 300000,
           "openai-codex/gpt-5.3-codex": 180000,
-          "openai-codex/gpt-5.1-codex-mini": 90000
+          "openai-codex/gpt-5.1-codex-mini": 90000,
+          "gemini-api/gemini-2.5-pro": 300000,
+          "gemini-api/gemini-2.5-flash": 180000
         }
       }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elvatis_com/openclaw-cli-bridge-elvatis",
-  "version": "2.7.3",
+  "version": "2.8.1",
   "description": "Bridges gemini, claude, and codex CLI tools as OpenClaw model providers. Reads existing CLI auth without re-login.",
   "type": "module",
   "openclaw": {
@@ -24,6 +24,7 @@
     "vitest": "^4.0.18"
   },
   "dependencies": {
+    "@google/genai": "^1.49.0",
     "playwright": "^1.58.2"
   },
   "license": "Apache-2.0"

package/src/config.ts

@@ -92,7 +92,7 @@ export const PROVIDER_SESSION_SWEEP_MS = 10 * 60 * 1_000; // 10 min
  */
 export const DEFAULT_MODEL_TIMEOUTS: Record<string, number> = {
   "cli-claude/claude-opus-4-6":        300_000,  // 5 min
-  "cli-claude/claude-sonnet-4-6":      180_000,  // 3 min
+  "cli-claude/claude-sonnet-4-6":      300_000,  // 5 min — match idleTimeoutSeconds
   "cli-claude/claude-haiku-4-5":        90_000,  // 90s
   "cli-gemini/gemini-2.5-pro":         300_000,  // 5 min — image generation needs more time
   "cli-gemini/gemini-2.5-flash":       180_000,  // 3 min
@@ -101,6 +101,8 @@ export const DEFAULT_MODEL_TIMEOUTS: Record<string, number> = {
   "openai-codex/gpt-5.4":             300_000,
   "openai-codex/gpt-5.3-codex":       180_000,
   "openai-codex/gpt-5.1-codex-mini":   90_000,
+  "gemini-api/gemini-2.5-pro":        300_000,  // 5 min — image generation needs time
+  "gemini-api/gemini-2.5-flash":      180_000,  // 3 min
 };
 
 // ──────────────────────────────────────────────────────────────────────────────
@@ -116,6 +118,7 @@ export const DEFAULT_MODEL_FALLBACKS: Record<string, string> = {
   "cli-gemini/gemini-3-pro-preview":  "cli-gemini/gemini-3-flash-preview",
   "cli-claude/claude-opus-4-6":       "cli-claude/claude-sonnet-4-6",
   "cli-claude/claude-sonnet-4-6":     "cli-claude/claude-haiku-4-5",
+  "gemini-api/gemini-2.5-pro":       "gemini-api/gemini-2.5-flash",
 };
 
 // ──────────────────────────────────────────────────────────────────────────────

package/src/gemini-api-runner.ts

@@ -0,0 +1,470 @@
+/**
+ * gemini-api-runner.ts
+ *
+ * Direct Gemini API integration via @google/genai SDK.
+ * Supports native text + image generation (responseModalities: ["TEXT", "IMAGE"]).
+ *
+ * Unlike CLI runners, this calls the Gemini API directly — no subprocess overhead.
+ * Images are returned as base64 data URIs in OpenAI-compatible content_parts format.
+ */
+
+import { GoogleGenAI } from "@google/genai";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import type { ToolDefinition, ToolCall } from "./tool-protocol.js";
+import { generateCallId } from "./tool-protocol.js";
+import type { ChatMessage } from "./cli-runner.js";
+
+// ──────────────────────────────────────────────────────────────────────────────
+// Types
+// ──────────────────────────────────────────────────────────────────────────────
+
+export interface ContentPart {
+  type: "text" | "image_url";
+  text?: string;
+  image_url?: { url: string };
+}
+
+export interface GeminiApiResult {
+  /** String for text-only, array for multimodal (text + images) */
+  content: string | ContentPart[];
+  finishReason: string;
+  promptTokens?: number;
+  completionTokens?: number;
+  tool_calls?: ToolCall[];
+}
+
+// ──────────────────────────────────────────────────────────────────────────────
+// API Key resolution
+// ──────────────────────────────────────────────────────────────────────────────
+
+let cachedApiKey: string | null = null;
+
+export function getApiKey(): string {
+  if (cachedApiKey) return cachedApiKey;
+
+  // 1. Environment variable
+  if (process.env.GOOGLE_API_KEY) {
+    cachedApiKey = process.env.GOOGLE_API_KEY;
+    return cachedApiKey;
+  }
+
+  // 2. Read from OpenClaw .env file
+  const envPath = join(homedir(), ".openclaw", ".env");
+  try {
+    const envContent = readFileSync(envPath, "utf-8");
+    const match = envContent.match(/^GOOGLE_API_KEY=(.+)$/m);
+    if (match?.[1]) {
+      cachedApiKey = match[1].trim();
+      return cachedApiKey;
+    }
+  } catch {
+    // File not found — fall through
+  }
+
+  throw new Error(
+    "GOOGLE_API_KEY not found. Set it as an environment variable or add it to ~/.openclaw/.env"
+  );
+}
+
+/** Reset cached key (for testing). */
+export function _resetApiKeyCache(): void {
+  cachedApiKey = null;
+}
+
+// ──────────────────────────────────────────────────────────────────────────────
+// Singleton client
+// ──────────────────────────────────────────────────────────────────────────────
+
+let client: GoogleGenAI | null = null;
+
+function getClient(): GoogleGenAI {
+  if (!client) {
+    client = new GoogleGenAI({ apiKey: getApiKey() });
+  }
+  return client;
+}
+
+/** Reset client (for testing). */
+export function _resetClient(): void {
+  client = null;
+}
+
+// ──────────────────────────────────────────────────────────────────────────────
+// Message conversion: OpenAI → Gemini
+// ──────────────────────────────────────────────────────────────────────────────
+
+interface GeminiContent {
+  role: "user" | "model";
+  parts: GeminiPart[];
+}
+
+type GeminiPart =
+  | { text: string }
+  | { inlineData: { mimeType: string; data: string } }
+  | { functionCall: { name: string; args: Record<string, unknown> } }
+  | { functionResponse: { name: string; response: Record<string, unknown> } };
+
+/**
+ * Convert OpenAI-format messages to Gemini API format.
+ * System messages → systemInstruction. Tool results → functionResponse parts.
+ */
+export function convertMessages(messages: ChatMessage[]): {
+  systemInstruction?: { parts: Array<{ text: string }> };
+  contents: GeminiContent[];
+} {
+  const systemParts: Array<{ text: string }> = [];
+  const contents: GeminiContent[] = [];
+
+  for (const msg of messages) {
+    const role = msg.role;
+
+    if (role === "system") {
+      const text = typeof msg.content === "string"
+        ? msg.content
+        : Array.isArray(msg.content)
+          ? msg.content.map((p: Record<string, unknown>) => String(p.text ?? "")).join("\n")
+          : "";
+      if (text) systemParts.push({ text });
+      continue;
+    }
+
+    if (role === "tool") {
+      // Tool result → functionResponse
+      const toolMsg = msg as ChatMessage & { tool_call_id?: string; name?: string };
+      const name = toolMsg.name ?? toolMsg.tool_call_id ?? "unknown";
+      const responseText = typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content);
+      let responseObj: Record<string, unknown>;
+      try {
+        responseObj = JSON.parse(responseText);
+        if (typeof responseObj !== "object" || responseObj === null) {
+          responseObj = { result: responseText };
+        }
+      } catch {
+        responseObj = { result: responseText };
+      }
+      contents.push({
+        role: "user",
+        parts: [{ functionResponse: { name, response: responseObj } }],
+      });
+      continue;
+    }
+
+    // assistant → model, user → user
+    const geminiRole: "user" | "model" = role === "assistant" ? "model" : "user";
+    const parts: GeminiPart[] = [];
+
+    // Handle tool_calls in assistant messages
+    const assistantMsg = msg as ChatMessage & { tool_calls?: Array<{ function: { name: string; arguments: string } }> };
+    if (assistantMsg.tool_calls?.length) {
+      for (const tc of assistantMsg.tool_calls) {
+        let args: Record<string, unknown> = {};
+        try { args = JSON.parse(tc.function.arguments); } catch { /* empty */ }
+        parts.push({ functionCall: { name: tc.function.name, args } });
+      }
+      if (typeof msg.content === "string" && msg.content) {
+        parts.unshift({ text: msg.content });
+      }
+      contents.push({ role: geminiRole, parts });
+      continue;
+    }
+
+    // Regular content
+    if (typeof msg.content === "string") {
+      if (msg.content) parts.push({ text: msg.content });
+    } else if (Array.isArray(msg.content)) {
+      for (const part of msg.content as Array<Record<string, unknown>>) {
+        if (part.type === "text" && typeof part.text === "string") {
+          parts.push({ text: part.text });
+        } else if (part.type === "image_url") {
+          const imageUrl = part.image_url as { url?: string } | undefined;
+          const url = imageUrl?.url ?? "";
+          const match = url.match(/^data:(image\/[\w+]+);base64,(.+)$/);
+          if (match) {
+            parts.push({ inlineData: { mimeType: match[1], data: match[2] } });
+          } else if (url) {
+            parts.push({ text: `[Image: ${url}]` });
+          }
+        }
+      }
+    }
+
+    if (parts.length > 0) {
+      contents.push({ role: geminiRole, parts });
+    }
+  }
+
+  return {
+    systemInstruction: systemParts.length > 0 ? { parts: systemParts } : undefined,
+    contents,
+  };
+}
+
+// ──────────────────────────────────────────────────────────────────────────────
+// Tool conversion: OpenAI → Gemini
+// ──────────────────────────────────────────────────────────────────────────────
+
+export function convertTools(tools: ToolDefinition[]): Array<{
+  functionDeclarations: Array<{
+    name: string;
+    description: string;
+    parameters: Record<string, unknown>;
+  }>;
+}> {
+  return [
+    {
+      functionDeclarations: tools.map((t) => ({
+        name: t.function.name,
+        description: t.function.description,
+        parameters: t.function.parameters,
+      })),
+    },
+  ];
+}
+
+// ──────────────────────────────────────────────────────────────────────────────
+// Response parsing
+// ──────────────────────────────────────────────────────────────────────────────
+
+function parseResponseParts(
+  parts: Array<Record<string, unknown>> | undefined
+): { content: string | ContentPart[]; tool_calls?: ToolCall[] } {
+  if (!parts?.length) return { content: "" };
+
+  const textParts: string[] = [];
+  const imageParts: ContentPart[] = [];
+  const toolCalls: ToolCall[] = [];
+
+  for (const part of parts) {
+    if (typeof part.text === "string") {
+      textParts.push(part.text);
+    }
+    if (part.inlineData) {
+      const data = part.inlineData as { mimeType: string; data: string };
+      imageParts.push({
+        type: "image_url",
+        image_url: { url: `data:${data.mimeType};base64,${data.data}` },
+      });
+    }
+    if (part.functionCall) {
+      const fc = part.functionCall as { name: string; args: Record<string, unknown> };
+      toolCalls.push({
+        id: generateCallId(),
+        type: "function",
+        function: {
+          name: fc.name,
+          arguments: JSON.stringify(fc.args ?? {}),
+        },
+      });
+    }
+  }
+
+  if (toolCalls.length > 0) {
+    return { content: textParts.join("") || null as unknown as string, tool_calls: toolCalls };
+  }
+
+  // Multimodal: text + images → content_parts array
+  if (imageParts.length > 0) {
+    const contentParts: ContentPart[] = [];
+    const joinedText = textParts.join("");
+    if (joinedText) contentParts.push({ type: "text", text: joinedText });
+    contentParts.push(...imageParts);
+    return { content: contentParts };
+  }
+
+  // Text-only
+  return { content: textParts.join("") };
+}
+
+// ──────────────────────────────────────────────────────────────────────────────
+// Non-streaming completion
+// ──────────────────────────────────────────────────────────────────────────────
+
+export interface GeminiApiOptions {
+  model: string;
+  timeoutMs?: number;
+  tools?: ToolDefinition[];
+  log?: (msg: string) => void;
+}
+
+export async function geminiApiComplete(
+  messages: ChatMessage[],
+  opts: GeminiApiOptions
+): Promise<GeminiApiResult> {
+  const ai = getClient();
+  const modelId = stripPrefix(opts.model);
+  const { systemInstruction, contents } = convertMessages(messages);
+
+  const config: Record<string, unknown> = {};
+
+  // Enable image generation for models that support it
+  if (!opts.tools?.length) {
+    config.responseModalities = ["TEXT", "IMAGE"];
+  }
+
+  const requestOpts: Record<string, unknown> = {
+    model: modelId,
+    contents,
+    config: {
+      ...config,
+      ...(systemInstruction ? { systemInstruction } : {}),
+      ...(opts.tools?.length ? { tools: convertTools(opts.tools) } : {}),
+    },
+  };
+
+  opts.log?.(`[gemini-api] ${modelId} · non-streaming · tools=${opts.tools?.length ?? 0}`);
+
+  const controller = new AbortController();
+  const timer = opts.timeoutMs
+    ? setTimeout(() => controller.abort(), opts.timeoutMs)
+    : null;
+
+  try {
+    const response = await ai.models.generateContent(requestOpts as Parameters<typeof ai.models.generateContent>[0]);
+
+    const candidate = response.candidates?.[0];
+    const parts = candidate?.content?.parts as Array<Record<string, unknown>> | undefined;
+    const parsed = parseResponseParts(parts);
+
+    const finishReason = mapFinishReason(candidate?.finishReason as string);
+
+    return {
+      content: parsed.content,
+      finishReason,
+      promptTokens: response.usageMetadata?.promptTokenCount,
+      completionTokens: response.usageMetadata?.candidatesTokenCount,
+      tool_calls: parsed.tool_calls,
+    };
+  } finally {
+    if (timer) clearTimeout(timer);
+  }
+}
+
+// ──────────────────────────────────────────────────────────────────────────────
+// Streaming completion
+// ──────────────────────────────────────────────────────────────────────────────
+
+export async function geminiApiCompleteStream(
+  messages: ChatMessage[],
+  opts: GeminiApiOptions,
+  onToken: (token: string) => void
+): Promise<GeminiApiResult> {
+  const ai = getClient();
+  const modelId = stripPrefix(opts.model);
+  const { systemInstruction, contents } = convertMessages(messages);
+
+  const config: Record<string, unknown> = {};
+
+  // Image generation not supported in streaming — use text only
+  // (Gemini streams text tokens but images arrive as complete blobs)
+
+  const requestOpts: Record<string, unknown> = {
+    model: modelId,
+    contents,
+    config: {
+      ...config,
+      ...(systemInstruction ? { systemInstruction } : {}),
+      ...(opts.tools?.length ? { tools: convertTools(opts.tools) } : {}),
+    },
+  };
+
+  opts.log?.(`[gemini-api] ${modelId} · streaming · tools=${opts.tools?.length ?? 0}`);
+
+  const controller = new AbortController();
+  const timer = opts.timeoutMs
+    ? setTimeout(() => controller.abort(), opts.timeoutMs)
+    : null;
+
+  try {
+    const stream = await ai.models.generateContentStream(requestOpts as Parameters<typeof ai.models.generateContentStream>[0]);
+
+    let fullText = "";
+    const allImageParts: ContentPart[] = [];
+    const allToolCalls: ToolCall[] = [];
+    let finishReason = "stop";
+    let promptTokens: number | undefined;
+    let completionTokens: number | undefined;
+
+    for await (const chunk of stream) {
+      const candidate = chunk.candidates?.[0];
+      const parts = candidate?.content?.parts as Array<Record<string, unknown>> | undefined;
+
+      if (parts) {
+        for (const part of parts) {
+          if (typeof part.text === "string") {
+            fullText += part.text;
+            onToken(part.text);
+          }
+          if (part.inlineData) {
+            const data = part.inlineData as { mimeType: string; data: string };
+            allImageParts.push({
+              type: "image_url",
+              image_url: { url: `data:${data.mimeType};base64,${data.data}` },
+            });
+          }
+          if (part.functionCall) {
+            const fc = part.functionCall as { name: string; args: Record<string, unknown> };
+            allToolCalls.push({
+              id: generateCallId(),
+              type: "function",
+              function: {
+                name: fc.name,
+                arguments: JSON.stringify(fc.args ?? {}),
+              },
+            });
+          }
+        }
+      }
+
+      if (candidate?.finishReason) {
+        finishReason = mapFinishReason(candidate.finishReason as string);
+      }
+      if (chunk.usageMetadata) {
+        promptTokens = chunk.usageMetadata.promptTokenCount;
+        completionTokens = chunk.usageMetadata.candidatesTokenCount;
+      }
+    }
+
+    let content: string | ContentPart[];
+    if (allImageParts.length > 0) {
+      const parts: ContentPart[] = [];
+      if (fullText) parts.push({ type: "text", text: fullText });
+      parts.push(...allImageParts);
+      content = parts;
+    } else {
+      content = fullText;
+    }
+
+    return {
+      content,
+      finishReason,
+      promptTokens,
+      completionTokens,
+      tool_calls: allToolCalls.length > 0 ? allToolCalls : undefined,
+    };
+  } finally {
+    if (timer) clearTimeout(timer);
+  }
+}
+
+// ──────────────────────────────────────────────────────────────────────────────
+// Helpers
+// ──────────────────────────────────────────────────────────────────────────────
+
+/** Strip provider prefix: "gemini-api/gemini-2.5-flash" → "gemini-2.5-flash" */
+function stripPrefix(model: string): string {
+  const slash = model.indexOf("/");
+  return slash >= 0 ? model.slice(slash + 1) : model;
+}
+
+/** Map Gemini finish reasons to OpenAI format. */
+function mapFinishReason(reason?: string): string {
+  switch (reason) {
+    case "STOP": return "stop";
+    case "MAX_TOKENS": return "length";
+    case "SAFETY": return "content_filter";
+    case "RECITATION": return "content_filter";
+    default: return "stop";
+  }
+}

package/src/proxy-server.ts

@@ -16,6 +16,7 @@ import { grokComplete, grokCompleteStream, type ChatMessage as GrokChatMessage }
 import { geminiComplete, geminiCompleteStream, type ChatMessage as GeminiBrowserChatMessage } from "./gemini-browser.js";
 import { claudeComplete, claudeCompleteStream, type ChatMessage as ClaudeBrowserChatMessage } from "./claude-browser.js";
 import { chatgptComplete, chatgptCompleteStream, type ChatMessage as ChatGPTBrowserChatMessage } from "./chatgpt-browser.js";
+import { geminiApiComplete, geminiApiCompleteStream, type GeminiApiResult, type ContentPart } from "./gemini-api-runner.js";
 import type { BrowserContext } from "playwright";
 import { renderStatusPage, type StatusProvider } from "./status-template.js";
 import { sessionManager } from "./session-manager.js";
@@ -74,6 +75,10 @@ export interface ProxyServerOptions {
   _chatgptComplete?: typeof chatgptComplete;
   /** Override for testing — replaces chatgptCompleteStream */
   _chatgptCompleteStream?: typeof chatgptCompleteStream;
+  /** Override for testing — replaces geminiApiComplete */
+  _geminiApiComplete?: typeof geminiApiComplete;
+  /** Override for testing — replaces geminiApiCompleteStream */
+  _geminiApiCompleteStream?: typeof geminiApiCompleteStream;
   /** Returns human-readable expiry string for each web provider (null = no login yet) */
   getExpiryInfo?: () => {
     grok: string | null;
@@ -140,6 +145,9 @@ export const CLI_MODELS = [
   { id: "web-gemini/gemini-3-flash",   name: "Gemini 3 Flash (web session)",   contextWindow: 1_048_576, maxTokens: 65_536 },
   // Claude → use cli-claude/* instead (web-claude removed in v1.6.x)
   // ChatGPT → use openai-codex/* or copilot-proxy instead (web-chatgpt removed in v1.6.x)
+  // ── Gemini API (native SDK, supports image generation) ─────────────────
+  { id: "gemini-api/gemini-2.5-flash", name: "Gemini 2.5 Flash (API)", contextWindow: 1_048_576, maxTokens: 65_535 },
+  { id: "gemini-api/gemini-2.5-pro",   name: "Gemini 2.5 Pro (API)",   contextWindow: 1_048_576, maxTokens: 65_535 },
   // ── OpenCode CLI ──────────────────────────────────────────────────────────
   { id: "opencode/default",             name: "OpenCode (CLI)",             contextWindow: 128_000,   maxTokens: 16_384 },
   // ── Pi CLI ──────────────────────────────────────────────────────────────
@@ -564,6 +572,94 @@ async function handleRequest(
     }
     // ─────────────────────────────────────────────────────────────────────────
 
+    // ── Gemini API routing (native SDK — supports image generation) ─────────
+    // Strip vllm/ prefix if present — OpenClaw sends full provider path
+    const geminiApiModel = model.startsWith("vllm/") ? model.slice(5) : model;
+    if (geminiApiModel.startsWith("gemini-api/")) {
+      const doComplete = opts._geminiApiComplete ?? geminiApiComplete;
+      const doCompleteStream = opts._geminiApiCompleteStream ?? geminiApiCompleteStream;
+      const perModelTimeout = opts.modelTimeouts?.[geminiApiModel];
+      const timeoutMs = perModelTimeout ?? opts.timeoutMs ?? 180_000;
+      const apiStart = Date.now();
+      const apiOpts = { model: geminiApiModel, timeoutMs, tools: hasTools ? tools : undefined, log: opts.log };
+      try {
+        if (stream) {
+          res.writeHead(200, { "Content-Type": "text/event-stream", "Cache-Control": "no-cache", Connection: "keep-alive", ...corsHeaders() });
+          sendSseChunk(res, { id, created, model: geminiApiModel, delta: { role: "assistant" }, finish_reason: null });
+          const result = await doCompleteStream(
+            cleanMessages,
+            apiOpts,
+            (token) => sendSseChunk(res, { id, created, model: geminiApiModel, delta: { content: token }, finish_reason: null })
+          );
+          const estComp = typeof result.content === "string" ? estimateTokens(result.content) : (result.completionTokens ?? 0);
+          metrics.recordRequest(geminiApiModel, Date.now() - apiStart, true, estPromptTokens, estComp);
+          // If images were generated during streaming, send the full multimodal content as a final chunk
+          if (Array.isArray(result.content)) {
+            sendSseChunk(res, { id, created, model: geminiApiModel, delta: { content: JSON.stringify(result.content) }, finish_reason: null });
+          }
+          if (result.tool_calls?.length) {
+            const toolCalls = result.tool_calls;
+            sendSseChunk(res, {
+              id, created, model: geminiApiModel,
+              delta: {
+                tool_calls: toolCalls.map((tc, idx) => ({
+                  index: idx, id: tc.id, type: "function",
+                  function: { name: tc.function.name, arguments: "" },
+                })),
+              },
+              finish_reason: null,
+            });
+            for (let idx = 0; idx < toolCalls.length; idx++) {
+              sendSseChunk(res, {
+                id, created, model: geminiApiModel,
+                delta: { tool_calls: [{ index: idx, function: { arguments: toolCalls[idx].function.arguments } }] },
+                finish_reason: null,
+              });
+            }
+            sendSseChunk(res, { id, created, model: geminiApiModel, delta: {}, finish_reason: "tool_calls" });
+          } else {
+            sendSseChunk(res, { id, created, model: geminiApiModel, delta: {}, finish_reason: result.finishReason });
+          }
+          res.write("data: [DONE]\n\n");
+          res.end();
+        } else {
+          const result = await doComplete(cleanMessages, apiOpts);
+          const estComp = typeof result.content === "string"
+            ? estimateTokens(result.content)
+            : (result.completionTokens ?? 0);
+          metrics.recordRequest(geminiApiModel, Date.now() - apiStart, true, estPromptTokens, estComp);
+          const message: Record<string, unknown> = { role: "assistant" };
+          if (result.tool_calls?.length) {
+            message.content = null;
+            message.tool_calls = result.tool_calls;
+          } else {
+            message.content = result.content;
+          }
+          const finishReason = result.tool_calls?.length ? "tool_calls" : result.finishReason;
+          res.writeHead(200, { "Content-Type": "application/json", ...corsHeaders() });
+          res.end(JSON.stringify({
+            id, object: "chat.completion", created, model: geminiApiModel,
+            choices: [{ index: 0, message, finish_reason: finishReason }],
+            usage: {
+              prompt_tokens: result.promptTokens ?? estPromptTokens,
+              completion_tokens: result.completionTokens ?? estComp,
+              total_tokens: (result.promptTokens ?? estPromptTokens) + (result.completionTokens ?? estComp),
+            },
+          }));
+        }
+      } catch (err) {
+        metrics.recordRequest(geminiApiModel, Date.now() - apiStart, false, estPromptTokens);
+        const msg = (err as Error).message;
+        opts.warn(`[cli-bridge] Gemini API error for ${geminiApiModel}: ${msg}`);
+        if (!res.headersSent) {
+          res.writeHead(500, { "Content-Type": "application/json", ...corsHeaders() });
+          res.end(JSON.stringify({ error: { message: msg, type: "gemini_api_error" } }));
+        }
+      }
+      return;
+    }
+    // ─────────────────────────────────────────────────────────────────────────
+
     // ── BitNet local inference routing ────────────────────────────────────────
     if (model.startsWith("local-bitnet/")) {
       const bitnetUrl = opts.getBitNetServerUrl?.() ?? DEFAULT_BITNET_SERVER_URL;

package/test/config.test.ts

@@ -62,17 +62,20 @@ describe("config.ts exports", () => {
 
   it("exports per-model timeouts for all major models", () => {
     expect(DEFAULT_MODEL_TIMEOUTS["cli-claude/claude-opus-4-6"]).toBe(300_000);
-    expect(DEFAULT_MODEL_TIMEOUTS["cli-claude/claude-sonnet-4-6"]).toBe(180_000);
+    expect(DEFAULT_MODEL_TIMEOUTS["cli-claude/claude-sonnet-4-6"]).toBe(300_000);
     expect(DEFAULT_MODEL_TIMEOUTS["cli-claude/claude-haiku-4-5"]).toBe(90_000);
     expect(DEFAULT_MODEL_TIMEOUTS["cli-gemini/gemini-2.5-pro"]).toBe(300_000);
     expect(DEFAULT_MODEL_TIMEOUTS["cli-gemini/gemini-2.5-flash"]).toBe(180_000);
     expect(DEFAULT_MODEL_TIMEOUTS["openai-codex/gpt-5.4"]).toBe(300_000);
+    expect(DEFAULT_MODEL_TIMEOUTS["gemini-api/gemini-2.5-pro"]).toBe(300_000);
+    expect(DEFAULT_MODEL_TIMEOUTS["gemini-api/gemini-2.5-flash"]).toBe(180_000);
   });
 
   it("exports model fallback chains", () => {
     expect(DEFAULT_MODEL_FALLBACKS["cli-claude/claude-sonnet-4-6"]).toBe("cli-claude/claude-haiku-4-5");
     expect(DEFAULT_MODEL_FALLBACKS["cli-claude/claude-opus-4-6"]).toBe("cli-claude/claude-sonnet-4-6");
     expect(DEFAULT_MODEL_FALLBACKS["cli-gemini/gemini-2.5-pro"]).toBe("cli-gemini/gemini-2.5-flash");
+    expect(DEFAULT_MODEL_FALLBACKS["gemini-api/gemini-2.5-pro"]).toBe("gemini-api/gemini-2.5-flash");
   });
 
   it("exports path constants rooted in ~/.openclaw", () => {

package/test/gemini-api-proxy.test.ts

@@ -0,0 +1,181 @@
+/**
+ * test/gemini-api-proxy.test.ts
+ *
+ * Integration tests for Gemini API routing in the cli-bridge proxy.
+ * Uses _geminiApiComplete/_geminiApiCompleteStream DI overrides (no real API calls).
+ */
+
+import { describe, it, expect, beforeAll, afterAll, vi } from "vitest";
+import http from "node:http";
+import type { AddressInfo } from "node:net";
+import { startProxyServer, CLI_MODELS } from "../src/proxy-server.js";
+import type { GeminiApiResult, GeminiApiOptions, ContentPart } from "../src/gemini-api-runner.js";
+import type { ChatMessage } from "../src/cli-runner.js";
+
+const stubComplete = vi.fn(async (
+  messages: ChatMessage[],
+  opts: GeminiApiOptions
+): Promise<GeminiApiResult> => ({
+  content: `api mock: ${typeof messages[messages.length - 1]?.content === "string" ? messages[messages.length - 1].content : "multipart"}`,
+  finishReason: "stop",
+  promptTokens: 10,
+  completionTokens: 5,
+}));
+
+const stubCompleteMultimodal = vi.fn(async (
+  _messages: ChatMessage[],
+  _opts: GeminiApiOptions
+): Promise<GeminiApiResult> => ({
+  content: [
+    { type: "text", text: "Here is the image:" },
+    { type: "image_url", image_url: { url: "data:image/png;base64,iVBOR..." } },
+  ] as ContentPart[],
+  finishReason: "stop",
+  promptTokens: 15,
+  completionTokens: 100,
+}));
+
+const stubCompleteStream = vi.fn(async (
+  messages: ChatMessage[],
+  opts: GeminiApiOptions,
+  onToken: (t: string) => void
+): Promise<GeminiApiResult> => {
+  const tokens = ["api ", "stream ", "response"];
+  for (const t of tokens) onToken(t);
+  return { content: tokens.join(""), finishReason: "stop", promptTokens: 10, completionTokens: 8 };
+});
+
+const stubCompleteToolCalls = vi.fn(async (
+  _messages: ChatMessage[],
+  _opts: GeminiApiOptions
+): Promise<GeminiApiResult> => ({
+  content: "",
+  finishReason: "stop",
+  tool_calls: [
+    { id: "call_abc123", type: "function", function: { name: "search", arguments: '{"q":"test"}' } },
+  ],
+}));
+
+async function httpPost(url: string, body: unknown): Promise<{ status: number; body: unknown; raw: string }> {
+  return new Promise((resolve, reject) => {
+    const data = JSON.stringify(body);
+    const u = new URL(url);
+    const req = http.request(
+      { hostname: u.hostname, port: Number(u.port), path: u.pathname, method: "POST",
+        headers: { "Content-Type": "application/json", "Content-Length": Buffer.byteLength(data) } },
+      (res) => { let raw = ""; res.on("data", c => raw += c); res.on("end", () => { try { resolve({ status: res.statusCode ?? 0, body: JSON.parse(raw), raw }); } catch { resolve({ status: res.statusCode ?? 0, body: raw, raw }); } }); }
+    );
+    req.on("error", reject); req.write(data); req.end();
+  });
+}
+async function httpGet(url: string): Promise<{ status: number; body: unknown }> {
+  return new Promise((resolve, reject) => {
+    const u = new URL(url);
+    const req = http.request({ hostname: u.hostname, port: Number(u.port), path: u.pathname, method: "GET" },
+      (res) => { let raw = ""; res.on("data", c => raw += c); res.on("end", () => { try { resolve({ status: res.statusCode ?? 0, body: JSON.parse(raw) }); } catch { resolve({ status: res.statusCode ?? 0, body: raw }); } }); }
+    );
+    req.on("error", reject); req.end();
+  });
+}
+async function httpPostRaw(url: string, body: unknown): Promise<{ status: number; raw: string }> {
+  return new Promise((resolve, reject) => {
+    const data = JSON.stringify(body);
+    const u = new URL(url);
+    const req = http.request(
+      { hostname: u.hostname, port: Number(u.port), path: u.pathname, method: "POST",
+        headers: { "Content-Type": "application/json", "Content-Length": Buffer.byteLength(data) } },
+      (res) => { let raw = ""; res.on("data", c => raw += c); res.on("end", () => resolve({ status: res.statusCode ?? 0, raw })); }
+    );
+    req.on("error", reject); req.write(data); req.end();
+  });
+}
+
+let server: http.Server;
+let baseUrl: string;
+
+beforeAll(async () => {
+  server = await startProxyServer({
+    port: 0, log: () => {}, warn: () => {},
+    // @ts-expect-error — stub types close enough for testing
+    _geminiApiComplete: stubComplete,
+    // @ts-expect-error — stub types close enough for testing
+    _geminiApiCompleteStream: stubCompleteStream,
+  });
+  baseUrl = `http://127.0.0.1:${(server.address() as AddressInfo).port}`;
+});
+afterAll(() => server.close());
+
+describe("Gemini API routing — model list", () => {
+  it("includes gemini-api/* models in /v1/models", async () => {
+    const res = await httpGet(`${baseUrl}/v1/models`);
+    expect(res.status).toBe(200);
+    const data = res.body as { data: Array<{ id: string }> };
+    const ids = data.data.map(m => m.id);
+    expect(ids).toContain("gemini-api/gemini-2.5-flash");
+    expect(ids).toContain("gemini-api/gemini-2.5-pro");
+  });
+
+  it("gemini-api models exist in CLI_MODELS constant", () => {
+    const ids = CLI_MODELS.map(m => m.id);
+    expect(ids).toContain("gemini-api/gemini-2.5-flash");
+    expect(ids).toContain("gemini-api/gemini-2.5-pro");
+  });
+});
+
+describe("Gemini API routing — non-streaming", () => {
+  it("returns text response for gemini-api model", async () => {
+    const res = await httpPost(`${baseUrl}/v1/chat/completions`, {
+      model: "gemini-api/gemini-2.5-flash",
+      messages: [{ role: "user", content: "Hello" }],
+    });
+    expect(res.status).toBe(200);
+    const data = res.body as { choices: Array<{ message: { content: string } }> };
+    expect(data.choices[0].message.content).toContain("api mock");
+  });
+
+  it("returns usage with real token counts from API", async () => {
+    const res = await httpPost(`${baseUrl}/v1/chat/completions`, {
+      model: "gemini-api/gemini-2.5-flash",
+      messages: [{ role: "user", content: "test" }],
+    });
+    const data = res.body as { usage: { prompt_tokens: number; completion_tokens: number } };
+    expect(data.usage.prompt_tokens).toBe(10);
+    expect(data.usage.completion_tokens).toBe(5);
+  });
+
+  it("returns correct model in response", async () => {
+    const res = await httpPost(`${baseUrl}/v1/chat/completions`, {
+      model: "gemini-api/gemini-2.5-pro",
+      messages: [{ role: "user", content: "pro model" }],
+    });
+    expect(res.status).toBe(200);
+    const data = res.body as { model: string };
+    expect(data.model).toBe("gemini-api/gemini-2.5-pro");
+  });
+
+  it("accepts vllm/ prefix and routes correctly", async () => {
+    const res = await httpPost(`${baseUrl}/v1/chat/completions`, {
+      model: "vllm/gemini-api/gemini-2.5-flash",
+      messages: [{ role: "user", content: "with prefix" }],
+    });
+    expect(res.status).toBe(200);
+    const data = res.body as { choices: Array<{ message: { content: string } }> };
+    expect(data.choices[0].message.content).toContain("api mock");
+  });
+});
+
+describe("Gemini API routing — streaming", () => {
+  it("returns SSE stream with text tokens", async () => {
+    const res = await httpPostRaw(`${baseUrl}/v1/chat/completions`, {
+      model: "gemini-api/gemini-2.5-flash",
+      messages: [{ role: "user", content: "stream test" }],
+      stream: true,
+    });
+    expect(res.status).toBe(200);
+    expect(res.raw).toContain("data: ");
+    expect(res.raw).toContain("[DONE]");
+    // Should contain the streamed tokens
+    expect(res.raw).toContain("api ");
+    expect(res.raw).toContain("stream ");
+  });
+});

package/test/gemini-api-runner.test.ts

@@ -0,0 +1,134 @@
+import { describe, it, expect } from "vitest";
+import { convertMessages, convertTools, type ContentPart } from "../src/gemini-api-runner.js";
+import type { ChatMessage } from "../src/cli-runner.js";
+import type { ToolDefinition } from "../src/tool-protocol.js";
+
+describe("gemini-api-runner", () => {
+  describe("convertMessages", () => {
+    it("converts system messages to systemInstruction", () => {
+      const messages: ChatMessage[] = [
+        { role: "system", content: "You are a helpful assistant." },
+        { role: "user", content: "Hello" },
+      ];
+      const result = convertMessages(messages);
+      expect(result.systemInstruction).toEqual({
+        parts: [{ text: "You are a helpful assistant." }],
+      });
+      expect(result.contents).toHaveLength(1);
+      expect(result.contents[0].role).toBe("user");
+    });
+
+    it("maps assistant role to model", () => {
+      const messages: ChatMessage[] = [
+        { role: "user", content: "Hi" },
+        { role: "assistant", content: "Hello!" },
+      ];
+      const result = convertMessages(messages);
+      expect(result.contents[0].role).toBe("user");
+      expect(result.contents[1].role).toBe("model");
+    });
+
+    it("converts tool results to functionResponse", () => {
+      const messages: ChatMessage[] = [
+        { role: "tool", content: '{"result": "42"}', name: "calculator" } as ChatMessage & { name: string },
+      ];
+      const result = convertMessages(messages);
+      expect(result.contents[0].role).toBe("user");
+      const part = result.contents[0].parts[0] as { functionResponse: { name: string; response: Record<string, unknown> } };
+      expect(part.functionResponse.name).toBe("calculator");
+      expect(part.functionResponse.response).toEqual({ result: "42" });
+    });
+
+    it("converts assistant tool_calls to functionCall parts", () => {
+      const messages = [
+        {
+          role: "assistant" as const,
+          content: null,
+          tool_calls: [
+            { id: "call_1", type: "function" as const, function: { name: "search", arguments: '{"q":"test"}' } },
+          ],
+        },
+      ] as unknown as ChatMessage[];
+      const result = convertMessages(messages);
+      expect(result.contents[0].role).toBe("model");
+      const part = result.contents[0].parts[0] as { functionCall: { name: string; args: Record<string, unknown> } };
+      expect(part.functionCall.name).toBe("search");
+      expect(part.functionCall.args).toEqual({ q: "test" });
+    });
+
+    it("converts image_url content parts to inlineData", () => {
+      const messages: ChatMessage[] = [
+        {
+          role: "user",
+          content: [
+            { type: "text", text: "What is this?" },
+            { type: "image_url", image_url: { url: "data:image/png;base64,iVBOR" } },
+          ] as unknown as string,
+        },
+      ];
+      const result = convertMessages(messages);
+      expect(result.contents[0].parts).toHaveLength(2);
+      const imgPart = result.contents[0].parts[1] as { inlineData: { mimeType: string; data: string } };
+      expect(imgPart.inlineData.mimeType).toBe("image/png");
+      expect(imgPart.inlineData.data).toBe("iVBOR");
+    });
+
+    it("handles multiple system messages", () => {
+      const messages: ChatMessage[] = [
+        { role: "system", content: "Rule 1" },
+        { role: "system", content: "Rule 2" },
+        { role: "user", content: "Go" },
+      ];
+      const result = convertMessages(messages);
+      expect(result.systemInstruction?.parts).toHaveLength(2);
+      expect(result.contents).toHaveLength(1);
+    });
+
+    it("skips empty content messages", () => {
+      const messages: ChatMessage[] = [
+        { role: "user", content: "" },
+        { role: "user", content: "Hello" },
+      ];
+      const result = convertMessages(messages);
+      expect(result.contents).toHaveLength(1);
+    });
+
+    it("handles plain string tool result", () => {
+      const messages: ChatMessage[] = [
+        { role: "tool", content: "plain text result", name: "myTool" } as ChatMessage & { name: string },
+      ];
+      const result = convertMessages(messages);
+      const part = result.contents[0].parts[0] as { functionResponse: { name: string; response: Record<string, unknown> } };
+      expect(part.functionResponse.response).toEqual({ result: "plain text result" });
+    });
+  });
+
+  describe("convertTools", () => {
+    it("wraps tool definitions in functionDeclarations", () => {
+      const tools: ToolDefinition[] = [
+        {
+          type: "function",
+          function: {
+            name: "search",
+            description: "Search the web",
+            parameters: { type: "object", properties: { q: { type: "string" } } },
+          },
+        },
+      ];
+      const result = convertTools(tools);
+      expect(result).toHaveLength(1);
+      expect(result[0].functionDeclarations).toHaveLength(1);
+      expect(result[0].functionDeclarations[0].name).toBe("search");
+      expect(result[0].functionDeclarations[0].description).toBe("Search the web");
+    });
+
+    it("handles multiple tools", () => {
+      const tools: ToolDefinition[] = [
+        { type: "function", function: { name: "a", description: "A", parameters: {} } },
+        { type: "function", function: { name: "b", description: "B", parameters: {} } },
+      ];
+      const result = convertTools(tools);
+      expect(result[0].functionDeclarations).toHaveLength(2);
+    });
+  });
+});