@visibe.ai/node 0.1.28 → 0.1.29

package/dist/cjs/client.js

@@ -353,9 +353,12 @@ class Visibe {
         return {
             span_id: opts.spanId,
             type: 'agent_start', // EXACT string — backend validates this
-            timestamp: new Date().toISOString(),
+            timestamp: opts.timestamp ?? new Date().toISOString(),
             agent_name: opts.agentName,
             description: `Agent started: ${opts.agentName}`,
+            ...(opts.inputText !== undefined ? { input_text: opts.inputText } : {}),
+            ...(opts.outputText !== undefined ? { output_text: opts.outputText } : {}),
+            ...(opts.durationMs !== undefined ? { duration_ms: opts.durationMs } : {}),
         };
     }
 }

package/dist/cjs/integrations/langgraph.js

@@ -4,40 +4,73 @@ exports.LangGraphCallback = void 0;
 exports.patchCompiledStateGraph = patchCompiledStateGraph;
 const node_crypto_1 = require("node:crypto");
 const langchain_1 = require("./langchain");
-// ---------------------------------------------------------------------------
-// LangGraphCallback
-// Extends LangChainCallback and adds node-level agent_start spans.
-// ---------------------------------------------------------------------------
 class LangGraphCallback extends langchain_1.LangChainCallback {
     constructor(options) {
         super(options);
+        this.pendingAgentSpans = new Map();
         this.nodeNames = new Set(options.nodeNames ?? []);
         // LangGraphCallback emits its own agent_start spans per node — suppress the
         // base-class root-chain emission to avoid a spurious 'LangGraph' agent span.
         this._emitRootAgentStart = false;
     }
-    // Override handleChainStart to emit agent_start spans for LangGraph nodes.
+    // Buffer the span info on chain start — span is sent on chain end so we
+    // can include both input_text and output_text in a single agent_start span.
     //
     // 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, tags, metadata, runType, name) {
-        // Always track the runId so child LLM calls can resolve parent_span_id.
+        // Always let the base class track runId → spanId FIRST so child LLM calls
+        // (which fire between chain start and chain end) resolve parent_span_id correctly.
         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);
-            // Register agent name so _findAgentName() resolves it for child llm_call / tool_call spans.
-            this.runIdToAgentName.set(runId, nodeName);
-            this.visibe.batcher.add(this.traceId, this.visibe.buildAgentStartSpan({
-                spanId,
-                agentName: nodeName,
-            }));
-        }
+        if (!nodeName || langchain_1.LANGGRAPH_INTERNAL_NODES.has(nodeName))
+            return;
+        // Ensure the spanId is assigned to this runId before any child spans are emitted.
+        const spanId = this.runIdToSpanId.get(runId) ?? this.nextSpanId();
+        this.runIdToSpanId.set(runId, spanId);
+        // Register agent name so _findAgentName() resolves it for child llm_call / tool_call spans.
+        this.runIdToAgentName.set(runId, nodeName);
+        // Buffer — will be sent with output_text when handleChainEnd fires.
+        this.pendingAgentSpans.set(runId, {
+            spanId,
+            agentName: nodeName,
+            startMs: Date.now(),
+            timestamp: new Date().toISOString(),
+            inputText: (0, langchain_1.serializeInput)(inputs, 1000),
+        });
+    }
+    // Flush the buffered agent_start span with both input and output text.
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    async handleChainEnd(outputs, runId) {
+        const pending = this.pendingAgentSpans.get(runId);
+        if (!pending)
+            return;
+        this.pendingAgentSpans.delete(runId);
+        this.visibe.batcher.add(this.traceId, this.visibe.buildAgentStartSpan({
+            spanId: pending.spanId,
+            agentName: pending.agentName,
+            timestamp: pending.timestamp,
+            inputText: pending.inputText,
+            outputText: (0, langchain_1.serializeInput)(outputs, 1000),
+            durationMs: Date.now() - pending.startMs,
+        }));
+    }
+    // Also flush on chain error so the span is never silently dropped.
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    async handleChainError(err, runId) {
+        const pending = this.pendingAgentSpans.get(runId);
+        if (!pending)
+            return;
+        this.pendingAgentSpans.delete(runId);
+        this.visibe.batcher.add(this.traceId, this.visibe.buildAgentStartSpan({
+            spanId: pending.spanId,
+            agentName: pending.agentName,
+            timestamp: pending.timestamp,
+            inputText: pending.inputText,
+            outputText: `Error: ${err?.message ?? String(err)}`,
+            durationMs: Date.now() - pending.startMs,
+        }));
     }
 }
 exports.LangGraphCallback = LangGraphCallback;
