@visibe.ai/node 0.1.4

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

@@ -0,0 +1,261 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.patchVercelAI = patchVercelAI;
+const node_crypto_1 = require("node:crypto");
+const group_context_1 = require("./group-context");
+const utils_1 = require("../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 = group_context_1.activeGroupTraceStorage.getStore();
+    const traceId = groupCtx?.traceId ?? (0, node_crypto_1.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 = (0, utils_1.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
+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/cjs/types/index.js

@@ -0,0 +1,5 @@
+"use strict";
+// ---------------------------------------------------------------------------
+// Public SDK options
+// ---------------------------------------------------------------------------
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/utils.js

@@ -0,0 +1,122 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TOOL_CONTENT_LIMIT = exports.LLM_CONTENT_LIMIT = exports.MODEL_PRICING = void 0;
+exports.calculateCost = calculateCost;
+exports.truncate = truncate;
+exports.detectProvider = detectProvider;
+// 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.
+exports.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(exports.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.
+ */
+function calculateCost(model, inputTokens, outputTokens) {
+    const modelLower = model.toLowerCase();
+    const match = _pricingKeys.find(k => modelLower.includes(k));
+    if (!match)
+        return 0;
+    const { input, output } = exports.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 '').
+ */
+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.
+ */
+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';
+}
+exports.LLM_CONTENT_LIMIT = 1000; // default for llm_call spans
+exports.TOOL_CONTENT_LIMIT = 500; // default for tool_call spans

package/dist/esm/api.js

@@ -0,0 +1,87 @@
+const DEFAULT_API_URL = 'https://api.visibe.ai';
+const DEFAULT_TIMEOUT_MS = 10000;
+export class APIClient {
+    constructor(options) {
+        this.apiUrl = options.apiUrl ?? DEFAULT_API_URL;
+        this.apiKey = options.apiKey;
+        this.timeout = options.timeout ?? DEFAULT_TIMEOUT_MS;
+        this._enabled = Boolean(options.apiKey);
+        if (!this._enabled) {
+            process.emitWarning('[Visibe] No API key provided — tracing is disabled. Set VISIBE_API_KEY or pass apiKey= to enable.', { type: 'VisibleSDKWarning', code: 'VISIBE_NO_API_KEY' });
+        }
+    }
+    async _request(method, path, body) {
+        if (!this._enabled)
+            return false;
+        try {
+            const response = await fetch(`${this.apiUrl}${path}`, {
+                method,
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Authorization': `Bearer ${this.apiKey}`,
+                },
+                body: body ? JSON.stringify(body) : undefined,
+                signal: AbortSignal.timeout(this.timeout),
+            });
+            return response.ok;
+        }
+        catch {
+            return false; // fire-and-forget — never throw
+        }
+    }
+    async createTrace(data) {
+        return this._request('POST', '/api/traces', data);
+    }
+    async sendSpan(traceId, span) {
+        return this._request('POST', `/api/traces/${traceId}/spans`, span);
+    }
+    async sendSpansBatch(traceId, spans) {
+        return this._request('POST', `/api/traces/${traceId}/spans/batch`, { spans });
+    }
+    async completeTrace(traceId, data) {
+        return this._request('PATCH', `/api/traces/${traceId}`, data);
+    }
+}
+// ---------------------------------------------------------------------------
+export class SpanBatcher {
+    constructor(api) {
+        this.api = api;
+        this.buffer = [];
+        this.batchSize = 50;
+        this.flushInterval = 2000; // ms
+        this.timer = setInterval(() => this.flush(), this.flushInterval);
+        // CRITICAL: unref() so the timer does not prevent the process from exiting
+        // once all user code has finished.
+        this.timer.unref();
+    }
+    add(traceId, span) {
+        // Fast-path: drop immediately when there is no API key — don't buffer.
+        if (!this.api._enabled)
+            return;
+        this.buffer.push({ traceId, span });
+        if (this.buffer.length >= this.batchSize)
+            this.flush();
+    }
+    flush() {
+        if (this.buffer.length === 0)
+            return;
+        // Drain atomically — safe because Node.js is single-threaded.
+        const batch = this.buffer.splice(0);
+        // Group spans by traceId so we make one batch request per active trace.
+        const byTrace = new Map();
+        for (const { traceId, span } of batch) {
+            const arr = byTrace.get(traceId) ?? [];
+            arr.push(span);
+            byTrace.set(traceId, arr);
+        }
+        for (const [traceId, spans] of byTrace) {
+            this.api.sendSpansBatch(traceId, spans).catch(() => { }); // fire-and-forget
+        }
+    }
+    async shutdown() {
+        clearInterval(this.timer);
+        this.flush();
+        // Give in-flight requests up to 300 ms to complete before the process exits.
+        await new Promise(resolve => setTimeout(resolve, 300));
+    }
+}