@visibe.ai/node 0.1.4

package/dist/esm/integrations/vercel-ai.js

@@ -0,0 +1,258 @@
+import { randomUUID } from 'node:crypto';
+import { activeGroupTraceStorage } from './group-context';
+import { calculateCost } from '../utils';
+// ---------------------------------------------------------------------------
+// Provider detection — Vercel AI SDK exposes model.provider as e.g.
+// "openai.chat", "anthropic.messages".  Strip the suffix to get a clean name.
+// ---------------------------------------------------------------------------
+// Vercel AI SDK gives bare provider names like "openai", "anthropic" — no model
+// prefix — so we can't use detectProvider() which expects full model IDs.
+// Map directly and fall back to detectProvider() for model-style strings.
+const _VERCEL_PROVIDER_MAP = {
+    openai: 'openai',
+    anthropic: 'anthropic',
+    amazon: 'amazon',
+    meta: 'meta',
+    mistral: 'mistral',
+    cohere: 'cohere',
+    ai21: 'ai21',
+    google: 'google',
+    deepseek: 'deepseek',
+};
+function detectVercelProvider(modelProvider) {
+    if (!modelProvider)
+        return 'unknown';
+    const prefix = modelProvider.split('.')[0].toLowerCase();
+    // If not in the map, return the prefix as-is — the Vercel AI SDK already
+    // provides a clean provider string (e.g. 'mock-provider', 'anthropic').
+    return _VERCEL_PROVIDER_MAP[prefix] ?? prefix;
+}
+// ---------------------------------------------------------------------------
+// Shared span sender — used by all three wrappers
+// ---------------------------------------------------------------------------
+async function sendLLMTrace(visibe, agentName, model, provider, inputTokens, outputTokens, inputText, outputText, durationMs) {
+    // Check if we are inside a track() group — route into the shared trace if so.
+    const groupCtx = activeGroupTraceStorage.getStore();
+    const traceId = groupCtx?.traceId ?? randomUUID();
+    if (!groupCtx) {
+        await visibe.apiClient.createTrace({
+            trace_id: traceId,
+            name: agentName,
+            framework: 'vercel_ai',
+            started_at: new Date().toISOString(),
+            ...(visibe.sessionId ? { session_id: visibe.sessionId } : {}),
+        });
+    }
+    const cost = calculateCost(model, inputTokens, outputTokens);
+    // Build span manually so we can override the provider from Vercel's metadata.
+    const span = {
+        span_id: `step_1`,
+        type: 'llm_call',
+        timestamp: new Date().toISOString(),
+        agent_name: agentName,
+        model,
+        provider,
+        status: 'success',
+        description: `LLM Call using ${model}`,
+        input_tokens: inputTokens,
+        output_tokens: outputTokens,
+        cost,
+        duration_ms: durationMs,
+        input_text: inputText.slice(0, visibe.contentLimit),
+        output_text: outputText.slice(0, visibe.contentLimit),
+    };
+    visibe.batcher.add(traceId, span);
+    // Notify the group tracker (if inside track()) about this LLM span.
+    groupCtx?.onLLMSpan(inputTokens, outputTokens, cost);
+    if (!groupCtx) {
+        visibe.batcher.flush();
+        const sent = await visibe.apiClient.completeTrace(traceId, {
+            status: 'completed',
+            ended_at: new Date().toISOString(),
+            duration_ms: durationMs,
+            llm_call_count: 1,
+            prompt: inputText.slice(0, visibe.contentLimit),
+            model,
+            total_cost: cost,
+            total_tokens: inputTokens + outputTokens,
+            total_input_tokens: inputTokens,
+            total_output_tokens: outputTokens,
+        });
+        const tokens = (inputTokens + outputTokens).toLocaleString();
+        const sentStr = sent ? 'OK' : 'FAILED';
+        console.log(`[Visibe] Trace: ${agentName} | 1 LLM calls | ${tokens} tokens | $${cost.toFixed(6)} | ${(durationMs / 1000).toFixed(1)}s | 0 tool calls | status: completed | model: ${model} | sent: ${sentStr}`);
+    }
+}
+// ---------------------------------------------------------------------------
+// Extract prompt text from Vercel AI SDK params
+// ---------------------------------------------------------------------------
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function extractVercelPrompt(params) {
+    if (typeof params.prompt === 'string')
+        return params.prompt;
+    if (Array.isArray(params.messages)) {
+        const msgs = params.messages;
+        for (let i = msgs.length - 1; i >= 0; i--) {
+            const msg = msgs[i];
+            if (msg?.role === 'user') {
+                if (typeof msg.content === 'string')
+                    return msg.content;
+                if (Array.isArray(msg.content)) {
+                    const part = msg.content.find((p) => p.type === 'text');
+                    return part?.text ?? '';
+                }
+            }
+        }
+    }
+    return '';
+}
+// ---------------------------------------------------------------------------
+// patchVercelAI — patches the ai module using a require.cache Proxy.
+//
+// ai@6 exports are non-configurable ESM→CJS getters — direct assignment and
+// Object.defineProperty both fail.  The only reliable approach is to replace
+// require.cache[key].exports with a Proxy that intercepts property reads, so
+// that any subsequent require('ai') call (including destructuring) returns the
+// patched wrappers.
+//
+// Called from index.ts patchFramework().  Returns a restore function.
+// ---------------------------------------------------------------------------
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function patchVercelAI(aiModule, visibe, agentName = 'vercel-ai') {
+    const origGenerateText = aiModule.generateText;
+    const origStreamText = aiModule.streamText;
+    const origGenerateObject = aiModule.generateObject;
+    // Build patched wrappers (declared as variables so the Proxy's get trap can close over them).
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    let patchedGenerateText;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    let patchedStreamText;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    let patchedGenerateObject;
+    // --- generateText ---
+    if (origGenerateText) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        patchedGenerateText = async (params) => {
+            const start = Date.now();
+            const result = await origGenerateText(params);
+            const model = params.model?.modelId ?? 'unknown';
+            const provider = detectVercelProvider(params.model?.provider);
+            // Await so the trace is guaranteed to be created before this function returns.
+            // This ensures test helpers (captureTraceId) capture the traceId reliably.
+            await sendLLMTrace(visibe, agentName, model, provider, 
+            // ai@3/4 uses promptTokens; ai@6 uses inputTokens
+            result.usage?.promptTokens ?? result.usage?.inputTokens ?? 0, result.usage?.completionTokens ?? result.usage?.outputTokens ?? 0, extractVercelPrompt(params), result.text ?? '', Date.now() - start).catch(() => { });
+            return result;
+        };
+    }
+    // --- streamText ---
+    if (origStreamText) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        patchedStreamText = (params) => {
+            const start = Date.now();
+            const stream = origStreamText(params);
+            const model = params.model?.modelId ?? 'unknown';
+            const provider = detectVercelProvider(params.model?.provider);
+            // The Vercel AI SDK's streamText result has a `.usage` promise that
+            // resolves after the stream is consumed.
+            if (stream?.usage && typeof stream.usage.then === 'function') {
+                stream.usage.then((usage) => {
+                    sendLLMTrace(visibe, agentName, model, provider, 
+                    // ai@3/4 uses promptTokens; ai@6 uses inputTokens
+                    usage?.promptTokens ?? usage?.inputTokens ?? 0, usage?.completionTokens ?? usage?.outputTokens ?? 0, extractVercelPrompt(params), '', // full text not easily available without consuming the stream
+                    Date.now() - start).catch(() => { });
+                }).catch(() => { });
+            }
+            return stream;
+        };
+    }
+    // --- generateObject ---
+    if (origGenerateObject) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        patchedGenerateObject = async (params) => {
+            const start = Date.now();
+            const result = await origGenerateObject(params);
+            const model = params.model?.modelId ?? 'unknown';
+            const provider = detectVercelProvider(params.model?.provider);
+            await sendLLMTrace(visibe, agentName, model, provider, 
+            // ai@3/4 uses promptTokens; ai@6 uses inputTokens
+            result.usage?.promptTokens ?? result.usage?.inputTokens ?? 0, result.usage?.completionTokens ?? result.usage?.outputTokens ?? 0, extractVercelPrompt(params), JSON.stringify(result.object ?? ''), Date.now() - start).catch(() => { });
+            return result;
+        };
+    }
+    // ---------------------------------------------------------------------------
+    // 1. Try direct property assignment first.
+    //    Works for plain objects (tests) and ai@3/4 where exports are configurable.
+    //    For ai@6 with non-configurable exports this silently fails; the Proxy (below)
+    //    handles that case.
+    // ---------------------------------------------------------------------------
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const directRestores = [];
+    try {
+        if (patchedGenerateText) {
+            const orig = aiModule.generateText;
+            aiModule.generateText = patchedGenerateText;
+            directRestores.push(() => { aiModule.generateText = orig; });
+        }
+    }
+    catch { /* non-configurable */ }
+    try {
+        if (patchedStreamText) {
+            const orig = aiModule.streamText;
+            aiModule.streamText = patchedStreamText;
+            directRestores.push(() => { aiModule.streamText = orig; });
+        }
+    }
+    catch { /* non-configurable */ }
+    try {
+        if (patchedGenerateObject) {
+            const orig = aiModule.generateObject;
+            aiModule.generateObject = patchedGenerateObject;
+            directRestores.push(() => { aiModule.generateObject = orig; });
+        }
+    }
+    catch { /* non-configurable */ }
+    // ---------------------------------------------------------------------------
+    // 2. Replace require.cache exports with a Proxy (ai@6 fallback).
+    //
+    // ai@6's exports are Object.defineProperty'd with configurable:false — direct
+    // assignment silently fails and Object.defineProperty throws.  By replacing the
+    // module's cache entry with a Proxy we intercept property reads on future
+    // require('ai') calls (including destructuring) and return our wrappers.
+    // ---------------------------------------------------------------------------
+    let cacheKey;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    let originalExports;
+    try {
+        // eslint-disable-next-line @typescript-eslint/no-require-imports
+        cacheKey = Object.keys(require.cache).find(k => require.cache[k]?.exports === aiModule);
+        if (cacheKey && require.cache[cacheKey]) {
+            originalExports = require.cache[cacheKey].exports;
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            require.cache[cacheKey].exports = new Proxy(aiModule, {
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                get(target, prop) {
+                    if (prop === 'generateText' && patchedGenerateText)
+                        return patchedGenerateText;
+                    if (prop === 'streamText' && patchedStreamText)
+                        return patchedStreamText;
+                    if (prop === 'generateObject' && patchedGenerateObject)
+                        return patchedGenerateObject;
+                    return Reflect.get(target, prop);
+                },
+            });
+        }
+    }
+    catch { /* require.cache not available in non-CJS contexts (e.g. pure ESM) */ }
+    // Restore function — undo direct assignments and reset require.cache.
+    return () => {
+        for (const restore of directRestores)
+            restore();
+        try {
+            if (cacheKey && require.cache[cacheKey]) {
+                require.cache[cacheKey].exports = originalExports;
+            }
+        }
+        catch { /* package may have been unloaded */ }
+    };
+}

