@arcote.tech/arc-ai-gemini 0.5.2 → 0.5.6

package/package.json

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

package/src/index.ts

@@ -2,6 +2,9 @@ import type {
   LLMProvider,
   CompletionRequest,
   CompletionResult,
+  Conversation,
+  ConversationTurn,
+  AssistantContentBlock,
   StreamChunk,
   ToolCall,
   TokenUsage,
@@ -38,51 +41,57 @@ export function gemini(config: GeminiConfig): LLMProvider {
     ];
   }
 
-  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 },
-              },
-            },
-          ],
-        };
-      }
-
+  /**
+   * Translate a single ConversationTurn into a Gemini `contents[]` entry.
+   * Adapter is a pure translator — caller already decided what to send via
+   * the Conversation discriminated union. Block ordering is preserved 1:1
+   * inside assistant turns by emitting parts in input order.
+   */
+  function turnToContent(turn: ConversationTurn): unknown {
+    if (turn.role === "user") {
+      return { role: "user", parts: [{ text: turn.content }] };
+    }
+    if (turn.role === "tool_result") {
       return {
-        role: m.role === "assistant" ? "model" : "user",
-        parts: [{ text: m.content }],
+        role: "user",
+        parts: [
+          {
+            functionResponse: {
+              name: turn.name,
+              response: { result: turn.content },
+            },
+          },
+        ],
       };
-    });
-
-    return { systemInstruction, contents };
+    }
+    // assistant — emit ordered parts
+    const parts: unknown[] = [];
+    for (const block of turn.blocks) {
+      if (block.type === "text") {
+        if (!block.text) continue;
+        parts.push({ text: block.text });
+      } else {
+        parts.push({
+          functionCall: { name: block.name, args: block.arguments },
+        });
+      }
+    }
+    return { role: "model", parts };
   }
 
-  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,
-    };
+  function buildContents(conversation: Conversation): unknown[] {
+    if (conversation.mode !== "full") {
+      throw new Error(
+        "Gemini provider does not support continuation mode — set " +
+          "`supportsContinuation: false` in the listener and pass " +
+          "`Conversation.mode = 'full'` with the full conversation history.",
+      );
+    }
+    return conversation.turns.map(turnToContent);
   }
 
-  async function complete(request: CompletionRequest): Promise<CompletionResult> {
-    const { systemInstruction, contents } = buildContents(request.messages);
+  function buildBody(request: CompletionRequest): Record<string, unknown> {
+    const contents = buildContents(request.conversation);
 
     const body: Record<string, unknown> = {
       contents,
@@ -92,18 +101,37 @@ export function gemini(config: GeminiConfig): LLMProvider {
       },
     };
 
-    if (systemInstruction) body.systemInstruction = systemInstruction;
+    if (request.instructions) {
+      body.systemInstruction = { parts: [{ text: request.instructions }] };
+    }
 
     const tools = translateTools(request.tools);
     if (tools) body.tools = tools;
-
     if (request.webSearch) {
-      body.tools = [
-        ...(tools ?? []),
-        { googleSearch: {} },
-      ];
+      body.tools = [...(tools ?? []), { googleSearch: {} }];
     }
 
+    return body;
+  }
+
+  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,
+    };
+  }
+
+  // ─── complete ─────────────────────────────────────────────────
+
+  async function complete(
+    request: CompletionRequest,
+  ): Promise<CompletionResult> {
+    const body = buildBody(request);
+
     const response = await fetch(
       `${baseUrl}/models/${request.model}:generateContent?key=${config.apiKey}`,
       {
@@ -122,14 +150,13 @@ export function gemini(config: GeminiConfig): LLMProvider {
     const candidate = data.candidates?.[0];
     const parts = candidate?.content?.parts ?? [];
 
-    let content = "";
-    const toolCalls: ToolCall[] = [];
-
+    const blocks: AssistantContentBlock[] = [];
     for (const part of parts) {
       if (part.text) {
-        content += part.text;
+        blocks.push({ type: "text", text: part.text });
       } else if (part.functionCall) {
-        toolCalls.push({
+        blocks.push({
+          type: "tool_call",
           id: generateToolCallId(),
           name: part.functionCall.name,
           arguments: part.functionCall.args ?? {},
@@ -137,42 +164,24 @@ export function gemini(config: GeminiConfig): LLMProvider {
       }
     }
 
-    const finishReason: FinishReason =
-      toolCalls.length > 0 ? "tool_call" : "stop";
+    const finishReason: FinishReason = blocks.some((b) => b.type === "tool_call")
+      ? "tool_call"
+      : "stop";
 
     return {
-      content,
-      toolCalls,
+      blocks,
       usage: parseUsage(data),
       finishReason,
     };
   }
 
+  // ─── streamComplete ───────────────────────────────────────────
+
   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 body = buildBody(request);
 
     const response = await fetch(
       `${baseUrl}/models/${request.model}:streamGenerateContent?alt=sse&key=${config.apiKey}`,
@@ -188,7 +197,10 @@ export function gemini(config: GeminiConfig): LLMProvider {
       throw new Error(`Gemini API error ${response.status}: ${error}`);
     }
 
-    let content = "";
+    // Gemini's streamGenerateContent emits parts in order across chunks. We
+    // append blocks as we see them; consecutive text parts merge into the
+    // current text block, function calls become their own blocks.
+    const blocks: AssistantContentBlock[] = [];
     let usage: TokenUsage = {
       inputTokens: 0,
       outputTokens: 0,
@@ -196,7 +208,6 @@ export function gemini(config: GeminiConfig): LLMProvider {
       cachedTokens: 0,
       reasoningTokens: 0,
     };
-    const toolCalls: ToolCall[] = [];
 
     const reader = response.body!.getReader();
     const decoder = new TextDecoder();
@@ -220,7 +231,12 @@ export function gemini(config: GeminiConfig): LLMProvider {
 
           for (const part of parts) {
             if (part.text) {
-              content += part.text;
+              const last = blocks[blocks.length - 1];
+              if (last?.type === "text") {
+                last.text += part.text;
+              } else {
+                blocks.push({ type: "text", text: part.text });
+              }
               onChunk({ type: "content_delta", content: part.text });
             } else if (part.functionCall) {
               const tc: ToolCall = {
@@ -228,12 +244,16 @@ export function gemini(config: GeminiConfig): LLMProvider {
                 name: part.functionCall.name,
                 arguments: part.functionCall.args ?? {},
               };
-              toolCalls.push(tc);
+              blocks.push({
+                type: "tool_call",
+                id: tc.id,
+                name: tc.name,
+                arguments: tc.arguments,
+              });
               onChunk({ type: "tool_call_start", toolCall: tc });
             }
           }
 
-          // Gemini sends usage in every chunk
           if (parsed.usageMetadata) {
             usage = parseUsage(parsed);
           }
@@ -243,12 +263,12 @@ export function gemini(config: GeminiConfig): LLMProvider {
       }
     }
 
-    const finishReason: FinishReason =
-      toolCalls.length > 0 ? "tool_call" : "stop";
+    const finishReason: FinishReason = blocks.some((b) => b.type === "tool_call")
+      ? "tool_call"
+      : "stop";
 
     return {
-      content,
-      toolCalls,
+      blocks,
       usage,
       finishReason,
     };
@@ -257,6 +277,7 @@ export function gemini(config: GeminiConfig): LLMProvider {
   return {
     name: "gemini",
     models: ["gemini-2.5-pro", "gemini-2.5-flash", "gemini-2.0-flash"],
+    supportsContinuation: false,
     complete,
     streamComplete,
   };