@visibe.ai/node 0.1.21 → 0.1.23

package/dist/cjs/index.js

@@ -100,6 +100,8 @@ async function patchFramework(framework, client) {
     try {
         switch (framework) {
             case 'openai': {
+                if (_originalOpenAI)
+                    break; // already patched by _syncPatch()
                 // eslint-disable-next-line @typescript-eslint/no-explicit-any
                 const openaiModule = await Promise.resolve().then(() => __importStar(require('openai')));
                 _originalOpenAI = openaiModule.OpenAI ?? openaiModule.default;
@@ -128,6 +130,8 @@ async function patchFramework(framework, client) {
                 break;
             }
             case 'anthropic': {
+                if (_originalAnthropic)
+                    break; // already patched by _syncPatch()
                 // 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;
@@ -154,6 +158,8 @@ async function patchFramework(framework, client) {
                 break;
             }
             case 'bedrock': {
+                if (_originalBedrockClient)
+                    break; // already patched by _syncPatch()
                 // 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;
@@ -190,12 +196,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': {
@@ -225,6 +244,98 @@ async function _autoPatch(client, frameworks) {
     }
 }
 // ---------------------------------------------------------------------------
+// _syncPatch() — synchronous CJS patching.
+//
+// In CJS builds, require() is synchronous so we can patch framework modules
+// inline inside init() BEFORE it returns.  This means instances created right
+// after init() (e.g. `const client = new OpenAI()`) are already using the
+// patched class — no async race condition.
+//
+// In ESM builds, require is undefined — the entire function silently no-ops
+// and _autoPatch() handles instrumentation via dynamic import() instead.
+// ---------------------------------------------------------------------------
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function _makePatchedClass(Orig, client) {
+    return class Patched extends Orig {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        constructor(...args) {
+            super(...args);
+            try {
+                client.instrument(this);
+            }
+            catch { /* never crash constructor */ }
+        }
+    };
+}
+function _syncPatch(client, frameworksToTry) {
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    if (typeof require === 'undefined')
+        return;
+    for (const fw of frameworksToTry) {
+        try {
+            switch (fw) {
+                case 'openai': {
+                    if (_originalOpenAI)
+                        break;
+                    // eslint-disable-next-line @typescript-eslint/no-require-imports, @typescript-eslint/no-explicit-any
+                    const m = require('openai');
+                    const Orig = m.OpenAI ?? m.default;
+                    if (!Orig)
+                        break;
+                    _originalOpenAI = Orig;
+                    const Patched = _makePatchedClass(Orig, client);
+                    try {
+                        _setProp(m, 'OpenAI', Patched);
+                        _setProp(m, 'default', Patched);
+                    }
+                    catch {
+                        _originalOpenAI = null;
+                    }
+                    break;
+                }
+                case 'anthropic': {
+                    if (_originalAnthropic)
+                        break;
+                    // eslint-disable-next-line @typescript-eslint/no-require-imports, @typescript-eslint/no-explicit-any
+                    const m = require('@anthropic-ai/sdk');
+                    const Orig = m.Anthropic ?? m.default;
+                    if (!Orig)
+                        break;
+                    _originalAnthropic = Orig;
+                    const Patched = _makePatchedClass(Orig, client);
+                    try {
+                        _setProp(m, 'Anthropic', Patched);
+                        _setProp(m, 'default', Patched);
+                    }
+                    catch {
+                        _originalAnthropic = null;
+                    }
+                    break;
+                }
+                case 'bedrock': {
+                    if (_originalBedrockClient)
+                        break;
+                    // eslint-disable-next-line @typescript-eslint/no-require-imports, @typescript-eslint/no-explicit-any
+                    const m = require('@aws-sdk/client-bedrock-runtime');
+                    const Orig = m.BedrockRuntimeClient;
+                    if (!Orig)
+                        break;
+                    _originalBedrockClient = Orig;
+                    const Patched = _makePatchedClass(Orig, client);
+                    try {
+                        m.BedrockRuntimeClient = Patched;
+                    }
+                    catch {
+                        _originalBedrockClient = null;
+                    }
+                    break;
+                }
+            }
+        }
+        catch { /* package not installed — skip */ }
+    }
+}
+// ---------------------------------------------------------------------------
 // init()
 // ---------------------------------------------------------------------------
 function init(options) {
@@ -233,10 +344,13 @@ function init(options) {
         return _globalClient;
     }
     _globalClient = new client_1.Visibe(options ?? {});
-    // 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;
+    // Synchronous CJS path — patches module exports inline so instances created
+    // right after init() (e.g. `const client = new OpenAI()`) are instrumented.
+    // In ESM, require is undefined and this silently no-ops.
+    _syncPatch(_globalClient, frameworksToTry);
+    // Async path — handles ESM and framework detection for LangChain/LangGraph
+    // (prototype patches don't need to be synchronous).
     _autoPatch(_globalClient, frameworksToTry).catch(() => { });
     if (!_shutdownRegistered) {
         const graceful = async () => { await shutdown(); process.exit(0); };

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/cjs/integrations/openai.js

@@ -152,8 +152,9 @@ class OpenAIIntegration extends base_1.BaseIntegration {
             throw err;
         }
         const model = response.model ?? params.model ?? 'unknown';
-        const inputTokens = response.usage?.prompt_tokens ?? 0;
-        const outputTokens = response.usage?.completion_tokens ?? 0;
+        // Support both openai v4 (prompt_tokens/completion_tokens) and v5/v6 (input_tokens/output_tokens)
+        const inputTokens = response.usage?.prompt_tokens ?? response.usage?.input_tokens ?? 0;
+        const outputTokens = response.usage?.completion_tokens ?? response.usage?.output_tokens ?? 0;
         const cost = (0, utils_1.calculateCost)(model, inputTokens, outputTokens);
         const choice = response.choices?.[0];
         const rawContent = choice?.message?.content;
@@ -244,9 +245,10 @@ class OpenAIIntegration extends base_1.BaseIntegration {
                             if (delta)
                                 outputText += delta;
                             // Last chunk carries usage when stream_options.include_usage is set
+                            // Support both openai v4 (prompt_tokens/completion_tokens) and v5/v6 (input_tokens/output_tokens)
                             if (chunk.usage) {
-                                inputTokens = chunk.usage.prompt_tokens ?? 0;
-                                outputTokens = chunk.usage.completion_tokens ?? 0;
+                                inputTokens = chunk.usage.prompt_tokens ?? chunk.usage.input_tokens ?? 0;
+                                outputTokens = chunk.usage.completion_tokens ?? chunk.usage.output_tokens ?? 0;
                             }
                         }
                         return result;

package/dist/esm/index.js

@@ -61,6 +61,8 @@ async function patchFramework(framework, client) {
     try {
         switch (framework) {
             case 'openai': {
+                if (_originalOpenAI)
+                    break; // already patched by _syncPatch()
                 // eslint-disable-next-line @typescript-eslint/no-explicit-any
                 const openaiModule = await import('openai');
                 _originalOpenAI = openaiModule.OpenAI ?? openaiModule.default;
@@ -89,6 +91,8 @@ async function patchFramework(framework, client) {
                 break;
             }
             case 'anthropic': {
+                if (_originalAnthropic)
+                    break; // already patched by _syncPatch()
                 // eslint-disable-next-line @typescript-eslint/no-explicit-any
                 const anthropicModule = await import('@anthropic-ai/sdk');
                 _originalAnthropic = anthropicModule.Anthropic ?? anthropicModule.default;
@@ -115,6 +119,8 @@ async function patchFramework(framework, client) {
                 break;
             }
             case 'bedrock': {
+                if (_originalBedrockClient)
+                    break; // already patched by _syncPatch()
                 // eslint-disable-next-line @typescript-eslint/no-explicit-any
                 const bedrockModule = await import('@aws-sdk/client-bedrock-runtime');
                 _originalBedrockClient = bedrockModule.BedrockRuntimeClient;
@@ -151,12 +157,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': {
@@ -186,6 +205,98 @@ async function _autoPatch(client, frameworks) {
     }
 }
 // ---------------------------------------------------------------------------
+// _syncPatch() — synchronous CJS patching.
+//
+// In CJS builds, require() is synchronous so we can patch framework modules
+// inline inside init() BEFORE it returns.  This means instances created right
+// after init() (e.g. `const client = new OpenAI()`) are already using the
+// patched class — no async race condition.
+//
+// In ESM builds, require is undefined — the entire function silently no-ops
+// and _autoPatch() handles instrumentation via dynamic import() instead.
+// ---------------------------------------------------------------------------
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function _makePatchedClass(Orig, client) {
+    return class Patched extends Orig {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        constructor(...args) {
+            super(...args);
+            try {
+                client.instrument(this);
+            }
+            catch { /* never crash constructor */ }
+        }
+    };
+}
+function _syncPatch(client, frameworksToTry) {
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    if (typeof require === 'undefined')
+        return;
+    for (const fw of frameworksToTry) {
+        try {
+            switch (fw) {
+                case 'openai': {
+                    if (_originalOpenAI)
+                        break;
+                    // eslint-disable-next-line @typescript-eslint/no-require-imports, @typescript-eslint/no-explicit-any
+                    const m = require('openai');
+                    const Orig = m.OpenAI ?? m.default;
+                    if (!Orig)
+                        break;
+                    _originalOpenAI = Orig;
+                    const Patched = _makePatchedClass(Orig, client);
+                    try {
+                        _setProp(m, 'OpenAI', Patched);
+                        _setProp(m, 'default', Patched);
+                    }
+                    catch {
+                        _originalOpenAI = null;
+                    }
+                    break;
+                }
+                case 'anthropic': {
+                    if (_originalAnthropic)
+                        break;
+                    // eslint-disable-next-line @typescript-eslint/no-require-imports, @typescript-eslint/no-explicit-any
+                    const m = require('@anthropic-ai/sdk');
+                    const Orig = m.Anthropic ?? m.default;
+                    if (!Orig)
+                        break;
+                    _originalAnthropic = Orig;
+                    const Patched = _makePatchedClass(Orig, client);
+                    try {
+                        _setProp(m, 'Anthropic', Patched);
+                        _setProp(m, 'default', Patched);
+                    }
+                    catch {
+                        _originalAnthropic = null;
+                    }
+                    break;
+                }
+                case 'bedrock': {
+                    if (_originalBedrockClient)
+                        break;
+                    // eslint-disable-next-line @typescript-eslint/no-require-imports, @typescript-eslint/no-explicit-any
+                    const m = require('@aws-sdk/client-bedrock-runtime');
+                    const Orig = m.BedrockRuntimeClient;
+                    if (!Orig)
+                        break;
+                    _originalBedrockClient = Orig;
+                    const Patched = _makePatchedClass(Orig, client);
+                    try {
+                        m.BedrockRuntimeClient = Patched;
+                    }
+                    catch {
+                        _originalBedrockClient = null;
+                    }
+                    break;
+                }
+            }
+        }
+        catch { /* package not installed — skip */ }
+    }
+}
+// ---------------------------------------------------------------------------
 // init()
 // ---------------------------------------------------------------------------
 export function init(options) {
@@ -194,10 +305,13 @@ export function init(options) {
         return _globalClient;
     }
     _globalClient = new Visibe(options ?? {});
-    // 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;
+    // Synchronous CJS path — patches module exports inline so instances created
+    // right after init() (e.g. `const client = new OpenAI()`) are instrumented.
+    // In ESM, require is undefined and this silently no-ops.
+    _syncPatch(_globalClient, frameworksToTry);
+    // Async path — handles ESM and framework detection for LangChain/LangGraph
+    // (prototype patches don't need to be synchronous).
     _autoPatch(_globalClient, frameworksToTry).catch(() => { });
     if (!_shutdownRegistered) {
         const graceful = async () => { await shutdown(); process.exit(0); };

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/esm/integrations/openai.js

@@ -148,8 +148,9 @@ export class OpenAIIntegration extends BaseIntegration {
             throw err;
         }
         const model = response.model ?? params.model ?? 'unknown';
-        const inputTokens = response.usage?.prompt_tokens ?? 0;
-        const outputTokens = response.usage?.completion_tokens ?? 0;
+        // Support both openai v4 (prompt_tokens/completion_tokens) and v5/v6 (input_tokens/output_tokens)
+        const inputTokens = response.usage?.prompt_tokens ?? response.usage?.input_tokens ?? 0;
+        const outputTokens = response.usage?.completion_tokens ?? response.usage?.output_tokens ?? 0;
         const cost = calculateCost(model, inputTokens, outputTokens);
         const choice = response.choices?.[0];
         const rawContent = choice?.message?.content;
@@ -240,9 +241,10 @@ export class OpenAIIntegration extends BaseIntegration {
                             if (delta)
                                 outputText += delta;
                             // Last chunk carries usage when stream_options.include_usage is set
+                            // Support both openai v4 (prompt_tokens/completion_tokens) and v5/v6 (input_tokens/output_tokens)
                             if (chunk.usage) {
-                                inputTokens = chunk.usage.prompt_tokens ?? 0;
-                                outputTokens = chunk.usage.completion_tokens ?? 0;
+                                inputTokens = chunk.usage.prompt_tokens ?? chunk.usage.input_tokens ?? 0;
+                                outputTokens = chunk.usage.completion_tokens ?? chunk.usage.output_tokens ?? 0;
                             }
                         }
                         return result;

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.23",
   "description": "AI Agent Observability — Track OpenAI, LangChain, LangGraph, Bedrock, Vercel AI, Anthropic",
   "main": "dist/cjs/index.js",
   "module": "dist/esm/index.js",