@arcote.tech/arc-ai-gemini 0.4.6

package/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "@arcote.tech/arc-ai-gemini",
+  "type": "module",
+  "version": "0.4.6",
+  "private": false,
+  "description": "Gemini (Google) adapter for Arc AI framework",
+  "main": "./src/index.ts",
+  "types": "./src/index.ts",
+  "scripts": {
+    "type-check": "tsc --noEmit"
+  },
+  "peerDependencies": {
+    "@arcote.tech/arc-ai": "^0.4.6",
+    "typescript": "^5.0.0"
+  },
+  "devDependencies": {
+    "@types/bun": "latest"
+  }
+}

package/src/index.ts

@@ -0,0 +1,263 @@
+import type {
+  LLMProvider,
+  CompletionRequest,
+  CompletionResult,
+  StreamChunk,
+  ToolCall,
+  TokenUsage,
+  FinishReason,
+} from "@arcote.tech/arc-ai";
+
+// ─── Config ──────────────────────────────────────────────────────
+
+export interface GeminiConfig {
+  apiKey: string;
+}
+
+// ─── Adapter ─────────────────────────────────────────────────────
+
+export function gemini(config: GeminiConfig): LLMProvider {
+  const baseUrl = "https://generativelanguage.googleapis.com/v1beta";
+
+  function generateToolCallId(): string {
+    return `tc_${crypto.randomUUID().replace(/-/g, "").slice(0, 24)}`;
+  }
+
+  function translateTools(
+    tools: CompletionRequest["tools"],
+  ): unknown[] | undefined {
+    if (!tools || tools.length === 0) return undefined;
+    return [
+      {
+        functionDeclarations: tools.map((t) => ({
+          name: t.name,
+          description: t.description,
+          parameters: t.parameters,
+        })),
+      },
+    ];
+  }
+
+  function buildContents(messages: CompletionRequest["messages"]) {
+    const systemMessages = messages.filter((m) => m.role === "system");
+    const nonSystemMessages = messages.filter((m) => m.role !== "system");
+
+    const systemInstruction = systemMessages.length
+      ? { parts: [{ text: systemMessages.map((m) => m.content).join("\n\n") }] }
+      : undefined;
+
+    const contents = nonSystemMessages.map((m) => {
+      if (m.role === "tool") {
+        return {
+          role: "user",
+          parts: [
+            {
+              functionResponse: {
+                name: m.name ?? "unknown",
+                response: { result: m.content },
+              },
+            },
+          ],
+        };
+      }
+
+      return {
+        role: m.role === "assistant" ? "model" : "user",
+        parts: [{ text: m.content }],
+      };
+    });
+
+    return { systemInstruction, contents };
+  }
+
+  function parseUsage(raw: any): TokenUsage {
+    const meta = raw.usageMetadata ?? {};
+    return {
+      inputTokens: meta.promptTokenCount ?? 0,
+      outputTokens: meta.candidatesTokenCount ?? 0,
+      totalTokens: meta.totalTokenCount ?? 0,
+      cachedTokens: meta.cachedContentTokenCount ?? 0,
+      reasoningTokens: 0,
+    };
+  }
+
+  async function complete(request: CompletionRequest): Promise<CompletionResult> {
+    const { systemInstruction, contents } = buildContents(request.messages);
+
+    const body: Record<string, unknown> = {
+      contents,
+      generationConfig: {
+        temperature: request.temperature,
+        maxOutputTokens: request.maxTokens,
+      },
+    };
+
+    if (systemInstruction) body.systemInstruction = systemInstruction;
+
+    const tools = translateTools(request.tools);
+    if (tools) body.tools = tools;
+
+    if (request.webSearch) {
+      body.tools = [
+        ...(tools ?? []),
+        { googleSearch: {} },
+      ];
+    }
+
+    const response = await fetch(
+      `${baseUrl}/models/${request.model}:generateContent?key=${config.apiKey}`,
+      {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(body),
+      },
+    );
+
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`Gemini API error ${response.status}: ${error}`);
+    }
+
+    const data = await response.json() as any;
+    const candidate = data.candidates?.[0];
+    const parts = candidate?.content?.parts ?? [];
+
+    let content = "";
+    const toolCalls: ToolCall[] = [];
+
+    for (const part of parts) {
+      if (part.text) {
+        content += part.text;
+      } else if (part.functionCall) {
+        toolCalls.push({
+          id: generateToolCallId(),
+          name: part.functionCall.name,
+          arguments: part.functionCall.args ?? {},
+        });
+      }
+    }
+
+    const finishReason: FinishReason =
+      toolCalls.length > 0 ? "tool_call" : "stop";
+
+    return {
+      content,
+      toolCalls,
+      usage: parseUsage(data),
+      finishReason,
+    };
+  }
+
+  async function streamComplete(
+    request: CompletionRequest,
+    onChunk: (chunk: StreamChunk) => void,
+  ): Promise<CompletionResult> {
+    const { systemInstruction, contents } = buildContents(request.messages);
+
+    const body: Record<string, unknown> = {
+      contents,
+      generationConfig: {
+        temperature: request.temperature,
+        maxOutputTokens: request.maxTokens,
+      },
+    };
+
+    if (systemInstruction) body.systemInstruction = systemInstruction;
+
+    const tools = translateTools(request.tools);
+    if (tools) body.tools = tools;
+
+    if (request.webSearch) {
+      body.tools = [
+        ...(tools ?? []),
+        { googleSearch: {} },
+      ];
+    }
+
+    const response = await fetch(
+      `${baseUrl}/models/${request.model}:streamGenerateContent?alt=sse&key=${config.apiKey}`,
+      {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(body),
+      },
+    );
+
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`Gemini API error ${response.status}: ${error}`);
+    }
+
+    let content = "";
+    let usage: TokenUsage = {
+      inputTokens: 0,
+      outputTokens: 0,
+      totalTokens: 0,
+      cachedTokens: 0,
+      reasoningTokens: 0,
+    };
+    const toolCalls: ToolCall[] = [];
+
+    const reader = response.body!.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split("\n");
+      buffer = lines.pop()!;
+
+      for (const line of lines) {
+        if (!line.startsWith("data: ")) continue;
+        const data = line.slice(6).trim();
+
+        try {
+          const parsed = JSON.parse(data);
+          const parts = parsed.candidates?.[0]?.content?.parts ?? [];
+
+          for (const part of parts) {
+            if (part.text) {
+              content += part.text;
+              onChunk({ type: "content_delta", content: part.text });
+            } else if (part.functionCall) {
+              const tc: ToolCall = {
+                id: generateToolCallId(),
+                name: part.functionCall.name,
+                arguments: part.functionCall.args ?? {},
+              };
+              toolCalls.push(tc);
+              onChunk({ type: "tool_call_start", toolCall: tc });
+            }
+          }
+
+          // Gemini sends usage in every chunk
+          if (parsed.usageMetadata) {
+            usage = parseUsage(parsed);
+          }
+        } catch {
+          // Skip malformed JSON
+        }
+      }
+    }
+
+    const finishReason: FinishReason =
+      toolCalls.length > 0 ? "tool_call" : "stop";
+
+    return {
+      content,
+      toolCalls,
+      usage,
+      finishReason,
+    };
+  }
+
+  return {
+    name: "gemini",
+    models: ["gemini-2.5-pro", "gemini-2.5-flash", "gemini-2.0-flash"],
+    complete,
+    streamComplete,
+  };
+}

package/tsconfig.json

@@ -0,0 +1,4 @@
+{
+  "extends": "../../../../../tsconfig.json",
+  "include": ["src/**/*"]
+}