@visibe.ai/node 0.1.21 → 0.1.22

package/dist/cjs/index.js

@@ -190,12 +190,25 @@ async function patchFramework(framework, client) {
             }
             case 'langchain': {
                 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                const { patchRunnableSequence } = await Promise.resolve().then(() => __importStar(require('./integrations/langchain')));
+                const { patchRunnableSequence, patchAgentExecutor } = 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;
+                const r1 = patchRunnableSequence(lcModule, client);
+                // Also patch AgentExecutor (langchain/agents) if installed — AgentExecutor is NOT a
+                // RunnableSequence so without this patch each agent loop iteration creates a separate trace.
+                let r2;
+                try {
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    const agentsModule = await Promise.resolve().then(() => __importStar(require('langchain/agents')));
+                    r2 = patchAgentExecutor(agentsModule, client);
+                }
+                catch { /* langchain package not installed — skip */ }
+                _lcRestore = () => {
+                    if (typeof r1 === 'function')
+                        r1();
+                    if (typeof r2 === 'function')
+                        r2();
+                };
                 break;
             }
             case 'vercel_ai': {

package/dist/cjs/integrations/langchain.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LangChainCallback = exports.LANGGRAPH_INTERNAL_NODES = exports.activeLangChainStorage = void 0;
 exports.patchRunnableSequence = patchRunnableSequence;
+exports.patchAgentExecutor = patchAgentExecutor;
 const node_async_hooks_1 = require("node:async_hooks");
 const node_crypto_1 = require("node:crypto");
 const utils_1 = require("../utils");
@@ -312,6 +313,109 @@ function patchRunnableSequence(lcModule, visibe) {
     };
 }
 // ---------------------------------------------------------------------------
+// patchAgentExecutor — patches AgentExecutor from `langchain/agents` so the
+// entire multi-step agent loop is captured as ONE trace.
+//
+// AgentExecutor is NOT a RunnableSequence — it extends Runnable directly and
+// calls the inner agent RunnableSequence in a loop.  Without this patch each
+// iteration fires patchRunnableSequence and creates a separate trace.
+// ---------------------------------------------------------------------------
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function patchAgentExecutor(agentsModule, visibe) {
+    const AgentExecutor = agentsModule?.AgentExecutor;
+    if (!AgentExecutor)
+        return () => { };
+    const originalInvoke = AgentExecutor.prototype.invoke;
+    const originalStream = AgentExecutor.prototype.stream;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    AgentExecutor.prototype.invoke = async function (input, config) {
+        if (exports.activeLangChainStorage.getStore() !== undefined) {
+            return originalInvoke.call(this, input, config);
+        }
+        const traceId = (0, node_crypto_1.randomUUID)();
+        const startedAt = new Date().toISOString();
+        const startMs = Date.now();
+        const agentName = this.name ?? 'langchain';
+        await visibe.apiClient.createTrace({
+            trace_id: traceId,
+            name: agentName,
+            framework: 'langchain',
+            started_at: startedAt,
+            ...(visibe.sessionId ? { session_id: visibe.sessionId } : {}),
+        });
+        const cb = new LangChainCallback({ visibe, traceId, agentName });
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        let result;
+        let status = 'completed';
+        try {
+            result = await exports.activeLangChainStorage.run(cb, () => originalInvoke.call(this, input, _mergeCallbacks(config, cb)));
+        }
+        catch (err) {
+            status = 'failed';
+            throw err;
+        }
+        finally {
+            visibe.batcher.flush();
+            await visibe.apiClient.completeTrace(traceId, {
+                status,
+                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,
+            });
+        }
+        return result;
+    };
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    AgentExecutor.prototype.stream = async function* (input, config) {
+        if (exports.activeLangChainStorage.getStore() !== undefined) {
+            yield* (await originalStream.call(this, input, config));
+            return;
+        }
+        const traceId = (0, node_crypto_1.randomUUID)();
+        const startedAt = new Date().toISOString();
+        const startMs = Date.now();
+        const agentName = this.name ?? 'langchain';
+        await visibe.apiClient.createTrace({
+            trace_id: traceId,
+            name: agentName,
+            framework: 'langchain',
+            started_at: startedAt,
+            ...(visibe.sessionId ? { session_id: visibe.sessionId } : {}),
+        });
+        const cb = new LangChainCallback({ visibe, traceId, agentName });
+        let status = 'completed';
+        try {
+            const gen = await exports.activeLangChainStorage.run(cb, () => originalStream.call(this, input, _mergeCallbacks(config, cb)));
+            yield* gen;
+        }
+        catch (err) {
+            status = 'failed';
+            throw err;
+        }
+        finally {
+            visibe.batcher.flush();
+            await visibe.apiClient.completeTrace(traceId, {
+                status,
+                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,
+            });
+        }
+    };
+    return () => {
+        AgentExecutor.prototype.invoke = originalInvoke;
+        AgentExecutor.prototype.stream = originalStream;
+    };
+}
+// ---------------------------------------------------------------------------
 // Private helpers
 // ---------------------------------------------------------------------------
 // eslint-disable-next-line @typescript-eslint/no-explicit-any

