@visibe.ai/node 0.1.16 → 0.1.18

package/dist/esm/index.js

@@ -4,30 +4,35 @@ import { Visibe } from './client.js';
 // ---------------------------------------------------------------------------
 let _globalClient = null;
 let _shutdownRegistered = false;
-// Saved original constructors so shutdown() can restore them.
-// Each is typed as `any` because we need to reassign imported class bindings.
+// Saved originals so shutdown() can restore them.
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 let _originalOpenAI = null;
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-let _originalBedrockClient = null;
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-let _originalCompiledStateGraph = null;
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
 let _originalAnthropic = null;
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+let _originalBedrockClient = null;
+// Prototype-restore functions returned by patch helpers.
+let _lgRestore = null;
+let _lcRestore = null;
 let _vercelAIRestore = null;
+let _autoPatchedFrameworks = [];
+const ALL_FRAMEWORKS = ['openai', 'anthropic', 'bedrock', 'langgraph', 'langchain', 'vercel_ai'];
 // ---------------------------------------------------------------------------
-// detectFrameworks()
+// detectFrameworks() — synchronous, CJS-only legacy helper
+// Auto-patching now uses dynamic import() and works in both CJS and ESM.
 // ---------------------------------------------------------------------------
-function tryRequire(pkg) {
-    try {
-        require(pkg);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
 export function detectFrameworks() {
+    const tryRequire = (pkg) => {
+        try {
+            // eslint-disable-next-line @typescript-eslint/no-require-imports
+            if (typeof require !== 'undefined') {
+                require(pkg);
+                return true;
+            }
+        }
+        catch { /* not installed */ }
+        return false;
+    };
     return {
         openai: tryRequire('openai'),
         langchain: tryRequire('@langchain/core'),
@@ -35,20 +40,32 @@ export function detectFrameworks() {
         bedrock: tryRequire('@aws-sdk/client-bedrock-runtime'),
         vercel_ai: tryRequire('ai'),
         anthropic: tryRequire('@anthropic-ai/sdk'),
-        // crewai and autogen are Python-only — no Node.js equivalent
     };
 }
 // ---------------------------------------------------------------------------
-// patchFramework() — auto-instruments a framework at the constructor level
+// patchFramework() — async, uses dynamic import() for CJS + ESM compat.
+//
+// Key design notes:
+//  - dynamic import() in CJS builds: TypeScript compiles to require()-based
+//    Promise, so we get the same mutable module object as require().
+//  - dynamic import() in ESM builds: gives the live ESM namespace (same
+//    instance as the user's own `import`).
+//  - Prototype patching (langgraph, langchain) works in both envs — prototypes
+//    are shared mutable objects regardless of CJS/ESM.
+//  - Module-export patching (openai, anthropic, bedrock) only works in CJS
+//    because ESM namespace objects are sealed. We try and silently skip in ESM.
 // ---------------------------------------------------------------------------
-function patchFramework(framework, client) {
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const _setProp = (obj, key, val) => Object.defineProperty(obj, key, { value: val, configurable: true, writable: true, enumerable: true });
+async function patchFramework(framework, client) {
     try {
         switch (framework) {
             case 'openai': {
-                const openaiModule = require('openai');
-                _originalOpenAI = openaiModule.OpenAI;
-                // Named 'OpenAI' so client.constructor.name === 'OpenAI' after construction.
-                // applyIntegration() in client.ts uses constructor.name to detect the client type.
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                const openaiModule = await import('openai');
+                _originalOpenAI = openaiModule.OpenAI ?? openaiModule.default;
+                if (!_originalOpenAI)
+                    return;
                 const PatchedOpenAI = class OpenAI extends _originalOpenAI {
                     // eslint-disable-next-line @typescript-eslint/no-explicit-any
                     constructor(...args) {
@@ -59,19 +76,24 @@ function patchFramework(framework, client) {
                         catch { /* never crash new OpenAI() */ }
                     }
                 };
-                // Use defineProperty because openai exports OpenAI/default as getter-only properties
-                // (no setter). Direct assignment silently fails in that case.
-                const setProp = (obj, key, val) => Object.defineProperty(obj, key, { value: val, configurable: true, writable: true, enumerable: true });
-                setProp(openaiModule, 'OpenAI', PatchedOpenAI);
-                // Also patch .default so that `import OpenAI from 'openai'` (esModuleInterop)
-                // picks up the instrumented class — TypeScript compiles default imports to .default.
-                setProp(openaiModule, 'default', PatchedOpenAI);
+                // In ESM, the namespace object is sealed — defineProperty throws TypeError.
+                // We catch that and skip (user must call client.instrument() explicitly).
+                try {
+                    _setProp(openaiModule, 'OpenAI', PatchedOpenAI);
+                    _setProp(openaiModule, 'default', PatchedOpenAI);
+                }
+                catch {
+                    _originalOpenAI = null;
+                    return;
+                }
                 break;
             }
             case 'anthropic': {
-                const anthropicModule = require('@anthropic-ai/sdk');
-                _originalAnthropic = anthropicModule.Anthropic;
-                // Named 'Anthropic' so constructor.name check in applyIntegration() matches.
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                const anthropicModule = await import('@anthropic-ai/sdk');
+                _originalAnthropic = anthropicModule.Anthropic ?? anthropicModule.default;
+                if (!_originalAnthropic)
+                    return;
                 const PatchedAnthropic = class Anthropic extends _originalAnthropic {
                     // eslint-disable-next-line @typescript-eslint/no-explicit-any
                     constructor(...args) {
@@ -82,17 +104,23 @@ function patchFramework(framework, client) {
                         catch { /* never crash new Anthropic() */ }
                     }
                 };
-                // Same getter-only issue as openai — use defineProperty.
-                const setAnthropicProp = (obj, key, val) => Object.defineProperty(obj, key, { value: val, configurable: true, writable: true, enumerable: true });
-                setAnthropicProp(anthropicModule, 'Anthropic', PatchedAnthropic);
-                // Also patch .default for esModuleInterop default import support.
-                setAnthropicProp(anthropicModule, 'default', PatchedAnthropic);
+                try {
+                    _setProp(anthropicModule, 'Anthropic', PatchedAnthropic);
+                    _setProp(anthropicModule, 'default', PatchedAnthropic);
+                }
+                catch {
+                    _originalAnthropic = null;
+                    return;
+                }
                 break;
             }
             case 'bedrock': {
-                const bedrockModule = require('@aws-sdk/client-bedrock-runtime');
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                const bedrockModule = await import('@aws-sdk/client-bedrock-runtime');
                 _originalBedrockClient = bedrockModule.BedrockRuntimeClient;
-                bedrockModule.BedrockRuntimeClient = class BedrockRuntimeClient extends _originalBedrockClient {
+                if (!_originalBedrockClient)
+                    return;
+                const PatchedBedrock = class BedrockRuntimeClient extends _originalBedrockClient {
                     // eslint-disable-next-line @typescript-eslint/no-explicit-any
                     constructor(...args) {
                         super(...args);
@@ -102,39 +130,61 @@ function patchFramework(framework, client) {
                         catch { /* never crash new BedrockRuntimeClient() */ }
                     }
                 };
+                try {
+                    bedrockModule.BedrockRuntimeClient = PatchedBedrock;
+                }
+                catch {
+                    _originalBedrockClient = null;
+                    return;
+                }
                 break;
             }
             case 'langgraph': {
-                const lgModule = require('@langchain/langgraph');
-                _originalCompiledStateGraph = lgModule.CompiledStateGraph;
-                // LangGraph instrumentation is applied via LangChainCallback at the class level.
-                // The actual patching happens inside the langgraph integration module.
-                const { patchCompiledStateGraph } = require('./integrations/langgraph');
-                patchCompiledStateGraph(lgModule, client);
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                const lgModule = await import('@langchain/langgraph');
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                const { patchCompiledStateGraph } = await import('./integrations/langgraph.js');
+                // patchCompiledStateGraph modifies CompiledStateGraph.prototype — prototype
+                // patching works in ESM because prototypes are shared mutable objects.
+                _lgRestore = patchCompiledStateGraph(lgModule, client);
                 break;
             }
             case 'langchain': {
-                // LangChain is instrumented via RunnableSequence constructor patching.
-                const { patchRunnableSequence } = require('./integrations/langchain');
-                const lcModule = require('@langchain/core/runnables');
-                patchRunnableSequence(lcModule, client);
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                const { patchRunnableSequence } = await import('./integrations/langchain.js');
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                const lcModule = await import('@langchain/core/runnables');
+                const result = patchRunnableSequence(lcModule, client);
+                if (typeof result === 'function')
+                    _lcRestore = result;
                 break;
             }
             case 'vercel_ai': {
-                const { patchVercelAI } = require('./integrations/vercel-ai');
-                const aiModule = require('ai');
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                const { patchVercelAI } = await import('./integrations/vercel-ai.js');
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                const aiModule = await import('ai');
                 _vercelAIRestore = patchVercelAI(aiModule, client);
                 break;
             }
         }
-        // Record which frameworks were successfully patched for the startup log.
         _autoPatchedFrameworks.push(framework);
     }
     catch {
         // Package not installed or patch failed — skip silently.
     }
 }
-let _autoPatchedFrameworks = [];
+// ---------------------------------------------------------------------------
+// _autoPatch() — async; fires from init() without blocking it
+// ---------------------------------------------------------------------------
+async function _autoPatch(client, frameworks) {
+    for (const fw of frameworks) {
+        await patchFramework(fw, client);
+    }
+    if (_autoPatchedFrameworks.length > 0) {
+        console.log(`[Visibe] Auto-instrumented: ${_autoPatchedFrameworks.join(', ')}`);
+    }
+}
 // ---------------------------------------------------------------------------
 // init()
 // ---------------------------------------------------------------------------
@@ -144,17 +194,11 @@ export function init(options) {
         return _globalClient;
     }
     _globalClient = new Visibe(options ?? {});
-    const detected = detectFrameworks();
-    const toInstrument = options?.frameworks
-        ?? Object.keys(detected).filter(k => detected[k]);
-    for (const fw of toInstrument) {
-        patchFramework(fw, _globalClient);
-    }
-    // Register graceful shutdown handlers.
-    // NOTE: process.on('exit') fires synchronously — async HTTP requests cannot
-    // complete there.  SIGTERM is what Docker/Kubernetes send before killing a
-    // container; without handling it all buffered spans are lost.
-    // We await shutdown() so the batcher's 300 ms window completes before exit.
+    // Fire async patching — works in both CJS and ESM via dynamic import().
+    // Patching typically completes within microseconds (cached modules) so there
+    // is no practical race condition for normal usage patterns.
+    const frameworksToTry = options?.frameworks ?? ALL_FRAMEWORKS;
+    _autoPatch(_globalClient, frameworksToTry).catch(() => { });
     if (!_shutdownRegistered) {
         const graceful = async () => { await shutdown(); process.exit(0); };
         process.on('SIGTERM', graceful);
@@ -162,9 +206,6 @@ export function init(options) {
         process.on('beforeExit', () => { shutdown().catch(() => { }); });
         _shutdownRegistered = true;
     }
-    if (_autoPatchedFrameworks.length > 0) {
-        console.log(`[Visibe] Auto-instrumented: ${_autoPatchedFrameworks.join(', ')}`);
-    }
     return _globalClient;
 }
 // ---------------------------------------------------------------------------
@@ -173,53 +214,65 @@ export function init(options) {
 export async function shutdown() {
     if (_globalClient === null)
         return;
-    // Capture the client reference and clear global state immediately so that
-    // re-init() calls work without needing to await this function.
     const client = _globalClient;
     _globalClient = null;
     _autoPatchedFrameworks = [];
-    // Restore patched constructors so the SDK leaves no trace after shutdown.
-    try {
-        if (_originalOpenAI) {
-            const m = require('openai');
+    // Restore patched module exports (works in CJS; silently no-ops in ESM).
+    if (_originalOpenAI) {
+        try {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const m = await import('openai');
             Object.defineProperty(m, 'OpenAI', { value: _originalOpenAI, configurable: true, writable: true, enumerable: true });
             Object.defineProperty(m, 'default', { value: _originalOpenAI, configurable: true, writable: true, enumerable: true });
-            _originalOpenAI = null;
         }
+        catch { /* ignore */ }
+        _originalOpenAI = null;
     }
-    catch { /* package may have been unloaded */ }
-    try {
-        if (_originalAnthropic) {
-            const m = require('@anthropic-ai/sdk');
+    if (_originalAnthropic) {
+        try {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const m = await import('@anthropic-ai/sdk');
             Object.defineProperty(m, 'Anthropic', { value: _originalAnthropic, configurable: true, writable: true, enumerable: true });
             Object.defineProperty(m, 'default', { value: _originalAnthropic, configurable: true, writable: true, enumerable: true });
-            _originalAnthropic = null;
         }
+        catch { /* ignore */ }
+        _originalAnthropic = null;
     }
-    catch { /* package may have been unloaded */ }
-    try {
-        if (_originalBedrockClient) {
-            require('@aws-sdk/client-bedrock-runtime').BedrockRuntimeClient = _originalBedrockClient;
-            _originalBedrockClient = null;
+    if (_originalBedrockClient) {
+        try {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const m = await import('@aws-sdk/client-bedrock-runtime');
+            m.BedrockRuntimeClient = _originalBedrockClient;
         }
+        catch { /* ignore */ }
+        _originalBedrockClient = null;
     }
-    catch { /* package may have been unloaded */ }
-    try {
-        if (_originalCompiledStateGraph) {
-            require('@langchain/langgraph').CompiledStateGraph = _originalCompiledStateGraph;
-            _originalCompiledStateGraph = null;
+    // Restore prototype patches via stored cleanup functions.
+    if (_lgRestore) {
+        try {
+            _lgRestore();
         }
+        catch { /* ignore */ }
+        ;
+        _lgRestore = null;
     }
-    catch { /* package may have been unloaded */ }
-    try {
-        if (_vercelAIRestore) {
+    if (_lcRestore) {
+        try {
+            _lcRestore();
+        }
+        catch { /* ignore */ }
+        ;
+        _lcRestore = null;
+    }
+    if (_vercelAIRestore) {
+        try {
             _vercelAIRestore();
-            _vercelAIRestore = null;
         }
+        catch { /* ignore */ }
+        ;
+        _vercelAIRestore = null;
     }
-    catch { /* package may have been unloaded */ }
-    // Flush buffered spans and wait up to 300 ms for in-flight HTTP requests to
-    // complete.  This prevents spans from being lost on SIGTERM.
+    // Flush buffered spans and wait up to 300 ms for in-flight HTTP requests.
     await client.batcher.shutdown();
 }
 // ---------------------------------------------------------------------------

package/dist/esm/integrations/langchain.js

@@ -7,19 +7,19 @@ export const activeLangChainStorage = new AsyncLocalStorage();
 // ---------------------------------------------------------------------------
 // LangChain token extraction
 // Different providers nest token usage in different locations.
-// Check in the order specified by the spec.
 // ---------------------------------------------------------------------------
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 function extractTokenUsage(output) {
     const usage = output?.llmOutput?.tokenUsage
         ?? output?.llmOutput?.usage
         ?? output?.generations?.[0]?.[0]?.generationInfo?.usage;
-    // Use ?? not || so token counts of 0 are preserved correctly.
     return {
         inputTokens: usage?.promptTokens ?? usage?.input_tokens ?? 0,
         outputTokens: usage?.completionTokens ?? usage?.output_tokens ?? 0,
     };
 }
+// Internal LangGraph system node names — never emit agent_start spans for these.
+export const LANGGRAPH_INTERNAL_NODES = new Set(['__start__', '__end__', 'LangGraph']);
 // ---------------------------------------------------------------------------
 // LangChainCallback
 // ---------------------------------------------------------------------------
@@ -30,23 +30,21 @@ export class LangChainCallback {
     constructor(options) {
         // Required by @langchain/core v1+ for proper callback registration.
         // Without `name`, ensureHandler() wraps via fromMethods() which drops prototype methods.
-        // Without `awaitHandlers`, callbacks run in a background queue (p-queue) and fire
-        // after model.invoke() returns — causing spans to be missed on flush/completeTrace.
+        // Without `awaitHandlers`, callbacks run in a background queue and fire after
+        // model.invoke() returns — causing spans to be missed on flush/completeTrace.
         this.name = 'visibe-langchain-callback';
         this.awaitHandlers = true;
         this.raiseError = false;
         // Maps LangChain runId → our spanId so we can set parent_span_id.
         this.runIdToSpanId = new Map();
-        // Tracks start times so we can compute durationMs.
-        this.pendingLLMCalls = new Map(); // runId → startMs
+        // Pending LLM calls: runId → { startMs, model, inputText }
+        this.pendingLLMCalls = new Map();
         this.pendingToolCalls = new Map();
         this.stepCounter = 0;
-        // Agents we have already emitted agent_start spans for.
-        this.seenAgents = new Set();
-        // Token / call accumulators — updated by handleLLMEnd, read by patchCompiledStateGraph
-        // and patchRunnableSequence to populate completeTrace totals.
+        // Token / call / cost accumulators — read by patchCompiledStateGraph / patchRunnableSequence.
         this.totalInputTokens = 0;
         this.totalOutputTokens = 0;
+        this.totalCost = 0;
         this.llmCallCount = 0;
         this.visibe = options.visibe;
         this.traceId = options.traceId;
@@ -55,17 +53,40 @@ export class LangChainCallback {
     // ---------------------------------------------------------------------------
     // LLM events
     // ---------------------------------------------------------------------------
+    // Called for text-completion models.
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    async handleLLMStart(_llm, _messages, runId) {
-        this.pendingLLMCalls.set(runId, Date.now());
+    async handleLLMStart(llm, prompts, runId) {
+        const model = llm?.kwargs?.model ?? llm?.kwargs?.model_name ?? undefined;
+        const inputText = Array.isArray(prompts) ? prompts.join('\n') : '';
+        this.pendingLLMCalls.set(runId, { startMs: Date.now(), model, inputText });
+    }
+    // Called for chat models (ChatOpenAI, ChatAnthropic, etc.).
+    // messages is BaseMessage[][] — one array per parallel completion request.
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    async handleChatModelStart(llm, messages, runId) {
+        const model = llm?.kwargs?.model ?? llm?.kwargs?.model_name ?? undefined;
+        let inputText = '';
+        try {
+            const msgs = messages?.[0] ?? [];
+            inputText = msgs.map((m) => {
+                const role = m?.getType?.() ?? m?._getType?.() ?? m?.role ?? 'user';
+                const content = typeof m?.content === 'string'
+                    ? m.content
+                    : JSON.stringify(m?.content ?? '');
+                return `${role}: ${content}`;
+            }).join('\n');
+        }
+        catch { /* ignore serialisation errors */ }
+        this.pendingLLMCalls.set(runId, { startMs: Date.now(), model, inputText });
     }
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     async handleLLMEnd(output, runId, parentRunId) {
-        const startMs = this.pendingLLMCalls.get(runId) ?? Date.now();
+        const pending = this.pendingLLMCalls.get(runId) ?? { startMs: Date.now() };
         this.pendingLLMCalls.delete(runId);
         const { inputTokens, outputTokens } = extractTokenUsage(output);
         const gen = output?.generations?.[0]?.[0];
-        const model = gen?.generationInfo?.model ?? this.agentName;
+        // Prefer model saved at LLM-start, fall back to generationInfo, then agentName.
+        const model = pending.model ?? gen?.generationInfo?.model ?? this.agentName;
         const cost = calculateCost(model, inputTokens, outputTokens);
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         const rawText = gen?.text ?? gen?.message?.content ?? '';
@@ -81,16 +102,15 @@ export class LangChainCallback {
             status: 'success',
             inputTokens,
             outputTokens,
-            inputText: '', // LangChain doesn't surface the raw prompt here
+            inputText: pending.inputText ?? '',
             outputText,
-            durationMs: Date.now() - startMs,
+            durationMs: Date.now() - pending.startMs,
         });
         this.visibe.batcher.add(this.traceId, span);
-        // Update local accumulators (used by patchCompiledStateGraph / patchRunnableSequence).
         this.totalInputTokens += inputTokens;
         this.totalOutputTokens += outputTokens;
+        this.totalCost += cost;
         this.llmCallCount++;
-        // Notify track() accumulator if running inside a group tracker.
         this._onLLMSpan?.(inputTokens, outputTokens, cost);
     }
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -139,16 +159,15 @@ export class LangChainCallback {
     }
     // ---------------------------------------------------------------------------
     // Chain events
+    //
+    // In LangGraph v1.2+, the node key is passed as the 8th `name` parameter, NOT
+    // via chain.name. We always store runId → spanId so nested LLM/tool calls get
+    // a valid parent_span_id regardless of whether the chain is a user-defined node.
     // ---------------------------------------------------------------------------
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    async handleChainStart(chain, _inputs, runId, parentRunId) {
-        // Emit an agent_start span the first time we see a named chain.
-        const chainName = chain?.id?.at(-1) ?? '';
-        if (chainName && !this.seenAgents.has(chainName)) {
-            this.seenAgents.add(chainName);
-            const spanId = this.nextSpanId();
-            this.runIdToSpanId.set(runId, spanId);
-            void parentRunId; // suppress unused warning
+    async handleChainStart(_chain, _inputs, runId, _parentRunId, _tags, _metadata, _runType, _name) {
+        if (!this.runIdToSpanId.has(runId)) {
+            this.runIdToSpanId.set(runId, this.nextSpanId());
         }
     }
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -174,7 +193,6 @@ export function patchRunnableSequence(lcModule, visibe) {
     const originalStream = RunnableSequence.prototype.stream;
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     RunnableSequence.prototype.invoke = async function (input, config) {
-        // If already inside a LangChain trace, pass through.
         if (activeLangChainStorage.getStore() !== undefined) {
             return originalInvoke.call(this, input, config);
         }
@@ -189,6 +207,7 @@ export function patchRunnableSequence(lcModule, visibe) {
             ...(visibe.sessionId ? { session_id: visibe.sessionId } : {}),
         });
         const cb = new LangChainCallback({ visibe, traceId, agentName: 'langchain' });
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         let result;
         let status = 'completed';
         try {
@@ -205,6 +224,7 @@ export function patchRunnableSequence(lcModule, visibe) {
                 ended_at: new Date().toISOString(),
                 duration_ms: Date.now() - startMs,
                 llm_call_count: cb.llmCallCount,
+                total_cost: cb.totalCost,
                 total_tokens: cb.totalInputTokens + cb.totalOutputTokens,
                 total_input_tokens: cb.totalInputTokens,
                 total_output_tokens: cb.totalOutputTokens,
@@ -231,9 +251,6 @@ export function patchRunnableSequence(lcModule, visibe) {
         const cb = new LangChainCallback({ visibe, traceId, agentName: 'langchain' });
         let status = 'completed';
         try {
-            // RunnableSequence.stream() is an async function (not async generator) returning
-            // a Promise<AsyncIterable>. activeLangChainStorage.run returns that Promise,
-            // so we must await before yield*.
             const gen = await activeLangChainStorage.run(cb, () => originalStream.call(this, input, _mergeCallbacks(config, cb)));
             yield* gen;
         }
@@ -248,6 +265,7 @@ export function patchRunnableSequence(lcModule, visibe) {
                 ended_at: new Date().toISOString(),
                 duration_ms: Date.now() - startMs,
                 llm_call_count: cb.llmCallCount,
+                total_cost: cb.totalCost,
                 total_tokens: cb.totalInputTokens + cb.totalOutputTokens,
                 total_input_tokens: cb.totalInputTokens,
                 total_output_tokens: cb.totalOutputTokens,
@@ -262,7 +280,6 @@ export function patchRunnableSequence(lcModule, visibe) {
 // ---------------------------------------------------------------------------
 // Private helpers
 // ---------------------------------------------------------------------------
-// Merge our callback into an existing LangChain config object.
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 function _mergeCallbacks(config, cb) {
     if (!config)

package/dist/esm/integrations/langgraph.js

@@ -1,5 +1,5 @@
 import { randomUUID } from 'node:crypto';
-import { LangChainCallback, activeLangChainStorage } from './langchain.js';
+import { LangChainCallback, activeLangChainStorage, LANGGRAPH_INTERNAL_NODES } from './langchain.js';
 // ---------------------------------------------------------------------------
 // LangGraphCallback
 // Extends LangChainCallback and adds node-level agent_start spans.
@@ -9,24 +9,26 @@ export class LangGraphCallback extends LangChainCallback {
         super(options);
         this.nodeNames = new Set(options.nodeNames ?? []);
     }
-    // Override handleChainStart to emit agent_start for known graph nodes.
+    // Override handleChainStart to emit agent_start spans for LangGraph nodes.
+    //
+    // In LangGraph v1.2+, the node key is the 8th `name` parameter (not chain.name).
+    // Internal system nodes (__start__, __end__, LangGraph) are filtered out.
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    async handleChainStart(chain, inputs, runId, parentRunId) {
-        // LangGraph may surface the node key in chain.name (run name) or chain.id[-1] (class name).
-        const chainName = chain?.name ?? chain?.id?.at(-1) ?? '';
-        if (chainName && this.nodeNames.has(chainName)) {
-            const spanId = this.nextSpanId();
+    async handleChainStart(chain, inputs, runId, parentRunId, tags, metadata, runType, name) {
+        // Always track the runId so child LLM calls can resolve parent_span_id.
+        await super.handleChainStart(chain, inputs, runId, parentRunId, tags, metadata, runType, name);
+        // The node key is passed as the 8th `name` parameter in LangGraph v1.2+.
+        // Fall back to chain.name for older versions.
+        const nodeName = name ?? chain?.name ?? '';
+        if (nodeName && !LANGGRAPH_INTERNAL_NODES.has(nodeName)) {
+            // Use the spanId already assigned by super for this runId.
+            const spanId = this.runIdToSpanId.get(runId) ?? this.nextSpanId();
             this.runIdToSpanId.set(runId, spanId);
-            // Emit an agent_start span for this node.
-            // type MUST be exactly "agent_start" — the backend validates this string.
             this.visibe.batcher.add(this.traceId, this.visibe.buildAgentStartSpan({
                 spanId,
-                agentName: chainName,
+                agentName: nodeName,
             }));
-            // Don't call super — we've already set the runId mapping.
-            return;
         }
-        await super.handleChainStart(chain, inputs, runId, parentRunId);
     }
 }
 // ---------------------------------------------------------------------------
@@ -82,6 +84,7 @@ export function patchCompiledStateGraph(lgModule, visibe) {
                 ended_at: new Date().toISOString(),
                 duration_ms: Date.now() - startMs,
                 llm_call_count: cb.llmCallCount,
+                total_cost: cb.totalCost,
                 total_tokens: cb.totalInputTokens + cb.totalOutputTokens,
                 total_input_tokens: cb.totalInputTokens,
                 total_output_tokens: cb.totalOutputTokens,
@@ -133,6 +136,7 @@ export function patchCompiledStateGraph(lgModule, visibe) {
                 ended_at: new Date().toISOString(),
                 duration_ms: Date.now() - startMs,
                 llm_call_count: cb.llmCallCount,
+                total_cost: cb.totalCost,
                 total_tokens: cb.totalInputTokens + cb.totalOutputTokens,
                 total_input_tokens: cb.totalInputTokens,
                 total_output_tokens: cb.totalOutputTokens,