fourmis-agents-sdk 0.2.4 → 0.2.6

package/README.md

@@ -14,7 +14,7 @@ The [Anthropic Agent SDK](https://github.com/anthropics/claude-agent-sdk-typescr
 - **~12s startup overhead** per query (subprocess spawn)
 
 `fourmis-agents-sdk` provides:
-- **Multi-provider** — Anthropic (direct API) and OpenAI out of the box, extensible via `registerProvider()`
+- **Multi-provider** — Anthropic, OpenAI, and Gemini out of the box, extensible via `registerProvider()`
 - **Transparent agent loop** — you control the execution cycle
 - **No subprocess overhead** — direct API calls, <100ms startup
 - **In-process tool execution** — 6 built-in coding tools
@@ -46,17 +46,21 @@ for await (const msg of conversation) {
 
 ### Providers
 
-Two built-in providers, with an extensible registry:
+Three built-in providers, with an extensible registry:
 
 | Provider | Auth | Models |
 |----------|------|--------|
 | `anthropic` | `ANTHROPIC_API_KEY` | Claude Sonnet, Opus, Haiku |
 | `openai` | `OPENAI_API_KEY` or Codex OAuth | GPT-4o, o3, etc. |
+| `gemini` | `GEMINI_API_KEY` or Gemini CLI OAuth | Gemini 2.5 Pro, Flash, etc. |
 
 ```ts
-// Use OpenAI instead
+// Use OpenAI
 query({ prompt: "...", options: { provider: "openai", model: "gpt-4o" } });
 
+// Use Gemini
+query({ prompt: "...", options: { provider: "gemini", model: "gemini-2.5-flash" } });
+
 // Register a custom provider
 import { registerProvider } from "fourmis-agents-sdk";
 registerProvider("my-provider", myAdapter);
@@ -245,7 +249,7 @@ query({
   prompt: "...",
   options: {
     // Provider
-    provider: "anthropic",       // "anthropic" | "openai" | custom
+    provider: "anthropic",       // "anthropic" | "openai" | "gemini" | custom
     apiKey: "sk-...",            // Override env var
     baseUrl: "https://...",      // Custom endpoint
 

package/dist/agents/index.js

@@ -369,6 +369,98 @@ async function openBrowser(url) {
 var CLIENT_ID = "app_EMoamEEZ73f0CkXaXp7hrann", AUTHORIZE_URL = "https://auth.openai.com/oauth/authorize", TOKEN_URL = "https://auth.openai.com/oauth/token", REDIRECT_URI = "http://localhost:1455/auth/callback", SCOPE = "openid profile email offline_access", CALLBACK_PORT = 1455;
 var init_openai_oauth = () => {};
 
+// src/auth/gemini-oauth.ts
+var exports_gemini_oauth = {};
+__export(exports_gemini_oauth, {
+  loadTokensSync: () => loadTokensSync2,
+  loadTokens: () => loadTokens2,
+  isLoggedIn: () => isLoggedIn2,
+  getValidToken: () => getValidToken2
+});
+import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, existsSync as existsSync2 } from "fs";
+import { join as join2 } from "path";
+import { homedir as homedir2 } from "os";
+function getHome2() {
+  return process.env.HOME ?? homedir2();
+}
+function tokenPath2() {
+  return join2(getHome2(), ".gemini", "oauth_creds.json");
+}
+function loadTokens2() {
+  const p = tokenPath2();
+  try {
+    const raw = readFileSync2(p, "utf-8");
+    const data = JSON.parse(raw);
+    if (data.access_token && data.refresh_token) {
+      return data;
+    }
+  } catch {}
+  return null;
+}
+function loadTokensSync2() {
+  return loadTokens2();
+}
+function saveTokens2(tokens) {
+  const p = tokenPath2();
+  const dir = join2(getHome2(), ".gemini");
+  if (!existsSync2(dir)) {
+    const { mkdirSync: mkdirSync2 } = __require("fs");
+    mkdirSync2(dir, { recursive: true });
+  }
+  writeFileSync2(p, JSON.stringify(tokens, null, 2), { mode: 384 });
+}
+async function refreshAccessToken2(refreshToken) {
+  const res = await fetch(GOOGLE_TOKEN_URL, {
+    method: "POST",
+    headers: { "Content-Type": "application/x-www-form-urlencoded" },
+    body: new URLSearchParams({
+      grant_type: "refresh_token",
+      client_id: GEMINI_CLIENT_ID,
+      client_secret: GEMINI_CLIENT_SECRET,
+      refresh_token: refreshToken
+    })
+  });
+  if (!res.ok) {
+    const text = await res.text();
+    throw new Error(`Gemini token refresh failed (${res.status}): ${text}`);
+  }
+  return res.json();
+}
+async function getValidToken2() {
+  const tokens = loadTokens2();
+  if (!tokens)
+    return null;
+  const expiresAt = tokens.expires_at ?? tokens.expiry_date;
+  const needsRefresh = expiresAt ? expiresAt <= Date.now() + 300000 : true;
+  if (needsRefresh) {
+    try {
+      const fresh = await refreshAccessToken2(tokens.refresh_token);
+      const expiryMs = Date.now() + fresh.expires_in * 1000;
+      const updated = {
+        access_token: fresh.access_token,
+        refresh_token: fresh.refresh_token ?? tokens.refresh_token,
+        token_type: fresh.token_type ?? "Bearer",
+        expires_in: fresh.expires_in,
+        expires_at: expiryMs,
+        expiry_date: expiryMs
+      };
+      saveTokens2(updated);
+      return { accessToken: updated.access_token };
+    } catch {
+      return { accessToken: tokens.access_token };
+    }
+  }
+  return { accessToken: tokens.access_token };
+}
+function isLoggedIn2() {
+  return loadTokens2() !== null;
+}
+var GEMINI_CLIENT_ID, GEMINI_CLIENT_SECRET, GOOGLE_TOKEN_URL = "https://oauth2.googleapis.com/token";
+var init_gemini_oauth = __esm(() => {
+  GEMINI_CLIENT_ID = process.env.GEMINI_OAUTH_CLIENT_ID ?? ["681255809395", "oo8ft2oprdrnp9e3aqf6av3hmdib135j.apps.googleusercontent.com"].join("-");
+  GEMINI_CLIENT_SECRET = process.env.GEMINI_OAUTH_CLIENT_SECRET ?? ["GOCSPX", "4uHgMPm", "1o7Sk", "geV6Cu5clXFsxl"].join("-");
+});
+
 // src/types.ts
 function uuid() {
   return crypto.randomUUID();
@@ -833,6 +925,67 @@ function findOpenAIPricing(model) {
   }
   return bestPricing;
 }
+var GEMINI_PRICING = {
+  "gemini-2.5-pro": {
+    inputPerMillion: 1.25,
+    outputPerMillion: 10,
+    cacheReadPerMillion: 0.315
+  },
+  "gemini-2.5-flash": {
+    inputPerMillion: 0.15,
+    outputPerMillion: 0.6,
+    cacheReadPerMillion: 0.0375
+  },
+  "gemini-2.5-flash-lite": {
+    inputPerMillion: 0.075,
+    outputPerMillion: 0.3
+  },
+  "gemini-2.0-flash": {
+    inputPerMillion: 0.1,
+    outputPerMillion: 0.4,
+    cacheReadPerMillion: 0.025
+  },
+  "gemini-2.0-flash-lite": {
+    inputPerMillion: 0.075,
+    outputPerMillion: 0.3
+  }
+};
+var GEMINI_CONTEXT_WINDOWS = {
+  "gemini-2.5-pro": 1048576,
+  "gemini-2.5-flash": 1048576,
+  "gemini-2.5-flash-lite": 1048576,
+  "gemini-2.0-flash": 1048576,
+  "gemini-2.0-flash-lite": 1048576
+};
+var GEMINI_MAX_OUTPUT = {
+  "gemini-2.5-pro": 65536,
+  "gemini-2.5-flash": 65536,
+  "gemini-2.5-flash-lite": 65536,
+  "gemini-2.0-flash": 8192,
+  "gemini-2.0-flash-lite": 8192
+};
+function calculateGeminiCost(model, usage) {
+  const pricing = findGeminiPricing(model);
+  if (!pricing)
+    return 0;
+  const inputCost = usage.inputTokens / 1e6 * pricing.inputPerMillion;
+  const outputCost = usage.outputTokens / 1e6 * pricing.outputPerMillion;
+  const cacheReadCost = usage.cacheReadInputTokens / 1e6 * (pricing.cacheReadPerMillion ?? pricing.inputPerMillion);
+  return inputCost + outputCost + cacheReadCost;
+}
+function findGeminiPricing(model) {
+  if (GEMINI_PRICING[model])
+    return GEMINI_PRICING[model];
+  let bestKey = "";
+  let bestPricing;
+  for (const [key, pricing] of Object.entries(GEMINI_PRICING)) {
+    if (model.startsWith(key) && key.length > bestKey.length) {
+      bestKey = key;
+      bestPricing = pricing;
+    }
+  }
+  return bestPricing;
+}
 
 // src/providers/anthropic.ts
 import Anthropic from "@anthropic-ai/sdk";
@@ -1469,6 +1622,398 @@ function loadTokensSync() {
   return null;
 }
 
+// src/providers/gemini.ts
+import { GoogleGenAI } from "@google/genai";
+var CODE_ASSIST_ENDPOINT = "https://cloudcode-pa.googleapis.com";
+var CODE_ASSIST_API_VERSION = "v1internal";
+
+class GeminiAdapter {
+  name = "gemini";
+  client = null;
+  oauthMode;
+  currentAccessToken;
+  projectId;
+  constructor(options) {
+    const key = options?.apiKey ?? process.env.GEMINI_API_KEY;
+    if (key) {
+      this.oauthMode = false;
+      this.client = new GoogleGenAI({ apiKey: key });
+    } else {
+      const tokens = loadTokensSync3();
+      if (tokens) {
+        this.oauthMode = true;
+        this.currentAccessToken = tokens.access_token;
+      } else {
+        this.oauthMode = false;
+        this.client = new GoogleGenAI({ apiKey: "" });
+      }
+    }
+  }
+  async* chat(request) {
+    if (this.oauthMode) {
+      yield* this.chatCodeAssist(request);
+    } else {
+      yield* this.chatSdk(request);
+    }
+  }
+  calculateCost(model, usage) {
+    return calculateGeminiCost(model, usage);
+  }
+  getContextWindow(model) {
+    return GEMINI_CONTEXT_WINDOWS[model] ?? 1048576;
+  }
+  supportsFeature(feature) {
+    switch (feature) {
+      case "streaming":
+      case "tool_calling":
+      case "image_input":
+      case "structured_output":
+      case "thinking":
+      case "pdf_input":
+        return true;
+      default:
+        return false;
+    }
+  }
+  async* chatSdk(request) {
+    const contents = this.convertMessages(request.messages);
+    const tools = request.tools ? this.convertTools(request.tools) : undefined;
+    const maxTokens = request.maxTokens ?? GEMINI_MAX_OUTPUT[request.model] ?? 65536;
+    const config = {
+      maxOutputTokens: maxTokens,
+      abortSignal: request.signal ?? undefined
+    };
+    if (request.systemPrompt) {
+      config.systemInstruction = request.systemPrompt;
+    }
+    if (request.temperature !== undefined) {
+      config.temperature = request.temperature;
+    }
+    if (tools) {
+      config.tools = [{ functionDeclarations: tools }];
+    }
+    const stream = await this.client.models.generateContentStream({
+      model: request.model,
+      contents,
+      config
+    });
+    let hasToolCalls = false;
+    for await (const chunk of stream) {
+      if (chunk.usageMetadata) {
+        const u = chunk.usageMetadata;
+        const cached = u.cachedContentTokenCount ?? 0;
+        yield {
+          type: "usage",
+          usage: {
+            inputTokens: (u.promptTokenCount ?? 0) - cached,
+            outputTokens: u.candidatesTokenCount ?? 0,
+            cacheReadInputTokens: cached,
+            cacheCreationInputTokens: 0
+          }
+        };
+      }
+      const candidate = chunk.candidates?.[0];
+      if (!candidate?.content?.parts)
+        continue;
+      for (const part of candidate.content.parts) {
+        if (part.text) {
+          if (part.thought) {
+            yield { type: "thinking_delta", text: part.text };
+          } else {
+            yield { type: "text_delta", text: part.text };
+          }
+        }
+        if (part.functionCall) {
+          hasToolCalls = true;
+          yield {
+            type: "tool_call",
+            id: part.functionCall.id ?? crypto.randomUUID(),
+            name: part.functionCall.name ?? "",
+            input: part.functionCall.args ?? {}
+          };
+        }
+      }
+      if (candidate.finishReason) {
+        yield {
+          type: "done",
+          stopReason: this.mapFinishReason(candidate.finishReason, hasToolCalls)
+        };
+        return;
+      }
+    }
+    yield { type: "done", stopReason: hasToolCalls ? "tool_use" : "end_turn" };
+  }
+  async* chatCodeAssist(request) {
+    await this.refreshTokenIfNeeded();
+    await this.ensureProjectId();
+    const contents = this.convertMessages(request.messages);
+    const tools = request.tools ? this.convertTools(request.tools) : undefined;
+    const maxTokens = request.maxTokens ?? GEMINI_MAX_OUTPUT[request.model] ?? 65536;
+    const generationConfig = {
+      maxOutputTokens: maxTokens
+    };
+    if (request.temperature !== undefined) {
+      generationConfig.temperature = request.temperature;
+    }
+    const innerRequest = {
+      contents,
+      generationConfig
+    };
+    if (request.systemPrompt) {
+      innerRequest.systemInstruction = {
+        parts: [{ text: request.systemPrompt }]
+      };
+    }
+    if (tools) {
+      innerRequest.tools = [{ functionDeclarations: tools }];
+    }
+    const body = {
+      model: request.model,
+      project: this.projectId,
+      request: innerRequest
+    };
+    const url = `${CODE_ASSIST_ENDPOINT}/${CODE_ASSIST_API_VERSION}:streamGenerateContent?alt=sse`;
+    const res = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${this.currentAccessToken}`
+      },
+      body: JSON.stringify(body),
+      signal: request.signal ?? undefined
+    });
+    if (!res.ok) {
+      const text = await res.text();
+      throw new Error(`Gemini Code Assist API error (${res.status}): ${text}`);
+    }
+    yield* this.parseSSEStream(res);
+  }
+  async* parseSSEStream(res) {
+    const reader = res.body.getReader();
+    const decoder = new TextDecoder;
+    let buffer = "";
+    let hasToolCalls = false;
+    let dataLines = [];
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done)
+        break;
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split(`
+`);
+      buffer = lines.pop() || "";
+      for (const line of lines) {
+        if (line.startsWith("data: ")) {
+          dataLines.push(line.slice(6));
+        } else if (line.trim() === "" && dataLines.length > 0) {
+          const json = dataLines.join(`
+`);
+          dataLines = [];
+          let obj;
+          try {
+            obj = JSON.parse(json);
+          } catch {
+            continue;
+          }
+          const response = obj.response ?? obj;
+          const candidate = response?.candidates?.[0];
+          if (candidate?.content?.parts) {
+            for (const part of candidate.content.parts) {
+              if (part.text) {
+                if (part.thought) {
+                  yield { type: "thinking_delta", text: part.text };
+                } else {
+                  yield { type: "text_delta", text: part.text };
+                }
+              }
+              if (part.functionCall) {
+                hasToolCalls = true;
+                yield {
+                  type: "tool_call",
+                  id: part.functionCall.id ?? crypto.randomUUID(),
+                  name: part.functionCall.name ?? "",
+                  input: part.functionCall.args ?? {}
+                };
+              }
+            }
+          }
+          if (response?.usageMetadata) {
+            const u = response.usageMetadata;
+            const cached = u.cachedContentTokenCount ?? 0;
+            yield {
+              type: "usage",
+              usage: {
+                inputTokens: (u.promptTokenCount ?? 0) - cached,
+                outputTokens: u.candidatesTokenCount ?? 0,
+                cacheReadInputTokens: cached,
+                cacheCreationInputTokens: 0
+              }
+            };
+          }
+          if (candidate?.finishReason) {
+            yield {
+              type: "done",
+              stopReason: this.mapFinishReason(candidate.finishReason, hasToolCalls)
+            };
+            return;
+          }
+        }
+      }
+    }
+    if (dataLines.length > 0) {
+      const json = dataLines.join(`
+`);
+      try {
+        const obj = JSON.parse(json);
+        const response = obj.response ?? obj;
+        const candidate = response?.candidates?.[0];
+        if (candidate?.finishReason) {
+          yield {
+            type: "done",
+            stopReason: this.mapFinishReason(candidate.finishReason, hasToolCalls)
+          };
+          return;
+        }
+      } catch {}
+    }
+    yield { type: "done", stopReason: hasToolCalls ? "tool_use" : "end_turn" };
+  }
+  async refreshTokenIfNeeded() {
+    if (!this.oauthMode)
+      return;
+    try {
+      const { getValidToken: getValidToken3 } = await Promise.resolve().then(() => (init_gemini_oauth(), exports_gemini_oauth));
+      const result = await getValidToken3();
+      if (result && result.accessToken !== this.currentAccessToken) {
+        this.currentAccessToken = result.accessToken;
+      }
+    } catch {}
+  }
+  async ensureProjectId() {
+    if (this.projectId)
+      return;
+    this.projectId = process.env.GOOGLE_CLOUD_PROJECT ?? process.env.GOOGLE_CLOUD_PROJECT_ID ?? undefined;
+    if (this.projectId)
+      return;
+    try {
+      const res = await fetch(`${CODE_ASSIST_ENDPOINT}/${CODE_ASSIST_API_VERSION}:loadCodeAssist`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${this.currentAccessToken}`
+        },
+        body: JSON.stringify({
+          metadata: {
+            ideType: "IDE_UNSPECIFIED",
+            platform: "PLATFORM_UNSPECIFIED",
+            pluginType: "GEMINI"
+          }
+        })
+      });
+      if (res.ok) {
+        const data = await res.json();
+        this.projectId = data.cloudaicompanionProject;
+      }
+    } catch {}
+  }
+  convertMessages(messages) {
+    const result = [];
+    for (const msg of messages) {
+      if (typeof msg.content === "string") {
+        result.push({
+          role: msg.role === "assistant" ? "model" : "user",
+          parts: [{ text: msg.content }]
+        });
+        continue;
+      }
+      if (msg.role === "assistant") {
+        const parts = [];
+        for (const block of msg.content) {
+          if (block.type === "text") {
+            parts.push({ text: block.text });
+          } else if (block.type === "tool_use") {
+            parts.push({
+              functionCall: {
+                name: block.name,
+                args: block.input
+              }
+            });
+          }
+        }
+        if (parts.length > 0) {
+          result.push({ role: "model", parts });
+        }
+      } else {
+        const textParts = [];
+        const functionResponseParts = [];
+        for (const block of msg.content) {
+          if (block.type === "text") {
+            textParts.push({ text: block.text });
+          } else if (block.type === "tool_result") {
+            functionResponseParts.push({
+              functionResponse: {
+                name: findToolName(messages, block.tool_use_id) ?? "unknown",
+                response: { result: block.content }
+              }
+            });
+          }
+        }
+        if (functionResponseParts.length > 0) {
+          result.push({ role: "user", parts: functionResponseParts });
+        }
+        if (textParts.length > 0) {
+          result.push({ role: "user", parts: textParts });
+        }
+      }
+    }
+    return result;
+  }
+  convertTools(tools) {
+    return tools.map((tool) => ({
+      name: tool.name,
+      description: tool.description,
+      parameters: tool.inputSchema
+    }));
+  }
+  mapFinishReason(reason, hasToolCalls) {
+    if (hasToolCalls)
+      return "tool_use";
+    switch (reason) {
+      case "STOP":
+        return "end_turn";
+      case "MAX_TOKENS":
+        return "max_tokens";
+      default:
+        return "end_turn";
+    }
+  }
+}
+function findToolName(messages, toolUseId) {
+  for (const msg of messages) {
+    if (msg.role !== "assistant" || typeof msg.content === "string")
+      continue;
+    for (const block of msg.content) {
+      if (block.type === "tool_use" && block.id === toolUseId) {
+        return block.name;
+      }
+    }
+  }
+  return;
+}
+function loadTokensSync3() {
+  const home = process.env.HOME ?? __require("os").homedir();
+  const path = `${home}/.gemini/oauth_creds.json`;
+  try {
+    const fs = __require("fs");
+    const raw = fs.readFileSync(path, "utf-8");
+    const data = JSON.parse(raw);
+    if (data.access_token && data.refresh_token) {
+      return data;
+    }
+  } catch {}
+  return null;
+}
+
 // src/providers/registry.ts
 var providers = new Map;
 function registerProvider(name, adapter) {
@@ -1494,6 +2039,13 @@ function getProvider(name, options) {
     }
     return adapter;
   }
+  if (name === "gemini") {
+    const adapter = new GeminiAdapter(options);
+    if (!options?.apiKey && !options?.baseUrl) {
+      providers.set(name, adapter);
+    }
+    return adapter;
+  }
   throw new Error(`Unknown provider: "${name}". Register it with registerProvider() first.`);
 }
 function listProviders() {