@@ -105,12 +138,16 @@ function patchCompiledStateGraph(lgModule, visibe) {
         return result;
     };
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    CompiledStateGraph.prototype.stream = async function* (input, config) {
+    CompiledStateGraph.prototype.stream = async function (input, config) {
         if (langchain_1.activeLangChainStorage.getStore() !== undefined) {
-            // Pregel.stream() is a regular async function returning a Promise<AsyncIterable>.
-            // We must await it before yield*.
-            yield* (await originalStream.call(this, input, config));
-            return;
+            // Pass-through: return the original stream directly with NO generator wrapping.
+            //
+            // Pregel.stream() is a regular async function returning a Promise<IterableReadableStreamWithAbortSignal>.
+            // Wrapping it in an async function* (yield*) was the root cause of ALS context loss
+            // for later graph nodes — the extra generator delegation layer breaks AsyncLocalStorage
+            // propagation through the eager .then()-pump inside IterableReadableStreamWithAbortSignal.
+            // Returning the Promise directly restores the exact original behavior.
+            return originalStream.call(this, input, config);
         }
         const traceId = (0, node_crypto_1.randomUUID)();
         const startedAt = new Date().toISOString();
@@ -131,31 +168,38 @@ function patchCompiledStateGraph(lgModule, visibe) {
             agentName: graphName,
             nodeNames,
         });
+        // Get the inner stream inside the ALS context so createAndRunLoop() (which runs
+        // fire-and-forget inside Pregel.stream()) inherits ALS = cb for all graph nodes.
+        const innerStream = await langchain_1.activeLangChainStorage.run(cb, () => originalStream.call(this, input, _mergeCallbacks(config, cb)));
+        // Return an async generator that wraps the stream for completion tracking.
+        // This path is only reached when the user calls app.stream() directly —
+        // not via app.invoke() (which takes the pass-through path above).
+        // createAndRunLoop() already runs in ALS = cb context (established above),
+        // so the generator wrapping here does NOT affect node ALS propagation.
         let status = 'completed';
-        try {
-            // activeLangChainStorage.run returns the callback's return value synchronously,
-            // which is a Promise<AsyncIterable> from Pregel.stream(). Await before yield*.
-            const gen = await langchain_1.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,
-                ...(cb.firstModel ? { model: cb.firstModel } : {}),
-            });
-        }
+        return (async function* () {
+            try {
+                yield* innerStream;
+            }
+            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,
+                    ...(cb.firstModel ? { model: cb.firstModel } : {}),
+                });
+            }
+        })();
     };
     return () => {
         CompiledStateGraph.prototype.invoke = originalInvoke;

package/dist/esm/client.js

@@ -350,9 +350,12 @@ export class Visibe {
         return {
             span_id: opts.spanId,
             type: 'agent_start', // EXACT string — backend validates this
-            timestamp: new Date().toISOString(),
+            timestamp: opts.timestamp ?? new Date().toISOString(),
             agent_name: opts.agentName,
             description: `Agent started: ${opts.agentName}`,
+            ...(opts.inputText !== undefined ? { input_text: opts.inputText } : {}),
+            ...(opts.outputText !== undefined ? { output_text: opts.outputText } : {}),
+            ...(opts.durationMs !== undefined ? { duration_ms: opts.durationMs } : {}),
         };
     }
 }

package/dist/esm/integrations/langgraph.js

@@ -1,39 +1,72 @@
 import { randomUUID } from 'node:crypto';
 import { LangChainCallback, activeLangChainStorage, LANGGRAPH_INTERNAL_NODES, serializeInput } from './langchain.js';
-// ---------------------------------------------------------------------------
-// LangGraphCallback
-// Extends LangChainCallback and adds node-level agent_start spans.
-// ---------------------------------------------------------------------------
 export class LangGraphCallback extends LangChainCallback {
     constructor(options) {
         super(options);
+        this.pendingAgentSpans = new Map();
         this.nodeNames = new Set(options.nodeNames ?? []);
         // LangGraphCallback emits its own agent_start spans per node — suppress the
         // base-class root-chain emission to avoid a spurious 'LangGraph' agent span.
         this._emitRootAgentStart = false;
     }
-    // Override handleChainStart to emit agent_start spans for LangGraph nodes.
+    // Buffer the span info on chain start — span is sent on chain end so we
+    // can include both input_text and output_text in a single agent_start span.
     //
     // 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, tags, metadata, runType, name) {
-        // Always track the runId so child LLM calls can resolve parent_span_id.
+        // Always let the base class track runId → spanId FIRST so child LLM calls
+        // (which fire between chain start and chain end) resolve parent_span_id correctly.
         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);