package/dist/esm/types/index.js

@@ -0,0 +1,4 @@
+// ---------------------------------------------------------------------------
+// Public SDK options
+// ---------------------------------------------------------------------------
+export {};

package/dist/esm/utils.js

@@ -0,0 +1,116 @@
+// Prices are per 1,000 tokens in USD.
+// Keys must stay sorted longest-first within the object for readability,
+// but calculateCost() re-sorts at runtime so insertion order doesn't matter.
+export const MODEL_PRICING = {
+    // OpenAI
+    'gpt-4o-mini': { input: 0.00015, output: 0.0006 },
+    'gpt-4.1-mini': { input: 0.0004, output: 0.0016 },
+    'gpt-4.1-nano': { input: 0.0001, output: 0.0004 },
+    'gpt-4.1': { input: 0.002, output: 0.008 },
+    'gpt-4-turbo': { input: 0.01, output: 0.03 },
+    'gpt-4o': { input: 0.0025, output: 0.01 },
+    'gpt-4': { input: 0.03, output: 0.06 },
+    'gpt-3.5-turbo': { input: 0.0015, output: 0.002 },
+    'o1-mini': { input: 0.003, output: 0.012 },
+    'o3-mini': { input: 0.0011, output: 0.0044 },
+    'o1': { input: 0.015, output: 0.06 },
+    // Anthropic (direct API)
+    'claude-3.5-sonnet': { input: 0.003, output: 0.015 },
+    'claude-3.5-haiku': { input: 0.0008, output: 0.004 },
+    'claude-3-opus': { input: 0.015, output: 0.075 },
+    'claude-3-sonnet': { input: 0.003, output: 0.015 },
+    'claude-3-haiku': { input: 0.00025, output: 0.00125 },
+    // Google (via OpenAI compat)
+    'gemini-1.5-pro': { input: 0.00125, output: 0.005 },
+    'gemini-1.5-flash': { input: 0.000075, output: 0.0003 },
+    'gemini-2.0-flash': { input: 0.0001, output: 0.0004 },
+    // DeepSeek
+    'deepseek-reasoner': { input: 0.00055, output: 0.00219 },
+    'deepseek-chat': { input: 0.00027, output: 0.0011 },
+    // AWS Bedrock — Anthropic
+    'anthropic.claude-3.5-sonnet': { input: 0.003, output: 0.015 },
+    'anthropic.claude-3.5-haiku': { input: 0.0008, output: 0.004 },
+    'anthropic.claude-3-opus': { input: 0.015, output: 0.075 },
+    'anthropic.claude-3-sonnet': { input: 0.003, output: 0.015 },
+    'anthropic.claude-3-haiku': { input: 0.00025, output: 0.00125 },
+    'anthropic.claude-4-sonnet': { input: 0.003, output: 0.015 },
+    'anthropic.claude-4-opus': { input: 0.015, output: 0.075 },
+    // AWS Bedrock — Meta
+    'meta.llama3-1-405b-instruct': { input: 0.00532, output: 0.016 },
+    'meta.llama3-1-70b-instruct': { input: 0.00265, output: 0.0035 },
+    'meta.llama3-1-8b-instruct': { input: 0.0003, output: 0.0006 },
+    'meta.llama3-70b-instruct': { input: 0.00265, output: 0.0035 },
+    'meta.llama3-8b-instruct': { input: 0.0003, output: 0.0006 },
+    // AWS Bedrock — Amazon
+    'amazon.titan-text-express': { input: 0.0002, output: 0.0006 },
+    'amazon.titan-text-lite': { input: 0.00015, output: 0.0002 },
+    'amazon.nova-pro': { input: 0.0008, output: 0.0032 },
+    'amazon.nova-lite': { input: 0.00006, output: 0.00024 },
+    'amazon.nova-micro': { input: 0.000035, output: 0.00014 },
+    // AWS Bedrock — Mistral / Cohere / AI21
+    'mistral.mistral-large': { input: 0.004, output: 0.012 },
+    'mistral.mistral-small': { input: 0.001, output: 0.003 },
+    'mistral.mixtral-8x7b-instruct': { input: 0.00045, output: 0.0007 },
+    'cohere.command-r-plus': { input: 0.003, output: 0.015 },
+    'cohere.command-r': { input: 0.0005, output: 0.0015 },
+    'ai21.jamba-1.5-large': { input: 0.002, output: 0.008 },
+    'ai21.jamba-1.5-mini': { input: 0.0002, output: 0.0004 },
+};
+// Sorted keys (longest first) built once at module load — avoids re-sorting on every call.
+const _pricingKeys = Object.keys(MODEL_PRICING).sort((a, b) => b.length - a.length);
+/**
+ * Calculate the USD cost for a single LLM call.
+ * Uses longest-prefix matching so "gpt-4o-mini" matches before "gpt-4".
+ * Always returns parseFloat(x.toFixed(6)) — toFixed(4) rounds tiny costs to $0.
+ */
+export function calculateCost(model, inputTokens, outputTokens) {
+    const modelLower = model.toLowerCase();
+    const match = _pricingKeys.find(k => modelLower.includes(k));
+    if (!match)
+        return 0;
+    const { input, output } = MODEL_PRICING[match];
+    const cost = (inputTokens / 1000) * input + (outputTokens / 1000) * output;
+    return parseFloat(cost.toFixed(6));
+}
+/**
+ * Truncate text to a maximum character limit.
+ * Returns '' for null/undefined. Appends '...' when truncated.
+ * Uses ?? not || so that empty strings are preserved (not converted to '').
+ */
+export function truncate(text, limit) {
+    if (text == null)
+        return '';
+    if (limit === 0)
+        return '';
+    if (text.length <= limit)
+        return text;
+    return text.slice(0, limit) + '...';
+}
+/**
+ * Detect the LLM provider from a model ID string.
+ * The result is used as the `provider` field on llm_call spans.
+ */
+export function detectProvider(model) {
+    const m = model.toLowerCase();
+    if (m.startsWith('gpt-') || m.startsWith('o1') || m.startsWith('o3'))
+        return 'openai';
+    if (m.startsWith('claude-') || m.startsWith('anthropic.'))
+        return 'anthropic';
+    if (m.startsWith('amazon.') || m.startsWith('nova') || m.startsWith('titan'))
+        return 'amazon';
+    if (m.startsWith('meta.') || m.startsWith('llama'))
+        return 'meta';
+    if (m.startsWith('mistral.') || m.startsWith('mixtral'))
+        return 'mistral';
+    if (m.startsWith('cohere.'))
+        return 'cohere';
+    if (m.startsWith('ai21.'))
+        return 'ai21';
+    if (m.startsWith('gemini'))
+        return 'google';
+    if (m.startsWith('deepseek'))
+        return 'deepseek';
+    return 'unknown';
+}
+export const LLM_CONTENT_LIMIT = 1000; // default for llm_call spans
+export const TOOL_CONTENT_LIMIT = 500; // default for tool_call spans

