trickle-observe 0.2.119 → 0.2.121

package/dist/llm-observer.d.ts

@@ -11,6 +11,7 @@
  */
 export declare function patchOpenAI(openaiModule: any, debug: boolean): void;
 export declare function patchAnthropic(anthropicModule: any, debug: boolean): void;
+export declare function patchGemini(geminiModule: any, debug: boolean): void;
 /**
  * Initialize the LLM observer — clears previous data file.
  */

package/dist/llm-observer.js

@@ -46,6 +46,7 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.patchOpenAI = patchOpenAI;
 exports.patchAnthropic = patchAnthropic;
+exports.patchGemini = patchGemini;
 exports.initLlmObserver = initLlmObserver;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
@@ -65,6 +66,12 @@ const PRICING = {
     'claude-3-5-sonnet-20241022': { input: 3, output: 15 },
     'claude-3-5-haiku-20241022': { input: 0.8, output: 4 },
     'claude-3-haiku-20240307': { input: 0.25, output: 1.25 },
+    'gemini-2.5-flash-lite': { input: 0.1, output: 0.4 },
+    'gemini-2.5-flash': { input: 0.3, output: 2.5 },
+    'gemini-2.5-pro': { input: 1.25, output: 10 },
+    'gemini-2.0-flash': { input: 0.1, output: 0.4 },
+    'gemini-1.5-flash': { input: 0.075, output: 0.3 },
+    'gemini-1.5-pro': { input: 1.25, output: 5 },
 };
 function getLlmFile() {
     if (llmFile)
@@ -489,6 +496,223 @@ function captureAnthropicError(params, err, startTime, debug) {
     });
 }
 // ────────────────────────────────────────────────────