-            // Register agent name so _findAgentName() resolves it for child llm_call / tool_call spans.
-            this.runIdToAgentName.set(runId, nodeName);
-            this.visibe.batcher.add(this.traceId, this.visibe.buildAgentStartSpan({
-                spanId,
-                agentName: nodeName,
-            }));
-        }
+        if (!nodeName || LANGGRAPH_INTERNAL_NODES.has(nodeName))
+            return;
+        // Ensure the spanId is assigned to this runId before any child spans are emitted.
+        const spanId = this.runIdToSpanId.get(runId) ?? this.nextSpanId();
+        this.runIdToSpanId.set(runId, spanId);
+        // Register agent name so _findAgentName() resolves it for child llm_call / tool_call spans.
+        this.runIdToAgentName.set(runId, nodeName);
+        // Buffer — will be sent with output_text when handleChainEnd fires.
+        this.pendingAgentSpans.set(runId, {
+            spanId,
+            agentName: nodeName,
+            startMs: Date.now(),
+            timestamp: new Date().toISOString(),
+            inputText: serializeInput(inputs, 1000),
+        });
+    }
+    // Flush the buffered agent_start span with both input and output text.
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    async handleChainEnd(outputs, runId) {
+        const pending = this.pendingAgentSpans.get(runId);
+        if (!pending)
+            return;
+        this.pendingAgentSpans.delete(runId);
+        this.visibe.batcher.add(this.traceId, this.visibe.buildAgentStartSpan({
+            spanId: pending.spanId,
+            agentName: pending.agentName,
+            timestamp: pending.timestamp,
+            inputText: pending.inputText,
+            outputText: serializeInput(outputs, 1000),
+            durationMs: Date.now() - pending.startMs,
+        }));
+    }
+    // Also flush on chain error so the span is never silently dropped.
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    async handleChainError(err, runId) {
+        const pending = this.pendingAgentSpans.get(runId);
+        if (!pending)
+            return;
+        this.pendingAgentSpans.delete(runId);
+        this.visibe.batcher.add(this.traceId, this.visibe.buildAgentStartSpan({
+            spanId: pending.spanId,
+            agentName: pending.agentName,
+            timestamp: pending.timestamp,
+            inputText: pending.inputText,
+            outputText: `Error: ${err?.message ?? String(err)}`,
+            durationMs: Date.now() - pending.startMs,
+        }));
     }
 }
 // ---------------------------------------------------------------------------
@@ -100,12 +133,16 @@ export function patchCompiledStateGraph(lgModule, visibe) {
         return result;
     };
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    CompiledStateGraph.prototype.stream = async function* (input, config) {
+    CompiledStateGraph.prototype.stream = async function (input, config) {
         if (activeLangChainStorage.getStore() !== undefined) {
-            // Pregel.stream() is a regular async function returning a Promise<AsyncIterable>.
-            // We must await it before yield*.
-            yield* (await originalStream.call(this, input, config));
-            return;
+            // Pass-through: return the original stream directly with NO generator wrapping.
+            //
+            // Pregel.stream() is a regular async function returning a Promise<IterableReadableStreamWithAbortSignal>.
+            // Wrapping it in an async function* (yield*) was the root cause of ALS context loss
+            // for later graph nodes — the extra generator delegation layer breaks AsyncLocalStorage
+            // propagation through the eager .then()-pump inside IterableReadableStreamWithAbortSignal.
+            // Returning the Promise directly restores the exact original behavior.
+            return originalStream.call(this, input, config);
         }
         const traceId = randomUUID();
         const startedAt = new Date().toISOString();
@@ -126,31 +163,38 @@ export function patchCompiledStateGraph(lgModule, visibe) {
             agentName: graphName,
             nodeNames,
         });
+        // Get the inner stream inside the ALS context so createAndRunLoop() (which runs
+        // fire-and-forget inside Pregel.stream()) inherits ALS = cb for all graph nodes.
+        const innerStream = await activeLangChainStorage.run(cb, () => originalStream.call(this, input, _mergeCallbacks(config, cb)));
+        // Return an async generator that wraps the stream for completion tracking.
+        // This path is only reached when the user calls app.stream() directly —
+        // not via app.invoke() (which takes the pass-through path above).
+        // createAndRunLoop() already runs in ALS = cb context (established above),
+        // so the generator wrapping here does NOT affect node ALS propagation.
         let status = 'completed';
-        try {
-            // activeLangChainStorage.run returns the callback's return value synchronously,
-            // which is a Promise<AsyncIterable> from Pregel.stream(). Await before yield*.
-            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,
-                ...(cb.firstModel ? { model: cb.firstModel } : {}),
-            });
-        }
+        return (async function* () {
+            try {
+                yield* innerStream;
+            }
+            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,
+                    ...(cb.firstModel ? { model: cb.firstModel } : {}),
+                });
+            }
+        })();
     };
     return () => {
         CompiledStateGraph.prototype.invoke = originalInvoke;

package/dist/types/client.d.ts

@@ -48,5 +48,9 @@ export declare class Visibe {
     buildAgentStartSpan(opts: {
         spanId: string;
         agentName: string;
+        timestamp?: string;
+        inputText?: string;
+        outputText?: string;
+        durationMs?: number;
     }): object;
 }

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

@@ -2,6 +2,7 @@ import { LangChainCallback } from './langchain';
 import type { Visibe } from '../client';
 export declare class LangGraphCallback extends LangChainCallback {
     private readonly nodeNames;
+    private readonly pendingAgentSpans;
     constructor(options: {
         visibe: Visibe;
         traceId: string;
@@ -9,5 +10,7 @@ export declare class LangGraphCallback extends LangChainCallback {
         nodeNames?: string[];
     });
     handleChainStart(chain: any, inputs: any, runId: string, parentRunId?: string, tags?: string[], metadata?: any, runType?: string, name?: string): Promise<void>;
+    handleChainEnd(outputs: any, runId: string): Promise<void>;
+    handleChainError(err: any, runId: string): Promise<void>;
 }
 export declare function patchCompiledStateGraph(lgModule: any, visibe: Visibe): () => void;

package/package.json

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