@visibe.ai/node 0.1.4

package/dist/esm/integrations/bedrock.js

@@ -0,0 +1,438 @@
+import { randomUUID } from 'node:crypto';
+import { BaseIntegration } from './base';
+import { activeGroupTraceStorage } from './group-context';
+import { calculateCost, detectProvider } from '../utils';
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function parseInvokeAnthropic(req, res) {
+    return {
+        prompt: req.messages?.at(-1)?.content?.[0]?.text ?? '',
+        outputText: res.content?.[0]?.text ?? '',
+        inputTokens: res.usage?.input_tokens ?? 0,
+        outputTokens: res.usage?.output_tokens ?? 0,
+    };
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function parseInvokeMeta(req, res) {
+    return {
+        prompt: req.prompt ?? '',
+        outputText: res.generation ?? '',
+        inputTokens: res.prompt_token_count ?? 0,
+        outputTokens: res.generation_token_count ?? 0,
+    };
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function parseInvokeMistral(req, res) {
+    // Mistral via InvokeModelCommand does not return token counts.
+    const text = res.outputs?.[0]?.text ?? res.choices?.[0]?.message?.content ?? '';
+    return { prompt: req.prompt ?? '', outputText: text, inputTokens: 0, outputTokens: 0 };
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function parseInvokeTitan(req, res) {
+    return {
+        prompt: req.inputText ?? '',
+        outputText: res.results?.[0]?.outputText ?? '',
+        inputTokens: res.inputTextTokenCount ?? 0,
+        outputTokens: res.results?.[0]?.tokenCount ?? 0,
+    };
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function parseInvokeNova(req, res) {
+    return {
+        prompt: req.messages?.at(-1)?.content?.[0]?.text ?? '',
+        outputText: res.output?.message?.content?.[0]?.text ?? '',
+        inputTokens: res.usage?.inputTokens ?? 0,
+        outputTokens: res.usage?.outputTokens ?? 0,
+    };
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function parseInvokeCohere(req, res) {
+    const text = res.text ?? res.generations?.[0]?.text ?? '';
+    const billedUnits = res.meta?.billed_units;
+    return {
+        prompt: req.prompt ?? req.message ?? '',
+        outputText: text,
+        inputTokens: billedUnits?.input_tokens ?? 0,
+        outputTokens: billedUnits?.output_tokens ?? 0,
+    };
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function parseInvokeAI21(req, res) {
+    return {
+        prompt: req.messages?.at(-1)?.content ?? '',
+        outputText: res.choices?.[0]?.message?.content ?? '',
+        inputTokens: res.usage?.prompt_tokens ?? 0,
+        outputTokens: res.usage?.completion_tokens ?? 0,
+    };
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function parseInvokeUnknown(_req, _res) {
+    return { prompt: '', outputText: '', inputTokens: 0, outputTokens: 0 };
+}
+function getInvokeParser(modelId) {
+    if (modelId.startsWith('anthropic.'))
+        return parseInvokeAnthropic;
+    if (modelId.startsWith('meta.'))
+        return parseInvokeMeta;
+    if (modelId.startsWith('mistral.'))
+        return parseInvokeMistral;
+    if (modelId.startsWith('amazon.titan'))
+        return parseInvokeTitan;
+    if (modelId.startsWith('amazon.nova'))
+        return parseInvokeNova;
+    if (modelId.startsWith('cohere.'))
+        return parseInvokeCohere;
+    if (modelId.startsWith('ai21.'))
+        return parseInvokeAI21;
+    return parseInvokeUnknown;
+}
+// ---------------------------------------------------------------------------
+// BedrockIntegration
+// ---------------------------------------------------------------------------
+export class BedrockIntegration extends BaseIntegration {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    patchClient(client, agentName) {
+        const originalSend = client.send.bind(client);
+        // We need the command constructors to do instanceof checks.
+        // They are imported lazily so this file can be loaded without the package installed.
+        let ConverseCommand;
+        let ConverseStreamCommand;
+        let InvokeModelCommand;
+        let InvokeModelWithResponseStreamCommand;
+        try {
+            const mod = require('@aws-sdk/client-bedrock-runtime');
+            ConverseCommand = mod.ConverseCommand;
+            ConverseStreamCommand = mod.ConverseStreamCommand;
+            InvokeModelCommand = mod.InvokeModelCommand;
+            InvokeModelWithResponseStreamCommand = mod.InvokeModelWithResponseStreamCommand;
+        }
+        catch {
+            // Package not installed — return a no-op restore.
+            return () => { };
+        }
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        client.send = async (command, ...rest) => {
+            if (ConverseCommand && command instanceof ConverseCommand) {
+                return this._traceConverse(originalSend, command, rest, agentName);
+            }
+            if (InvokeModelCommand && command instanceof InvokeModelCommand) {
+                return this._traceInvokeModel(originalSend, command, rest, agentName);
+            }
+            if (ConverseStreamCommand && command instanceof ConverseStreamCommand) {
+                return this._traceConverseStream(originalSend, command, rest, agentName);
+            }
+            if (InvokeModelWithResponseStreamCommand &&
+                command instanceof InvokeModelWithResponseStreamCommand) {
+                // Streaming invoke — pass through for now; non-streaming covers most use cases.
+                return originalSend(command, ...rest);
+            }
+            return originalSend(command, ...rest);
+        };
+        return () => { client.send = originalSend; };
+    }
+    // ---------------------------------------------------------------------------
+    // ConverseCommand
+    // ---------------------------------------------------------------------------
+    async _traceConverse(
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    original, 
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    command, 
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    rest, agentName) {
+        const groupCtx = activeGroupTraceStorage.getStore();
+        const traceId = groupCtx?.traceId ?? randomUUID();
+        const startedAt = new Date().toISOString();
+        const startMs = Date.now();
+        const input = command.input;
+        if (!groupCtx) {
+            await this.visibe.apiClient.createTrace({
+                trace_id: traceId,
+                name: agentName,
+                framework: 'bedrock',
+                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(command, ...rest);
+        }
+        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 = input.modelId ?? 'unknown';
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const prompt = input.messages?.at(-1)?.content?.find((b) => b.text)?.text ?? '';
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const output = response.output?.message?.content?.find((b) => b.text)?.text ?? '';
+        const inputTokens = response.usage?.inputTokens ?? 0;
+        const outputTokens = response.usage?.outputTokens ?? 0;
+        const cost = calculateCost(model, inputTokens, outputTokens);
+        this.visibe.batcher.add(traceId, this.visibe.buildLLMSpan({
+            spanId,
+            agentName,
+            model,
+            status: spanStatus,
+            inputTokens,
+            outputTokens,
+            inputText: prompt,
+            outputText: output,
+            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,
+                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;
+    }
+    // ---------------------------------------------------------------------------
+    // InvokeModelCommand — raw JSON body, provider-specific parsing
+    // ---------------------------------------------------------------------------
+    async _traceInvokeModel(
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    original, 
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    command, 
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    rest, agentName) {
+        const groupCtx = activeGroupTraceStorage.getStore();
+        const traceId = groupCtx?.traceId ?? randomUUID();
+        const startedAt = new Date().toISOString();
+        const startMs = Date.now();
+        if (!groupCtx) {
+            await this.visibe.apiClient.createTrace({
+                trace_id: traceId,
+                name: agentName,
+                framework: 'bedrock',
+                started_at: startedAt,
+                ...(this.visibe.sessionId ? { session_id: this.visibe.sessionId } : {}),
+            });
+        }
+        const modelId = command.input?.modelId ?? 'unknown';
+        const spanId = this.nextSpanId();
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        let response;
+        let spanStatus = 'success';
+        // Decode the request body (Uint8Array or Buffer).
+        let reqBody = {};
+        try {
+            const bodyStr = new TextDecoder().decode(command.input?.body);
+            reqBody = JSON.parse(bodyStr);
+        }
+        catch { /* malformed body — continue with empty */ }
+        try {
+            response = await original(command, ...rest);
+        }
+        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;
+        }
+        // The JS SDK already buffers the response body as Uint8Array — no streaming needed.
+        let resBody = {};
+        try {
+            const bodyStr = new TextDecoder().decode(response.body);
+            resBody = JSON.parse(bodyStr);
+        }
+        catch { /* malformed body — continue with empty */ }
+        const parse = getInvokeParser(modelId);
+        const { prompt, outputText, inputTokens, outputTokens } = parse(reqBody, resBody);
+        const cost = calculateCost(modelId, inputTokens, outputTokens);
+        this.visibe.batcher.add(traceId, this.visibe.buildLLMSpan({
+            spanId,
+            agentName,
+            model: modelId,
+            status: spanStatus,
+            inputTokens,
+            outputTokens,
+            inputText: prompt,
+            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,
+                model: modelId,
+                total_cost: cost,
+                total_tokens: inputTokens + outputTokens,
+                total_input_tokens: inputTokens,
+                total_output_tokens: outputTokens,
+            });
+            _printSummary(agentName, modelId, inputTokens, outputTokens, cost, Date.now() - startMs, sent);
+        }
+        return response;
+    }
+    // ---------------------------------------------------------------------------
+    // ConverseStreamCommand — stream, accumulate, then finalize
+    // ---------------------------------------------------------------------------
+    async _traceConverseStream(
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    original, 
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    command, 
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    rest, agentName) {
+        const groupCtx = activeGroupTraceStorage.getStore();
+        const traceId = groupCtx?.traceId ?? randomUUID();
+        const startedAt = new Date().toISOString();
+        const startMs = Date.now();
+        const model = command.input?.modelId ?? 'unknown';
+        const spanId = this.nextSpanId();
+        if (!groupCtx) {
+            await this.visibe.apiClient.createTrace({
+                trace_id: traceId,
+                name: agentName,
+                framework: 'bedrock',
+                started_at: startedAt,
+                ...(this.visibe.sessionId ? { session_id: this.visibe.sessionId } : {}),
+            });
+        }
+        const response = await original(command, ...rest);
+        // The Converse stream emits a `metadata` event with usage totals.
+        let inputTokens = 0, outputTokens = 0;
+        let outputText = '';
+        const stream = response.stream;
+        if (stream && typeof stream[Symbol.asyncIterator] === 'function') {
+            const visibe = this.visibe;
+            const batcher = this.visibe.batcher;
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const origIter = stream[Symbol.asyncIterator].bind(stream);
+            let finalized = false;
+            const finalize = async (status) => {
+                if (finalized)
+                    return;
+                finalized = true;
+                const cost = calculateCost(model, inputTokens, outputTokens);
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                const prompt = command.input?.messages?.at(-1)?.content?.find((b) => b.text)?.text ?? '';
+                batcher.add(traceId, visibe.buildLLMSpan({
+                    spanId, agentName, model, status,
+                    inputTokens, outputTokens,
+                    inputText: prompt,
+                    outputText,
+                    durationMs: Date.now() - startMs,
+                }));
+                // Notify the group tracker (if inside track()) about this LLM span.
+                groupCtx?.onLLMSpan(inputTokens, outputTokens, cost);
+                if (!groupCtx) {
+                    batcher.flush();
+                    const sent = await visibe.apiClient.completeTrace(traceId, {
+                        status: status === 'success' ? 'completed' : 'failed',
+                        ended_at: new Date().toISOString(),
+                        duration_ms: Date.now() - startMs,
+                        llm_call_count: 1,
+                        prompt,
+                        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);
+                }
+            };
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            stream[Symbol.asyncIterator] = () => {
+                const it = origIter();
+                return {
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    async next() {
+                        try {
+                            const result = await it.next();
+                            if (!result.done) {
+                                const chunk = result.value;
+                                // Accumulate text deltas
+                                const textDelta = chunk?.contentBlockDelta?.delta?.text;
+                                if (textDelta)
+                                    outputText += textDelta;
+                                // Metadata chunk carries usage
+                                if (chunk?.metadata?.usage) {
+                                    inputTokens = chunk.metadata.usage.inputTokens ?? 0;
+                                    outputTokens = chunk.metadata.usage.outputTokens ?? 0;
+                                }
+                            }
+                            else {
+                                await finalize('success');
+                            }
+                            return result;
+                        }
+                        catch (err) {
+                            await finalize('failed');
+                            throw err;
+                        }
+                    },
+                    async return(value) {
+                        await finalize('success');
+                        return it.return ? it.return(value) : { done: true, value };
+                    },
+                };
+            };
+        }
+        return response;
+    }
+}
+// ---------------------------------------------------------------------------
+// Module-level factory
+// ---------------------------------------------------------------------------
+export function patchBedrockClient(
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+client, agentName, visibe) {
+    const integration = new BedrockIntegration(visibe);
+    return integration.patchClient(client, agentName);
+}
+// ---------------------------------------------------------------------------
+// Private helpers
+// ---------------------------------------------------------------------------
+function _printSummary(name, model, inputTokens, outputTokens, cost, durationMs, sent) {
+    const tokens = (inputTokens + outputTokens).toLocaleString();
+    const sentStr = sent ? 'OK' : 'FAILED';
+    console.log(`[Visibe] Trace: ${name} | 1 LLM calls | ${tokens} tokens | $${cost.toFixed(6)} | ${(durationMs / 1000).toFixed(1)}s | 0 tool calls | status: completed | model: ${model} | sent: ${sentStr}`);
+}
+// Re-export detectProvider so it's available for tests against this module.
+export { detectProvider };

package/dist/esm/integrations/group-context.js

@@ -0,0 +1,7 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
+/**
+ * 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 const activeGroupTraceStorage = new AsyncLocalStorage();