package/dist/types/api.d.ts

@@ -0,0 +1,27 @@
+export declare class APIClient {
+    readonly apiUrl: string;
+    private readonly apiKey;
+    private readonly timeout;
+    readonly _enabled: boolean;
+    constructor(options: {
+        apiUrl?: string;
+        apiKey?: string;
+        timeout?: number;
+    });
+    private _request;
+    createTrace(data: object): Promise<boolean>;
+    sendSpan(traceId: string, span: object): Promise<boolean>;
+    sendSpansBatch(traceId: string, spans: object[]): Promise<boolean>;
+    completeTrace(traceId: string, data: object): Promise<boolean>;
+}
+export declare class SpanBatcher {
+    private readonly api;
+    private buffer;
+    private readonly batchSize;
+    private readonly flushInterval;
+    private timer;
+    constructor(api: APIClient);
+    add(traceId: string, span: object): void;
+    flush(): void;
+    shutdown(): Promise<void>;
+}

package/dist/types/client.d.ts

@@ -0,0 +1,50 @@
+import { APIClient, SpanBatcher } from './api';
+import type { InitOptions } from './types';
+export type { InitOptions };
+export declare class Visibe {
+    readonly apiClient: APIClient;
+    readonly batcher: SpanBatcher;
+    readonly contentLimit: number;
+    readonly sessionId: string | undefined;
+    readonly debug: boolean;
+    private readonly _instrumented;
+    constructor(options: InitOptions);
+    instrument(client: object, options?: {
+        name?: string;
+    }): void;
+    uninstrument(client: object): void;
+    track<T>(client: object, name: string, fn: () => Promise<T>): Promise<T>;
+    flushSpans(): void;
+    buildLLMSpan(opts: {
+        spanId: string;
+        parentSpanId?: string;
+        agentName: string;
+        model: string;
+        status: 'success' | 'failed';
+        inputTokens: number;
+        outputTokens: number;
+        inputText: string;
+        outputText: string;
+        durationMs: number;
+    }): object;
+    buildToolSpan(opts: {
+        spanId: string;
+        parentSpanId?: string;
+        toolName: string;
+        agentName: string;
+        status: 'success' | 'failed';
+        durationMs: number;
+        inputText: string;
+        outputText: string;
+    }): object;
+    buildErrorSpan(opts: {
+        spanId: string;
+        errorType: string;
+        errorMessage: string;
+        durationMs?: number;
+    }): object;
+    buildAgentStartSpan(opts: {
+        spanId: string;
+        agentName: string;
+    }): object;
+}

