@agentforge-io/llm-langchain 0.1.0 → 0.2.0

package/dist/index.d.ts

@@ -1 +1,2 @@
 export { OpenAIProvider, type OpenAIProviderOptions, } from './providers/openai-provider';
+export { GeminiProvider, type GeminiProviderOptions, } from './providers/gemini-provider';

package/dist/index.js

@@ -16,6 +16,8 @@
 // The host wires which provider runs per tenant; this package only ships
 // the adapters, not the resolution logic.
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.OpenAIProvider = void 0;
+exports.GeminiProvider = exports.OpenAIProvider = void 0;
 var openai_provider_1 = require("./providers/openai-provider");
 Object.defineProperty(exports, "OpenAIProvider", { enumerable: true, get: function () { return openai_provider_1.OpenAIProvider; } });
+var gemini_provider_1 = require("./providers/gemini-provider");
+Object.defineProperty(exports, "GeminiProvider", { enumerable: true, get: function () { return gemini_provider_1.GeminiProvider; } });

package/dist/providers/gemini-provider.d.ts

@@ -0,0 +1,16 @@
+import type { LLMProvider, LLMProviderCapabilities, LLMStreamEvent, LLMStreamParams } from '@agentforge-io/core/ai';
+export interface GeminiProviderOptions {
+    apiKey: string;
+    /** Provider id surfaced to the platform resolver. Defaults to `'gemini'`. */
+    id?: string;
+    /** Human-readable label. Defaults to `'Google Gemini'`. */
+    displayName?: string;
+}
+export declare class GeminiProvider implements LLMProvider {
+    readonly id: string;
+    readonly displayName: string;
+    readonly capabilities: LLMProviderCapabilities;
+    private readonly apiKey;
+    constructor(opts: GeminiProviderOptions);
+    stream(params: LLMStreamParams): AsyncGenerator<LLMStreamEvent>;
+}

package/dist/providers/gemini-provider.js