+// Google Gemini SDK instrumentation (@google/genai)
+// ────────────────────────────────────────────────────
+function patchGemini(geminiModule, debug) {
+    if (!geminiModule || getattr(geminiModule, '_trickle_llm_patched'))
+        return;
+    setattr(geminiModule, '_trickle_llm_patched', true);
+    // @google/genai exports GoogleGenAI class
+    // Usage: const ai = new GoogleGenAI({ apiKey }); ai.models.generateContent({...})
+    const GoogleGenAI = geminiModule.GoogleGenAI || geminiModule.default?.GoogleGenAI;
+    if (typeof GoogleGenAI !== 'function') {
+        if (debug)
+            console.log('[trickle/llm] Gemini: GoogleGenAI class not found');
+        return;
+    }
+    try {
+        // GoogleGenAI creates models as own property in the constructor.
+        // Patch the GoogleGenAI constructor to wrap generateContent after creation.
+        const origGoogleGenAIInit = GoogleGenAI.prototype.constructor;
+        // Use a post-construction hook: after new GoogleGenAI() creates the instance
+        // with models.generateContent as an own property, wrap that method.
+        const tmpClient = new GoogleGenAI({ apiKey: 'trickle-probe' });
+        const ModelsClass = Object.getPrototypeOf(tmpClient.models)?.constructor;
+        if (ModelsClass) {
+            const origModelsInit = ModelsClass;
+            // Patch the Models constructor to wrap generateContent after instance creation
+            const origConstruct = ModelsClass.prototype.constructor;
+            // We can't replace the ES6 class constructor, so instead we use a
+            // post-construction approach: hook into GoogleGenAI's prototype to
+            // patch models on each new client instance.
+            const origGAIProto = GoogleGenAI.prototype;
+            const origInitDescriptors = Object.getOwnPropertyDescriptors(origGAIProto);
+            // Define a lazy wrapper: first time models.generateContent is called,
+            // install the instrumentation wrapper
+            function wrapModelsInstance(models) {
+                if (!models || models.__trickle_patched)
+                    return;
+                models.__trickle_patched = true;
+                if (typeof models.generateContent === 'function') {
+                    const origGenerate = models.generateContent.bind(models);
+                    models.generateContent = function patchedGenerateContent(...args) {
+                        const params = args[0] || {};
+                        const startTime = performance.now();
+                        const result = origGenerate(...args);
+                        if (result && typeof result.then === 'function') {
+                            return result.then((response) => {
+                                captureGeminiResponse(params, response, startTime, false, debug);
+                                return response;
+                            }).catch((err) => {
+                                captureGeminiError(params, err, startTime, debug);
+                                throw err;
+                            });
+                        }
+                        return result;
+                    };
+                }
+                if (typeof models.generateContentStream === 'function') {
+                    const origStream = models.generateContentStream.bind(models);
+                    models.generateContentStream = function patchedStream(...args) {
+                        const params = args[0] || {};
+                        const startTime = performance.now();
+                        const result = origStream(...args);
+                        if (result && typeof result.then === 'function') {
+                            return result.then((stream) => handleGeminiStream(stream, params, startTime, debug));
+                        }
+                        return result;
+                    };
+                }
+            }
+            // Intercept the GoogleGenAI constructor to patch each instance's models
+            // Since we can't replace ES6 class constructors, we use a Proxy
+            const proxyHandler = {
+                construct(target, args, newTarget) {
+                    const instance = Reflect.construct(target, args, newTarget);
+                    if (instance.models)
+                        wrapModelsInstance(instance.models);
+                    return instance;
+                }
+            };
+            const ProxiedGoogleGenAI = new Proxy(GoogleGenAI, proxyHandler);
+            // Replace on the module (try both export styles)
+            try {
+                geminiModule.GoogleGenAI = ProxiedGoogleGenAI;
+            }
+            catch { }
+            try {
+                if (geminiModule.default?.GoogleGenAI)
+                    geminiModule.default.GoogleGenAI = ProxiedGoogleGenAI;
+            }
+            catch { }
+            // Also patch the already-created probe instance (in case someone imported before us)
+            // This is a no-op since the probe is discarded.
+            if (debug)
+                console.log('[trickle/llm] Patched Gemini SDK');
+        }
+    }
+    catch (e) {
+        if (debug)
+            console.log('[trickle/llm] Gemini patch probe failed:', e.message);
+    }
+}
+function captureGeminiResponse(params, response, startTime, isStream, debug) {
+    const usage = response.usageMetadata || {};
+    const model = params.model || 'gemini-unknown';
+    const inputTokens = usage.promptTokenCount || 0;
+    const outputTokens = usage.candidatesTokenCount || 0;
+    const totalTokens = usage.totalTokenCount || inputTokens + outputTokens;
+    let outputText = '';
+    let finishReason = 'unknown';
+    try {
+        outputText = response.text || '';
+    }
+    catch {
+        const candidates = response.candidates || [];
+        if (candidates[0]?.content?.parts?.[0]?.text) {
+            outputText = candidates[0].content.parts[0].text;
+        }
+    }
+    const candidates = response.candidates || [];
+    if (candidates[0]?.finishReason)
+        finishReason = candidates[0].finishReason;
+    // Extract input preview from contents
+    let inputPreview = '';
+    const contents = params.contents;
+    if (typeof contents === 'string') {
+        inputPreview = truncate(contents);
+    }
+    else if (Array.isArray(contents)) {
+        const last = contents[contents.length - 1];
+        if (typeof last === 'string')
+            inputPreview = truncate(last);
+        else if (last?.parts?.[0]?.text)
+            inputPreview = truncate(last.parts[0].text);
+    }
+    const event = {
+        kind: 'llm_call', provider: 'gemini', model,
+        durationMs: round(performance.now() - startTime),
+        inputTokens, outputTokens, totalTokens,
+        estimatedCostUsd: estimateCost(model, inputTokens, outputTokens),
+        stream: isStream, finishReason,
+        temperature: params.config?.temperature,
+        maxTokens: params.config?.maxOutputTokens,
+        systemPrompt: typeof params.config?.systemInstruction === 'string'
+            ? truncate(params.config.systemInstruction, 200) : undefined,
+        inputPreview, outputPreview: truncate(outputText),
+        messageCount: Array.isArray(contents) ? contents.length : (contents ? 1 : 0),
+        toolUse: !!(params.config?.tools?.length || params.tools?.length),
+        timestamp: Date.now(),
+    };
+    writeLlmEvent(event);
+    if (debug)
+        console.log(`[trickle/llm] Gemini: ${model} (${totalTokens} tokens, ${event.durationMs}ms)`);
+}
+function captureGeminiError(params, err, startTime, debug) {
+    const model = params.model || 'gemini-unknown';
+    writeLlmEvent({
+        kind: 'llm_call', provider: 'gemini', model,
+        durationMs: round(performance.now() - startTime),
+        inputTokens: 0, outputTokens: 0, totalTokens: 0, estimatedCostUsd: 0,
+        stream: false, finishReason: 'error',
+        temperature: params.config?.temperature,
+        maxTokens: params.config?.maxOutputTokens,
+        inputPreview: typeof params.contents === 'string' ? truncate(params.contents) : '',
+        outputPreview: '', messageCount: 0,
+        toolUse: false, timestamp: Date.now(),
+        error: truncate(err?.message || String(err), 200),
+    });
+}
+async function handleGeminiStream(stream, params, startTime, debug) {
+    if (!stream || !stream[Symbol.asyncIterator])
+        return stream;
+    const chunks = [];
+    const origIterator = stream[Symbol.asyncIterator].bind(stream);
+    let lastUsage = null;
+    stream[Symbol.asyncIterator] = function () {
+        const iter = origIterator();
+        return {
+            async next() {
+                const result = await iter.next();
+                if (!result.done) {
+                    const chunk = result.value;
+                    try {
+                        if (chunk.text)
+                            chunks.push(chunk.text);
+                    }
+                    catch { }
+                    if (chunk.usageMetadata)
+                        lastUsage = chunk.usageMetadata;
+                }
+                else {
+                    // Stream finished
+                    const model = params.model || 'gemini-unknown';
+                    const inputTokens = lastUsage?.promptTokenCount || 0;
+                    const outputTokens = lastUsage?.candidatesTokenCount || 0;
+                    writeLlmEvent({
+                        kind: 'llm_call', provider: 'gemini', model,
+                        durationMs: round(performance.now() - startTime),
+                        inputTokens, outputTokens, totalTokens: inputTokens + outputTokens,
+                        estimatedCostUsd: estimateCost(model, inputTokens, outputTokens),
+                        stream: true, finishReason: 'stop',
+                        temperature: params.config?.temperature,
+                        maxTokens: params.config?.maxOutputTokens,
+                        inputPreview: typeof params.contents === 'string' ? truncate(params.contents) : '',
+                        outputPreview: truncate(chunks.join('')),
+                        messageCount: 0, toolUse: false, timestamp: Date.now(),
+                    });
+                    if (debug)
+                        console.log(`[trickle/llm] Gemini stream: ${model} (${outputTokens} tokens)`);
+                }
+                return result;
+            },
+            return: iter.return?.bind(iter),
+            throw: iter.throw?.bind(iter),
+        };
+    };
+    return stream;
+}
+// ────────────────────────────────────────────────────
 // Helpers
 // ────────────────────────────────────────────────────
 function round(n) {

package/dist/mcp-observer.d.ts

@@ -0,0 +1,13 @@
+/**
+ * MCP tool call observer — auto-instruments MCP client and server SDKs
+ * to capture tool invocations, arguments, responses, latency, and errors.
+ *
+ * Writes to .trickle/mcp.jsonl as:
+ *   { "kind": "mcp_tool_call", "tool": "fetch", "direction": "outgoing",
+ *     "durationMs": 234.5, "args": {...}, "result": "...", ... }
+ *
+ * Zero code changes needed — intercepted via Module._load hook.
+ */
+export declare function patchMcpClient(mcpModule: any, debug: boolean): void;
+export declare function patchMcpServer(mcpModule: any, debug: boolean): void;
+export declare function initMcpObserver(): void;

package/dist/mcp-observer.js

@@ -0,0 +1,298 @@
+"use strict";
+/**
+ * MCP tool call observer — auto-instruments MCP client and server SDKs
+ * to capture tool invocations, arguments, responses, latency, and errors.
+ *
+ * Writes to .trickle/mcp.jsonl as:
+ *   { "kind": "mcp_tool_call", "tool": "fetch", "direction": "outgoing",
+ *     "durationMs": 234.5, "args": {...}, "result": "...", ... }
+ *
+ * Zero code changes needed — intercepted via Module._load hook.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.patchMcpClient = patchMcpClient;
+exports.patchMcpServer = patchMcpServer;
+exports.initMcpObserver = initMcpObserver;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+let mcpFile = null;
+let eventCount = 0;
+const MAX_MCP_EVENTS = 1000;
+const TRUNCATE_LEN = 500;
+function getMcpFile() {
+    if (mcpFile)
+        return mcpFile;
+    const dir = process.env.TRICKLE_LOCAL_DIR || path.join(process.cwd(), '.trickle');
+    try {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+    catch { }
+    mcpFile = path.join(dir, 'mcp.jsonl');
+    return mcpFile;
+}
+function writeMcpEvent(event) {
+    if (eventCount >= MAX_MCP_EVENTS)
+        return;
+    eventCount++;
+    try {
+        fs.appendFileSync(getMcpFile(), JSON.stringify(event) + '\n');
+    }
+    catch { }
+}
+function truncate(s, len = TRUNCATE_LEN) {
+    if (!s)
+        return '';
+    return s.length > len ? s.substring(0, len) + '...' : s;
+}
+function sanitizeArgs(args) {
+    if (args === null || args === undefined)
+        return null;
+    try {
+        const s = JSON.stringify(args);
+        return s.length > 1000 ? JSON.parse(s.substring(0, 1000) + '"}') : args;
+    }
+    catch {
+        return String(args).substring(0, 200);
+    }
+}
+function extractResultPreview(result) {
+    if (!result)
+        return '';
+    // MCP CallToolResult has .content array
+    if (result.content && Array.isArray(result.content)) {
+        const texts = result.content
+            .filter((c) => c.type === 'text' && c.text)
+            .map((c) => c.text);
+        return truncate(texts.join('\n'));
+    }
+    if (typeof result === 'string')
+        return truncate(result);
+    try {
+        return truncate(JSON.stringify(result));
+    }
+    catch {
+        return '';
+    }
+}
+// ────────────────────────────────────────────────────
+// Client-side: patch Client.callTool
+// ────────────────────────────────────────────────────
+function patchMcpClient(mcpModule, debug) {
+    if (!mcpModule || mcpModule.__trickle_mcp_patched)
+        return;
+    mcpModule.__trickle_mcp_patched = true;
+    // @modelcontextprotocol/sdk exports Client class
+    const ClientClass = mcpModule.Client;
+    if (!ClientClass) {
+        if (debug)
+            console.log('[trickle/mcp] Client class not found in module');
+        return;
+    }
+    // Patch callTool on the prototype
+    const proto = ClientClass.prototype;
+    if (proto.callTool && !proto.callTool.__trickle_patched) {
+        const origCallTool = proto.callTool;
+        proto.callTool = async function patchedCallTool(...args) {
+            const params = args[0] || {};
+            const toolName = typeof params === 'string' ? params : (params.name || 'unknown');
+            const toolArgs = typeof params === 'string' ? args[1] : (params.arguments || params.args);
+            const startTime = performance.now();
+            try {
+                const result = await origCallTool.apply(this, args);
+                const durationMs = Math.round((performance.now() - startTime) * 100) / 100;
+                writeMcpEvent({
+                    kind: 'mcp_tool_call', tool: toolName, direction: 'outgoing',
+                    durationMs, args: sanitizeArgs(toolArgs),
+                    resultPreview: extractResultPreview(result),
+                    isError: result?.isError || false,
+                    errorMessage: result?.isError ? extractResultPreview(result) : undefined,
+                    timestamp: Date.now(),
+                });
+                if (debug)
+                    console.log(`[trickle/mcp] callTool: ${toolName} (${durationMs}ms)`);
+                return result;
+            }
+            catch (err) {
+                const durationMs = Math.round((performance.now() - startTime) * 100) / 100;
+                writeMcpEvent({
+                    kind: 'mcp_tool_call', tool: toolName, direction: 'outgoing',
+                    durationMs, args: sanitizeArgs(toolArgs),
+                    resultPreview: '', isError: true,
+                    errorMessage: truncate(err?.message || String(err), 200),
+                    timestamp: Date.now(),
+                });
+                throw err;
+            }
+        };
+        proto.callTool.__trickle_patched = true;
+        if (debug)
+            console.log('[trickle/mcp] Patched Client.callTool');
+    }
+    // Also patch listTools for discovery
+    if (proto.listTools && !proto.listTools.__trickle_patched) {
+        const origListTools = proto.listTools;
+        proto.listTools = async function patchedListTools(...args) {
+            const startTime = performance.now();
+            const result = await origListTools.apply(this, args);
+            const durationMs = Math.round((performance.now() - startTime) * 100) / 100;
+            const toolCount = result?.tools?.length || 0;
+            writeMcpEvent({
+                kind: 'mcp_tool_call', tool: '__list_tools', direction: 'outgoing',
+                durationMs, args: null,
+                resultPreview: `${toolCount} tools available`,
+                isError: false, timestamp: Date.now(),
+            });
+            return result;
+        };
+        proto.listTools.__trickle_patched = true;
+    }
+}
+// ────────────────────────────────────────────────────
+// Server-side: patch Server to wrap tool handlers
+// ────────────────────────────────────────────────────
+function patchMcpServer(mcpModule, debug) {
+    // Server is exported from @modelcontextprotocol/sdk
+    const ServerClass = mcpModule.Server || mcpModule.McpServer;
+    if (!ServerClass || ServerClass.__trickle_mcp_server_patched)
+        return;
+    ServerClass.__trickle_mcp_server_patched = true;
+    const proto = ServerClass.prototype;
+    // Patch the .tool() registration method to wrap handlers
+    if (proto.tool && !proto.tool.__trickle_patched) {
+        const origTool = proto.tool;
+        proto.tool = function patchedTool(...args) {
+            // tool(name, schema, handler) or tool(name, handler)
+            const toolName = typeof args[0] === 'string' ? args[0] : 'unknown';
+            const lastArg = args[args.length - 1];
+            if (typeof lastArg === 'function') {
+                const originalHandler = lastArg;
+                args[args.length - 1] = async function wrappedHandler(...handlerArgs) {
+                    const startTime = performance.now();
+                    try {
+                        const result = await originalHandler.apply(this, handlerArgs);
+                        const durationMs = Math.round((performance.now() - startTime) * 100) / 100;
+                        writeMcpEvent({
+                            kind: 'mcp_tool_call', tool: toolName, direction: 'incoming',
+                            durationMs, args: sanitizeArgs(handlerArgs[0]),
+                            resultPreview: extractResultPreview(result),
+                            isError: result?.isError || false,
+                            timestamp: Date.now(),
+                        });
+                        if (debug)
+                            console.log(`[trickle/mcp] tool handler: ${toolName} (${durationMs}ms)`);
+                        return result;
+                    }
+                    catch (err) {
+                        const durationMs = Math.round((performance.now() - startTime) * 100) / 100;
+                        writeMcpEvent({
+                            kind: 'mcp_tool_call', tool: toolName, direction: 'incoming',
+                            durationMs, args: sanitizeArgs(handlerArgs[0]),
+                            resultPreview: '', isError: true,
+                            errorMessage: truncate(err?.message || String(err), 200),
+                            timestamp: Date.now(),
+                        });
+                        throw err;
+                    }
+                };
+            }
+            return origTool.apply(this, args);
+        };
+        proto.tool.__trickle_patched = true;
+        if (debug)
+            console.log('[trickle/mcp] Patched Server.tool');
+    }
+    // Patch setRequestHandler for lower-level interception
+    if (proto.setRequestHandler && !proto.setRequestHandler.__trickle_patched) {
+        const origSetHandler = proto.setRequestHandler;
+        proto.setRequestHandler = function patchedSetHandler(schema, handler) {
+            if (typeof handler === 'function') {
+                const origHandler = handler;
+                const capturedHandler = origHandler;
+                handler = async function wrappedHandler(...args) {
+                    const request = args[0];
+                    const method = request?.method || schema?.method || 'unknown';
+                    if (method === 'tools/call') {
+                        const startTime = performance.now();
+                        try {
+                            const result = await capturedHandler.apply(this, args);
+                            const durationMs = Math.round((performance.now() - startTime) * 100) / 100;
+                            writeMcpEvent({
+                                kind: 'mcp_tool_call', tool: request?.params?.name || 'unknown',
+                                direction: 'incoming', durationMs,
+                                args: sanitizeArgs(request?.params?.arguments),
+                                resultPreview: extractResultPreview(result),
+                                isError: result?.isError || false,
+                                timestamp: Date.now(),
+                            });
+                            return result;
+                        }
+                        catch (err) {
+                            const durationMs = Math.round((performance.now() - startTime) * 100) / 100;
+                            writeMcpEvent({
+                                kind: 'mcp_tool_call', tool: request?.params?.name || 'unknown',
+                                direction: 'incoming', durationMs,
+                                args: sanitizeArgs(request?.params?.arguments),
+                                resultPreview: '', isError: true,
+                                errorMessage: truncate(err?.message || String(err), 200),
+                                timestamp: Date.now(),
+                            });
+                            throw err;
+                        }
+                    }
+                    return capturedHandler.apply(this, args);
+                };
+            }
+            return origSetHandler.call(this, schema, handler);
+        };
+        proto.setRequestHandler.__trickle_patched = true;
+    }
+}
+// ────────────────────────────────────────────────────
+// Initialization
+// ────────────────────────────────────────────────────
+function initMcpObserver() {
+    const dir = process.env.TRICKLE_LOCAL_DIR || path.join(process.cwd(), '.trickle');
+    try {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+    catch { }
+    mcpFile = path.join(dir, 'mcp.jsonl');
+    try {
+        fs.writeFileSync(mcpFile, '');
+    }
+    catch { }
+    eventCount = 0;
+}

package/dist/observe-register.js

@@ -42,6 +42,7 @@ const express_1 = require("./express");
 const trace_var_1 = require("./trace-var");
 const call_trace_1 = require("./call-trace");
 const llm_observer_1 = require("./llm-observer");
+const mcp_observer_1 = require("./mcp-observer");
 const vite_plugin_1 = require("./vite-plugin");
 // ── Source map support ──
 // Lightweight VLQ decoder for mapping compiled JS lines back to original TS lines
@@ -1242,6 +1243,8 @@ if (enabled) {
     (0, call_trace_1.initCallTrace)();
     // ── Hook 0b3: Initialize LLM observer ──
     (0, llm_observer_1.initLlmObserver)();
+    // ── Hook 0b4: Initialize MCP observer ──
+    (0, mcp_observer_1.initMcpObserver)();
     // ── Hook 0c: Capture environment snapshot ──
     try {
         const envDir = process.env.TRICKLE_LOCAL_DIR || path_1.default.join(process.cwd(), '.trickle');
@@ -1552,6 +1555,32 @@ if (enabled) {
             }
             catch { /* not critical */ }
         }