package/dist/types/index.d.ts

@@ -0,0 +1,7 @@
+import { Visibe } from './client';
+import type { InitOptions } from './types';
+export declare function detectFrameworks(): Record<string, boolean>;
+export declare function init(options?: InitOptions): Visibe;
+export declare function shutdown(): Promise<void>;
+export { Visibe } from './client';
+export type { InitOptions, TraceSummary, SpanType, SpanStatus, TraceStatus, LLMProvider } from './types';

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

@@ -0,0 +1,9 @@
+import { BaseIntegration } from './base';
+import type { Visibe } from '../client';
+export declare class AnthropicIntegration extends BaseIntegration {
+    private _insideStream;
+    patchClient(client: any, agentName: string): () => void;
+    private _wrapCreate;
+    private _wrapStream;
+}
+export declare function patchAnthropicClient(client: any, agentName: string, visibe: Visibe): () => void;

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

@@ -0,0 +1,17 @@
+import type { Visibe } from '../client';
+/**
+ * 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()`.
+ */
+export declare abstract class BaseIntegration {
+    protected readonly visibe: Visibe;
+    constructor(visibe: Visibe);
+    abstract patchClient(client: object, agentName: string): () => void;
+    private _stepCounter;
+    protected nextSpanId(): string;
+    protected newTraceId(): string;
+}

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

