@bolt-ai/providers-gemini 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Bolt AI
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.cjs

@@ -0,0 +1,181 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  buildGeminiContents: () => buildGeminiContents,
+  createGeminiProvider: () => createGeminiProvider,
+  fromGeminiFunctionCalls: () => fromGeminiFunctionCalls,
+  toGeminiFunctionName: () => toGeminiFunctionName,
+  toGeminiTools: () => toGeminiTools
+});
+module.exports = __toCommonJS(index_exports);
+var import_genai = require("@google/genai");
+function createGeminiProvider(opts = {}) {
+  const options = typeof opts === "string" ? { model: opts } : opts;
+  const apiKey = options.apiKey ?? process.env.GEMINI_API_KEY ?? process.env.GOOGLE_API_KEY ?? "";
+  if (!apiKey && !options.client) throw new Error("GEMINI_API_KEY or GOOGLE_API_KEY is required");
+  const model = options.model ?? process.env.GEMINI_MODEL ?? "gemini-2.5-flash";
+  const temperature = options.temperature ?? 0.2;
+  const client = options.client ?? new import_genai.GoogleGenAI({ apiKey });
+  return {
+    id: `gemini:${model}`,
+    supports: ["text", "json"],
+    async call(args) {
+      const prompt = args.prompt ?? (typeof args.input === "string" ? args.input : JSON.stringify(args.input ?? ""));
+      const contents = buildGeminiContents(prompt, args.toolResults);
+      const request = buildGeminiRequest({
+        model,
+        temperature,
+        contents,
+        tools: args.tools,
+        kind: args.kind,
+        schema: args.schema
+      });
+      if (args.onToken && args.kind === "text" && client.models.generateContentStream) {
+        const stream = await client.models.generateContentStream(request);
+        return collectGeminiStream(stream, args.onToken, args.tools);
+      }
+      const resp = await client.models.generateContent(request);
+      const raw = resp;
+      const toolCalls = fromGeminiFunctionCalls(extractGeminiFunctionCalls(raw), args.tools);
+      if (toolCalls.length) {
+        return { toolCalls, tokens: raw.usageMetadata?.totalTokenCount };
+      }
+      const content = extractGeminiText(raw);
+      const output = args.kind === "json" ? safeParseJSON(content) : content;
+      return { output, tokens: raw.usageMetadata?.totalTokenCount };
+    }
+  };
+}
+function toGeminiFunctionName(toolId) {
+  const normalized = toolId.replace(/[^A-Za-z0-9_]/g, "_");
+  if (/^[A-Za-z_]/.test(normalized)) return normalized.slice(0, 64);
+  return `tool_${normalized}`.slice(0, 64);
+}
+function toGeminiTools(tools) {
+  if (!tools?.length) return void 0;
+  return [
+    {
+      functionDeclarations: tools.map((tool) => ({
+        name: toGeminiFunctionName(tool.id),
+        description: tool.description ?? tool.id,
+        parametersJsonSchema: tool.schema ?? { type: "object", properties: {} }
+      }))
+    }
+  ];
+}
+function fromGeminiFunctionCalls(functionCalls, tools) {
+  if (!Array.isArray(functionCalls)) return [];
+  const providerNameToToolId = new Map(
+    (tools ?? []).map((tool) => [toGeminiFunctionName(tool.id), tool.id])
+  );
+  return functionCalls.map((functionCall) => {
+    const raw = functionCall;
+    const name = String(raw?.name ?? "").trim();
+    if (!name) return null;
+    return {
+      id: raw.id ? String(raw.id) : void 0,
+      toolId: providerNameToToolId.get(name) ?? name,
+      args: raw.args ?? {}
+    };
+  }).filter((toolCall) => Boolean(toolCall));
+}
+function buildGeminiContents(prompt, toolResults) {
+  const contents = [{ role: "user", parts: [{ text: prompt }] }];
+  if (!toolResults?.length) return contents;
+  contents.push({
+    role: "user",
+    parts: toolResults.map((result) => ({
+      functionResponse: {
+        id: result.id,
+        name: toGeminiFunctionName(result.toolId),
+        response: normalizeGeminiFunctionResponse(result.output)
+      }
+    }))
+  });
+  return contents;
+}
+function buildGeminiRequest(args) {
+  const tools = toGeminiTools(args.tools);
+  const config = {
+    temperature: args.temperature,
+    ...args.kind === "json" ? { responseMimeType: "application/json" } : {},
+    ...args.kind === "json" && args.schema ? { responseSchema: args.schema } : {},
+    ...tools?.length ? { tools, toolConfig: { functionCallingConfig: { mode: "AUTO" } } } : {}
+  };
+  return {
+    model: args.model,
+    contents: args.contents,
+    config
+  };
+}
+async function collectGeminiStream(stream, onToken, tools) {
+  let full = "";
+  const functionCalls = [];
+  for await (const chunk of stream) {
+    const text = extractGeminiText(chunk);
+    if (text) {
+      full += text;
+      onToken(text);
+    }
+    functionCalls.push(...extractGeminiFunctionCalls(chunk));
+  }
+  const toolCalls = fromGeminiFunctionCalls(functionCalls, tools);
+  if (toolCalls.length) return { toolCalls };
+  return { output: full };
+}
+function extractGeminiText(response) {
+  if (typeof response?.text === "string") return response.text;
+  if (typeof response?.text === "function") return response.text();
+  const parts = response?.candidates?.[0]?.content?.parts ?? response?.content?.parts ?? [];
+  return parts.map((part) => typeof part?.text === "string" ? part.text : "").join("");
+}
+function extractGeminiFunctionCalls(response) {
+  if (Array.isArray(response?.functionCalls)) return response.functionCalls;
+  const parts = response?.candidates?.[0]?.content?.parts ?? response?.content?.parts ?? [];
+  return parts.map((part) => part?.functionCall).filter(Boolean);
+}
+function normalizeGeminiFunctionResponse(output) {
+  if (output && typeof output === "object" && !Array.isArray(output)) return output;
+  return { result: output };
+}
+function safeParseJSON(s) {
+  try {
+    return JSON.parse(s);
+  } catch {
+    const m = s.match(/\{[\s\S]*\}|\[[\s\S]*\]/);
+    if (m) {
+      try {
+        return JSON.parse(m[0]);
+      } catch {
+      }
+    }
+    return { raw: s };
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  buildGeminiContents,
+  createGeminiProvider,
+  fromGeminiFunctionCalls,
+  toGeminiFunctionName,
+  toGeminiTools
+});

