@visibe.ai/node 0.1.4

package/dist/cjs/index.js

@@ -0,0 +1,216 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Visibe = void 0;
+exports.detectFrameworks = detectFrameworks;
+exports.init = init;
+exports.shutdown = shutdown;
+const client_1 = require("./client");
+// ---------------------------------------------------------------------------
+// Global state
+// ---------------------------------------------------------------------------
+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.
+// 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;
+let _vercelAIRestore = null;
+// ---------------------------------------------------------------------------
+// detectFrameworks()
+// ---------------------------------------------------------------------------
+function tryRequire(pkg) {
+    try {
+        require(pkg);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function detectFrameworks() {
+    return {
+        openai: tryRequire('openai'),
+        langchain: tryRequire('@langchain/core'),
+        langgraph: tryRequire('@langchain/langgraph'),
+        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
+// ---------------------------------------------------------------------------
+function patchFramework(framework, client) {
+    try {
+        switch (framework) {
+            case 'openai': {
+                const openaiModule = require('openai');
+                _originalOpenAI = openaiModule.OpenAI;
+                openaiModule.OpenAI = class extends _originalOpenAI {
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    constructor(...args) {
+                        super(...args);
+                        try {
+                            client.instrument(this);
+                        }
+                        catch { /* never crash new OpenAI() */ }
+                    }
+                };
+                break;
+            }
+            case 'anthropic': {
+                const anthropicModule = require('@anthropic-ai/sdk');
+                _originalAnthropic = anthropicModule.Anthropic;
+                anthropicModule.Anthropic = class extends _originalAnthropic {
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    constructor(...args) {
+                        super(...args);
+                        try {
+                            client.instrument(this);
+                        }
+                        catch { /* never crash new Anthropic() */ }
+                    }
+                };
+                break;
+            }
+            case 'bedrock': {
+                const bedrockModule = require('@aws-sdk/client-bedrock-runtime');
+                _originalBedrockClient = bedrockModule.BedrockRuntimeClient;
+                bedrockModule.BedrockRuntimeClient = class extends _originalBedrockClient {
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    constructor(...args) {
+                        super(...args);
+                        try {
+                            client.instrument(this);
+                        }
+                        catch { /* never crash new BedrockRuntimeClient() */ }
+                    }
+                };
+                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);
+                break;
+            }
+            case 'langchain': {
+                // LangChain is instrumented via RunnableSequence constructor patching.
+                const { patchRunnableSequence } = require('./integrations/langchain');
+                const lcModule = require('@langchain/core/runnables');
+                patchRunnableSequence(lcModule, client);
+                break;
+            }
+            case 'vercel_ai': {
+                const { patchVercelAI } = require('./integrations/vercel-ai');
+                const aiModule = 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 = [];
+// ---------------------------------------------------------------------------
+// init()
+// ---------------------------------------------------------------------------
+function init(options) {
+    if (_globalClient !== null) {
+        process.emitWarning('[Visibe] Already initialized — call shutdown() first to re-init', { type: 'VisibleSDKWarning' });
+        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.
+    if (!_shutdownRegistered) {
+        const graceful = async () => { await shutdown(); process.exit(0); };
+        process.on('SIGTERM', graceful);
+        process.on('SIGINT', graceful);
+        process.on('beforeExit', () => { shutdown().catch(() => { }); });
+        _shutdownRegistered = true;
+    }
+    if (_autoPatchedFrameworks.length > 0) {
+        console.log(`[Visibe] Auto-instrumented: ${_autoPatchedFrameworks.join(', ')}`);
+    }
+    return _globalClient;
+}
+// ---------------------------------------------------------------------------
+// shutdown()
+// ---------------------------------------------------------------------------
+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) {
+            require('openai').OpenAI = _originalOpenAI;
+            _originalOpenAI = null;
+        }
+    }
+    catch { /* package may have been unloaded */ }
+    try {
+        if (_originalAnthropic) {
+            require('@anthropic-ai/sdk').Anthropic = _originalAnthropic;
+            _originalAnthropic = null;
+        }
+    }
+    catch { /* package may have been unloaded */ }
+    try {
+        if (_originalBedrockClient) {
+            require('@aws-sdk/client-bedrock-runtime').BedrockRuntimeClient = _originalBedrockClient;
+            _originalBedrockClient = null;
+        }
+    }
+    catch { /* package may have been unloaded */ }
+    try {
+        if (_originalCompiledStateGraph) {
+            require('@langchain/langgraph').CompiledStateGraph = _originalCompiledStateGraph;
+            _originalCompiledStateGraph = null;
+        }
+    }
+    catch { /* package may have been unloaded */ }
+    try {
+        if (_vercelAIRestore) {
+            _vercelAIRestore();
+            _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.
+    await client.batcher.shutdown();
+}
+// ---------------------------------------------------------------------------
+// Re-export public surface
+// ---------------------------------------------------------------------------
+var client_2 = require("./client");
+Object.defineProperty(exports, "Visibe", { enumerable: true, get: function () { return client_2.Visibe; } });

package/dist/cjs/integrations/anthropic.js

@@ -0,0 +1,277 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AnthropicIntegration = void 0;
+exports.patchAnthropicClient = patchAnthropicClient;
+const node_crypto_1 = require("node:crypto");
+const base_1 = require("./base");
+const group_context_1 = require("./group-context");
+const utils_1 = require("../utils");
+class AnthropicIntegration extends base_1.BaseIntegration {
+    constructor() {
+        super(...arguments);
+        // Guard against re-entry: messages.stream() internally calls messages.create({stream:true}).
+        // When this flag is true we're already inside _wrapStream — pass create() calls through.
+        this._insideStream = false;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    patchClient(client, agentName) {
+        const originalCreate = client.messages.create.bind(client.messages);
+        const originalStream = client.messages.stream?.bind(client.messages);
+        // --- messages.create ---
+        // NOTE: this must NOT be an async function — the Anthropic SDK's MessageStream
+        // calls messages.create({stream:true}) and uses .withResponse() on the return
+        // value, which only exists on APIPromise (not on a regular Promise).  Keeping
+        // this function synchronous lets us return the APIPromise directly on re-entry.
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        client.messages.create = (params, options) => {
+            // Re-entry guard: messages.stream() calls messages.create({stream:true}) internally.
+            // Return the original APIPromise synchronously so .withResponse() is available.
+            if (params?.stream && this._insideStream) {
+                return originalCreate(params, options);
+            }
+            // Streaming via messages.create with stream:true is handled the same way
+            // as messages.stream — both return a stream object in the Anthropic SDK.
+            if (params?.stream) {
+                return this._wrapStream(
+                // When stream:true is passed to create(), the SDK returns a stream.
+                // We forward to the same stream wrapper.
+                (...a) => originalCreate(...a), params, options, agentName);
+            }
+            return this._wrapCreate(originalCreate, params, options, agentName);
+        };
+        // --- messages.stream (explicit stream helper) ---
+        if (originalStream) {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            client.messages.stream = (params, options) => {
+                return this._wrapStream(originalStream, params, options, agentName);
+            };
+        }
+        return () => {
+            client.messages.create = originalCreate;
+            if (originalStream)
+                client.messages.stream = originalStream;
+        };
+    }
+    // ---------------------------------------------------------------------------
+    // Non-streaming
+    // ---------------------------------------------------------------------------
+    async _wrapCreate(
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    original, 
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    params, 
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    options, agentName) {
+        const groupCtx = group_context_1.activeGroupTraceStorage.getStore();
+        const traceId = groupCtx?.traceId ?? (0, node_crypto_1.randomUUID)();
+        const startedAt = new Date().toISOString();
+        const startMs = Date.now();
+        if (!groupCtx) {
+            await this.visibe.apiClient.createTrace({
+                trace_id: traceId,
+                name: agentName,
+                framework: 'anthropic',
+                started_at: startedAt,
+                ...(this.visibe.sessionId ? { session_id: this.visibe.sessionId } : {}),
+            });
+        }
+        const spanId = this.nextSpanId();
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        let response;
+        let spanStatus = 'success';
+        try {
+            response = await original(params, options);
+        }
+        catch (err) {
+            spanStatus = 'failed';
+            this.visibe.batcher.add(traceId, this.visibe.buildErrorSpan({
+                spanId: this.nextSpanId(),
+                errorType: err?.constructor?.name ?? 'Error',
+                errorMessage: err?.message ?? String(err),
+            }));
+            if (!groupCtx) {
+                this.visibe.batcher.flush();
+                await this.visibe.apiClient.completeTrace(traceId, {
+                    status: 'failed', ended_at: new Date().toISOString(), duration_ms: Date.now() - startMs,
+                });
+            }
+            throw err;
+        }
+        const model = response.model ?? params.model ?? 'unknown';
+        const inputTokens = response.usage?.input_tokens ?? 0;
+        const outputTokens = response.usage?.output_tokens ?? 0;
+        const cost = (0, utils_1.calculateCost)(model, inputTokens, outputTokens);
+        // Extract text; fall back to tool_use formatting when content is text-free.
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const textBlock = response.content?.find((b) => b.type === 'text');
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const toolUse = response.content?.filter((b) => b.type === 'tool_use') ?? [];
+        const outputText = textBlock?.text
+            ?? toolUse.map((t) => `${t.name}(${JSON.stringify(t.input)})`).join('; ');
+        const inputText = _extractAnthropicInputText(params);
+        this.visibe.batcher.add(traceId, this.visibe.buildLLMSpan({
+            spanId,
+            agentName,
+            model,
+            status: spanStatus,
+            inputTokens,
+            outputTokens,
+            inputText,
+            outputText,
+            durationMs: Date.now() - startMs,
+        }));
+        // Notify the group tracker (if inside track()) about this LLM span.
+        groupCtx?.onLLMSpan(inputTokens, outputTokens, cost);
+        if (!groupCtx) {
+            this.visibe.batcher.flush();
+            const sent = await this.visibe.apiClient.completeTrace(traceId, {
+                status: 'completed',
+                ended_at: new Date().toISOString(),
+                duration_ms: Date.now() - startMs,
+                llm_call_count: 1,
+                prompt: inputText,
+                model,
+                total_cost: cost,
+                total_tokens: inputTokens + outputTokens,
+                total_input_tokens: inputTokens,
+                total_output_tokens: outputTokens,
+            });
+            _printSummary(agentName, model, inputTokens, outputTokens, cost, Date.now() - startMs, sent);
+        }
+        return response;
+    }
+    // ---------------------------------------------------------------------------
+    // Streaming — listen for the final 'message' event which carries full usage.
+    // ---------------------------------------------------------------------------
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    _wrapStream(
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    original, 
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    params, 
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    options, agentName) {
+        // Capture group context at call time so the event handler closure can use it.
+        const groupCtx = group_context_1.activeGroupTraceStorage.getStore();
+        const traceId = groupCtx?.traceId ?? (0, node_crypto_1.randomUUID)();
+        const startedAt = new Date().toISOString();
+        const startMs = Date.now();
+        const spanId = this.nextSpanId();
+        // Create trace asynchronously — fire-and-forget is fine for the stream case.
+        if (!groupCtx) {
+            this.visibe.apiClient.createTrace({
+                trace_id: traceId,
+                name: agentName,
+                framework: 'anthropic',
+                started_at: startedAt,
+                ...(this.visibe.sessionId ? { session_id: this.visibe.sessionId } : {}),
+            }).catch(() => { });
+        }
+        // Set flag before calling original so that any re-entrant messages.create({stream:true})
+        // calls (triggered internally by the Anthropic SDK's stream helper) are passed through.
+        this._insideStream = true;
+        let stream;
+        try {
+            stream = original(params, options);
+        }
+        finally {
+            this._insideStream = false;
+        }
+        // 'message' fires once at the end with the complete message + usage.
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        stream.on('message', (msg) => {
+            const model = msg.model ?? params.model ?? 'unknown';
+            const inputTokens = msg.usage?.input_tokens ?? 0;
+            const outputTokens = msg.usage?.output_tokens ?? 0;
+            const cost = (0, utils_1.calculateCost)(model, inputTokens, outputTokens);
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const textBlock = msg.content?.find((b) => b.type === 'text');
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const toolUse = msg.content?.filter((b) => b.type === 'tool_use') ?? [];
+            const outputText = textBlock?.text
+                ?? toolUse.map((t) => `${t.name}(${JSON.stringify(t.input)})`).join('; ');
+            const inputText = _extractAnthropicInputText(params);
+            this.visibe.batcher.add(traceId, this.visibe.buildLLMSpan({
+                spanId,
+                agentName,
+                model,
+                status: 'success',
+                inputTokens,
+                outputTokens,
+                inputText,
+                outputText,
+                durationMs: Date.now() - startMs,
+            }));
+            // Notify the group tracker (if inside track()) about this LLM span.
+            groupCtx?.onLLMSpan(inputTokens, outputTokens, cost);
+            if (!groupCtx) {
+                this.visibe.batcher.flush();
+                this.visibe.apiClient.completeTrace(traceId, {
+                    status: 'completed',
+                    ended_at: new Date().toISOString(),
+                    duration_ms: Date.now() - startMs,
+                    llm_call_count: 1,
+                    prompt: inputText,
+                    model,
+                    total_cost: cost,
+                    total_tokens: inputTokens + outputTokens,
+                    total_input_tokens: inputTokens,
+                    total_output_tokens: outputTokens,
+                }).then(sent => {
+                    _printSummary(agentName, model, inputTokens, outputTokens, cost, Date.now() - startMs, sent);
+                }).catch(() => { });
+            }
+        });
+        stream.on('error', (err) => {
+            this.visibe.batcher.add(traceId, this.visibe.buildErrorSpan({
+                spanId: this.nextSpanId(),
+                errorType: err?.constructor?.name ?? 'Error',
+                errorMessage: err?.message ?? String(err),
+                durationMs: Date.now() - startMs,
+            }));
+            if (!groupCtx) {
+                this.visibe.batcher.flush();
+                this.visibe.apiClient.completeTrace(traceId, {
+                    status: 'failed', ended_at: new Date().toISOString(), duration_ms: Date.now() - startMs,
+                }).catch(() => { });
+            }
+        });
+        return stream;
+    }
+}
+exports.AnthropicIntegration = AnthropicIntegration;
+// ---------------------------------------------------------------------------
+// Module-level factory
+// ---------------------------------------------------------------------------
+function patchAnthropicClient(
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+client, agentName, visibe) {
+    const integration = new AnthropicIntegration(visibe);
+    return integration.patchClient(client, agentName);
+}
+// ---------------------------------------------------------------------------
+// Private helpers
+// ---------------------------------------------------------------------------
+// Extract the last user message text from Anthropic messages params.
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function _extractAnthropicInputText(params) {
+    const messages = params?.messages ?? [];
+    for (let i = messages.length - 1; i >= 0; i--) {
+        const msg = messages[i];
+        if (msg?.role === 'user') {
+            if (typeof msg.content === 'string')
+                return msg.content;
+            if (Array.isArray(msg.content)) {
+                const part = msg.content.find((b) => b.type === 'text');
+                return part?.text ?? '';
+            }
+        }
+    }
+    return '';
+}
+function _printSummary(name, model, inputTokens, outputTokens, cost, durationMs, sent) {
+    const durationSec = (durationMs / 1000).toFixed(1);
+    const tokens = (inputTokens + outputTokens).toLocaleString();
+    const sentStr = sent ? 'OK' : 'FAILED';
+    console.log(`[Visibe] Trace: ${name} | 1 LLM calls | ${tokens} tokens | $${cost.toFixed(6)} | ${durationSec}s | 0 tool calls | status: completed | model: ${model} | sent: ${sentStr}`);
+}

package/dist/cjs/integrations/base.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseIntegration = void 0;
+const node_crypto_1 = require("node:crypto");
+/**
+ * Shared base for all framework integrations.
+ *
+ * Each integration subclass implements `patchClient()` which patches a specific
+ * client instance and returns a restore function that undoes the patch.
+ * The restore function is stored by `Visibe.instrument()` and called on
+ * `Visibe.uninstrument()`.
+ */
+class BaseIntegration {
+    constructor(visibe) {
+        // ---------------------------------------------------------------------------
+        // Shared span-ID counter
+        // Each integration instance has its own counter — they do not share state.
+        // ---------------------------------------------------------------------------
+        this._stepCounter = 0;
+        this.visibe = visibe;
+    }
+    nextSpanId() {
+        return `step_${++this._stepCounter}`;
+    }
+    // ---------------------------------------------------------------------------
+    // Shared trace lifecycle helpers
+    // ---------------------------------------------------------------------------
+    newTraceId() {
+        return (0, node_crypto_1.randomUUID)();
+    }
+}
+exports.BaseIntegration = BaseIntegration;