fourmis-agents-sdk 0.2.4 → 0.2.5

package/dist/providers/gemini.js

@@ -0,0 +1,710 @@
+// @bun
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = import.meta.require;
+
+// src/auth/gemini-oauth.ts
+var exports_gemini_oauth = {};
+__export(exports_gemini_oauth, {
+  loadTokensSync: () => loadTokensSync,
+  loadTokens: () => loadTokens,
+  isLoggedIn: () => isLoggedIn,
+  getValidToken: () => getValidToken
+});
+import { readFileSync, writeFileSync, existsSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+function getHome() {
+  return process.env.HOME ?? homedir();
+}
+function tokenPath() {
+  return join(getHome(), ".gemini", "oauth_creds.json");
+}
+function loadTokens() {
+  const p = tokenPath();
+  try {
+    const raw = readFileSync(p, "utf-8");
+    const data = JSON.parse(raw);
+    if (data.access_token && data.refresh_token) {
+      return data;
+    }
+  } catch {}
+  return null;
+}
+function loadTokensSync() {
+  return loadTokens();
+}
+function saveTokens(tokens) {
+  const p = tokenPath();
+  const dir = join(getHome(), ".gemini");
+  if (!existsSync(dir)) {
+    const { mkdirSync } = __require("fs");
+    mkdirSync(dir, { recursive: true });
+  }
+  writeFileSync(p, JSON.stringify(tokens, null, 2), { mode: 384 });
+}
+async function refreshAccessToken(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 getValidToken() {
+  const tokens = loadTokens();
+  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 refreshAccessToken(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
+      };
+      saveTokens(updated);
+      return { accessToken: updated.access_token };
+    } catch {
+      return { accessToken: tokens.access_token };
+    }
+  }
+  return { accessToken: tokens.access_token };
+}
+function isLoggedIn() {
+  return loadTokens() !== null;
+}
+var GEMINI_CLIENT_ID = "681255809395-oo8ft2oprdrnp9e3aqf6av3hmdib135j.apps.googleusercontent.com", GEMINI_CLIENT_SECRET = "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", GOOGLE_TOKEN_URL = "https://oauth2.googleapis.com/token";
+var init_gemini_oauth = () => {};
+
+// src/utils/cost.ts
+var ANTHROPIC_PRICING = {
+  "claude-opus-4-6": {
+    inputPerMillion: 15,
+    outputPerMillion: 75,
+    cacheReadPerMillion: 1.5,
+    cacheWritePerMillion: 18.75
+  },
+  "claude-sonnet-4-5-20250929": {
+    inputPerMillion: 3,
+    outputPerMillion: 15,
+    cacheReadPerMillion: 0.3,
+    cacheWritePerMillion: 3.75
+  },
+  "claude-haiku-4-5-20251001": {
+    inputPerMillion: 0.8,
+    outputPerMillion: 4,
+    cacheReadPerMillion: 0.08,
+    cacheWritePerMillion: 1
+  },
+  "claude-3-5-sonnet-20241022": {
+    inputPerMillion: 3,
+    outputPerMillion: 15,
+    cacheReadPerMillion: 0.3,
+    cacheWritePerMillion: 3.75
+  },
+  "claude-3-5-haiku-20241022": {
+    inputPerMillion: 0.8,
+    outputPerMillion: 4,
+    cacheReadPerMillion: 0.08,
+    cacheWritePerMillion: 1
+  }
+};
+var ANTHROPIC_CONTEXT_WINDOWS = {
+  "claude-opus-4-6": 200000,
+  "claude-sonnet-4-5-20250929": 200000,
+  "claude-haiku-4-5-20251001": 200000,
+  "claude-3-5-sonnet-20241022": 200000,
+  "claude-3-5-haiku-20241022": 200000
+};
+var ANTHROPIC_MAX_OUTPUT = {
+  "claude-opus-4-6": 32000,
+  "claude-sonnet-4-5-20250929": 16384,
+  "claude-haiku-4-5-20251001": 8192,
+  "claude-3-5-sonnet-20241022": 8192,
+  "claude-3-5-haiku-20241022": 8192
+};
+function calculateAnthropicCost(model, usage) {
+  const pricing = findPricing(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);
+  const cacheWriteCost = usage.cacheCreationInputTokens / 1e6 * (pricing.cacheWritePerMillion ?? pricing.inputPerMillion);
+  return inputCost + outputCost + cacheReadCost + cacheWriteCost;
+}
+function findPricing(model) {
+  if (ANTHROPIC_PRICING[model])
+    return ANTHROPIC_PRICING[model];
+  for (const [key, pricing] of Object.entries(ANTHROPIC_PRICING)) {
+    if (key.startsWith(model) || model.startsWith(key.split("-2025")[0])) {
+      return pricing;
+    }
+  }
+  return;
+}
+var OPENAI_PRICING = {
+  "gpt-4.1": {
+    inputPerMillion: 2,
+    outputPerMillion: 8,
+    cacheReadPerMillion: 0.5
+  },
+  "gpt-4.1-mini": {
+    inputPerMillion: 0.4,
+    outputPerMillion: 1.6,
+    cacheReadPerMillion: 0.1
+  },
+  "gpt-4.1-nano": {
+    inputPerMillion: 0.1,
+    outputPerMillion: 0.4,
+    cacheReadPerMillion: 0.025
+  },
+  "gpt-4o": {
+    inputPerMillion: 2.5,
+    outputPerMillion: 10,
+    cacheReadPerMillion: 1.25
+  },
+  "gpt-4o-mini": {
+    inputPerMillion: 0.15,
+    outputPerMillion: 0.6,
+    cacheReadPerMillion: 0.075
+  },
+  o3: {
+    inputPerMillion: 2,
+    outputPerMillion: 8,
+    cacheReadPerMillion: 0.5
+  },
+  "o3-mini": {
+    inputPerMillion: 1.1,
+    outputPerMillion: 4.4,
+    cacheReadPerMillion: 0.275
+  },
+  "o4-mini": {
+    inputPerMillion: 1.1,
+    outputPerMillion: 4.4,
+    cacheReadPerMillion: 0.275
+  }
+};
+var OPENAI_CONTEXT_WINDOWS = {
+  "gpt-4.1": 1047576,
+  "gpt-4.1-mini": 1047576,
+  "gpt-4.1-nano": 1047576,
+  "gpt-4o": 128000,
+  "gpt-4o-mini": 128000,
+  o3: 200000,
+  "o3-mini": 200000,
+  "o4-mini": 200000
+};
+var OPENAI_MAX_OUTPUT = {
+  "gpt-4.1": 32768,
+  "gpt-4.1-mini": 32768,
+  "gpt-4.1-nano": 32768,
+  "gpt-4o": 16384,
+  "gpt-4o-mini": 16384,
+  o3: 1e5,
+  "o3-mini": 1e5,
+  "o4-mini": 1e5
+};
+function calculateOpenAICost(model, usage) {
+  const pricing = findOpenAIPricing(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 findOpenAIPricing(model) {
+  if (OPENAI_PRICING[model])
+    return OPENAI_PRICING[model];
+  let bestKey = "";
+  let bestPricing;
+  for (const [key, pricing] of Object.entries(OPENAI_PRICING)) {
+    if (model.startsWith(key) && key.length > bestKey.length) {
+      bestKey = key;
+      bestPricing = pricing;
+    }
+  }
+  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/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 = loadTokensSync2();
+      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: getValidToken2 } = await Promise.resolve().then(() => (init_gemini_oauth(), exports_gemini_oauth));
+      const result = await getValidToken2();
+      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 loadTokensSync2() {
+  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;
+}
+export {
+  GeminiAdapter
+};