package/dist/index.d.cts

@@ -0,0 +1,28 @@
+import { ModelProvider, ProviderToolDefinition, ProviderToolCall, ProviderToolResult } from '@bolt-ai/core';
+
+type GeminiClient = {
+    models: {
+        generateContent(args: Record<string, unknown>): Promise<unknown>;
+        generateContentStream?(args: Record<string, unknown>): Promise<unknown>;
+    };
+};
+interface GeminiProviderOptions {
+    apiKey?: string;
+    model?: string;
+    temperature?: number;
+    client?: GeminiClient;
+}
+declare function createGeminiProvider(model?: string): ModelProvider;
+declare function createGeminiProvider(opts?: GeminiProviderOptions): ModelProvider;
+declare function toGeminiFunctionName(toolId: string): string;
+declare function toGeminiTools(tools?: ProviderToolDefinition[]): {
+    functionDeclarations: {
+        name: string;
+        description: string;
+        parametersJsonSchema: any;
+    }[];
+}[] | undefined;
+declare function fromGeminiFunctionCalls(functionCalls: unknown, tools?: ProviderToolDefinition[]): ProviderToolCall[];
+declare function buildGeminiContents(prompt: string, toolResults?: ProviderToolResult[]): any[];
+
+export { type GeminiProviderOptions, buildGeminiContents, createGeminiProvider, fromGeminiFunctionCalls, toGeminiFunctionName, toGeminiTools };

package/dist/index.d.ts