@@ -0,0 +1,11 @@
+import { BaseIntegration } from './base';
+import { detectProvider } from '../utils';
+import type { Visibe } from '../client';
+export declare class BedrockIntegration extends BaseIntegration {
+    patchClient(client: any, agentName: string): () => void;
+    private _traceConverse;
+    private _traceInvokeModel;
+    private _traceConverseStream;
+}
+export declare function patchBedrockClient(client: any, agentName: string, visibe: Visibe): () => void;
+export { detectProvider };

package/dist/types/integrations/group-context.d.ts

@@ -0,0 +1,12 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
+export interface GroupContext {
+    readonly traceId: string;
+    onLLMSpan: (inputTokens: number, outputTokens: number, cost: number) => void;
+    onToolSpan: () => void;
+}
+/**
+ * Set by Visibe.track() around the user's fn().
+ * All integrations read from this store to route spans into the shared group trace
+ * and report token/cost totals back to the track() accumulator.
+ */
+export declare const activeGroupTraceStorage: AsyncLocalStorage<GroupContext>;

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

@@ -0,0 +1,40 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
+import type { Visibe } from '../client';
+export declare const activeLangChainStorage: AsyncLocalStorage<LangChainCallback>;
+export declare class LangChainCallback {
+    readonly name = "visibe-langchain-callback";
+    readonly awaitHandlers = true;
+    readonly raiseError = false;
+    protected readonly visibe: Visibe;
+    protected readonly traceId: string;
+    protected readonly agentName: string;
+    protected runIdToSpanId: Map<string, string>;
+    protected pendingLLMCalls: Map<string, number>;
+    protected pendingToolCalls: Map<string, {
+        startMs: number;
+        inputText: string;
+    }>;
+    protected stepCounter: number;
+    protected nextSpanId(): string;
+    protected seenAgents: Set<string>;
+    totalInputTokens: number;
+    totalOutputTokens: number;
+    llmCallCount: number;
+    constructor(options: {
+        visibe: Visibe;
+        traceId: string;
+        agentName: string;
+    });
+    handleLLMStart(_llm: any, _messages: any[], runId: string): Promise<void>;
+    handleLLMEnd(output: any, runId: string, parentRunId?: string): Promise<void>;
+    handleLLMError(err: Error, runId: string): Promise<void>;
+    handleToolStart(_tool: any, input: string, runId: string): Promise<void>;
+    handleToolEnd(output: string, runId: string, parentRunId?: string): Promise<void>;
+    handleToolError(err: Error, runId: string): Promise<void>;
+    handleChainStart(chain: any, _inputs: any, runId: string, parentRunId?: string): Promise<void>;
+    handleChainEnd(_outputs: any, _runId: string): Promise<void>;
+    handleChainError(err: Error, _runId: string): Promise<void>;
+    _onLLMSpan?: (inputTokens: number, outputTokens: number, cost: number) => void;
+    _onToolSpan?: () => void;
+}
+export declare function patchRunnableSequence(lcModule: any, visibe: Visibe): () => void;

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