@@ -0,0 +1,212 @@
+"use strict";
+// ─── Gemini provider (via LangChain) ────────────────────────────────────────
+//
+// Adapts `@langchain/google-genai`'s `ChatGoogleGenerativeAI` to the
+// framework-free `LLMProvider` contract. Mirrors `OpenAIProvider`'s shape
+// so the rest of the system (registry, resolver, agent runner) treats
+// every provider uniformly.
+//
+// Notable differences from OpenAI:
+//   - Gemini's tool-calling event shape uses `tool_calls` on the final
+//     AIMessage rather than `tool_call_chunks` arriving incrementally.
+//     LangChain normalises both into a similar surface but we read the
+//     final tool_calls off the LAST chunk's `.tool_calls` array.
+//   - Gemini's stop reasons are STOP / MAX_TOKENS / SAFETY / RECITATION /
+//     OTHER. We collapse SAFETY/RECITATION/OTHER into `end_turn` because
+//     none of them carry runner-actionable semantics — the model just
+//     stopped early. The platform's logging layer reads the raw reason
+//     separately for telemetry.
+//
+// Like `OpenAIProvider`, this class doesn't load LangChain modules until
+// `stream()` is called — `ChatGoogleGenerativeAI` is constructed per turn
+// (the model id varies). Safe because the HTTP client is stateless.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GeminiProvider = void 0;
+const google_genai_1 = require("@langchain/google-genai");
+const messages_1 = require("@langchain/core/messages");
+class GeminiProvider {
+    constructor(opts) {
+        this.capabilities = {
+            supportsTools: true,
+            supportsStreaming: true,
+            // Gemini accepts `temperature` on every modern (1.5+) family.
+            supportsTemperature: true,
+            // Gemini DOES allow multiple function calls per turn — they arrive
+            // in the same response's `functionCalls` array, which LangChain
+            // surfaces as `tool_calls`.
+            supportsParallelTools: true,
+        };
+        this.id = opts.id ?? 'gemini';
+        this.displayName = opts.displayName ?? 'Google Gemini';
+        this.apiKey = opts.apiKey;
+    }
+    async *stream(params) {
+        const llm = new google_genai_1.ChatGoogleGenerativeAI({
+            apiKey: this.apiKey,
+            model: params.model,
+            temperature: params.temperature,
+            maxOutputTokens: params.maxTokens,
+            streaming: true,
+        });
+        const bound = params.tools && params.tools.length > 0
+            ? llm.bindTools(params.tools.map(toLangChainTool))
+            : llm;
+        const messages = toLangChainMessages(params.systemPrompt, params.messages);
+        let textBuffer = '';
+        // Gemini emits tool_calls as a finalised list on the closing
+        // chunk (not incremental like OpenAI). We track the last chunk's
+        // `tool_calls` and parse them at end-of-stream.
+        let finalToolCalls = [];
+        let usageInput = 0;
+        let usageOutput = 0;
+        let stopReason = 'end_turn';
+        const stream = await bound.stream(messages);
+        for await (const chunk of stream) {
+            const text = typeof chunk.content === 'string'
+                ? chunk.content
+                : chunk.content
+                    .map((c) => typeof c === 'string'
+                    ? c
+                    : 'text' in c
+                        ? c.text
+                        : '')
+                    .join('');
+            if (text) {
+                textBuffer += text;
+                yield { type: 'text_delta', delta: text };
+            }
+            const chunkToolCalls = chunk
+                .tool_calls;
+            if (chunkToolCalls && chunkToolCalls.length > 0) {
+                finalToolCalls = chunkToolCalls;
+            }
+            const usageMeta = chunk.usage_metadata;
+            if (usageMeta) {
+                usageInput = usageMeta.input_tokens ?? usageInput;
+                usageOutput = usageMeta.output_tokens ?? usageOutput;
+            }
+            const finishReason = chunk
+                .response_metadata?.finish_reason ??
+                chunk.finish_reason;
+            if (finishReason) {
+                stopReason = normalizeFinishReason(finishReason);
+            }
+        }
+        const finalContent = [];
+        if (textBuffer) {
+            finalContent.push({ type: 'text', text: textBuffer });
+        }
+        for (const call of finalToolCalls) {
+            const id = call.id ?? `call_${Math.random().toString(36).slice(2, 10)}`;
+            yield {
+                type: 'tool_use_start',
+                toolUseId: id,
+                toolName: call.name,
+                input: call.args,
+            };
+            finalContent.push({
+                type: 'tool_use',
+                id,
+                name: call.name,
+                input: call.args,
+            });
+        }
+        if (finalToolCalls.length > 0 && stopReason !== 'max_tokens') {
+            stopReason = 'tool_use';
+        }
+        yield {
+            type: 'usage_delta',
+            usage: {
+                inputTokens: usageInput,
+                outputTokens: usageOutput,
+                totalTokens: usageInput + usageOutput,
+            },
+        };
+        yield {
+            type: 'message_stop',
+            stopReason,
+            content: finalContent,
+        };
+    }
+}
+exports.GeminiProvider = GeminiProvider;
+// ─── Translation helpers ────────────────────────────────────────────────────
+function toLangChainTool(t) {
+    return {
+        type: 'function',
+        function: {
+            name: t.name,
+            description: t.description,
+            parameters: t.input_schema,
+        },
+    };
+}
+function toLangChainMessages(systemPrompt, messages) {
+    const out = [];
+    if (systemPrompt) {
+        out.push(new messages_1.SystemMessage(systemPrompt));
+    }
+    for (const m of messages) {
+        if (typeof m.content === 'string') {
+            out.push(m.role === 'user'
+                ? new messages_1.HumanMessage(m.content)
+                : new messages_1.AIMessage(m.content));
+            continue;
+        }
+        if (m.role === 'user') {
+            const textParts = [];
+            for (const block of m.content) {
+                if (block.type === 'text') {
+                    textParts.push(block.text);
+                }
+                else if (block.type === 'tool_result') {
+                    if (textParts.length > 0) {
+                        out.push(new messages_1.HumanMessage(textParts.join('\n')));
+                        textParts.length = 0;
+                    }
+                    out.push(new messages_1.ToolMessage({
+                        tool_call_id: block.tool_use_id,
+                        content: block.content,
+                        status: block.is_error ? 'error' : 'success',
+                    }));
+                }
+            }
+            if (textParts.length > 0) {
+                out.push(new messages_1.HumanMessage(textParts.join('\n')));
+            }
+        }
+        else {
+            const textParts = [];
+            const toolCalls = [];
+            for (const block of m.content) {
+                if (block.type === 'text')
+                    textParts.push(block.text);
+                else if (block.type === 'tool_use')
+                    toolCalls.push({
+                        id: block.id,
+                        name: block.name,
+                        args: block.input,
+                        type: 'tool_call',
+                    });
+            }
+            out.push(new messages_1.AIMessage({
+                content: textParts.join('\n'),
+                tool_calls: toolCalls,
+            }));
+        }
+    }
+    return out;
+}
+function normalizeFinishReason(raw) {
+    switch (raw.toUpperCase()) {
+        case 'TOOL_CALLS':
+        case 'FUNCTION_CALL':
+            return 'tool_use';
+        case 'MAX_TOKENS':
+        case 'LENGTH':
+            return 'max_tokens';
+        case 'STOP':
+        default:
+            return 'end_turn';
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentforge-io/llm-langchain",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "LangChain-backed LLM providers (OpenAI, Grok, Gemini) implementing the framework-free `LLMProvider` contract from @agentforge-io/core. Drop-in replacements for AnthropicProvider — same stream events, same tool schema, no changes to the agent runner.",
   "license": "MIT",
   "main": "dist/index.js",