@@ -0,0 +1,28 @@
+import { ModelProvider, ProviderToolDefinition, ProviderToolCall, ProviderToolResult } from '@bolt-ai/core';
+
+type GeminiClient = {
+    models: {
+        generateContent(args: Record<string, unknown>): Promise<unknown>;
+        generateContentStream?(args: Record<string, unknown>): Promise<unknown>;
+    };
+};
+interface GeminiProviderOptions {
+    apiKey?: string;
+    model?: string;
+    temperature?: number;
+    client?: GeminiClient;
+}
+declare function createGeminiProvider(model?: string): ModelProvider;
+declare function createGeminiProvider(opts?: GeminiProviderOptions): ModelProvider;
+declare function toGeminiFunctionName(toolId: string): string;
+declare function toGeminiTools(tools?: ProviderToolDefinition[]): {
+    functionDeclarations: {
+        name: string;
+        description: string;
+        parametersJsonSchema: any;
+    }[];
+}[] | undefined;
+declare function fromGeminiFunctionCalls(functionCalls: unknown, tools?: ProviderToolDefinition[]): ProviderToolCall[];
+declare function buildGeminiContents(prompt: string, toolResults?: ProviderToolResult[]): any[];
+
+export { type GeminiProviderOptions, buildGeminiContents, createGeminiProvider, fromGeminiFunctionCalls, toGeminiFunctionName, toGeminiTools };

package/dist/index.js