@@ -0,0 +1,13 @@
+import { LangChainCallback } from './langchain';
+import type { Visibe } from '../client';
+export declare class LangGraphCallback extends LangChainCallback {
+    private readonly nodeNames;
+    constructor(options: {
+        visibe: Visibe;
+        traceId: string;
+        agentName: string;
+        nodeNames?: string[];
+    });
+    handleChainStart(chain: any, inputs: any, runId: string, parentRunId?: string): Promise<void>;
+}
+export declare function patchCompiledStateGraph(lgModule: any, visibe: Visibe): () => void;

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

@@ -0,0 +1,11 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
+import { BaseIntegration } from './base';
+import type { Visibe } from '../client';
+export declare const activeLangChainStorage: AsyncLocalStorage<any>;
+export declare class OpenAIIntegration extends BaseIntegration {
+    patchClient(client: any, agentName: string): () => void;
+    private _wrapCreate;
+    private _wrapStream;
+    private _wrapResponsesCreate;
+}
+export declare function patchOpenAIClient(client: any, agentName: string, visibe: Visibe): () => void;

package/dist/types/integrations/vercel-ai.d.ts

@@ -0,0 +1,2 @@
+import type { Visibe } from '../client';
+export declare function patchVercelAI(aiModule: any, visibe: Visibe, agentName?: string): () => void;

