@visibe.ai/node 0.1.16 → 0.1.18

package/dist/cjs/index.js

@@ -1,4 +1,37 @@
 "use strict";
+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.Visibe = void 0;
 exports.detectFrameworks = detectFrameworks;
@@ -10,30 +43,35 @@ const client_1 = require("./client");
 // ---------------------------------------------------------------------------
 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;
-    }
-}
 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'),
@@ -41,20 +79,32 @@ 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 Promise.resolve().then(() => __importStar(require('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) {
@@ -65,19 +115,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 Promise.resolve().then(() => __importStar(require('@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) {
@@ -88,17 +143,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 Promise.resolve().then(() => __importStar(require('@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);
@@ -108,39 +169,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 Promise.resolve().then(() => __importStar(require('@langchain/langgraph')));
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                const { patchCompiledStateGraph } = await Promise.resolve().then(() => __importStar(require('./integrations/langgraph')));
+                // 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 Promise.resolve().then(() => __importStar(require('./integrations/langchain')));
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                const lcModule = await Promise.resolve().then(() => __importStar(require('@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 Promise.resolve().then(() => __importStar(require('./integrations/vercel-ai')));
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                const aiModule = await Promise.resolve().then(() => __importStar(require('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()
 // ---------------------------------------------------------------------------
@@ -150,17 +233,11 @@ function init(options) {
         return _globalClient;
     }
     _globalClient = new client_1.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);
@@ -168,9 +245,6 @@ function init(options) {
         process.on('beforeExit', () => { shutdown().catch(() => { }); });
         _shutdownRegistered = true;
     }
-    if (_autoPatchedFrameworks.length > 0) {
-        console.log(`[Visibe] Auto-instrumented: ${_autoPatchedFrameworks.join(', ')}`);
-    }
     return _globalClient;
 }
 // ---------------------------------------------------------------------------
@@ -179,53 +253,65 @@ function init(options) {
 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 Promise.resolve().then(() => __importStar(require('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 Promise.resolve().then(() => __importStar(require('@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 Promise.resolve().then(() => __importStar(require('@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/cjs/integrations/langchain.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.LangChainCallback = exports.activeLangChainStorage = void 0;
+exports.LangChainCallback = exports.LANGGRAPH_INTERNAL_NODES = exports.activeLangChainStorage = void 0;
 exports.patchRunnableSequence = patchRunnableSequence;
 const node_async_hooks_1 = require("node:async_hooks");
 const node_crypto_1 = require("node:crypto");
@@ -11,19 +11,19 @@ exports.activeLangChainStorage = new node_async_hooks_1.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.
+exports.LANGGRAPH_INTERNAL_NODES = new Set(['__start__', '__end__', 'LangGraph']);
 // ---------------------------------------------------------------------------
 // LangChainCallback
 // ---------------------------------------------------------------------------
@@ -34,23 +34,21 @@ 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;
@@ -59,17 +57,40 @@ 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 = (0, utils_1.calculateCost)(model, inputTokens, outputTokens);
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         const rawText = gen?.text ?? gen?.message?.content ?? '';
@@ -85,16 +106,15 @@ 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
@@ -143,16 +163,15 @@ 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
@@ -179,7 +198,6 @@ 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 (exports.activeLangChainStorage.getStore() !== undefined) {
             return originalInvoke.call(this, input, config);
         }
@@ -194,6 +212,7 @@ 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 {
@@ -210,6 +229,7 @@ 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,
@@ -236,9 +256,6 @@ 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 exports.activeLangChainStorage.run(cb, () => originalStream.call(this, input, _mergeCallbacks(config, cb)));
             yield* gen;
         }
@@ -253,6 +270,7 @@ 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,
@@ -267,7 +285,6 @@ 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/cjs/integrations/langgraph.js

@@ -13,24 +13,26 @@ class LangGraphCallback extends langchain_1.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 && !langchain_1.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);
     }
 }
 exports.LangGraphCallback = LangGraphCallback;
@@ -87,6 +89,7 @@ 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,
@@ -138,6 +141,7 @@ 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,