@visibe.ai/node 0.1.4

package/dist/esm/integrations/openai.js

@@ -0,0 +1,442 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
+import { randomUUID } from 'node:crypto';
+import { BaseIntegration } from './base';
+import { activeGroupTraceStorage } from './group-context';
+import { calculateCost } from '../utils';
+// ---------------------------------------------------------------------------
+// AsyncLocalStorage — used to prevent double-tracing when LangChain/LangGraph
+// is the outer trace owner.  The OpenAI wrapper checks this store at the start
+// of every intercepted call; if it is set, the call is passed through as-is.
+// ---------------------------------------------------------------------------
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export const activeLangChainStorage = new AsyncLocalStorage();
+// ---------------------------------------------------------------------------
+// Helpers — extract text from OpenAI message arrays
+// ---------------------------------------------------------------------------
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function extractLastUserMessage(messages) {
+    if (!Array.isArray(messages))
+        return '';
+    // Walk backwards to find the last user-role message
+    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;
+            // Content can be an array of content parts (vision / multi-modal)
+            if (Array.isArray(msg.content)) {
+                const textPart = msg.content.find((p) => p.type === 'text');
+                return textPart?.text ?? '';
+            }
+        }
+    }
+    return '';
+}
+// When the model makes a tool call the message content is null.
+// Format all tool calls as "toolName(args); toolName(args)".
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function formatToolCalls(toolCalls) {
+    if (!Array.isArray(toolCalls) || toolCalls.length === 0)
+        return '';
+    return toolCalls
+        .map((tc) => `${tc.function?.name ?? 'unknown'}(${tc.function?.arguments ?? ''})`)
+        .join('; ');
+}
+// Extract plain text from a Responses API input value (string or message array).
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function extractResponsesInputText(input) {
+    if (typeof input === 'string')
+        return input;
+    if (Array.isArray(input)) {
+        for (let i = input.length - 1; i >= 0; i--) {
+            const msg = input[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 === 'input_text' || p.type === 'text');
+                    return part?.text ?? '';
+                }
+            }
+        }
+    }
+    return '';
+}
+// ---------------------------------------------------------------------------
+// OpenAIIntegration class
+// ---------------------------------------------------------------------------
+export class OpenAIIntegration extends BaseIntegration {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    patchClient(client, agentName) {
+        const originalCreate = client.chat.completions.create.bind(client.chat.completions);
+        const originalResponsesCreate = client.responses?.create?.bind(client.responses);
+        // --- chat.completions.create ---
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        client.chat.completions.create = async (params, options) => {
+            // If a LangChain/LangGraph trace is active, pass through without wrapping.
+            if (activeLangChainStorage.getStore() !== undefined) {
+                return originalCreate(params, options);
+            }
+            if (params.stream) {
+                return this._wrapStream(originalCreate, params, options, agentName);
+            }
+            return this._wrapCreate(originalCreate, params, options, agentName);
+        };
+        // --- responses.create (Responses API) ---
+        if (originalResponsesCreate) {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            client.responses.create = async (params, options) => {
+                if (activeLangChainStorage.getStore() !== undefined) {
+                    return originalResponsesCreate(params, options);
+                }
+                return this._wrapResponsesCreate(originalResponsesCreate, params, options, agentName);
+            };
+        }
+        // Return restore function
+        return () => {
+            client.chat.completions.create = originalCreate;
+            if (originalResponsesCreate) {
+                client.responses.create = originalResponsesCreate;
+            }
+        };
+    }
+    // ---------------------------------------------------------------------------
+    // chat.completions.create — 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: 'openai',
+                started_at: startedAt,
+                ...(this.visibe.sessionId ? { session_id: this.visibe.sessionId } : {}),
+            });
+        }
+        const spanId = this.nextSpanId();
+        let response;
+        let spanStatus = 'success';
+        try {
+            response = await original(params, options);
+        }
+        catch (err) {
+            spanStatus = 'failed';
+            const errorSpan = this.visibe.buildErrorSpan({
+                spanId: this.nextSpanId(),
+                errorType: err?.constructor?.name ?? 'Error',
+                errorMessage: err?.message ?? String(err),
+            });
+            this.visibe.batcher.add(traceId, errorSpan);
+            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?.prompt_tokens ?? 0;
+        const outputTokens = response.usage?.completion_tokens ?? 0;
+        const cost = calculateCost(model, inputTokens, outputTokens);
+        const choice = response.choices?.[0];
+        const rawContent = choice?.message?.content;
+        const toolCalls = choice?.message?.tool_calls ?? [];
+        const outputText = rawContent ?? formatToolCalls(toolCalls);
+        const inputText = extractLastUserMessage(params.messages ?? []);
+        const llmSpan = this.visibe.buildLLMSpan({
+            spanId,
+            agentName,
+            model,
+            status: spanStatus,
+            inputTokens,
+            outputTokens,
+            inputText,
+            outputText,
+            durationMs: Date.now() - startMs,
+        });
+        this.visibe.batcher.add(traceId, llmSpan);
+        // 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;
+    }
+    // ---------------------------------------------------------------------------
+    // chat.completions.create — streaming (stream: true)
+    // ---------------------------------------------------------------------------
+    async _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) {
+        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: 'openai',
+                started_at: startedAt,
+                ...(this.visibe.sessionId ? { session_id: this.visibe.sessionId } : {}),
+            });
+        }
+        // Inject stream_options so the final chunk includes usage data.
+        const augmentedParams = {
+            ...params,
+            stream_options: { ...params.stream_options, include_usage: true },
+        };
+        const spanId = this.nextSpanId();
+        let outputText = '';
+        let inputTokens = 0, outputTokens = 0;
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        let model = params.model ?? 'unknown';
+        const originalStream = await original(augmentedParams, options);
+        // Wrap the async iterator to accumulate chunks, then finalize on exhaustion.
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const wrappedStream = {
+            ...originalStream,
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            [Symbol.asyncIterator]() {
+                const iter = originalStream[Symbol.asyncIterator]();
+                return {
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    async next() {
+                        const result = await iter.next();
+                        if (!result.done) {
+                            const chunk = result.value;
+                            model = chunk.model ?? model;
+                            const delta = chunk.choices?.[0]?.delta?.content;
+                            if (delta)
+                                outputText += delta;
+                            // Last chunk carries usage when stream_options.include_usage is set
+                            if (chunk.usage) {
+                                inputTokens = chunk.usage.prompt_tokens ?? 0;
+                                outputTokens = chunk.usage.completion_tokens ?? 0;
+                            }
+                        }
+                        return result;
+                    },
+                };
+            },
+        };
+        // After the caller consumes the stream, finalize the span.
+        // We do this by overriding the stream's return/throw so finalization
+        // runs both on normal exhaustion and on early break.
+        const finalize = async (streamStatus) => {
+            const cost = calculateCost(model, inputTokens, outputTokens);
+            const inputText = extractLastUserMessage(params.messages ?? []);
+            const llmSpan = this.visibe.buildLLMSpan({
+                spanId,
+                agentName,
+                model,
+                status: streamStatus,
+                inputTokens,
+                outputTokens,
+                inputText,
+                outputText,
+                durationMs: Date.now() - startMs,
+            });
+            this.visibe.batcher.add(traceId, llmSpan);
+            // 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: streamStatus === 'success' ? 'completed' : 'failed',
+                    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);
+            }
+        };
+        // Attach finalize to the iterator methods the OpenAI SDK exposes.
+        const iter = wrappedStream[Symbol.asyncIterator].bind(wrappedStream);
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        wrappedStream[Symbol.asyncIterator] = () => {
+            const it = iter();
+            let finalized = false;
+            const doFinalize = async (status) => {
+                if (!finalized) {
+                    finalized = true;
+                    await finalize(status);
+                }
+            };
+            return {
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                async next() {
+                    try {
+                        const result = await it.next();
+                        if (result.done)
+                            await doFinalize('success');
+                        return result;
+                    }
+                    catch (err) {
+                        await doFinalize('failed');
+                        throw err;
+                    }
+                },
+                async return(value) {
+                    await doFinalize('success');
+                    return it.return ? it.return(value) : { done: true, value };
+                },
+                async throw(err) {
+                    await doFinalize('failed');
+                    return it.throw ? it.throw(err) : Promise.reject(err);
+                },
+            };
+        };
+        return wrappedStream;
+    }
+    // ---------------------------------------------------------------------------
+    // Responses API — client.responses.create
+    // ---------------------------------------------------------------------------
+    async _wrapResponsesCreate(
+    // 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: 'openai',
+                started_at: startedAt,
+                ...(this.visibe.sessionId ? { session_id: this.visibe.sessionId } : {}),
+            });
+        }
+        const spanId = this.nextSpanId();
+        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 output text from message items; format function/web-search calls.
+        const outputItems = response.output ?? [];
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const textParts = outputItems
+            .filter((item) => item.type === 'message')
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            .flatMap((item) => item.content ?? [])
+            .filter((c) => c.type === 'output_text' || c.type === 'text')
+            .map((c) => c.text ?? '');
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const toolItems = outputItems.filter((item) => item.type === 'function_call' || item.type === 'web_search_call');
+        const toolText = toolItems
+            .map((item) => `${item.name ?? item.type}(${JSON.stringify(item.arguments ?? {})})`)
+            .join('; ');
+        const outputText = textParts.join('') || toolText;
+        const inputText = extractResponsesInputText(params.input);
+        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;
+    }
+}
+// ---------------------------------------------------------------------------
+// Module-level factory — called by client.ts applyIntegration()
+// ---------------------------------------------------------------------------
+export function patchOpenAIClient(
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+client, agentName, visibe) {
+    const integration = new OpenAIIntegration(visibe);
+    return integration.patchClient(client, agentName);
+}
+// ---------------------------------------------------------------------------
+// Private helpers
+// ---------------------------------------------------------------------------
+function _printSummary(name, model, inputTokens, outputTokens, cost, durationMs, sent) {
+    const durationSec = (durationMs / 1000).toFixed(1);
+    const tokens = (inputTokens + outputTokens).toLocaleString();
+    const costStr = `$${cost.toFixed(6)}`;
+    const sentStr = sent ? 'OK' : 'FAILED';
+    console.log(`[Visibe] Trace: ${name} | 1 LLM calls | ${tokens} tokens | ${costStr} | ${durationSec}s | 0 tool calls | status: completed | model: ${model} | sent: ${sentStr}`);
+}