+        // MCP SDK (client + server) — match any subpath import
+        if (request.includes('@modelcontextprotocol/sdk') && !expressPatched.has('mcp-client') && exports.Client) {
+            expressPatched.add('mcp-client');
+            try {
+                const { patchMcpClient } = require(path_1.default.join(__dirname, 'mcp-observer.js'));
+                patchMcpClient(exports, debug);
+            }
+            catch { /* not critical */ }
+        }
+        if (request.includes('@modelcontextprotocol/sdk') && !expressPatched.has('mcp-server') && (exports.Server || exports.McpServer)) {
+            expressPatched.add('mcp-server');
+            try {
+                const { patchMcpServer } = require(path_1.default.join(__dirname, 'mcp-observer.js'));
+                patchMcpServer(exports, debug);
+            }
+            catch { /* not critical */ }
+        }
+        // Google Gemini SDK
+        if (request === '@google/genai' && !expressPatched.has('@google/genai')) {
+            expressPatched.add('@google/genai');
+            try {
+                const { patchGemini } = require(path_1.default.join(__dirname, 'llm-observer.js'));
+                patchGemini(exports, debug);
+            }
+            catch { /* not critical */ }
+        }
         // Resolve to absolute path for dedup — do this FIRST since bundlers like
         // tsx/esbuild may use path aliases (e.g., @config/env) that don't start
         // with './' or '/'. We need the resolved path to decide if it's user code.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "trickle-observe",
