@visibe.ai/node 0.1.4

package/dist/esm/integrations/anthropic.js

@@ -0,0 +1,272 @@
+import { randomUUID } from 'node:crypto';
+import { BaseIntegration } from './base';
+import { activeGroupTraceStorage } from './group-context';
+import { calculateCost } from '../utils';
+export class AnthropicIntegration extends 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 = 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: '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 = 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 = activeGroupTraceStorage.getStore();
+        const traceId = groupCtx?.traceId ?? 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 = 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;
+    }
+}
+// ---------------------------------------------------------------------------
+// Module-level factory
+// ---------------------------------------------------------------------------
+export 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/esm/integrations/base.js

@@ -0,0 +1,28 @@
+import { randomUUID } from '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()`.
+ */
+export 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 randomUUID();
+    }
+}