@agentier/google 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Google Gemini provider for the agenti framework.
+ *
+ * @packageDocumentation
+ */
+export { google } from './provider';
+export type { GoogleProviderConfig } from './types';

package/dist/index.js

@@ -0,0 +1,220 @@
+// src/mapper.ts
+function toGeminiContents(messages) {
+  let systemInstruction;
+  const contents = [];
+  for (const msg of messages) {
+    if (msg.role === "system") {
+      systemInstruction = { parts: [{ text: msg.content ?? "" }] };
+      continue;
+    }
+    if (msg.role === "user") {
+      contents.push({ role: "user", parts: [{ text: msg.content ?? "" }] });
+      continue;
+    }
+    if (msg.role === "assistant") {
+      const parts = [];
+      if (msg.content) {
+        parts.push({ text: msg.content });
+      }
+      if (msg.toolCalls) {
+        for (const tc of msg.toolCalls) {
+          parts.push({
+            functionCall: { name: tc.name, args: tc.arguments }
+          });
+        }
+      }
+      if (parts.length > 0) {
+        contents.push({ role: "model", parts });
+      }
+      continue;
+    }
+    if (msg.role === "tool") {
+      const part = {
+        functionResponse: {
+          name: msg.name ?? "",
+          response: { content: msg.content ?? "" }
+        }
+      };
+      const last = contents[contents.length - 1];
+      if (last && last.role === "user" && last.parts.some((p) => ("functionResponse" in p))) {
+        last.parts.push(part);
+      } else {
+        contents.push({ role: "user", parts: [part] });
+      }
+    }
+  }
+  return { systemInstruction, contents };
+}
+function toGeminiTools(tools) {
+  return [
+    {
+      functionDeclarations: tools.map((t) => ({
+        name: t.name,
+        description: t.description,
+        parameters: t.parameters
+      }))
+    }
+  ];
+}
+function fromGeminiResponse(candidates) {
+  let text = "";
+  const toolCalls = [];
+  let callIndex = 0;
+  const parts = candidates[0]?.content?.parts ?? [];
+  for (const part of parts) {
+    if ("text" in part) {
+      text += part.text;
+    } else if ("functionCall" in part) {
+      toolCalls.push({
+        id: `call_${callIndex++}`,
+        name: part.functionCall.name,
+        arguments: part.functionCall.args
+      });
+    }
+  }
+  return { text: text || null, toolCalls };
+}
+
+// src/provider.ts
+function google(config) {
+  const apiVersion = config.apiVersion ?? "v1beta";
+  const baseUrl = (config.baseUrl ?? `https://generativelanguage.googleapis.com/${apiVersion}`).replace(/\/$/, "");
+  const fetchFn = config.fetch ?? globalThis.fetch;
+  function buildHeaders() {
+    return {
+      "Content-Type": "application/json",
+      ...config.defaultHeaders
+    };
+  }
+  function buildBody(params) {
+    const { systemInstruction, contents } = toGeminiContents(params.messages);
+    const body = {
+      contents
+    };
+    if (systemInstruction)
+      body.systemInstruction = systemInstruction;
+    if (params.tools && params.tools.length > 0) {
+      body.tools = toGeminiTools(params.tools);
+    }
+    const generationConfig = {};
+    if (params.temperature !== undefined)
+      generationConfig.temperature = params.temperature;
+    if (params.topP !== undefined)
+      generationConfig.topP = params.topP;
+    if (params.maxOutputTokens !== undefined)
+      generationConfig.maxOutputTokens = params.maxOutputTokens;
+    if (Object.keys(generationConfig).length > 0) {
+      body.generationConfig = generationConfig;
+    }
+    return body;
+  }
+  const provider = {
+    name: "google",
+    async chat(params) {
+      const url = `${baseUrl}/models/${params.model}:generateContent?key=${config.apiKey}`;
+      const response = await fetchFn(url, {
+        method: "POST",
+        headers: buildHeaders(),
+        body: JSON.stringify(buildBody(params)),
+        signal: params.signal
+      });
+      if (!response.ok) {
+        const errorBody = await response.text();
+        throw new Error(`Google API error (${response.status}): ${errorBody}`);
+      }
+      const data = await response.json();
+      const { text, toolCalls } = fromGeminiResponse(data.candidates ?? []);
+      return {
+        content: text,
+        toolCalls,
+        usage: {
+          inputTokens: data.usageMetadata?.promptTokenCount ?? 0,
+          outputTokens: data.usageMetadata?.candidatesTokenCount ?? 0
+        },
+        raw: data
+      };
+    },
+    async* stream(params) {
+      const url = `${baseUrl}/models/${params.model}:streamGenerateContent?alt=sse&key=${config.apiKey}`;
+      const response = await fetchFn(url, {
+        method: "POST",
+        headers: buildHeaders(),
+        body: JSON.stringify(buildBody(params)),
+        signal: params.signal
+      });
+      if (!response.ok) {
+        const errorBody = await response.text();
+        throw new Error(`Google API error (${response.status}): ${errorBody}`);
+      }
+      const reader = response.body?.getReader();
+      if (!reader)
+        throw new Error("No response body");
+      const decoder = new TextDecoder;
+      let buffer = "";
+      let fullContent = "";
+      const toolCalls = [];
+      let callIndex = 0;
+      let inputTokens = 0;
+      let outputTokens = 0;
+      try {
+        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) {
+            const trimmed = line.trim();
+            if (!trimmed.startsWith("data: "))
+              continue;
+            const data = trimmed.slice(6);
+            try {
+              const parsed = JSON.parse(data);
+              const parts = parsed.candidates?.[0]?.content?.parts ?? [];
+              for (const part of parts) {
+                if ("text" in part) {
+                  fullContent += part.text;
+                  yield { type: "token", text: part.text };
+                } else if ("functionCall" in part) {
+                  const id = `call_${callIndex++}`;
+                  const call = {
+                    id,
+                    name: part.functionCall.name,
+                    arguments: part.functionCall.args
+                  };
+                  toolCalls.push(call);
+                  yield {
+                    type: "tool_call_start",
+                    id,
+                    name: part.functionCall.name
+                  };
+                  yield { type: "tool_call_end", id, call };
+                }
+              }
+              if (parsed.usageMetadata) {
+                inputTokens = parsed.usageMetadata.promptTokenCount ?? inputTokens;
+                outputTokens = parsed.usageMetadata.candidatesTokenCount ?? outputTokens;
+              }
+            } catch {}
+          }
+        }
+      } finally {
+        reader.releaseLock();
+      }
+      yield {
+        type: "done",
+        response: {
+          content: fullContent || null,
+          toolCalls,
+          usage: { inputTokens, outputTokens }
+        }
+      };
+    }
+  };
+  return provider;
+}
+export {
+  google
+};