-  "version": "0.2.119",
+  "version": "0.2.121",
   "description": "Runtime type observability for JavaScript applications",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/llm-observer.ts

@@ -30,6 +30,12 @@ const PRICING: Record<string, { input: number; output: number }> = {
   'claude-3-5-sonnet-20241022': { input: 3, output: 15 },
   'claude-3-5-haiku-20241022': { input: 0.8, output: 4 },
   'claude-3-haiku-20240307': { input: 0.25, output: 1.25 },
+  'gemini-2.5-flash-lite': { input: 0.1, output: 0.4 },
+  'gemini-2.5-flash': { input: 0.3, output: 2.5 },
+  'gemini-2.5-pro': { input: 1.25, output: 10 },
+  'gemini-2.0-flash': { input: 0.1, output: 0.4 },
+  'gemini-1.5-flash': { input: 0.075, output: 0.3 },
+  'gemini-1.5-pro': { input: 1.25, output: 5 },
 };
 
 function getLlmFile(): string {
@@ -480,6 +486,217 @@ function captureAnthropicError(params: any, err: any, startTime: number, debug:
   });
 }
 
+// ────────────────────────────────────────────────────
+// Google Gemini SDK instrumentation (@google/genai)
+// ────────────────────────────────────────────────────
+
+export function patchGemini(geminiModule: any, debug: boolean): void {
+  if (!geminiModule || getattr(geminiModule, '_trickle_llm_patched')) return;
+  setattr(geminiModule, '_trickle_llm_patched', true);
+
+  // @google/genai exports GoogleGenAI class
+  // Usage: const ai = new GoogleGenAI({ apiKey }); ai.models.generateContent({...})
+  const GoogleGenAI = geminiModule.GoogleGenAI || geminiModule.default?.GoogleGenAI;
+  if (typeof GoogleGenAI !== 'function') {
+    if (debug) console.log('[trickle/llm] Gemini: GoogleGenAI class not found');
+    return;
+  }
+
+  try {
+    // GoogleGenAI creates models as own property in the constructor.
+    // Patch the GoogleGenAI constructor to wrap generateContent after creation.
+    const origGoogleGenAIInit = GoogleGenAI.prototype.constructor;
+
+    // Use a post-construction hook: after new GoogleGenAI() creates the instance
+    // with models.generateContent as an own property, wrap that method.
+    const tmpClient = new GoogleGenAI({ apiKey: 'trickle-probe' });
+    const ModelsClass = Object.getPrototypeOf(tmpClient.models)?.constructor;
+
+    if (ModelsClass) {
+      const origModelsInit = ModelsClass;
+      // Patch the Models constructor to wrap generateContent after instance creation
+      const origConstruct = ModelsClass.prototype.constructor;
+
+      // We can't replace the ES6 class constructor, so instead we use a
+      // post-construction approach: hook into GoogleGenAI's prototype to
+      // patch models on each new client instance.
+      const origGAIProto = GoogleGenAI.prototype;
+      const origInitDescriptors = Object.getOwnPropertyDescriptors(origGAIProto);
+
+      // Define a lazy wrapper: first time models.generateContent is called,
+      // install the instrumentation wrapper
+      function wrapModelsInstance(models: any): void {
+        if (!models || models.__trickle_patched) return;
+        models.__trickle_patched = true;
+
+        if (typeof models.generateContent === 'function') {
+          const origGenerate = models.generateContent.bind(models);
+          models.generateContent = function patchedGenerateContent(...args: any[]) {
+            const params = args[0] || {};
+            const startTime = performance.now();
+            const result = origGenerate(...args);
+            if (result && typeof result.then === 'function') {
+              return result.then((response: any) => {
+                captureGeminiResponse(params, response, startTime, false, debug);
+                return response;
+              }).catch((err: any) => {
+                captureGeminiError(params, err, startTime, debug);
+                throw err;
+              });
+            }
+            return result;
+          };
+        }
+
+        if (typeof models.generateContentStream === 'function') {
+          const origStream = models.generateContentStream.bind(models);
+          models.generateContentStream = function patchedStream(...args: any[]) {
+            const params = args[0] || {};
+            const startTime = performance.now();
+            const result = origStream(...args);
+            if (result && typeof result.then === 'function') {
+              return result.then((stream: any) => handleGeminiStream(stream, params, startTime, debug));
+            }
+            return result;
+          };
+        }
+      }
+
+      // Intercept the GoogleGenAI constructor to patch each instance's models
+      // Since we can't replace ES6 class constructors, we use a Proxy
+      const proxyHandler: ProxyHandler<any> = {
+        construct(target: any, args: any[], newTarget: any): object {
+          const instance = Reflect.construct(target, args, newTarget) as any;
+          if (instance.models) wrapModelsInstance(instance.models);
+          return instance as object;
+        }
+      };
+      const ProxiedGoogleGenAI = new Proxy(GoogleGenAI, proxyHandler);
+
+      // Replace on the module (try both export styles)
+      try { geminiModule.GoogleGenAI = ProxiedGoogleGenAI; } catch {}
+      try { if (geminiModule.default?.GoogleGenAI) geminiModule.default.GoogleGenAI = ProxiedGoogleGenAI; } catch {}
+
+      // Also patch the already-created probe instance (in case someone imported before us)
+      // This is a no-op since the probe is discarded.
+
+      if (debug) console.log('[trickle/llm] Patched Gemini SDK');
+    }
+  } catch (e: any) {
+    if (debug) console.log('[trickle/llm] Gemini patch probe failed:', e.message);
+  }
+}
+
+function captureGeminiResponse(params: any, response: any, startTime: number, isStream: boolean, debug: boolean): void {
+  const usage = response.usageMetadata || {};
+  const model = params.model || 'gemini-unknown';
+  const inputTokens = usage.promptTokenCount || 0;
+  const outputTokens = usage.candidatesTokenCount || 0;
+  const totalTokens = usage.totalTokenCount || inputTokens + outputTokens;
+
+  let outputText = '';
+  let finishReason = 'unknown';
+  try {
+    outputText = response.text || '';
+  } catch {
+    const candidates = response.candidates || [];
+    if (candidates[0]?.content?.parts?.[0]?.text) {
+      outputText = candidates[0].content.parts[0].text;
+    }
+  }
+  const candidates = response.candidates || [];
+  if (candidates[0]?.finishReason) finishReason = candidates[0].finishReason;
+
+  // Extract input preview from contents
+  let inputPreview = '';
+  const contents = params.contents;
+  if (typeof contents === 'string') {
+    inputPreview = truncate(contents);
+  } else if (Array.isArray(contents)) {
+    const last = contents[contents.length - 1];
+    if (typeof last === 'string') inputPreview = truncate(last);
+    else if (last?.parts?.[0]?.text) inputPreview = truncate(last.parts[0].text);
+  }
+
+  const event: LlmEvent = {
+    kind: 'llm_call', provider: 'gemini', model,
+    durationMs: round(performance.now() - startTime),
+    inputTokens, outputTokens, totalTokens,
+    estimatedCostUsd: estimateCost(model, inputTokens, outputTokens),
+    stream: isStream, finishReason,
+    temperature: params.config?.temperature,
+    maxTokens: params.config?.maxOutputTokens,
+    systemPrompt: typeof params.config?.systemInstruction === 'string'
+      ? truncate(params.config.systemInstruction, 200) : undefined,
+    inputPreview, outputPreview: truncate(outputText),
+    messageCount: Array.isArray(contents) ? contents.length : (contents ? 1 : 0),
+    toolUse: !!(params.config?.tools?.length || params.tools?.length),
+    timestamp: Date.now(),
+  };
+  writeLlmEvent(event);
+  if (debug) console.log(`[trickle/llm] Gemini: ${model} (${totalTokens} tokens, ${event.durationMs}ms)`);
+}
+
+function captureGeminiError(params: any, err: any, startTime: number, debug: boolean): void {
+  const model = params.model || 'gemini-unknown';
+  writeLlmEvent({
+    kind: 'llm_call', provider: 'gemini', model,
+    durationMs: round(performance.now() - startTime),
+    inputTokens: 0, outputTokens: 0, totalTokens: 0, estimatedCostUsd: 0,
+    stream: false, finishReason: 'error',
+    temperature: params.config?.temperature,
+    maxTokens: params.config?.maxOutputTokens,
+    inputPreview: typeof params.contents === 'string' ? truncate(params.contents) : '',
+    outputPreview: '', messageCount: 0,
+    toolUse: false, timestamp: Date.now(),
+    error: truncate(err?.message || String(err), 200),
+  });
+}
+
+async function handleGeminiStream(stream: any, params: any, startTime: number, debug: boolean): Promise<any> {
+  if (!stream || !stream[Symbol.asyncIterator]) return stream;
+
+  const chunks: string[] = [];
+  const origIterator = stream[Symbol.asyncIterator].bind(stream);
+  let lastUsage: any = null;
+
+  stream[Symbol.asyncIterator] = function () {
+    const iter = origIterator();
+    return {
+      async next() {
+        const result = await iter.next();
+        if (!result.done) {
+          const chunk = result.value;
+          try { if (chunk.text) chunks.push(chunk.text); } catch {}
+          if (chunk.usageMetadata) lastUsage = chunk.usageMetadata;
+        } else {
+          // Stream finished
+          const model = params.model || 'gemini-unknown';
+          const inputTokens = lastUsage?.promptTokenCount || 0;
+          const outputTokens = lastUsage?.candidatesTokenCount || 0;
+          writeLlmEvent({
+            kind: 'llm_call', provider: 'gemini', model,
+            durationMs: round(performance.now() - startTime),
+            inputTokens, outputTokens, totalTokens: inputTokens + outputTokens,
+            estimatedCostUsd: estimateCost(model, inputTokens, outputTokens),
+            stream: true, finishReason: 'stop',
+            temperature: params.config?.temperature,
+            maxTokens: params.config?.maxOutputTokens,
+            inputPreview: typeof params.contents === 'string' ? truncate(params.contents) : '',
+            outputPreview: truncate(chunks.join('')),
+            messageCount: 0, toolUse: false, timestamp: Date.now(),
+          });
+          if (debug) console.log(`[trickle/llm] Gemini stream: ${model} (${outputTokens} tokens)`);
+        }
+        return result;
+      },
+      return: iter.return?.bind(iter),
+      throw: iter.throw?.bind(iter),
+    };
+  };
+  return stream;
+}
+
 // ────────────────────────────────────────────────────
 // Helpers
 // ────────────────────────────────────────────────────

