@agentforge-io/llm-langchain 0.1.0 → 0.3.0

package/dist/index.d.ts

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

package/dist/index.js

@@ -16,6 +16,10 @@
 // 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.GroqProvider = 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; } });
+var groq_provider_1 = require("./providers/groq-provider");
+Object.defineProperty(exports, "GroqProvider", { enumerable: true, get: function () { return groq_provider_1.GroqProvider; } });

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/dist/providers/groq-provider.d.ts

@@ -0,0 +1,15 @@
+import { OpenAIProvider, type OpenAIProviderOptions } from './openai-provider';
+export interface GroqProviderOptions extends Omit<OpenAIProviderOptions, 'baseURL' | 'organization'> {
+    /** Override the default base URL. Only useful for a proxy/test setup;
+     *  production points at https://api.groq.com/openai/v1. */
+    baseURL?: string;
+}
+/**
+ * Groq inference provider. Same wire format as OpenAI Chat Completions,
+ * just at a different endpoint. The class extends OpenAIProvider so we
+ * inherit the entire stream-event translation pipeline — only the
+ * default base URL changes.
+ */
+export declare class GroqProvider extends OpenAIProvider {
+    constructor(opts: GroqProviderOptions);
+}

package/dist/providers/groq-provider.js

@@ -0,0 +1,44 @@
+"use strict";
+// ─── Groq provider ──────────────────────────────────────────────────────────
+//
+// Groq runs OpenAI-compatible inference on their own LPU hardware — same
+// wire format as OpenAI's `/v1/chat/completions`, just at
+// `https://api.groq.com/openai/v1`. So this whole provider is the OpenAI
+// adapter with the base URL pinned + a different id/displayName for
+// telemetry attribution.
+//
+// Worth a separate class (not just an env override on OpenAIProvider)
+// because:
+//   - Groq's free tier is the killer feature; the platform wants to
+//     attribute spend / quota separately in the dashboard
+//   - The model catalog is DIFFERENT (Llama 3, Mixtral, Gemma, etc.) —
+//     hardcoding them in the platform registration would lie about
+//     which provider answered the turn
+//   - Capability flags can diverge: some Groq-hosted models don't
+//     expose tool calling even though OpenAI's catalog does
+//
+// Don't confuse with Grok (xAI). They sound alike but:
+//   - Grok = xAI's own model family ("grok-2", "grok-2-mini"), served
+//     at api.x.ai. Uses GrokProvider in the platform.
+//   - Groq = inference service serving open-weight models. Uses THIS
+//     provider in the platform.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GroqProvider = void 0;
+const openai_provider_1 = require("./openai-provider");
+/**
+ * Groq inference provider. Same wire format as OpenAI Chat Completions,
+ * just at a different endpoint. The class extends OpenAIProvider so we
+ * inherit the entire stream-event translation pipeline — only the
+ * default base URL changes.
+ */
+class GroqProvider extends openai_provider_1.OpenAIProvider {
+    constructor(opts) {
+        super({
+            apiKey: opts.apiKey,
+            baseURL: opts.baseURL ?? 'https://api.groq.com/openai/v1',
+            id: opts.id ?? 'groq',
+            displayName: opts.displayName ?? 'Groq',
+        });
+    }
+}
+exports.GroqProvider = GroqProvider;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentforge-io/llm-langchain",
-  "version": "0.1.0",
+  "version": "0.3.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",