package/dist/mapper.d.ts

@@ -0,0 +1,79 @@
+import type { Message, ToolCall, ToolJsonSchema } from '@agentier/core';
+/** Wire format for a Gemini conversation turn. */
+export interface GeminiContent {
+    role: 'user' | 'model';
+    parts: GeminiPart[];
+}
+/**
+ * A single part within a Gemini message.
+ *
+ * Can be plain text, a function call from the model, or a function response
+ * from the caller.
+ */
+export type GeminiPart = {
+    text: string;
+} | {
+    functionCall: {
+        name: string;
+        args: Record<string, unknown>;
+    };
+} | {
+    functionResponse: {
+        name: string;
+        response: {
+            content: string;
+        };
+    };
+};
+/** Wire format for a Gemini function (tool) declaration. */
+export interface GeminiFunctionDeclaration {
+    name: string;
+    description: string;
+    parameters: Record<string, unknown>;
+}
+/**
+ * Converts agenti `Message` objects into Gemini `contents` and an optional `systemInstruction`.
+ *
+ * System messages become a top-level `systemInstruction`. Tool result messages
+ * are placed inside `user` turns as `functionResponse` parts, and consecutive
+ * tool results are merged into a single turn, matching the Gemini protocol.
+ *
+ * @param messages - Array of provider-agnostic messages.
+ * @returns An object with optional `systemInstruction` and the `contents` array.
+ */
+export declare function toGeminiContents(messages: Message[]): {
+    systemInstruction?: {
+        parts: [{
+            text: string;
+        }];
+    };
+    contents: GeminiContent[];
+};
+/**
+ * Converts agenti tool schemas into the Gemini function declarations format.
+ *
+ * Wraps all declarations in a single tool group, as required by the Gemini API.
+ *
+ * @param tools - Array of provider-agnostic tool JSON schemas.
+ * @returns Array containing one tool group with all function declarations.
+ */
+export declare function toGeminiTools(tools: ToolJsonSchema[]): {
+    functionDeclarations: GeminiFunctionDeclaration[];
+}[];
+/**
+ * Extracts text and tool calls from a Gemini response candidates array.
+ *
+ * Since Gemini does not return tool call IDs, synthetic IDs are generated
+ * using an incrementing counter (`call_0`, `call_1`, etc.).
+ *
+ * @param candidates - The `candidates` array from the Gemini API response.
+ * @returns Parsed text (or `null` if empty) and an array of agenti `ToolCall` objects.
+ */
+export declare function fromGeminiResponse(candidates: Array<{
+    content: {
+        parts: GeminiPart[];
+    };
+}>): {
+    text: string | null;
+    toolCalls: ToolCall[];
+};