package/src/mcp-observer.ts

@@ -0,0 +1,260 @@
+/**
+ * MCP tool call observer — auto-instruments MCP client and server SDKs
+ * to capture tool invocations, arguments, responses, latency, and errors.
+ *
+ * Writes to .trickle/mcp.jsonl as:
+ *   { "kind": "mcp_tool_call", "tool": "fetch", "direction": "outgoing",
+ *     "durationMs": 234.5, "args": {...}, "result": "...", ... }
+ *
+ * Zero code changes needed — intercepted via Module._load hook.
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+
+let mcpFile: string | null = null;
+let eventCount = 0;
+const MAX_MCP_EVENTS = 1000;
+const TRUNCATE_LEN = 500;
+
+function getMcpFile(): string {
+  if (mcpFile) return mcpFile;
+  const dir = process.env.TRICKLE_LOCAL_DIR || path.join(process.cwd(), '.trickle');
+  try { fs.mkdirSync(dir, { recursive: true }); } catch {}
+  mcpFile = path.join(dir, 'mcp.jsonl');
+  return mcpFile;
+}
+
+interface McpEvent {
+  kind: 'mcp_tool_call';
+  tool: string;
+  direction: 'outgoing' | 'incoming';
+  durationMs: number;
+  args: unknown;
+  resultPreview: string;
+  isError: boolean;
+  errorMessage?: string;
+  timestamp: number;
+}
+
+function writeMcpEvent(event: McpEvent): void {
+  if (eventCount >= MAX_MCP_EVENTS) return;
+  eventCount++;
+  try {
+    fs.appendFileSync(getMcpFile(), JSON.stringify(event) + '\n');
+  } catch {}
+}
+
+function truncate(s: string, len = TRUNCATE_LEN): string {
+  if (!s) return '';
+  return s.length > len ? s.substring(0, len) + '...' : s;
+}
+
+function sanitizeArgs(args: unknown): unknown {
+  if (args === null || args === undefined) return null;
+  try {
+    const s = JSON.stringify(args);
+    return s.length > 1000 ? JSON.parse(s.substring(0, 1000) + '"}') : args;
+  } catch { return String(args).substring(0, 200); }
+}
+
+function extractResultPreview(result: any): string {
+  if (!result) return '';
+  // MCP CallToolResult has .content array
+  if (result.content && Array.isArray(result.content)) {
+    const texts = result.content
+      .filter((c: any) => c.type === 'text' && c.text)
+      .map((c: any) => c.text);
+    return truncate(texts.join('\n'));
+  }
+  if (typeof result === 'string') return truncate(result);
+  try { return truncate(JSON.stringify(result)); } catch { return ''; }
+}
+
+// ────────────────────────────────────────────────────
+// Client-side: patch Client.callTool
+// ────────────────────────────────────────────────────
+
+export function patchMcpClient(mcpModule: any, debug: boolean): void {
+  if (!mcpModule || mcpModule.__trickle_mcp_patched) return;
+  mcpModule.__trickle_mcp_patched = true;
+
+  // @modelcontextprotocol/sdk exports Client class
+  const ClientClass = mcpModule.Client;
+  if (!ClientClass) {
+    if (debug) console.log('[trickle/mcp] Client class not found in module');
+    return;
+  }
+
+  // Patch callTool on the prototype
+  const proto = ClientClass.prototype;
+  if (proto.callTool && !proto.callTool.__trickle_patched) {
+    const origCallTool = proto.callTool;
+    proto.callTool = async function patchedCallTool(this: any, ...args: any[]) {
+      const params = args[0] || {};
+      const toolName = typeof params === 'string' ? params : (params.name || 'unknown');
+      const toolArgs = typeof params === 'string' ? args[1] : (params.arguments || params.args);
+      const startTime = performance.now();
+
+      try {
+        const result = await origCallTool.apply(this, args);
+        const durationMs = Math.round((performance.now() - startTime) * 100) / 100;
+        writeMcpEvent({
+          kind: 'mcp_tool_call', tool: toolName, direction: 'outgoing',
+          durationMs, args: sanitizeArgs(toolArgs),
+          resultPreview: extractResultPreview(result),
+          isError: result?.isError || false,
+          errorMessage: result?.isError ? extractResultPreview(result) : undefined,
+          timestamp: Date.now(),
+        });
+        if (debug) console.log(`[trickle/mcp] callTool: ${toolName} (${durationMs}ms)`);
+        return result;
+      } catch (err: any) {
+        const durationMs = Math.round((performance.now() - startTime) * 100) / 100;
+        writeMcpEvent({
+          kind: 'mcp_tool_call', tool: toolName, direction: 'outgoing',
+          durationMs, args: sanitizeArgs(toolArgs),
+          resultPreview: '', isError: true,
+          errorMessage: truncate(err?.message || String(err), 200),
+          timestamp: Date.now(),
+        });
+        throw err;
+      }
+    };
+    proto.callTool.__trickle_patched = true;
+    if (debug) console.log('[trickle/mcp] Patched Client.callTool');
+  }
+
+  // Also patch listTools for discovery
+  if (proto.listTools && !proto.listTools.__trickle_patched) {
+    const origListTools = proto.listTools;
+    proto.listTools = async function patchedListTools(this: any, ...args: any[]) {
+      const startTime = performance.now();
+      const result = await origListTools.apply(this, args);
+      const durationMs = Math.round((performance.now() - startTime) * 100) / 100;
+      const toolCount = result?.tools?.length || 0;
+      writeMcpEvent({
+        kind: 'mcp_tool_call', tool: '__list_tools', direction: 'outgoing',
+        durationMs, args: null,
+        resultPreview: `${toolCount} tools available`,
+        isError: false, timestamp: Date.now(),
+      });
+      return result;
+    };
+    proto.listTools.__trickle_patched = true;
+  }
+}
+
+// ────────────────────────────────────────────────────
+// Server-side: patch Server to wrap tool handlers
+// ────────────────────────────────────────────────────
+
+export function patchMcpServer(mcpModule: any, debug: boolean): void {
+  // Server is exported from @modelcontextprotocol/sdk
+  const ServerClass = mcpModule.Server || mcpModule.McpServer;
+  if (!ServerClass || ServerClass.__trickle_mcp_server_patched) return;
+  ServerClass.__trickle_mcp_server_patched = true;
+
+  const proto = ServerClass.prototype;
+
+  // Patch the .tool() registration method to wrap handlers
+  if (proto.tool && !proto.tool.__trickle_patched) {
+    const origTool = proto.tool;
+    proto.tool = function patchedTool(this: any, ...args: any[]) {
+      // tool(name, schema, handler) or tool(name, handler)
+      const toolName = typeof args[0] === 'string' ? args[0] : 'unknown';
+      const lastArg = args[args.length - 1];
+
+      if (typeof lastArg === 'function') {
+        const originalHandler = lastArg;
+        args[args.length - 1] = async function wrappedHandler(...handlerArgs: any[]) {
+          const startTime = performance.now();
+          try {
+            const result = await originalHandler.apply(this, handlerArgs);
+            const durationMs = Math.round((performance.now() - startTime) * 100) / 100;
+            writeMcpEvent({
+              kind: 'mcp_tool_call', tool: toolName, direction: 'incoming',
+              durationMs, args: sanitizeArgs(handlerArgs[0]),
+              resultPreview: extractResultPreview(result),
+              isError: result?.isError || false,
+              timestamp: Date.now(),
+            });
+            if (debug) console.log(`[trickle/mcp] tool handler: ${toolName} (${durationMs}ms)`);
+            return result;
+          } catch (err: any) {
+            const durationMs = Math.round((performance.now() - startTime) * 100) / 100;
+            writeMcpEvent({
+              kind: 'mcp_tool_call', tool: toolName, direction: 'incoming',
+              durationMs, args: sanitizeArgs(handlerArgs[0]),
+              resultPreview: '', isError: true,
+              errorMessage: truncate(err?.message || String(err), 200),
+              timestamp: Date.now(),
+            });
+            throw err;
+          }
+        };
+      }
+
+      return origTool.apply(this, args);
+    };
+    proto.tool.__trickle_patched = true;
+    if (debug) console.log('[trickle/mcp] Patched Server.tool');
+  }
+
+  // Patch setRequestHandler for lower-level interception
+  if (proto.setRequestHandler && !proto.setRequestHandler.__trickle_patched) {
+    const origSetHandler = proto.setRequestHandler;
+    proto.setRequestHandler = function patchedSetHandler(this: any, schema: any, handler: any) {
+      if (typeof handler === 'function') {
+        const origHandler = handler;
+        const capturedHandler = origHandler;
+        handler = async function wrappedHandler(this: any, ...args: any[]) {
+          const request = args[0];
+          const method = request?.method || schema?.method || 'unknown';
+          if (method === 'tools/call') {
+            const startTime = performance.now();
+            try {
+              const result = await capturedHandler.apply(this, args);
+              const durationMs = Math.round((performance.now() - startTime) * 100) / 100;
+              writeMcpEvent({
+                kind: 'mcp_tool_call', tool: request?.params?.name || 'unknown',
+                direction: 'incoming', durationMs,
+                args: sanitizeArgs(request?.params?.arguments),
+                resultPreview: extractResultPreview(result),
+                isError: result?.isError || false,
+                timestamp: Date.now(),
+              });
+              return result;
+            } catch (err: any) {
+              const durationMs = Math.round((performance.now() - startTime) * 100) / 100;
+              writeMcpEvent({
+                kind: 'mcp_tool_call', tool: request?.params?.name || 'unknown',
+                direction: 'incoming', durationMs,
+                args: sanitizeArgs(request?.params?.arguments),
+                resultPreview: '', isError: true,
+                errorMessage: truncate(err?.message || String(err), 200),
+                timestamp: Date.now(),
+              });
+              throw err;
+            }
+          }
+          return capturedHandler.apply(this, args);
+        };
+      }
+      return origSetHandler.call(this, schema, handler);
+    };
+    proto.setRequestHandler.__trickle_patched = true;
+  }
+}
+
+// ────────────────────────────────────────────────────
+// Initialization
+// ────────────────────────────────────────────────────
+
+export function initMcpObserver(): void {
+  const dir = process.env.TRICKLE_LOCAL_DIR || path.join(process.cwd(), '.trickle');
+  try { fs.mkdirSync(dir, { recursive: true }); } catch {}
+  mcpFile = path.join(dir, 'mcp.jsonl');
+  try { fs.writeFileSync(mcpFile, ''); } catch {}
+  eventCount = 0;
+}

package/src/observe-register.ts

@@ -39,6 +39,7 @@ import { instrumentExpress, trickleMiddleware } from './express';
 import { initVarTracer, traceVar } from './trace-var';
 import { initCallTrace } from './call-trace';
 import { initLlmObserver } from './llm-observer';
+import { initMcpObserver } from './mcp-observer';
 import {
   findReassignments,
   findForLoopVars,
@@ -1231,6 +1232,9 @@ if (enabled) {
   // ── Hook 0b3: Initialize LLM observer ──
   initLlmObserver();
 
+  // ── Hook 0b4: Initialize MCP observer ──
+  initMcpObserver();
+
   // ── Hook 0c: Capture environment snapshot ──
   try {
     const envDir = process.env.TRICKLE_LOCAL_DIR || path.join(process.cwd(), '.trickle');
@@ -1537,6 +1541,31 @@ if (enabled) {
       } catch { /* not critical */ }
     }
 
