lupislabs 1.0.0 → 1.0.1

package/dist/http-interceptor.js

@@ -1,12 +1,63 @@
-import * as api from '@opentelemetry/api';
+import { SensitiveDataFilterUtil } from './sensitive-data-filter.js';
 import { createRequire } from 'module';
+import { patchFetch } from './interceptors/fetch-interceptor.js';
+import { patchNodeHttp } from './interceptors/node-http-interceptor.js';
+import { patchAxios } from './interceptors/axios-interceptor.js';
+import { patchGot } from './interceptors/got-interceptor.js';
+import { detectProvider, resolveHandler } from './providers/provider-detector.js';
 const requireFunc = createRequire(import.meta.url);
 export class HttpInterceptor {
-    constructor(tracer, provider, projectId) {
+    constructor(traceCollector, projectId, sensitiveDataFilter) {
         this.isIntercepting = false;
-        this.tracer = tracer;
-        this.provider = provider;
+        this.currentMetadata = {};
+        this.traceCollector = traceCollector;
         this.projectId = projectId;
+        this.sensitiveDataFilter = new SensitiveDataFilterUtil(sensitiveDataFilter || {
+            filterSensitiveData: true,
+            sensitiveDataPatterns: [],
+            redactionMode: 'mask',
+        });
+    }
+    setChatId(chatId) {
+        this.currentChatId = chatId;
+    }
+    clearChatId() {
+        this.currentChatId = undefined;
+    }
+    setMetadata(metadata) {
+        this.currentMetadata = { ...this.currentMetadata, ...metadata };
+    }
+    clearMetadata() {
+        this.currentMetadata = {};
+    }
+    createTrace(url, method, statusCode, duration, provider, requestHeaders, responseHeaders, tokenUsage, costBreakdown, model, requestBody, responseBody, error) {
+        return {
+            id: `${Date.now()}-${Math.random().toString(36).substring(7)}`,
+            projectId: this.projectId,
+            timestamp: Date.now(),
+            type: 'http_request',
+            duration,
+            url,
+            method,
+            statusCode,
+            provider,
+            requestHeaders,
+            responseHeaders,
+            tokenUsage,
+            costBreakdown,
+            model,
+            requestBody,
+            responseBody,
+            chatId: this.currentChatId,
+            metadata: Object.keys(this.currentMetadata).length > 0 ? { ...this.currentMetadata } : undefined,
+            error,
+        };
+    }
+    sanitizeRequestBody(body) {
+        return this.sensitiveDataFilter.sanitizeRequestBody(body);
+    }
+    sanitizeResponseBody(body) {
+        return this.sensitiveDataFilter.sanitizeResponseBody(body);
     }
     startIntercepting() {
         if (this.isIntercepting) {
@@ -14,7 +65,13 @@ export class HttpInterceptor {
         }
         this.isIntercepting = true;
         this.patchFetch();
-        this.patchNodeHttp();
+        const enableNodeHttpEnv = typeof process !== 'undefined' ? process.env?.LUPIS_ENABLE_NODE_HTTP : undefined;
+        const shouldPatchNodeHttp = enableNodeHttpEnv === 'true' || (enableNodeHttpEnv !== 'false' && (typeof globalThis.fetch !== 'function' || enableNodeHttpEnv === undefined));
+        if (shouldPatchNodeHttp) {
+            this.patchNodeHttp();
+        }
+        this.patchAxios();
+        this.patchGot();
     }
     stopIntercepting() {
         if (!this.isIntercepting)
@@ -35,6 +92,22 @@ export class HttpInterceptor {
         }
         catch (e) {
         }
+        try {
+            const axios = requireFunc('axios');
+            if (this.originalAxiosRequest && axios.default) {
+                axios.default.request = this.originalAxiosRequest;
+            }
+        }
+        catch (e) {
+        }
+        try {
+            const got = requireFunc('got');
+            if (this.originalGotRequest && got.default) {
+                got.default = this.originalGotRequest;
+            }
+        }
+        catch (e) {
+        }
     }
     patchFetch() {
         try {
@@ -42,177 +115,21 @@ export class HttpInterceptor {
                 return;
             }
             this.originalFetch = globalThis.fetch;
-            const self = this;
-            globalThis.fetch = async function (input, init) {
-                const startTime = Date.now();
-                const url = typeof input === 'string' ? input : input.toString();
-                const method = init?.method || 'GET';
-                const provider = self.detectProvider(url);
-                const handler = self.resolveHandler(provider);
-                if (url.includes('/v1/traces')) {
-                    return self.originalFetch(input, init);
-                }
-                const span = self.tracer.startSpan(`HTTP ${method}`, {
-                    kind: api.SpanKind.CLIENT,
-                    attributes: {
-                        'http.method': method,
-                        'http.url': url,
-                        'url.full': url,
-                        'http.provider': provider,
-                        'lupis.project.id': self.projectId,
-                        'lupis.complete': 'true',
-                    },
-                });
-                if (init?.body) {
-                    const requestBody = typeof init.body === 'string' ? init.body : JSON.stringify(init.body);
-                    span.setAttribute('http.request.body', requestBody);
-                }
-                if (init?.headers) {
-                    const headers = {};
-                    if (init.headers instanceof Headers) {
-                        init.headers.forEach((value, key) => {
-                            headers[key] = value;
-                        });
-                    }
-                    else if (Array.isArray(init.headers)) {
-                        init.headers.forEach(([key, value]) => {
-                            headers[key] = value;
-                        });
-                    }
-                    else {
-                        Object.assign(headers, init.headers);
-                    }
-                    span.setAttribute('http.request.headers', JSON.stringify(headers));
-                }
-                try {
-                    const response = await self.originalFetch(input, init);
-                    const duration = Date.now() - startTime;
-                    span.setAttribute('http.status_code', response.status);
-                    span.setAttribute('http.response.status_code', response.status);
-                    span.setAttribute('http.response.status', response.status);
-                    const responseHeaders = Object.fromEntries(response.headers.entries());
-                    span.setAttribute('http.response.headers', JSON.stringify(responseHeaders));
-                    // Try tee() first - if it works, we have a true streaming response
-                    if (response.body && typeof response.body.tee === 'function') {
-                        const bodyStream = response.body;
-                        const [clientStream, traceStream] = bodyStream.tee();
-                        const decoder = new TextDecoder();
-                        const chunks = [];
-                        let providerState = undefined;
-                        const trackStream = async () => {
-                            const reader = traceStream.getReader();
-                            try {
-                                while (true) {
-                                    const { done, value } = await reader.read();
-                                    if (done) {
-                                        const remaining = decoder.decode();
-                                        if (remaining) {
-                                            chunks.push(remaining);
-                                        }
-                                        break;
-                                    }
-                                    if (value) {
-                                        const chunkText = decoder.decode(value, { stream: true });
-                                        if (chunkText) {
-                                            chunks.push(chunkText);
-                                            if (handler && handler.isStreamingChunk(chunkText)) {
-                                                const { state, result } = handler.accumulateChunk(providerState, chunkText);
-                                                providerState = state;
-                                                if (result) {
-                                                    // no-op for now; we only send final aggregated trace to minimize noise
-                                                }
-                                            }
-                                        }
-                                    }
-                                }
-                                // Send only final aggregated trace
-                                let bodyText = chunks.join('');
-                                let normalized = bodyText;
-                                try {
-                                    if (handler) {
-                                        if (providerState && Array.isArray(providerState.__rawChunks)) {
-                                            const data = providerState.__rawChunks;
-                                            const aggregatedText = providerState.__aggregatedText;
-                                            const toolCalls = providerState.__toolCalls;
-                                            const usage = providerState.__usage;
-                                            normalized = {
-                                                type: 'streaming_response',
-                                                provider,
-                                                aggregatedText,
-                                                data,
-                                                toolCalls,
-                                                usage,
-                                                contentType: response.headers.get('content-type') || undefined,
-                                                totalChunks: data.length,
-                                                totalLength: data.reduce((n, s) => n + s.length, 0),
-                                                isComplete: true,
-                                            };
-                                            span.setAttribute('http.response.body', JSON.stringify(normalized));
-                                        }
-                                        else {
-                                            normalized = handler.normalizeFinal(bodyText);
-                                            span.setAttribute('http.response.body', typeof normalized === 'string' ? normalized : JSON.stringify(normalized));
-                                        }
-                                    }
-                                    else {
-                                        span.setAttribute('http.response.body', bodyText);
-                                    }
-                                }
-                                catch (e) {
-                                    span.setAttribute('http.response.body', bodyText);
-                                }
-                                span.setStatus({ code: response.ok ? api.SpanStatusCode.OK : api.SpanStatusCode.ERROR });
-                                span.end();
-                            }
-                            catch (error) {
-                                span.recordException(error);
-                                span.setStatus({
-                                    code: api.SpanStatusCode.ERROR,
-                                    message: error.message
-                                });
-                                span.end();
-                            }
-                        };
-                        trackStream().catch(console.warn);
-                        return new Response(clientStream, {
-                            headers: response.headers,
-                            status: response.status,
-                            statusText: response.statusText,
-                        });
-                    }
-                    // For non-streaming responses or when tee() isn't available, handle as regular response
-                    if (response.body && typeof response.body.getReader === 'function') {
-                        const clone = response.clone();
-                        const responseText = await self.getRawResponseText(clone);
-                        let normalizedBody = responseText;
-                        try {
-                            if (handler) {
-                                normalizedBody = handler.normalizeFinal(responseText);
-                            }
-                        }
-                        catch (e) {
-                            normalizedBody = responseText;
-                        }
-                        span.setAttribute('http.response.body', typeof normalizedBody === 'string' ? normalizedBody : JSON.stringify(normalizedBody));
-                        span.setStatus({ code: response.ok ? api.SpanStatusCode.OK : api.SpanStatusCode.ERROR });
-                        span.end();
-                        return response;
-                    }
-                    span.setAttribute('http.response.body', '');
-                    span.setStatus({ code: response.ok ? api.SpanStatusCode.OK : api.SpanStatusCode.ERROR });
-                    span.end();
-                    return response;
-                }
-                catch (error) {
-                    span.recordException(error);
-                    span.setStatus({
-                        code: api.SpanStatusCode.ERROR,
-                        message: error.message
-                    });
-                    span.end();
-                    throw error;
-                }
+            const context = {
+                originalFetch: this.originalFetch,
+                traceCollector: this.traceCollector,
+                projectId: this.projectId,
+                currentChatId: this.currentChatId,
+                currentMetadata: this.currentMetadata,
+                sensitiveDataFilter: this.sensitiveDataFilter,
+                createTrace: this.createTrace.bind(this),
+                detectProvider: detectProvider,
+                resolveHandler: resolveHandler,
+                getRawResponseText: this.getRawResponseText.bind(this),
+                sanitizeRequestBody: this.sanitizeRequestBody.bind(this),
+                sanitizeResponseBody: this.sanitizeResponseBody.bind(this),
             };
+            patchFetch(context);
         }
         catch (e) {
             console.warn('[Lupis SDK] Failed to patch fetch:', e);
@@ -223,169 +140,88 @@ export class HttpInterceptor {
             const http = requireFunc('http');
             const https = requireFunc('https');
             const zlib = requireFunc('zlib');
+            console.log('[Lupis SDK] Patching Node.js http/https modules');
             this.zlib = zlib;
             this.originalHttpRequest = http.request;
             this.originalHttpsRequest = https.request;
-            const self = this;
-            const createPatchedRequest = (original, protocol) => {
-                return function (options, callback) {
-                    const url = typeof options === 'string' ? options :
-                        `${protocol}://${options.hostname || options.host || 'localhost'}${options.port ? ':' + options.port : ''}${options.path || '/'}`;
-                    const method = options.method || 'GET';
-                    const provider = self.detectProvider(url);
-                    const span = self.tracer.startSpan(`HTTP ${method}`, {
-                        kind: api.SpanKind.CLIENT,
-                        attributes: {
-                            'http.method': method,
-                            'http.url': url,
-                            'url.full': url,
-                            'http.provider': provider,
-                            'lupis.project.id': self.projectId,
-                            'lupis.complete': 'true',
-                        },
-                    });
-                    const startTime = Date.now();
-                    let requestBody = '';
-                    const req = original.call(this, options, (res) => {
-                        const duration = Date.now() - startTime;
-                        span.setAttribute('http.status_code', res.statusCode);
-                        span.setAttribute('http.response.status_code', res.statusCode);
-                        span.setAttribute('http.response.status', res.statusCode);
-                        const responseHeaders = {};
-                        Object.keys(res.headers || {}).forEach(key => {
-                            responseHeaders[key] = res.headers[key];
-                        });
-                        span.setAttribute('http.response.headers', JSON.stringify(responseHeaders));
-                        const responseChunks = [];
-                        const originalOn = res.on.bind(res);
-                        const providerHandler = self.resolveHandler(provider);
-                        const contentType = res.headers['content-type'] || '';
-                        const isStreaming = contentType.includes('text/event-stream');
-                        let streamState = undefined;
-                        res.on = function (event, handler) {
-                            if (event === 'data') {
-                                return originalOn(event, (chunk) => {
-                                    responseChunks.push(Buffer.from(chunk));
-                                    if (isStreaming && providerHandler) {
-                                        const chunkText = chunk.toString('utf8');
-                                        if (providerHandler.isStreamingChunk(chunkText)) {
-                                            const { state } = providerHandler.accumulateChunk(streamState, chunkText);
-                                            streamState = state;
-                                        }
-                                    }
-                                    return handler(chunk);
-                                });
-                            }
-                            if (event === 'end') {
-                                return originalOn(event, () => {
-                                    if (responseChunks.length > 0) {
-                                        try {
-                                            const buffer = Buffer.concat(responseChunks);
-                                            const contentEncoding = res.headers['content-encoding'];
-                                            const decompressed = self.decompressIfNeeded(buffer, contentEncoding);
-                                            const limitedText = decompressed.length > 1000000
-                                                ? decompressed.substring(0, 1000000) + '...[truncated]'
-                                                : decompressed;
-                                            let normalizedBody = limitedText;
-                                            if (providerHandler) {
-                                                if (isStreaming && streamState && Array.isArray(streamState.__rawChunks)) {
-                                                    normalizedBody = {
-                                                        type: 'streaming_response',
-                                                        provider,
-                                                        aggregatedText: streamState.__aggregatedText,
-                                                        data: streamState.__rawChunks,
-                                                        toolCalls: streamState.__toolCalls,
-                                                        usage: streamState.__usage,
-                                                        contentType,
-                                                        totalChunks: streamState.__rawChunks.length,
-                                                        totalLength: streamState.__rawChunks.reduce((n, s) => n + s.length, 0),
-                                                        isComplete: true,
-                                                    };
-                                                }
-                                                else {
-                                                    normalizedBody = providerHandler.normalizeFinal(limitedText);
-                                                }
-                                            }
-                                            span.setAttribute('http.response.body', typeof normalizedBody === 'string' ? normalizedBody : JSON.stringify(normalizedBody));
-                                        }
-                                        catch (e) {
-                                            span.setAttribute('http.response.body', `[Unable to process response: ${e instanceof Error ? e.message : String(e)}]`);
-                                        }
-                                    }
-                                    span.setStatus({
-                                        code: res.statusCode >= 200 && res.statusCode < 400 ?
-                                            api.SpanStatusCode.OK : api.SpanStatusCode.ERROR
-                                    });
-                                    span.end();
-                                    return handler();
-                                });
-                            }
-                            return originalOn(event, handler);
-                        };
-                        if (callback) {
-                            callback(res);
-                        }
-                    });
-                    const originalWrite = req.write.bind(req);
-                    req.write = function (chunk, encoding, callback) {
-                        if (chunk) {
-                            requestBody += chunk.toString();
-                        }
-                        return originalWrite(chunk, encoding, callback);
-                    };
-                    const originalEnd = req.end.bind(req);
-                    req.end = function (chunk, encoding, callback) {
-                        if (chunk) {
-                            requestBody += chunk.toString();
-                        }
-                        if (requestBody) {
-                            span.setAttribute('http.request.body', requestBody);
-                        }
-                        if (options.headers) {
-                            span.setAttribute('http.request.headers', JSON.stringify(options.headers));
-                        }
-                        return originalEnd(chunk, encoding, callback);
-                    };
-                    req.on('error', (error) => {
-                        span.recordException(error);
-                        span.setStatus({
-                            code: api.SpanStatusCode.ERROR,
-                            message: error.message
-                        });
-                        span.end();
-                    });
-                    return req;
-                };
+            const context = {
+                originalHttpRequest: this.originalHttpRequest,
+                originalHttpsRequest: this.originalHttpsRequest,
+                zlib: this.zlib,
+                traceCollector: this.traceCollector,
+                projectId: this.projectId,
+                currentChatId: this.currentChatId,
+                currentMetadata: this.currentMetadata,
+                sensitiveDataFilter: this.sensitiveDataFilter,
+                createTrace: this.createTrace.bind(this),
+                detectProvider: detectProvider,
+                resolveHandler: resolveHandler,
+                decompressIfNeeded: this.decompressIfNeeded.bind(this),
+                requireFunc: requireFunc,
+                sanitizeRequestBody: this.sanitizeRequestBody.bind(this),
+                sanitizeResponseBody: this.sanitizeResponseBody.bind(this),
             };
-            http.request = createPatchedRequest(this.originalHttpRequest, 'http');
-            https.request = createPatchedRequest(this.originalHttpsRequest, 'https');
+            console.log('[Lupis SDK] Patching Node.js http/https modules with context:', context);
+            patchNodeHttp(context);
         }
         catch (e) {
             console.warn('[Lupis SDK] Failed to patch Node.js http/https:', e);
         }
     }
-    detectProvider(url) {
-        if (url.includes('api.openai.com'))
-            return 'openai';
-        if (url.includes('api.anthropic.com'))
-            return 'claude';
-        if (url.includes('api.cohere.ai'))
-            return 'cohere';
-        if (url.includes('api.huggingface.co'))
-            return 'huggingface';
-        if (url.includes('api.google.com'))
-            return 'google';
-        return 'unknown';
+    patchAxios() {
+        try {
+            const axios = requireFunc('axios');
+            if (!axios || (!axios.default && !axios.request)) {
+                return;
+            }
+            const axiosInstance = axios.default || axios;
+            if (!axiosInstance.request) {
+                return;
+            }
+            this.originalAxiosRequest = axiosInstance.request;
+            const context = {
+                originalAxiosRequest: this.originalAxiosRequest,
+                traceCollector: this.traceCollector,
+                projectId: this.projectId,
+                currentChatId: this.currentChatId,
+                currentMetadata: this.currentMetadata,
+                sensitiveDataFilter: this.sensitiveDataFilter,
+                createTrace: this.createTrace.bind(this),
+                detectProvider: detectProvider,
+                resolveHandler: resolveHandler,
+                requireFunc: requireFunc,
+                sanitizeRequestBody: this.sanitizeRequestBody.bind(this),
+                sanitizeResponseBody: this.sanitizeResponseBody.bind(this),
+            };
+            patchAxios(context);
+        }
+        catch (e) {
+        }
     }
-    resolveHandler(provider) {
-        const p = provider;
-        switch (p) {
-            case 'openai':
-                return OpenAIHandler;
-            case 'claude':
-                return AnthropicHandler;
-            default:
-                return undefined;
+    patchGot() {
+        try {
+            const got = requireFunc('got');
+            if (!got.default) {
+                return;
+            }
+            this.originalGotRequest = got.default;
+            const context = {
+                originalGotRequest: this.originalGotRequest,
+                traceCollector: this.traceCollector,
+                projectId: this.projectId,
+                currentChatId: this.currentChatId,
+                currentMetadata: this.currentMetadata,
+                sensitiveDataFilter: this.sensitiveDataFilter,
+                createTrace: this.createTrace.bind(this),
+                detectProvider: detectProvider,
+                resolveHandler: resolveHandler,
+                requireFunc: requireFunc,
+                sanitizeRequestBody: this.sanitizeRequestBody.bind(this),
+                sanitizeResponseBody: this.sanitizeResponseBody.bind(this),
+            };
+            patchGot(context);
+        }
+        catch (e) {
         }
     }
     async getRawResponseText(response) {
@@ -426,92 +262,4 @@ export class HttpInterceptor {
         }
     }
 }
-const OpenAIHandler = {
-    provider: 'openai',
-    detect: (url) => url.includes('api.openai.com'),
-    isStreamingChunk: (textChunk) => textChunk.includes('\ndata: '),
-    accumulateChunk: (state, textChunk) => {
-        const next = state || { __rawChunks: [], __aggregatedText: '', __toolCalls: [], __usage: null };
-        next.__rawChunks.push(textChunk);
-        const lines = textChunk.split('\n');
-        for (const line of lines) {
-            if (!line.startsWith('data: '))
-                continue;
-            const payload = line.substring(6).trim();
-            if (payload === '[DONE]')
-                continue;
-            try {
-                const json = JSON.parse(payload);
-                if (Array.isArray(json.choices)) {
-                    for (const choice of json.choices) {
-                        if (choice.delta?.content)
-                            next.__aggregatedText += choice.delta.content;
-                        if (Array.isArray(choice.delta?.tool_calls))
-                            next.__toolCalls.push(...choice.delta.tool_calls);
-                    }
-                }
-                if (json?.usage) {
-                    next.__usage = json.usage;
-                }
-            }
-            catch { }
-        }
-        return { state: next };
-    },
-    normalizeFinal: (rawBodyText) => {
-        try {
-            const parsed = JSON.parse(rawBodyText);
-            const aggregatedText = parsed.choices?.[0]?.message?.content || '';
-            return { ...parsed, aggregatedText };
-        }
-        catch {
-            return rawBodyText;
-        }
-    },
-};
-const AnthropicHandler = {
-    provider: 'claude',
-    detect: (url) => url.includes('api.anthropic.com'),
-    isStreamingChunk: (textChunk) => textChunk.includes('\nevent: ') || textChunk.includes('\ndata: '),
-    accumulateChunk: (state, textChunk) => {
-        const next = state || { __rawChunks: [], __aggregatedText: '', __toolCalls: [], __usage: null };
-        next.__rawChunks.push(textChunk);
-        const lines = textChunk.split('\n');
-        for (const line of lines) {
-            if (!line.startsWith('data: '))
-                continue;
-            try {
-                const json = JSON.parse(line.substring(6));
-                if (json?.delta?.text)
-                    next.__aggregatedText += json.delta.text;
-                if (json?.type === 'tool_use') {
-                    next.__toolCalls.push({
-                        id: json.id,
-                        name: json.name,
-                        type: 'function',
-                        function: { name: json.name, arguments: JSON.stringify(json.input || {}) },
-                    });
-                }
-                if (json?.usage) {
-                    next.__usage = json.usage;
-                }
-                if (json?.type === 'message_delta' && json?.usage) {
-                    next.__usage = json.usage;
-                }
-            }
-            catch { }
-        }
-        return { state: next };
-    },
-    normalizeFinal: (rawBodyText) => {
-        try {
-            const parsed = JSON.parse(rawBodyText);
-            const aggregatedText = parsed.content?.[0]?.text || '';
-            return { ...parsed, aggregatedText };
-        }
-        catch {
-            return rawBodyText;
-        }
-    },
-};
 //# sourceMappingURL=http-interceptor.js.map