@@ -0,0 +1,152 @@
+// src/index.ts
+import { GoogleGenAI } from "@google/genai";
+function createGeminiProvider(opts = {}) {
+  const options = typeof opts === "string" ? { model: opts } : opts;
+  const apiKey = options.apiKey ?? process.env.GEMINI_API_KEY ?? process.env.GOOGLE_API_KEY ?? "";
+  if (!apiKey && !options.client) throw new Error("GEMINI_API_KEY or GOOGLE_API_KEY is required");
+  const model = options.model ?? process.env.GEMINI_MODEL ?? "gemini-2.5-flash";
+  const temperature = options.temperature ?? 0.2;
+  const client = options.client ?? new GoogleGenAI({ apiKey });
+  return {
+    id: `gemini:${model}`,
+    supports: ["text", "json"],
+    async call(args) {
+      const prompt = args.prompt ?? (typeof args.input === "string" ? args.input : JSON.stringify(args.input ?? ""));
+      const contents = buildGeminiContents(prompt, args.toolResults);
+      const request = buildGeminiRequest({
+        model,
+        temperature,
+        contents,
+        tools: args.tools,
+        kind: args.kind,
+        schema: args.schema
+      });
+      if (args.onToken && args.kind === "text" && client.models.generateContentStream) {
+        const stream = await client.models.generateContentStream(request);
+        return collectGeminiStream(stream, args.onToken, args.tools);
+      }
+      const resp = await client.models.generateContent(request);
+      const raw = resp;
+      const toolCalls = fromGeminiFunctionCalls(extractGeminiFunctionCalls(raw), args.tools);
+      if (toolCalls.length) {
+        return { toolCalls, tokens: raw.usageMetadata?.totalTokenCount };
+      }
+      const content = extractGeminiText(raw);
+      const output = args.kind === "json" ? safeParseJSON(content) : content;
+      return { output, tokens: raw.usageMetadata?.totalTokenCount };
+    }
+  };
+}
+function toGeminiFunctionName(toolId) {
+  const normalized = toolId.replace(/[^A-Za-z0-9_]/g, "_");
+  if (/^[A-Za-z_]/.test(normalized)) return normalized.slice(0, 64);
+  return `tool_${normalized}`.slice(0, 64);
+}
+function toGeminiTools(tools) {
+  if (!tools?.length) return void 0;
+  return [
+    {
+      functionDeclarations: tools.map((tool) => ({
+        name: toGeminiFunctionName(tool.id),
+        description: tool.description ?? tool.id,
+        parametersJsonSchema: tool.schema ?? { type: "object", properties: {} }
+      }))
+    }
+  ];
+}
+function fromGeminiFunctionCalls(functionCalls, tools) {
+  if (!Array.isArray(functionCalls)) return [];
+  const providerNameToToolId = new Map(
+    (tools ?? []).map((tool) => [toGeminiFunctionName(tool.id), tool.id])
+  );
+  return functionCalls.map((functionCall) => {
+    const raw = functionCall;
+    const name = String(raw?.name ?? "").trim();
+    if (!name) return null;
+    return {
+      id: raw.id ? String(raw.id) : void 0,
+      toolId: providerNameToToolId.get(name) ?? name,
+      args: raw.args ?? {}
+    };
+  }).filter((toolCall) => Boolean(toolCall));
+}
+function buildGeminiContents(prompt, toolResults) {
+  const contents = [{ role: "user", parts: [{ text: prompt }] }];
+  if (!toolResults?.length) return contents;
+  contents.push({
+    role: "user",
+    parts: toolResults.map((result) => ({
+      functionResponse: {
+        id: result.id,
+        name: toGeminiFunctionName(result.toolId),
+        response: normalizeGeminiFunctionResponse(result.output)
+      }
+    }))
+  });
+  return contents;
+}
+function buildGeminiRequest(args) {
+  const tools = toGeminiTools(args.tools);
+  const config = {
+    temperature: args.temperature,
+    ...args.kind === "json" ? { responseMimeType: "application/json" } : {},
+    ...args.kind === "json" && args.schema ? { responseSchema: args.schema } : {},
+    ...tools?.length ? { tools, toolConfig: { functionCallingConfig: { mode: "AUTO" } } } : {}
+  };
+  return {
+    model: args.model,
+    contents: args.contents,
+    config
+  };
+}
+async function collectGeminiStream(stream, onToken, tools) {
+  let full = "";
+  const functionCalls = [];
+  for await (const chunk of stream) {
+    const text = extractGeminiText(chunk);
+    if (text) {
+      full += text;
+      onToken(text);
+    }
+    functionCalls.push(...extractGeminiFunctionCalls(chunk));
+  }
+  const toolCalls = fromGeminiFunctionCalls(functionCalls, tools);
+  if (toolCalls.length) return { toolCalls };
+  return { output: full };
+}
+function extractGeminiText(response) {
+  if (typeof response?.text === "string") return response.text;
+  if (typeof response?.text === "function") return response.text();
+  const parts = response?.candidates?.[0]?.content?.parts ?? response?.content?.parts ?? [];
+  return parts.map((part) => typeof part?.text === "string" ? part.text : "").join("");
+}
+function extractGeminiFunctionCalls(response) {
+  if (Array.isArray(response?.functionCalls)) return response.functionCalls;
+  const parts = response?.candidates?.[0]?.content?.parts ?? response?.content?.parts ?? [];
+  return parts.map((part) => part?.functionCall).filter(Boolean);
+}
+function normalizeGeminiFunctionResponse(output) {
+  if (output && typeof output === "object" && !Array.isArray(output)) return output;
+  return { result: output };
+}
+function safeParseJSON(s) {
+  try {
+    return JSON.parse(s);
+  } catch {
+    const m = s.match(/\{[\s\S]*\}|\[[\s\S]*\]/);
+    if (m) {
+      try {
+        return JSON.parse(m[0]);
+      } catch {
+      }
+    }
+    return { raw: s };
+  }
+}
+export {
+  buildGeminiContents,
+  createGeminiProvider,
+  fromGeminiFunctionCalls,
+  toGeminiFunctionName,
+  toGeminiTools
+};

package/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "@bolt-ai/providers-gemini",
+  "version": "1.0.0",
+  "description": "Gemini model provider adapter for Bolt AI agents.",
+  "license": "MIT",
+  "author": "Bolt AI",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/TheCypher/Bolt-Agentic.git"
+  },
+  "homepage": "https://github.com/TheCypher/Bolt-Agentic#readme",
+  "bugs": {
+    "url": "https://github.com/TheCypher/Bolt-Agentic/issues"
+  },
+  "keywords": [
+    "ai",
+    "agents",
+    "gemini",
+    "providers",
+    "bolt"
+  ],
+  "type": "module",
+  "main": "dist/index.cjs",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "peerDependencies": {
+    "@bolt-ai/core": ">=1.0.0"
+  },
+  "peerDependenciesMeta": {
+    "@bolt-ai/core": {
+      "optional": false
+    }
+  },
+  "dependencies": {
+    "@google/genai": "^1.52.0"
+  },
+  "devDependencies": {
+    "tsup": "^8.5.0",
+    "typescript": "^5.5.0",
+    "rimraf": "^6.0.1",
+    "@bolt-ai/core": "1.0.0"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --dts --format esm,cjs --tsconfig tsconfig.json",
+    "clean": "rimraf dist"
+  }
+}