+    // MCP SDK (client + server) — match any subpath import
+    if (request.includes('@modelcontextprotocol/sdk') && !expressPatched.has('mcp-client') && exports.Client) {
+      expressPatched.add('mcp-client');
+      try {
+        const { patchMcpClient } = require(path.join(__dirname, 'mcp-observer.js'));
+        patchMcpClient(exports, debug);
+      } catch { /* not critical */ }
+    }
+    if (request.includes('@modelcontextprotocol/sdk') && !expressPatched.has('mcp-server') && (exports.Server || exports.McpServer)) {
+      expressPatched.add('mcp-server');
+      try {
+        const { patchMcpServer } = require(path.join(__dirname, 'mcp-observer.js'));
+        patchMcpServer(exports, debug);
+      } catch { /* not critical */ }
+    }
+
+    // Google Gemini SDK
+    if (request === '@google/genai' && !expressPatched.has('@google/genai')) {
+      expressPatched.add('@google/genai');
+      try {
+        const { patchGemini } = require(path.join(__dirname, 'llm-observer.js'));
+        patchGemini(exports, debug);
+      } catch { /* not critical */ }
+    }
+
     // Resolve to absolute path for dedup — do this FIRST since bundlers like
     // tsx/esbuild may use path aliases (e.g., @config/env) that don't start
     // with './' or '/'. We need the resolved path to decide if it's user code.