trickle-observe 0.2.117 → 0.2.118

package/dist/llm-observer.d.ts

@@ -0,0 +1,17 @@
+/**
+ * LLM call observer — auto-instruments OpenAI, Anthropic, and other LLM SDKs
+ * to capture prompts, completions, token counts, latency, cost, and model metadata.
+ *
+ * Writes to .trickle/llm.jsonl as:
+ *   { "kind": "llm_call", "provider": "openai", "model": "gpt-4",
+ *     "inputTokens": 100, "outputTokens": 50, "durationMs": 1234.5, ... }
+ *
+ * Supports both streaming and non-streaming calls.
+ * Zero code changes needed — intercepted via Module._load hook.
+ */
+export declare function patchOpenAI(openaiModule: any, debug: boolean): void;
+export declare function patchAnthropic(anthropicModule: any, debug: boolean): void;
+/**
+ * Initialize the LLM observer — clears previous data file.
+ */
+export declare function initLlmObserver(): void;

package/dist/llm-observer.js

@@ -0,0 +1,526 @@
+"use strict";
+/**
+ * LLM call observer — auto-instruments OpenAI, Anthropic, and other LLM SDKs
+ * to capture prompts, completions, token counts, latency, cost, and model metadata.
+ *
+ * Writes to .trickle/llm.jsonl as:
+ *   { "kind": "llm_call", "provider": "openai", "model": "gpt-4",
+ *     "inputTokens": 100, "outputTokens": 50, "durationMs": 1234.5, ... }
+ *
+ * Supports both streaming and non-streaming calls.
+ * 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.patchOpenAI = patchOpenAI;
+exports.patchAnthropic = patchAnthropic;
+exports.initLlmObserver = initLlmObserver;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+let llmFile = null;
+let eventCount = 0;
+const MAX_LLM_EVENTS = 500;
+const TRUNCATE_LEN = 500;
+// Approximate pricing per 1M tokens (USD) — used for cost estimation
+const PRICING = {
+    'gpt-4o': { input: 2.5, output: 10 },
+    'gpt-4o-mini': { input: 0.15, output: 0.6 },
+    'gpt-4-turbo': { input: 10, output: 30 },
+    'gpt-4': { input: 30, output: 60 },
+    'gpt-3.5-turbo': { input: 0.5, output: 1.5 },
+    'claude-opus-4-20250514': { input: 15, output: 75 },
+    'claude-sonnet-4-20250514': { input: 3, output: 15 },
+    '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 },
+};
+function getLlmFile() {
+    if (llmFile)
+        return llmFile;
+    const dir = process.env.TRICKLE_LOCAL_DIR || path.join(process.cwd(), '.trickle');
+    try {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+    catch { }
+    llmFile = path.join(dir, 'llm.jsonl');
+    return llmFile;
+}
+function writeLlmEvent(event) {
+    if (eventCount >= MAX_LLM_EVENTS)
+        return;
+    eventCount++;
+    try {
+        fs.appendFileSync(getLlmFile(), JSON.stringify(event) + '\n');
+    }
+    catch { }
+}
+function truncate(s, len = TRUNCATE_LEN) {
+    if (!s)
+        return '';
+    return s.length > len ? s.substring(0, len) + '...' : s;
+}
+function estimateCost(model, inputTokens, outputTokens) {
+    // Find best matching pricing key
+    const key = Object.keys(PRICING).find(k => model.includes(k)) || '';
+    if (!key)
+        return 0;
+    const p = PRICING[key];
+    return Math.round(((inputTokens * p.input + outputTokens * p.output) / 1_000_000) * 1_000_000) / 1_000_000;
+}
+function extractInputPreview(messages) {
+    if (!Array.isArray(messages) || messages.length === 0)
+        return '';
+    const last = messages[messages.length - 1];
+    if (typeof last?.content === 'string')
+        return truncate(last.content);
+    if (Array.isArray(last?.content)) {
+        const textPart = last.content.find((p) => p.type === 'text');
+        if (textPart?.text)
+            return truncate(textPart.text);
+    }
+    return '';
+}
+function extractSystemPrompt(messages) {
+    if (!Array.isArray(messages))
+        return undefined;
+    const sys = messages.find((m) => m.role === 'system');
+    if (sys?.content && typeof sys.content === 'string')
+        return truncate(sys.content, 200);
+    return undefined;
+}
+function hasToolUse(params) {
+    return !!(params.tools && Array.isArray(params.tools) && params.tools.length > 0);
+}
+// ────────────────────────────────────────────────────
+// OpenAI SDK v4+ instrumentation
+// ────────────────────────────────────────────────────
+function patchOpenAI(openaiModule, debug) {
+    if (!openaiModule || getattr(openaiModule, '_trickle_llm_patched'))
+        return;
+    setattr(openaiModule, '_trickle_llm_patched', true);
+    const OpenAIClass = openaiModule.OpenAI || openaiModule.default;
+    if (typeof OpenAIClass !== 'function')
+        return;
+    // OpenAI SDK v4+ creates resource instances (chat, completions) in the constructor
+    // as own properties. The Completions class is not directly exported, but we can
+    // access it by creating a temporary client and getting the prototype of chat.completions.
+    try {
+        // Create a temporary client to discover the Completions class
+        // (ES6 classes require `new`, can't use .call())
+        const tmpClient = new OpenAIClass({ apiKey: 'trickle-probe' });
+        const CompletionsClass = Object.getPrototypeOf(tmpClient.chat?.completions)?.constructor;
+        if (CompletionsClass && CompletionsClass.prototype.create && !CompletionsClass.prototype.create.__trickle_patched) {
+            const origCreate = CompletionsClass.prototype.create;
+            CompletionsClass.prototype.create = function patchedCreate(...args) {
+                const params = args[0] || {};
+                const startTime = performance.now();
+                const isStream = !!params.stream;
+                const result = origCreate.apply(this, args);
+                if (isStream)
+                    return handleOpenAIStream(result, params, startTime, debug);
+                if (result && typeof result.then === 'function') {
+                    return result.then((response) => {
+                        captureOpenAIResponse(params, response, startTime, debug);
+                        return response;
+                    }).catch((err) => {
+                        captureOpenAIError(params, err, startTime, debug);
+                        throw err;
+                    });
+                }
+                return result;
+            };
+            CompletionsClass.prototype.create.__trickle_patched = true;
+            if (debug)
+                console.log('[trickle/llm] Patched OpenAI SDK');
+            return;
+        }
+    }
+    catch (e) {
+        if (debug)
+            console.log('[trickle/llm] OpenAI patch probe failed:', e.message);
+    }
+}
+function patchOpenAIClient(client, debug) {
+    // Patch chat.completions.create
+    if (client.chat?.completions?.create && !client.chat.completions.create.__trickle_patched) {
+        const origCreate = client.chat.completions.create.bind(client.chat.completions);
+        client.chat.completions.create = function patchedCreate(...args) {
+            const params = args[0] || {};
+            const startTime = performance.now();
+            const isStream = !!params.stream;
+            const result = origCreate(...args);
+            if (isStream) {
+                return handleOpenAIStream(result, params, startTime, debug);
+            }
+            // Non-streaming: hook the promise
+            if (result && typeof result.then === 'function') {
+                return result.then((response) => {
+                    captureOpenAIResponse(params, response, startTime, debug);
+                    return response;
+                }).catch((err) => {
+                    captureOpenAIError(params, err, startTime, debug);
+                    throw err;
+                });
+            }
+            return result;
+        };
+        client.chat.completions.create.__trickle_patched = true;
+    }
+    // Patch completions.create (legacy)
+    if (client.completions?.create && !client.completions.create.__trickle_patched) {
+        const origCreate = client.completions.create.bind(client.completions);
+        client.completions.create = function patchedCreate(...args) {
+            const params = args[0] || {};
+            const startTime = performance.now();
+            const result = origCreate(...args);
+            if (result && typeof result.then === 'function') {
+                return result.then((response) => {
+                    const usage = response.usage || {};
+                    const text = response.choices?.[0]?.text || '';
+                    writeLlmEvent({
+                        kind: 'llm_call', provider: 'openai', model: params.model || 'unknown',
+                        durationMs: round(performance.now() - startTime),
+                        inputTokens: usage.prompt_tokens || 0, outputTokens: usage.completion_tokens || 0,
+                        totalTokens: usage.total_tokens || 0,
+                        estimatedCostUsd: estimateCost(params.model || '', usage.prompt_tokens || 0, usage.completion_tokens || 0),
+                        stream: false, finishReason: response.choices?.[0]?.finish_reason || 'unknown',
+                        temperature: params.temperature, maxTokens: params.max_tokens,
+                        inputPreview: truncate(params.prompt || ''), outputPreview: truncate(text),
+                        messageCount: 0, toolUse: false, timestamp: Date.now(),
+                    });
+                    return response;
+                });
+            }
+            return result;
+        };
+        client.completions.create.__trickle_patched = true;
+    }
+}
+async function handleOpenAIStream(resultPromise, params, startTime, debug) {
+    const stream = await resultPromise;
+    const chunks = [];
+    let finishReason = 'unknown';
+    let totalInputTokens = 0;
+    let totalOutputTokens = 0;
+    // Wrap the async iterator
+    const origIterator = stream[Symbol.asyncIterator].bind(stream);
+    stream[Symbol.asyncIterator] = function () {
+        const iter = origIterator();
+        return {
+            async next() {
+                const result = await iter.next();
+                if (!result.done) {
+                    const chunk = result.value;
+                    const delta = chunk.choices?.[0]?.delta;
+                    if (delta?.content)
+                        chunks.push(delta.content);
+                    if (chunk.choices?.[0]?.finish_reason)
+                        finishReason = chunk.choices[0].finish_reason;
+                    if (chunk.usage) {
+                        totalInputTokens = chunk.usage.prompt_tokens || totalInputTokens;
+                        totalOutputTokens = chunk.usage.completion_tokens || totalOutputTokens;
+                    }
+                }
+                else {
+                    // Stream finished — capture
+                    const outputText = chunks.join('');
+                    writeLlmEvent({
+                        kind: 'llm_call', provider: 'openai', model: params.model || 'unknown',
+                        durationMs: round(performance.now() - startTime),
+                        inputTokens: totalInputTokens, outputTokens: totalOutputTokens,
+                        totalTokens: totalInputTokens + totalOutputTokens,
+                        estimatedCostUsd: estimateCost(params.model || '', totalInputTokens, totalOutputTokens),
+                        stream: true, finishReason,
+                        temperature: params.temperature, maxTokens: params.max_tokens,
+                        systemPrompt: extractSystemPrompt(params.messages),
+                        inputPreview: extractInputPreview(params.messages),
+                        outputPreview: truncate(outputText),
+                        messageCount: params.messages?.length || 0,
+                        toolUse: hasToolUse(params), timestamp: Date.now(),
+                    });
+                    if (debug)
+                        console.log(`[trickle/llm] OpenAI stream: ${params.model} (${totalOutputTokens} tokens)`);
+                }
+                return result;
+            },
+            return: iter.return?.bind(iter),
+            throw: iter.throw?.bind(iter),
+        };
+    };
+    return stream;
+}
+function captureOpenAIResponse(params, response, startTime, debug) {
+    const usage = response.usage || {};
+    const outputText = response.choices?.[0]?.message?.content || '';
+    const event = {
+        kind: 'llm_call', provider: 'openai', model: params.model || 'unknown',
+        durationMs: round(performance.now() - startTime),
+        inputTokens: usage.prompt_tokens || 0, outputTokens: usage.completion_tokens || 0,
+        totalTokens: usage.total_tokens || 0,
+        estimatedCostUsd: estimateCost(params.model || '', usage.prompt_tokens || 0, usage.completion_tokens || 0),
+        stream: false, finishReason: response.choices?.[0]?.finish_reason || 'unknown',
+        temperature: params.temperature, maxTokens: params.max_tokens,
+        systemPrompt: extractSystemPrompt(params.messages),
+        inputPreview: extractInputPreview(params.messages),
+        outputPreview: truncate(outputText),
+        messageCount: params.messages?.length || 0,
+        toolUse: hasToolUse(params), timestamp: Date.now(),
+    };
+    writeLlmEvent(event);
+    if (debug)
+        console.log(`[trickle/llm] OpenAI: ${params.model} (${usage.total_tokens || 0} tokens, ${event.durationMs}ms)`);
+}
+function captureOpenAIError(params, err, startTime, debug) {
+    writeLlmEvent({
+        kind: 'llm_call', provider: 'openai', model: params.model || 'unknown',
+        durationMs: round(performance.now() - startTime),
+        inputTokens: 0, outputTokens: 0, totalTokens: 0, estimatedCostUsd: 0,
+        stream: !!params.stream, finishReason: 'error',
+        temperature: params.temperature, maxTokens: params.max_tokens,
+        systemPrompt: extractSystemPrompt(params.messages),
+        inputPreview: extractInputPreview(params.messages),
+        outputPreview: '', messageCount: params.messages?.length || 0,
+        toolUse: hasToolUse(params), timestamp: Date.now(),
+        error: truncate(err?.message || String(err), 200),
+    });
+}
+// ────────────────────────────────────────────────────
+// Anthropic SDK instrumentation
+// ────────────────────────────────────────────────────
+function patchAnthropic(anthropicModule, debug) {
+    if (!anthropicModule || getattr(anthropicModule, '_trickle_llm_patched'))
+        return;
+    setattr(anthropicModule, '_trickle_llm_patched', true);
+    const AnthropicClass = anthropicModule.Anthropic || anthropicModule.default;
+    if (typeof AnthropicClass !== 'function')
+        return;
+    try {
+        const tmpClient = new AnthropicClass({ apiKey: 'trickle-probe' });
+        const MessagesClass = Object.getPrototypeOf(tmpClient.messages)?.constructor;
+        if (MessagesClass && MessagesClass.prototype.create && !MessagesClass.prototype.create.__trickle_patched) {
+            const origCreate = MessagesClass.prototype.create;
+            MessagesClass.prototype.create = function patchedCreate(...args) {
+                const params = args[0] || {};
+                const startTime = performance.now();
+                const isStream = !!params.stream;
+                const result = origCreate.apply(this, args);
+                if (result && typeof result.then === 'function') {
+                    return result.then((response) => {
+                        if (isStream)
+                            return handleAnthropicStream(response, params, startTime, debug);
+                        captureAnthropicResponse(params, response, startTime, debug);
+                        return response;
+                    }).catch((err) => {
+                        captureAnthropicError(params, err, startTime, debug);
+                        throw err;
+                    });
+                }
+                return result;
+            };
+            MessagesClass.prototype.create.__trickle_patched = true;
+            if (debug)
+                console.log('[trickle/llm] Patched Anthropic SDK');
+            return;
+        }
+    }
+    catch (e) {
+        if (debug)
+            console.log('[trickle/llm] Anthropic patch probe failed:', e.message);
+    }
+}
+function patchAnthropicClient(client, debug) {
+    // Patch messages.create
+    if (client.messages?.create && !client.messages.create.__trickle_patched) {
+        const origCreate = client.messages.create.bind(client.messages);
+        client.messages.create = function patchedCreate(...args) {
+            const params = args[0] || {};
+            const startTime = performance.now();
+            const isStream = !!params.stream;
+            const result = origCreate(...args);
+            if (result && typeof result.then === 'function') {
+                return result.then((response) => {
+                    if (isStream) {
+                        return handleAnthropicStream(response, params, startTime, debug);
+                    }
+                    captureAnthropicResponse(params, response, startTime, debug);
+                    return response;
+                }).catch((err) => {
+                    captureAnthropicError(params, err, startTime, debug);
+                    throw err;
+                });
+            }
+            return result;
+        };
+        client.messages.create.__trickle_patched = true;
+    }
+    // Patch messages.stream (if it exists)
+    if (client.messages?.stream && !client.messages.stream.__trickle_patched) {
+        const origStream = client.messages.stream.bind(client.messages);
+        client.messages.stream = 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) => handleAnthropicStream(stream, params, startTime, debug));
+            }
+            return handleAnthropicStream(result, params, startTime, debug);
+        };
+        client.messages.stream.__trickle_patched = true;
+    }
+}
+function handleAnthropicStream(stream, params, startTime, debug) {
+    // Anthropic streams have a finalMessage() or on('message') pattern
+    // Hook into the stream events to capture the final result
+    if (stream && typeof stream.on === 'function') {
+        stream.on('finalMessage', (message) => {
+            captureAnthropicResponse(params, message, startTime, debug);
+        });
+    }
+    // Also support the async iterator pattern
+    if (stream && stream[Symbol.asyncIterator]) {
+        const origIterator = stream[Symbol.asyncIterator].bind(stream);
+        const chunks = [];
+        stream[Symbol.asyncIterator] = function () {
+            const iter = origIterator();
+            return {
+                async next() {
+                    const result = await iter.next();
+                    if (!result.done) {
+                        const event = result.value;
+                        if (event.type === 'content_block_delta' && event.delta?.text) {
+                            chunks.push(event.delta.text);
+                        }
+                        if (event.type === 'message_stop' || event.type === 'message_delta') {
+                            if (event.usage) {
+                                const outputText = chunks.join('');
+                                writeLlmEvent({
+                                    kind: 'llm_call', provider: 'anthropic', model: params.model || 'unknown',
+                                    durationMs: round(performance.now() - startTime),
+                                    inputTokens: event.usage.input_tokens || 0,
+                                    outputTokens: event.usage.output_tokens || 0,
+                                    totalTokens: (event.usage.input_tokens || 0) + (event.usage.output_tokens || 0),
+                                    estimatedCostUsd: estimateCost(params.model || '', event.usage.input_tokens || 0, event.usage.output_tokens || 0),
+                                    stream: true, finishReason: 'end_turn',
+                                    temperature: params.temperature, maxTokens: params.max_tokens,
+                                    systemPrompt: typeof params.system === 'string' ? truncate(params.system, 200) : undefined,
+                                    inputPreview: extractInputPreview(params.messages),
+                                    outputPreview: truncate(outputText),
+                                    messageCount: params.messages?.length || 0,
+                                    toolUse: hasToolUse(params), timestamp: Date.now(),
+                                });
+                            }
+                        }
+                    }
+                    return result;
+                },
+                return: iter.return?.bind(iter),
+                throw: iter.throw?.bind(iter),
+            };
+        };
+    }
+    return stream;
+}
+function captureAnthropicResponse(params, response, startTime, debug) {
+    const usage = response.usage || {};
+    const outputText = response.content?.map((c) => c.text || '').join('') || '';
+    const event = {
+        kind: 'llm_call', provider: 'anthropic', model: response.model || params.model || 'unknown',
+        durationMs: round(performance.now() - startTime),
+        inputTokens: usage.input_tokens || 0, outputTokens: usage.output_tokens || 0,
+        totalTokens: (usage.input_tokens || 0) + (usage.output_tokens || 0),
+        estimatedCostUsd: estimateCost(response.model || params.model || '', usage.input_tokens || 0, usage.output_tokens || 0),
+        stream: false, finishReason: response.stop_reason || 'unknown',
+        temperature: params.temperature, maxTokens: params.max_tokens,
+        systemPrompt: typeof params.system === 'string' ? truncate(params.system, 200) : undefined,
+        inputPreview: extractInputPreview(params.messages),
+        outputPreview: truncate(outputText),
+        messageCount: params.messages?.length || 0,
+        toolUse: hasToolUse(params) || response.content?.some((c) => c.type === 'tool_use'),
+        timestamp: Date.now(),
+    };
+    writeLlmEvent(event);
+    if (debug)
+        console.log(`[trickle/llm] Anthropic: ${event.model} (${event.totalTokens} tokens, ${event.durationMs}ms)`);
+}
+function captureAnthropicError(params, err, startTime, debug) {
+    writeLlmEvent({
+        kind: 'llm_call', provider: 'anthropic', model: params.model || 'unknown',
+        durationMs: round(performance.now() - startTime),
+        inputTokens: 0, outputTokens: 0, totalTokens: 0, estimatedCostUsd: 0,
+        stream: !!params.stream, finishReason: 'error',
+        temperature: params.temperature, maxTokens: params.max_tokens,
+        systemPrompt: typeof params.system === 'string' ? truncate(params.system, 200) : undefined,
+        inputPreview: extractInputPreview(params.messages),
+        outputPreview: '', messageCount: params.messages?.length || 0,
+        toolUse: hasToolUse(params), timestamp: Date.now(),
+        error: truncate(err?.message || String(err), 200),
+    });
+}
+// ────────────────────────────────────────────────────
+// Helpers
+// ────────────────────────────────────────────────────
+function round(n) {
+    return Math.round(n * 100) / 100;
+}
+function getattr(obj, key) {
+    try {
+        return !!obj[key];
+    }
+    catch {
+        return false;
+    }
+}
+function setattr(obj, key, val) {
+    try {
+        obj[key] = val;
+    }
+    catch { }
+}
+/**
+ * Initialize the LLM observer — clears previous data file.
+ */
+function initLlmObserver() {
+    const dir = process.env.TRICKLE_LOCAL_DIR || path.join(process.cwd(), '.trickle');
+    try {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+    catch { }
+    llmFile = path.join(dir, 'llm.jsonl');
+    try {
+        fs.writeFileSync(llmFile, '');
+    }
+    catch { }
+    eventCount = 0;
+}

package/dist/observe-register.js

@@ -41,6 +41,7 @@ const fetch_observer_1 = require("./fetch-observer");
 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 vite_plugin_1 = require("./vite-plugin");
 // ── Source map support ──
 // Lightweight VLQ decoder for mapping compiled JS lines back to original TS lines
@@ -1239,6 +1240,8 @@ if (enabled) {
     }
     // ── Hook 0b2: Initialize call trace ──
     (0, call_trace_1.initCallTrace)();
+    // ── Hook 0b3: Initialize LLM observer ──
+    (0, llm_observer_1.initLlmObserver)();
     // ── Hook 0c: Capture environment snapshot ──
     try {
         const envDir = process.env.TRICKLE_LOCAL_DIR || path_1.default.join(process.cwd(), '.trickle');
@@ -1531,6 +1534,24 @@ if (enabled) {
             }
             catch { /* not critical */ }
         }
+        // OpenAI SDK
+        if (request === 'openai' && !expressPatched.has('openai')) {
+            expressPatched.add('openai');
+            try {
+                const { patchOpenAI } = require(path_1.default.join(__dirname, 'llm-observer.js'));
+                patchOpenAI(exports, debug);
+            }
+            catch { /* not critical */ }
+        }
+        // Anthropic SDK
+        if ((request === '@anthropic-ai/sdk' || request === 'anthropic') && !expressPatched.has('anthropic')) {
+            expressPatched.add('anthropic');
+            try {
+                const { patchAnthropic } = require(path_1.default.join(__dirname, 'llm-observer.js'));
+                patchAnthropic(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/dist/vite-plugin.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/vite-plugin.test.js

@@ -0,0 +1,160 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Unit tests for the Vite plugin transform (React component tracking).
+ *
+ * Run with: node --experimental-strip-types --test src/vite-plugin.test.ts
+ * Or after build: node --test dist/vite-plugin.test.js
+ */
+const node_test_1 = require("node:test");
+const strict_1 = __importDefault(require("node:assert/strict"));
+const vite_plugin_js_1 = require("../dist/vite-plugin.js");
+// Helper: transform code as if it came from a .tsx file
+function transformTsx(code) {
+    const plugin = (0, vite_plugin_js_1.tricklePlugin)({ debug: false, traceVars: false });
+    const result = plugin.transform(code, '/test/App.tsx');
+    return result ? result.code : null;
+}
+function transformTs(code) {
+    const plugin = (0, vite_plugin_js_1.tricklePlugin)({ debug: false, traceVars: false });
+    const result = plugin.transform(code, '/test/util.ts');
+    return result ? result.code : null;
+}
+// ── React file detection ─────────────────────────────────────────────────────
+(0, node_test_1.describe)('React file detection', () => {
+    (0, node_test_1.it)('tracks uppercase components in .tsx files', () => {
+        const code = `function UserCard(props) { return null; }`;
+        const out = transformTsx(code);
+        strict_1.default.ok(out, 'should transform');
+        strict_1.default.ok(out.includes('__trickle_rc'), 'should inject render tracker');
+    });
+    (0, node_test_1.it)('does not inject render tracker for .ts files', () => {
+        const code = `function UserCard(props) { return null; }`;
+        const out = transformTs(code);
+        // May still transform for function wrapping, but not for render tracking
+        if (out) {
+            strict_1.default.ok(!out.includes('__trickle_rc'), 'should NOT inject render tracker in .ts files');
+        }
+    });
+    (0, node_test_1.it)('does not track lowercase functions as components', () => {
+        const code = `function helper(x) { return x + 1; }`;
+        const out = transformTsx(code);
+        if (out) {
+            strict_1.default.ok(!out.includes('__trickle_rc'), 'lowercase function should not be tracked');
+        }
+    });
+});
+// ── Props capture: function declarations ─────────────────────────────────────
+(0, node_test_1.describe)('Props capture — function declarations', () => {
+    (0, node_test_1.it)('uses arguments[0] for simple param: function Component(props)', () => {
+        const code = `function MyComponent(props) { return null; }`;
+        const out = transformTsx(code);
+        strict_1.default.ok(out, 'should transform');
+        strict_1.default.ok(out.includes('arguments[0]'), 'should pass arguments[0] as props');
+    });
+    (0, node_test_1.it)('uses arguments[0] for destructured param: function Component({ name })', () => {
+        const code = `function UserCard({ name, age }) { return null; }`;
+        const out = transformTsx(code);
+        strict_1.default.ok(out, 'should transform');
+        strict_1.default.ok(out.includes('arguments[0]'), 'should pass arguments[0] for destructured params');
+    });
+    (0, node_test_1.it)('injects __trickle_rc call at start of function body', () => {
+        const code = `function MyComponent(props) {\n  const x = 1;\n  return null;\n}`;
+        const out = transformTsx(code);
+        strict_1.default.ok(out, 'should transform');
+        // __trickle_rc should appear before body statements
+        const rcIdx = out.indexOf('__trickle_rc');
+        const bodyIdx = out.indexOf('const x = 1');
+        strict_1.default.ok(rcIdx !== -1, '__trickle_rc should be present');
+        strict_1.default.ok(bodyIdx !== -1, 'body code should be present');
+        strict_1.default.ok(rcIdx < bodyIdx, '__trickle_rc should come before body statements');
+    });
+    (0, node_test_1.it)('includes correct component name and line in __trickle_rc call', () => {
+        const code = `function UserCard(props) { return null; }`;
+        const out = transformTsx(code);
+        strict_1.default.ok(out, 'should transform');
+        strict_1.default.ok(out.includes('"UserCard"'), 'should include component name');
+        strict_1.default.ok(out.includes('__trickle_rc("UserCard"'), 'should call with component name');
+    });
+});
+// ── Props capture: arrow function components ──────────────────────────────────
+(0, node_test_1.describe)('Props capture — arrow function components', () => {
+    (0, node_test_1.it)('uses single param name for simple arrow: const C = (props) => {}', () => {
+        const code = `const Dashboard = (props) => { return null; };`;
+        const out = transformTsx(code);
+        strict_1.default.ok(out, 'should transform');
+        strict_1.default.ok(out.includes('__trickle_rc'), 'should inject render tracker');
+        // props should be the param variable, not arguments[0]
+        strict_1.default.ok(out.includes('__trickle_rc("Dashboard"'), 'should use component name');
+        // should NOT use arguments[0] for arrow functions
+        const rcCall = out.match(/__trickle_rc\("Dashboard",[^)]+\)/);
+        strict_1.default.ok(rcCall, 'should have __trickle_rc call');
+        strict_1.default.ok(!rcCall[0].includes('arguments[0]'), 'arrow functions should not use arguments[0]');
+    });
+    (0, node_test_1.it)('reconstructs object for destructured arrow: const C = ({ a, b }) => {}', () => {
+        const code = `const Counter = ({ count, label }) => { return null; };`;
+        const out = transformTsx(code);
+        strict_1.default.ok(out, 'should transform');
+        strict_1.default.ok(out.includes('__trickle_rc'), 'should inject render tracker');
+        // Should reconstruct { count, label }
+        const rcCall = out.match(/__trickle_rc\("Counter",[^,]+,([^)]+)\)/);
+        if (rcCall) {
+            strict_1.default.ok(rcCall[1].includes('count') && rcCall[1].includes('label'), 'should reconstruct props object from destructured fields');
+        }
+    });
+    (0, node_test_1.it)('passes undefined for no-param arrow: const C = () => {}', () => {
+        const code = `const NoProps = () => { return null; };`;
+        const out = transformTsx(code);
+        if (out && out.includes('__trickle_rc')) {
+            strict_1.default.ok(out.includes('undefined'), 'should pass undefined for no-param component');
+        }
+    });
+});
+// ── render count tracking ─────────────────────────────────────────────────────
+(0, node_test_1.describe)('Render count tracking', () => {
+    (0, node_test_1.it)('includes react_render kind in emitted record code', () => {
+        const code = `function Card(props) { return null; }`;
+        const out = transformTsx(code);
+        strict_1.default.ok(out, 'should transform');
+        strict_1.default.ok(out.includes("'react_render'"), 'emitted record should have kind react_render');
+    });
+    (0, node_test_1.it)('includes props data in emitted record', () => {
+        const code = `function Card(props) { return null; }`;
+        const out = transformTsx(code);
+        strict_1.default.ok(out, 'should transform');
+        strict_1.default.ok(out.includes('rec.props'), 'should capture props onto the record');
+        strict_1.default.ok(out.includes('propKeys'), 'should include propKeys');
+    });
+    (0, node_test_1.it)('tracks multiple components in one file', () => {
+        const code = [
+            `function Header(props) { return null; }`,
+            `function Footer(props) { return null; }`,
+            `function helper(x) { return x; }`,
+        ].join('\n');
+        const out = transformTsx(code);
+        strict_1.default.ok(out, 'should transform');
+        strict_1.default.ok(out.includes('"Header"'), 'should track Header');
+        strict_1.default.ok(out.includes('"Footer"'), 'should track Footer');
+        // helper should not be tracked as a component
+        const rcCalls = out.match(/__trickle_rc\("helper"/g);
+        strict_1.default.ok(!rcCalls, 'lowercase helper should not be tracked');
+    });
+});
+// ── findFunctionBodyBrace — destructured params don't confuse brace finding ───
+(0, node_test_1.describe)('Correct function body brace detection', () => {
+    (0, node_test_1.it)('finds body brace even with destructured object params', () => {
+        const code = `function Form({ onSubmit, title }) {\n  const x = 1;\n  return null;\n}`;
+        const out = transformTsx(code);
+        strict_1.default.ok(out, 'should transform');
+        // __trickle_rc should be INSIDE the function body (before 'const x = 1')
+        const rcIdx = out.indexOf('__trickle_rc');
+        const bodyIdx = out.indexOf('const x = 1');
+        strict_1.default.ok(rcIdx < bodyIdx, 'render tracker must be inside the function body, before first statement');
+        // The wrap insertion should be AFTER the closing brace of the function
+        const wrapIdx = out.indexOf('__trickle_wrap');
+        strict_1.default.ok(wrapIdx > bodyIdx, 'function wrap should be after the function body');
+    });
+});

package/package.json

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

package/src/llm-observer.ts

@@ -0,0 +1,508 @@
+/**
+ * LLM call observer — auto-instruments OpenAI, Anthropic, and other LLM SDKs
+ * to capture prompts, completions, token counts, latency, cost, and model metadata.
+ *
+ * Writes to .trickle/llm.jsonl as:
+ *   { "kind": "llm_call", "provider": "openai", "model": "gpt-4",
+ *     "inputTokens": 100, "outputTokens": 50, "durationMs": 1234.5, ... }
+ *
+ * Supports both streaming and non-streaming calls.
+ * Zero code changes needed — intercepted via Module._load hook.
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+
+let llmFile: string | null = null;
+let eventCount = 0;
+const MAX_LLM_EVENTS = 500;
+const TRUNCATE_LEN = 500;
+
+// Approximate pricing per 1M tokens (USD) — used for cost estimation
+const PRICING: Record<string, { input: number; output: number }> = {
+  'gpt-4o': { input: 2.5, output: 10 },
+  'gpt-4o-mini': { input: 0.15, output: 0.6 },
+  'gpt-4-turbo': { input: 10, output: 30 },
+  'gpt-4': { input: 30, output: 60 },
+  'gpt-3.5-turbo': { input: 0.5, output: 1.5 },
+  'claude-opus-4-20250514': { input: 15, output: 75 },
+  'claude-sonnet-4-20250514': { input: 3, output: 15 },
+  '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 },
+};
+
+function getLlmFile(): string {
+  if (llmFile) return llmFile;
+  const dir = process.env.TRICKLE_LOCAL_DIR || path.join(process.cwd(), '.trickle');
+  try { fs.mkdirSync(dir, { recursive: true }); } catch {}
+  llmFile = path.join(dir, 'llm.jsonl');
+  return llmFile;
+}
+
+interface LlmEvent {
+  kind: 'llm_call';
+  provider: string;
+  model: string;
+  durationMs: number;
+  inputTokens: number;
+  outputTokens: number;
+  totalTokens: number;
+  estimatedCostUsd: number;
+  stream: boolean;
+  finishReason: string;
+  temperature?: number;
+  maxTokens?: number;
+  systemPrompt?: string;
+  inputPreview: string;
+  outputPreview: string;
+  messageCount: number;
+  toolUse: boolean;
+  timestamp: number;
+  error?: string;
+}
+
+function writeLlmEvent(event: LlmEvent): void {
+  if (eventCount >= MAX_LLM_EVENTS) return;
+  eventCount++;
+  try {
+    fs.appendFileSync(getLlmFile(), 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 estimateCost(model: string, inputTokens: number, outputTokens: number): number {
+  // Find best matching pricing key
+  const key = Object.keys(PRICING).find(k => model.includes(k)) || '';
+  if (!key) return 0;
+  const p = PRICING[key];
+  return Math.round(((inputTokens * p.input + outputTokens * p.output) / 1_000_000) * 1_000_000) / 1_000_000;
+}
+
+function extractInputPreview(messages: any[]): string {
+  if (!Array.isArray(messages) || messages.length === 0) return '';
+  const last = messages[messages.length - 1];
+  if (typeof last?.content === 'string') return truncate(last.content);
+  if (Array.isArray(last?.content)) {
+    const textPart = last.content.find((p: any) => p.type === 'text');
+    if (textPart?.text) return truncate(textPart.text);
+  }
+  return '';
+}
+
+function extractSystemPrompt(messages: any[]): string | undefined {
+  if (!Array.isArray(messages)) return undefined;
+  const sys = messages.find((m: any) => m.role === 'system');
+  if (sys?.content && typeof sys.content === 'string') return truncate(sys.content, 200);
+  return undefined;
+}
+
+function hasToolUse(params: any): boolean {
+  return !!(params.tools && Array.isArray(params.tools) && params.tools.length > 0);
+}
+
+// ────────────────────────────────────────────────────
+// OpenAI SDK v4+ instrumentation
+// ────────────────────────────────────────────────────
+
+export function patchOpenAI(openaiModule: any, debug: boolean): void {
+  if (!openaiModule || getattr(openaiModule, '_trickle_llm_patched')) return;
+  setattr(openaiModule, '_trickle_llm_patched', true);
+
+  const OpenAIClass = openaiModule.OpenAI || openaiModule.default;
+  if (typeof OpenAIClass !== 'function') return;
+
+  // OpenAI SDK v4+ creates resource instances (chat, completions) in the constructor
+  // as own properties. The Completions class is not directly exported, but we can
+  // access it by creating a temporary client and getting the prototype of chat.completions.
+  try {
+    // Create a temporary client to discover the Completions class
+    // (ES6 classes require `new`, can't use .call())
+    const tmpClient = new OpenAIClass({ apiKey: 'trickle-probe' });
+    const CompletionsClass = Object.getPrototypeOf(tmpClient.chat?.completions)?.constructor;
+    if (CompletionsClass && CompletionsClass.prototype.create && !CompletionsClass.prototype.create.__trickle_patched) {
+      const origCreate = CompletionsClass.prototype.create;
+      CompletionsClass.prototype.create = function patchedCreate(this: any, ...args: any[]) {
+        const params = args[0] || {};
+        const startTime = performance.now();
+        const isStream = !!params.stream;
+        const result = origCreate.apply(this, args);
+        if (isStream) return handleOpenAIStream(result, params, startTime, debug);
+        if (result && typeof result.then === 'function') {
+          return result.then((response: any) => {
+            captureOpenAIResponse(params, response, startTime, debug);
+            return response;
+          }).catch((err: any) => {
+            captureOpenAIError(params, err, startTime, debug);
+            throw err;
+          });
+        }
+        return result;
+      };
+      (CompletionsClass.prototype.create as any).__trickle_patched = true;
+      if (debug) console.log('[trickle/llm] Patched OpenAI SDK');
+      return;
+    }
+  } catch (e: any) {
+    if (debug) console.log('[trickle/llm] OpenAI patch probe failed:', e.message);
+  }
+}
+
+function patchOpenAIClient(client: any, debug: boolean): void {
+  // Patch chat.completions.create
+  if (client.chat?.completions?.create && !client.chat.completions.create.__trickle_patched) {
+    const origCreate = client.chat.completions.create.bind(client.chat.completions);
+    client.chat.completions.create = function patchedCreate(...args: any[]) {
+      const params = args[0] || {};
+      const startTime = performance.now();
+      const isStream = !!params.stream;
+
+      const result = origCreate(...args);
+
+      if (isStream) {
+        return handleOpenAIStream(result, params, startTime, debug);
+      }
+
+      // Non-streaming: hook the promise
+      if (result && typeof result.then === 'function') {
+        return result.then((response: any) => {
+          captureOpenAIResponse(params, response, startTime, debug);
+          return response;
+        }).catch((err: any) => {
+          captureOpenAIError(params, err, startTime, debug);
+          throw err;
+        });
+      }
+
+      return result;
+    };
+    client.chat.completions.create.__trickle_patched = true;
+  }
+
+  // Patch completions.create (legacy)
+  if (client.completions?.create && !client.completions.create.__trickle_patched) {
+    const origCreate = client.completions.create.bind(client.completions);
+    client.completions.create = function patchedCreate(...args: any[]) {
+      const params = args[0] || {};
+      const startTime = performance.now();
+
+      const result = origCreate(...args);
+      if (result && typeof result.then === 'function') {
+        return result.then((response: any) => {
+          const usage = response.usage || {};
+          const text = response.choices?.[0]?.text || '';
+          writeLlmEvent({
+            kind: 'llm_call', provider: 'openai', model: params.model || 'unknown',
+            durationMs: round(performance.now() - startTime),
+            inputTokens: usage.prompt_tokens || 0, outputTokens: usage.completion_tokens || 0,
+            totalTokens: usage.total_tokens || 0,
+            estimatedCostUsd: estimateCost(params.model || '', usage.prompt_tokens || 0, usage.completion_tokens || 0),
+            stream: false, finishReason: response.choices?.[0]?.finish_reason || 'unknown',
+            temperature: params.temperature, maxTokens: params.max_tokens,
+            inputPreview: truncate(params.prompt || ''), outputPreview: truncate(text),
+            messageCount: 0, toolUse: false, timestamp: Date.now(),
+          });
+          return response;
+        });
+      }
+      return result;
+    };
+    client.completions.create.__trickle_patched = true;
+  }
+}
+
+async function handleOpenAIStream(resultPromise: any, params: any, startTime: number, debug: boolean): Promise<any> {
+  const stream = await resultPromise;
+  const chunks: string[] = [];
+  let finishReason = 'unknown';
+  let totalInputTokens = 0;
+  let totalOutputTokens = 0;
+
+  // Wrap the async iterator
+  const origIterator = stream[Symbol.asyncIterator].bind(stream);
+  stream[Symbol.asyncIterator] = function () {
+    const iter = origIterator();
+    return {
+      async next() {
+        const result = await iter.next();
+        if (!result.done) {
+          const chunk = result.value;
+          const delta = chunk.choices?.[0]?.delta;
+          if (delta?.content) chunks.push(delta.content);
+          if (chunk.choices?.[0]?.finish_reason) finishReason = chunk.choices[0].finish_reason;
+          if (chunk.usage) {
+            totalInputTokens = chunk.usage.prompt_tokens || totalInputTokens;
+            totalOutputTokens = chunk.usage.completion_tokens || totalOutputTokens;
+          }
+        } else {
+          // Stream finished — capture
+          const outputText = chunks.join('');
+          writeLlmEvent({
+            kind: 'llm_call', provider: 'openai', model: params.model || 'unknown',
+            durationMs: round(performance.now() - startTime),
+            inputTokens: totalInputTokens, outputTokens: totalOutputTokens,
+            totalTokens: totalInputTokens + totalOutputTokens,
+            estimatedCostUsd: estimateCost(params.model || '', totalInputTokens, totalOutputTokens),
+            stream: true, finishReason,
+            temperature: params.temperature, maxTokens: params.max_tokens,
+            systemPrompt: extractSystemPrompt(params.messages),
+            inputPreview: extractInputPreview(params.messages),
+            outputPreview: truncate(outputText),
+            messageCount: params.messages?.length || 0,
+            toolUse: hasToolUse(params), timestamp: Date.now(),
+          });
+          if (debug) console.log(`[trickle/llm] OpenAI stream: ${params.model} (${totalOutputTokens} tokens)`);
+        }
+        return result;
+      },
+      return: iter.return?.bind(iter),
+      throw: iter.throw?.bind(iter),
+    };
+  };
+
+  return stream;
+}
+
+function captureOpenAIResponse(params: any, response: any, startTime: number, debug: boolean): void {
+  const usage = response.usage || {};
+  const outputText = response.choices?.[0]?.message?.content || '';
+  const event: LlmEvent = {
+    kind: 'llm_call', provider: 'openai', model: params.model || 'unknown',
+    durationMs: round(performance.now() - startTime),
+    inputTokens: usage.prompt_tokens || 0, outputTokens: usage.completion_tokens || 0,
+    totalTokens: usage.total_tokens || 0,
+    estimatedCostUsd: estimateCost(params.model || '', usage.prompt_tokens || 0, usage.completion_tokens || 0),
+    stream: false, finishReason: response.choices?.[0]?.finish_reason || 'unknown',
+    temperature: params.temperature, maxTokens: params.max_tokens,
+    systemPrompt: extractSystemPrompt(params.messages),
+    inputPreview: extractInputPreview(params.messages),
+    outputPreview: truncate(outputText),
+    messageCount: params.messages?.length || 0,
+    toolUse: hasToolUse(params), timestamp: Date.now(),
+  };
+  writeLlmEvent(event);
+  if (debug) console.log(`[trickle/llm] OpenAI: ${params.model} (${usage.total_tokens || 0} tokens, ${event.durationMs}ms)`);
+}
+
+function captureOpenAIError(params: any, err: any, startTime: number, debug: boolean): void {
+  writeLlmEvent({
+    kind: 'llm_call', provider: 'openai', model: params.model || 'unknown',
+    durationMs: round(performance.now() - startTime),
+    inputTokens: 0, outputTokens: 0, totalTokens: 0, estimatedCostUsd: 0,
+    stream: !!params.stream, finishReason: 'error',
+    temperature: params.temperature, maxTokens: params.max_tokens,
+    systemPrompt: extractSystemPrompt(params.messages),
+    inputPreview: extractInputPreview(params.messages),
+    outputPreview: '', messageCount: params.messages?.length || 0,
+    toolUse: hasToolUse(params), timestamp: Date.now(),
+    error: truncate(err?.message || String(err), 200),
+  });
+}
+
+// ────────────────────────────────────────────────────
+// Anthropic SDK instrumentation
+// ────────────────────────────────────────────────────
+
+export function patchAnthropic(anthropicModule: any, debug: boolean): void {
+  if (!anthropicModule || getattr(anthropicModule, '_trickle_llm_patched')) return;
+  setattr(anthropicModule, '_trickle_llm_patched', true);
+
+  const AnthropicClass = anthropicModule.Anthropic || anthropicModule.default;
+  if (typeof AnthropicClass !== 'function') return;
+
+  try {
+    const tmpClient = new AnthropicClass({ apiKey: 'trickle-probe' });
+    const MessagesClass = Object.getPrototypeOf(tmpClient.messages)?.constructor;
+    if (MessagesClass && MessagesClass.prototype.create && !MessagesClass.prototype.create.__trickle_patched) {
+      const origCreate = MessagesClass.prototype.create;
+      MessagesClass.prototype.create = function patchedCreate(this: any, ...args: any[]) {
+        const params = args[0] || {};
+        const startTime = performance.now();
+        const isStream = !!params.stream;
+        const result = origCreate.apply(this, args);
+        if (result && typeof result.then === 'function') {
+          return result.then((response: any) => {
+            if (isStream) return handleAnthropicStream(response, params, startTime, debug);
+            captureAnthropicResponse(params, response, startTime, debug);
+            return response;
+          }).catch((err: any) => {
+            captureAnthropicError(params, err, startTime, debug);
+            throw err;
+          });
+        }
+        return result;
+      };
+      (MessagesClass.prototype.create as any).__trickle_patched = true;
+      if (debug) console.log('[trickle/llm] Patched Anthropic SDK');
+      return;
+    }
+  } catch (e: any) {
+    if (debug) console.log('[trickle/llm] Anthropic patch probe failed:', e.message);
+  }
+}
+
+function patchAnthropicClient(client: any, debug: boolean): void {
+  // Patch messages.create
+  if (client.messages?.create && !client.messages.create.__trickle_patched) {
+    const origCreate = client.messages.create.bind(client.messages);
+    client.messages.create = function patchedCreate(...args: any[]) {
+      const params = args[0] || {};
+      const startTime = performance.now();
+      const isStream = !!params.stream;
+
+      const result = origCreate(...args);
+
+      if (result && typeof result.then === 'function') {
+        return result.then((response: any) => {
+          if (isStream) {
+            return handleAnthropicStream(response, params, startTime, debug);
+          }
+          captureAnthropicResponse(params, response, startTime, debug);
+          return response;
+        }).catch((err: any) => {
+          captureAnthropicError(params, err, startTime, debug);
+          throw err;
+        });
+      }
+      return result;
+    };
+    client.messages.create.__trickle_patched = true;
+  }
+
+  // Patch messages.stream (if it exists)
+  if (client.messages?.stream && !client.messages.stream.__trickle_patched) {
+    const origStream = client.messages.stream.bind(client.messages);
+    client.messages.stream = 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) => handleAnthropicStream(stream, params, startTime, debug));
+      }
+      return handleAnthropicStream(result, params, startTime, debug);
+    };
+    client.messages.stream.__trickle_patched = true;
+  }
+}
+
+function handleAnthropicStream(stream: any, params: any, startTime: number, debug: boolean): any {
+  // Anthropic streams have a finalMessage() or on('message') pattern
+  // Hook into the stream events to capture the final result
+  if (stream && typeof stream.on === 'function') {
+    stream.on('finalMessage', (message: any) => {
+      captureAnthropicResponse(params, message, startTime, debug);
+    });
+  }
+  // Also support the async iterator pattern
+  if (stream && stream[Symbol.asyncIterator]) {
+    const origIterator = stream[Symbol.asyncIterator].bind(stream);
+    const chunks: string[] = [];
+    stream[Symbol.asyncIterator] = function () {
+      const iter = origIterator();
+      return {
+        async next() {
+          const result = await iter.next();
+          if (!result.done) {
+            const event = result.value;
+            if (event.type === 'content_block_delta' && event.delta?.text) {
+              chunks.push(event.delta.text);
+            }
+            if (event.type === 'message_stop' || event.type === 'message_delta') {
+              if (event.usage) {
+                const outputText = chunks.join('');
+                writeLlmEvent({
+                  kind: 'llm_call', provider: 'anthropic', model: params.model || 'unknown',
+                  durationMs: round(performance.now() - startTime),
+                  inputTokens: event.usage.input_tokens || 0,
+                  outputTokens: event.usage.output_tokens || 0,
+                  totalTokens: (event.usage.input_tokens || 0) + (event.usage.output_tokens || 0),
+                  estimatedCostUsd: estimateCost(params.model || '', event.usage.input_tokens || 0, event.usage.output_tokens || 0),
+                  stream: true, finishReason: 'end_turn',
+                  temperature: params.temperature, maxTokens: params.max_tokens,
+                  systemPrompt: typeof params.system === 'string' ? truncate(params.system, 200) : undefined,
+                  inputPreview: extractInputPreview(params.messages),
+                  outputPreview: truncate(outputText),
+                  messageCount: params.messages?.length || 0,
+                  toolUse: hasToolUse(params), timestamp: Date.now(),
+                });
+              }
+            }
+          }
+          return result;
+        },
+        return: iter.return?.bind(iter),
+        throw: iter.throw?.bind(iter),
+      };
+    };
+  }
+  return stream;
+}
+
+function captureAnthropicResponse(params: any, response: any, startTime: number, debug: boolean): void {
+  const usage = response.usage || {};
+  const outputText = response.content?.map((c: any) => c.text || '').join('') || '';
+  const event: LlmEvent = {
+    kind: 'llm_call', provider: 'anthropic', model: response.model || params.model || 'unknown',
+    durationMs: round(performance.now() - startTime),
+    inputTokens: usage.input_tokens || 0, outputTokens: usage.output_tokens || 0,
+    totalTokens: (usage.input_tokens || 0) + (usage.output_tokens || 0),
+    estimatedCostUsd: estimateCost(response.model || params.model || '', usage.input_tokens || 0, usage.output_tokens || 0),
+    stream: false, finishReason: response.stop_reason || 'unknown',
+    temperature: params.temperature, maxTokens: params.max_tokens,
+    systemPrompt: typeof params.system === 'string' ? truncate(params.system, 200) : undefined,
+    inputPreview: extractInputPreview(params.messages),
+    outputPreview: truncate(outputText),
+    messageCount: params.messages?.length || 0,
+    toolUse: hasToolUse(params) || response.content?.some((c: any) => c.type === 'tool_use'),
+    timestamp: Date.now(),
+  };
+  writeLlmEvent(event);
+  if (debug) console.log(`[trickle/llm] Anthropic: ${event.model} (${event.totalTokens} tokens, ${event.durationMs}ms)`);
+}
+
+function captureAnthropicError(params: any, err: any, startTime: number, debug: boolean): void {
+  writeLlmEvent({
+    kind: 'llm_call', provider: 'anthropic', model: params.model || 'unknown',
+    durationMs: round(performance.now() - startTime),
+    inputTokens: 0, outputTokens: 0, totalTokens: 0, estimatedCostUsd: 0,
+    stream: !!params.stream, finishReason: 'error',
+    temperature: params.temperature, maxTokens: params.max_tokens,
+    systemPrompt: typeof params.system === 'string' ? truncate(params.system, 200) : undefined,
+    inputPreview: extractInputPreview(params.messages),
+    outputPreview: '', messageCount: params.messages?.length || 0,
+    toolUse: hasToolUse(params), timestamp: Date.now(),
+    error: truncate(err?.message || String(err), 200),
+  });
+}
+
+// ────────────────────────────────────────────────────
+// Helpers
+// ────────────────────────────────────────────────────
+
+function round(n: number): number {
+  return Math.round(n * 100) / 100;
+}
+
+function getattr(obj: any, key: string): boolean {
+  try { return !!obj[key]; } catch { return false; }
+}
+
+function setattr(obj: any, key: string, val: any): void {
+  try { obj[key] = val; } catch {}
+}
+
+/**
+ * Initialize the LLM observer — clears previous data file.
+ */
+export function initLlmObserver(): void {
+  const dir = process.env.TRICKLE_LOCAL_DIR || path.join(process.cwd(), '.trickle');
+  try { fs.mkdirSync(dir, { recursive: true }); } catch {}
+  llmFile = path.join(dir, 'llm.jsonl');
+  try { fs.writeFileSync(llmFile, ''); } catch {}
+  eventCount = 0;
+}

package/src/observe-register.ts

@@ -38,6 +38,7 @@ import { patchFetch } from './fetch-observer';
 import { instrumentExpress, trickleMiddleware } from './express';
 import { initVarTracer, traceVar } from './trace-var';
 import { initCallTrace } from './call-trace';
+import { initLlmObserver } from './llm-observer';
 import {
   findReassignments,
   findForLoopVars,
@@ -1227,6 +1228,9 @@ if (enabled) {
   // ── Hook 0b2: Initialize call trace ──
   initCallTrace();
 
+  // ── Hook 0b3: Initialize LLM observer ──
+  initLlmObserver();
+
   // ── Hook 0c: Capture environment snapshot ──
   try {
     const envDir = process.env.TRICKLE_LOCAL_DIR || path.join(process.cwd(), '.trickle');
@@ -1515,6 +1519,24 @@ if (enabled) {
       } catch { /* not critical */ }
     }
 
+    // OpenAI SDK
+    if (request === 'openai' && !expressPatched.has('openai')) {
+      expressPatched.add('openai');
+      try {
+        const { patchOpenAI } = require(path.join(__dirname, 'llm-observer.js'));
+        patchOpenAI(exports, debug);
+      } catch { /* not critical */ }
+    }
+
+    // Anthropic SDK
+    if ((request === '@anthropic-ai/sdk' || request === 'anthropic') && !expressPatched.has('anthropic')) {
+      expressPatched.add('anthropic');
+      try {
+        const { patchAnthropic } = require(path.join(__dirname, 'llm-observer.js'));
+        patchAnthropic(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.