package/dist/esm/index.js

@@ -151,12 +151,25 @@ async function patchFramework(framework, client) {
             }
             case 'langchain': {
                 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                const { patchRunnableSequence } = await import('./integrations/langchain.js');
+                const { patchRunnableSequence, patchAgentExecutor } = 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;
+                const r1 = patchRunnableSequence(lcModule, client);
+                // Also patch AgentExecutor (langchain/agents) if installed — AgentExecutor is NOT a
+                // RunnableSequence so without this patch each agent loop iteration creates a separate trace.
+                let r2;
+                try {
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    const agentsModule = await import('langchain/agents');
+                    r2 = patchAgentExecutor(agentsModule, client);
+                }
+                catch { /* langchain package not installed — skip */ }
+                _lcRestore = () => {
+                    if (typeof r1 === 'function')
+                        r1();
+                    if (typeof r2 === 'function')
+                        r2();
+                };
                 break;
             }
             case 'vercel_ai': {

package/dist/esm/integrations/langchain.js

@@ -307,6 +307,109 @@ export function patchRunnableSequence(lcModule, visibe) {
     };
 }
 // ---------------------------------------------------------------------------
+// patchAgentExecutor — patches AgentExecutor from `langchain/agents` so the
+// entire multi-step agent loop is captured as ONE trace.
+//
+// AgentExecutor is NOT a RunnableSequence — it extends Runnable directly and
+// calls the inner agent RunnableSequence in a loop.  Without this patch each
+// iteration fires patchRunnableSequence and creates a separate trace.
+// ---------------------------------------------------------------------------
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function patchAgentExecutor(agentsModule, visibe) {
+    const AgentExecutor = agentsModule?.AgentExecutor;
+    if (!AgentExecutor)
+        return () => { };
+    const originalInvoke = AgentExecutor.prototype.invoke;
+    const originalStream = AgentExecutor.prototype.stream;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    AgentExecutor.prototype.invoke = async function (input, config) {
+        if (activeLangChainStorage.getStore() !== undefined) {
+            return originalInvoke.call(this, input, config);
+        }
+        const traceId = randomUUID();
+        const startedAt = new Date().toISOString();
+        const startMs = Date.now();
+        const agentName = this.name ?? 'langchain';
+        await visibe.apiClient.createTrace({
+            trace_id: traceId,
+            name: agentName,
+            framework: 'langchain',
+            started_at: startedAt,
+            ...(visibe.sessionId ? { session_id: visibe.sessionId } : {}),
+        });
+        const cb = new LangChainCallback({ visibe, traceId, agentName });
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        let result;
+        let status = 'completed';
+        try {
+            result = await activeLangChainStorage.run(cb, () => originalInvoke.call(this, input, _mergeCallbacks(config, cb)));
+        }
+        catch (err) {
+            status = 'failed';
+            throw err;
+        }
+        finally {
+            visibe.batcher.flush();
+            await visibe.apiClient.completeTrace(traceId, {
+                status,
+                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,
+            });
+        }
+        return result;
+    };
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    AgentExecutor.prototype.stream = async function* (input, config) {
+        if (activeLangChainStorage.getStore() !== undefined) {
+            yield* (await originalStream.call(this, input, config));
+            return;
+        }
+        const traceId = randomUUID();
+        const startedAt = new Date().toISOString();
+        const startMs = Date.now();
+        const agentName = this.name ?? 'langchain';
+        await visibe.apiClient.createTrace({
+            trace_id: traceId,
+            name: agentName,
+            framework: 'langchain',
+            started_at: startedAt,
+            ...(visibe.sessionId ? { session_id: visibe.sessionId } : {}),
+        });
+        const cb = new LangChainCallback({ visibe, traceId, agentName });
+        let status = 'completed';
+        try {
+            const gen = await activeLangChainStorage.run(cb, () => originalStream.call(this, input, _mergeCallbacks(config, cb)));
+            yield* gen;
+        }
+        catch (err) {
+            status = 'failed';
+            throw err;
+        }
+        finally {
+            visibe.batcher.flush();
+            await visibe.apiClient.completeTrace(traceId, {
+                status,
+                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,
+            });
+        }
+    };
+    return () => {
+        AgentExecutor.prototype.invoke = originalInvoke;
+        AgentExecutor.prototype.stream = originalStream;
+    };
+}
+// ---------------------------------------------------------------------------
 // Private helpers
 // ---------------------------------------------------------------------------
 // eslint-disable-next-line @typescript-eslint/no-explicit-any

package/dist/types/integrations/langchain.d.ts

@@ -49,3 +49,4 @@ export declare class LangChainCallback {
     _onToolSpan?: () => void;
 }
 export declare function patchRunnableSequence(lcModule: any, visibe: Visibe): () => void;
+export declare function patchAgentExecutor(agentsModule: any, visibe: Visibe): () => void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@visibe.ai/node",
-  "version": "0.1.21",
+  "version": "0.1.22",
   "description": "AI Agent Observability — Track OpenAI, LangChain, LangGraph, Bedrock, Vercel AI, Anthropic",
   "main": "dist/cjs/index.js",
   "module": "dist/esm/index.js",