package/dist/provider.d.ts

@@ -0,0 +1,24 @@
+import type { ModelProvider } from '@agentier/core';
+import type { GoogleProviderConfig } from './types';
+/**
+ * Creates a Google Gemini {@link ModelProvider}.
+ *
+ * Supports both blocking `chat` (via `generateContent`) and streaming `stream`
+ * (via `streamGenerateContent`) endpoints. The API key is passed as a query
+ * parameter rather than a header, matching the Gemini REST convention.
+ *
+ * @param config - Provider configuration including API key and optional overrides.
+ * @returns A `ModelProvider` wired to the Google Gemini API.
+ *
+ * @example
+ * ```ts
+ * import { google } from '@agentier/provider-google'
+ *
+ * const provider = google({ apiKey: process.env.GOOGLE_API_KEY! })
+ * const response = await provider.chat({
+ *   model: 'gemini-2.0-flash',
+ *   messages: [{ role: 'user', content: 'Hello!' }],
+ * })
+ * ```
+ */
+export declare function google(config: GoogleProviderConfig): ModelProvider;

package/dist/types.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Configuration for the Google (Gemini) provider.
+ *
+ * @example
+ * ```ts
+ * const config: GoogleProviderConfig = {
+ *   apiKey: process.env.GOOGLE_API_KEY!,
+ *   apiVersion: 'v1beta',
+ * }
+ * ```
+ */
+export interface GoogleProviderConfig {
+    /** Google AI API key appended as a query parameter to each request. */
+    apiKey: string;
+    /** Base URL for API requests. Defaults to `https://generativelanguage.googleapis.com/{apiVersion}`. */
+    baseUrl?: string;
+    /** Gemini API version used in the default base URL. Defaults to `'v1beta'`. */
+    apiVersion?: string;
+    /** Additional headers merged into every request. */
+    defaultHeaders?: Record<string, string>;
+    /** Custom `fetch` implementation, useful for proxies or test doubles. */
+    fetch?: typeof globalThis.fetch;
+}

package/package.json

@@ -0,0 +1,29 @@
+{
+    "name": "@agentier/google",
+    "version": "0.1.0",
+    "type": "module",
+    "main": "./dist/index.js",
+    "types": "./dist/index.d.ts",
+    "exports": {
+        ".": {
+            "import": "./dist/index.js",
+            "types": "./dist/index.d.ts"
+        }
+    },
+    "files": [
+        "dist"
+    ],
+    "scripts": {
+        "build": "bun build ./src/index.ts --outdir ./dist --target node",
+        "test": "bun test",
+        "typecheck": "tsc --noEmit"
+    },
+    "peerDependencies": {
+        "@agentier/core": "^0.1.0"
+    },
+    "devDependencies": {
+        "@agentier/core": "workspace:*",
+        "typescript": "^5.5.0",
+        "@types/bun": "latest"
+    }
+}