package/dist/types/types/index.d.ts

@@ -0,0 +1,21 @@
+export interface InitOptions {
+    apiKey?: string;
+    apiUrl?: string;
+    frameworks?: string[];
+    contentLimit?: number;
+    sessionId?: string;
+    debug?: boolean;
+}
+export type SpanType = 'llm_call' | 'tool_call' | 'error' | 'agent_start';
+export type SpanStatus = 'success' | 'failed';
+export type TraceStatus = 'completed' | 'failed';
+export type LLMProvider = 'openai' | 'anthropic' | 'amazon' | 'meta' | 'mistral' | 'cohere' | 'ai21' | 'google' | 'deepseek' | 'unknown';
+export interface TraceSummary {
+    name: string;
+    llmCallCount: number;
+    toolCallCount: number;
+    totalTokens: number;
+    totalCost: number;
+    durationMs: number;
+    status: TraceStatus;
+}

package/dist/types/utils.d.ts

@@ -0,0 +1,23 @@
+export declare const MODEL_PRICING: Record<string, {
+    input: number;
+    output: number;
+}>;
+/**
+ * Calculate the USD cost for a single LLM call.
+ * Uses longest-prefix matching so "gpt-4o-mini" matches before "gpt-4".
+ * Always returns parseFloat(x.toFixed(6)) — toFixed(4) rounds tiny costs to $0.
+ */
+export declare function calculateCost(model: string, inputTokens: number, outputTokens: number): number;
+/**
+ * Truncate text to a maximum character limit.
+ * Returns '' for null/undefined. Appends '...' when truncated.
+ * Uses ?? not || so that empty strings are preserved (not converted to '').
+ */
+export declare function truncate(text: string | null | undefined, limit: number): string;
+/**
+ * Detect the LLM provider from a model ID string.
+ * The result is used as the `provider` field on llm_call spans.
+ */
+export declare function detectProvider(model: string): string;
+export declare const LLM_CONTENT_LIMIT = 1000;
+export declare const TOOL_CONTENT_LIMIT = 500;