@signalvaultio/node 0.1.0 → 0.3.0

package/dist/index.js

@@ -6,91 +6,286 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.SignalVaultClient = void 0;
 const openai_1 = __importDefault(require("openai"));
 const uuid_1 = require("uuid");
+const tools_1 = require("./tools");
+// ---------------------------------------------------------------------------
+// Environment guard
+// ---------------------------------------------------------------------------
 /**
- * SignalVault Client — wraps OpenAI with guardrails and audit logging.
+ * Hard-fails if the SDK is loaded in a browser context. The SDK relies on
+ * `async_hooks` (Node-only) and is intended for server-side use; bundling it
+ * for the browser would expose `apiKey`, `openaiApiKey`, and `anthropicApiKey`
+ * to end users — which is exactly the kind of leak this product is meant to
+ * prevent.
+ */
+function assertNodeEnvironment() {
+    // `process` exists on Node and not in plain browsers. `window` is the
+    // canonical browser global. We refuse to run if we look browser-like.
+    const hasProcess = typeof process !== 'undefined' && process?.versions?.node;
+    const hasWindow = typeof globalThis.window !== 'undefined';
+    if (!hasProcess || hasWindow) {
+        throw new Error('[SignalVault] This SDK is server-side only. Do not bundle it for browser use — ' +
+            'it will leak your API keys to end users. Call SignalVault from your backend instead.');
+    }
+}
+// ---------------------------------------------------------------------------
+// SignalVaultClient
+// ---------------------------------------------------------------------------
+/**
+ * SignalVault Client — wraps OpenAI and/or Anthropic with guardrails and audit logging.
  *
- * @example
+ * @example OpenAI
  * ```typescript
  * const client = new SignalVaultClient({
  *   apiKey: 'sk_live_...',
  *   openaiApiKey: process.env.OPENAI_API_KEY!,
  *   baseUrl: 'https://api.signalvault.io',
+ *   metadata: { user_id: '123' },
  * });
- *
- * // Non-streaming
  * const res = await client.chat.completions.create({ model: 'gpt-4', messages: [...] });
+ * ```
  *
- * // Streaming
- * const stream = await client.chat.completions.create({ model: 'gpt-4', messages: [...], stream: true });
- * for await (const chunk of stream) { ... }
+ * @example Anthropic
+ * ```typescript
+ * const client = new SignalVaultClient({
+ *   apiKey: 'sk_live_...',
+ *   anthropicApiKey: process.env.ANTHROPIC_API_KEY!,
+ *   baseUrl: 'https://api.signalvault.io',
+ * });
+ * const res = await client.messages.create({ model: 'claude-3-5-sonnet-20241022', messages: [...], max_tokens: 1024 });
  * ```
  */
 class SignalVaultClient {
     constructor(config) {
-        this.signalvaultApiKey = config.apiKey;
-        this.signalvaultBaseUrl = (config.baseUrl || 'http://localhost:4000').replace(/\/+$/, '');
-        this.signalvaultEnvironment = config.environment || 'production';
+        assertNodeEnvironment();
+        if (!config.openaiApiKey && !config.anthropicApiKey) {
+            throw new Error('[SignalVault] At least one of openaiApiKey or anthropicApiKey is required.');
+        }
+        this.svApiKey = config.apiKey;
+        this.svBaseUrl = (config.baseUrl || 'http://localhost:4000').replace(/\/+$/, '');
+        this.svEnvironment = config.environment || 'production';
         this.debugMode = config.debug || false;
         this.mirrorMode = config.mirrorMode || false;
-        this.openai = new openai_1.default({
-            apiKey: config.openaiApiKey,
-        });
+        this.preflightTimeout = config.preflightTimeout ?? 2000;
+        this.bgTimeout = config.timeout ?? 10000;
+        this.defaultMetadata = config.metadata ?? {};
+        this.openai = config.openaiApiKey
+            ? new openai_1.default({ apiKey: config.openaiApiKey })
+            : null;
+        if (config.anthropicApiKey) {
+            try {
+                // eslint-disable-next-line @typescript-eslint/no-var-requires
+                const mod = require('@anthropic-ai/sdk');
+                const Anthropic = mod.default ?? mod;
+                this.anthropic = new Anthropic({ apiKey: config.anthropicApiKey });
+            }
+            catch {
+                throw new Error('[SignalVault] @anthropic-ai/sdk is not installed. Run: npm install @anthropic-ai/sdk');
+            }
+        }
+        else {
+            this.anthropic = null;
+        }
     }
+    // ---------------------------------------------------------------------------
+    // Agent tool-use capture
+    // ---------------------------------------------------------------------------
     /**
-     * Chat completions with SignalVault guardrails.
-     * Supports both streaming and non-streaming.
+     * Wraps a function so every call records an `agent.tool_call` event with
+     * timing, input, output, and any error. The wrapper auto-times, runs the
+     * inner function, fires the audit event in the background, and returns the
+     * inner result (or rethrows the inner error).
+     *
+     * Tool calls invoked inside a `withContext({ requestId })` block auto-pick
+     * up the requestId for correlation with the parent ai.request.
+     *
+     * @example
+     * ```typescript
+     * const fetchWeather = signalvault.tool('fetch_weather', async (city: string) => {
+     *   const res = await fetch(`https://api.example.com/weather?city=${city}`);
+     *   return res.json();
+     * });
+     *
+     * const weather = await fetchWeather('London');
+     * ```
      */
+    tool(name, fn, options) {
+        return (0, tools_1.wrapTool)({
+            recordFn: (opts) => this.sendToolCallEvent(opts),
+            debug: this.debugMode,
+        }, name, fn, options);
+    }
+    /**
+     * Manual tool recording API. Use when the wrapper isn't a fit (streaming
+     * tools, custom timing, post-hoc capture from logs).
+     *
+     * @example
+     * ```typescript
+     * await signalvault.tools.record({
+     *   toolName: 'fetch_weather',
+     *   toolInput: { city: 'London' },
+     *   toolOutput: { temp: 12.3 },
+     *   durationMs: 142,
+     * });
+     * ```
+     */
+    get tools() {
+        return {
+            record: (opts) => this.sendToolCallEvent(opts),
+        };
+    }
+    /**
+     * Runs the given async function inside a context where tool calls are
+     * automatically correlated to the provided `requestId`. Useful for grouping
+     * a multi-step agent loop under one logical turn.
+     *
+     * @example
+     * ```typescript
+     * await signalvault.withContext({ requestId: 'agent-turn-abc' }, async () => {
+     *   const llm = await signalvault.chat.completions.create({...});
+     *   await fetchWeather('London'); // tool call auto-linked to 'agent-turn-abc'
+     * });
+     * ```
+     */
+    withContext(ctx, fn) {
+        return (0, tools_1.runWithContext)(ctx, fn);
+    }
+    async sendToolCallEvent(opts) {
+        const metadata = { ...this.defaultMetadata, ...(opts.metadata ?? {}) };
+        // Validate + sanitize before constructing the body. validateToolName throws
+        // on missing/empty name; surfacing that to the caller is intentional —
+        // the manual API should refuse malformed input rather than silently fail.
+        const safeName = (0, tools_1.validateToolName)(opts.toolName);
+        const payload = {
+            tool_name: safeName,
+            tool_input: (0, tools_1.sanitizePayload)(opts.toolInput),
+            tool_output: (0, tools_1.sanitizePayload)(opts.toolOutput),
+            duration_ms: opts.durationMs,
+        };
+        const safeError = (0, tools_1.sanitizeError)(opts.error);
+        if (safeError !== undefined)
+            payload.error = safeError;
+        if (opts.startedAt)
+            payload.started_at = opts.startedAt;
+        const body = {
+            type: 'agent.tool_call',
+            environment: this.svEnvironment,
+            metadata,
+            payload,
+        };
+        if (opts.requestId)
+            body.request_id = opts.requestId;
+        let serialized;
+        try {
+            serialized = JSON.stringify(body);
+        }
+        catch (error) {
+            // sanitizePayload should make this impossible, but guard the outer
+            // serialize too — we'd rather drop the audit than crash the app.
+            console.warn('[SignalVault] tool_call serialization failed, event dropped:', error);
+            return;
+        }
+        try {
+            const response = await fetch(`${this.svBaseUrl}/v1/events`, {
+                method: 'POST',
+                headers: this.authHeaders(),
+                signal: AbortSignal.timeout(this.bgTimeout),
+                body: serialized,
+            });
+            // Surface 4xx unconditionally — those are usually misconfigurations
+            // (bad key, malformed payload) the user must know about. 5xx are noisy
+            // and only logged in debug mode.
+            if (!response.ok) {
+                if (response.status >= 400 && response.status < 500) {
+                    console.warn(`[SignalVault] tool_call rejected with ${response.status}. ` +
+                        `Check your apiKey and event payload.`);
+                }
+                else if (this.debugMode) {
+                    console.error('[SignalVault] tool_call event failed:', response.status);
+                }
+            }
+        }
+        catch (error) {
+            if (this.debugMode) {
+                console.error('[SignalVault] tool_call event error:', error);
+            }
+        }
+    }
+    // ---------------------------------------------------------------------------
+    // OpenAI: chat.completions
+    // ---------------------------------------------------------------------------
     get chat() {
+        if (!this.openai) {
+            throw new Error('[SignalVault] openaiApiKey was not provided.');
+        }
+        const self = this;
         return {
             completions: {
-                create: async (params) => {
+                async create(params, options) {
                     const requestId = (0, uuid_1.v4)();
-                    if (this.debugMode) {
-                        console.log('[SignalVault] Processing request:', requestId, this.mirrorMode ? '(MIRROR MODE)' : '', params.stream ? '(STREAMING)' : '');
+                    const metadata = { ...self.defaultMetadata, ...(options?.metadata ?? {}) };
+                    if (self.debugMode) {
+                        console.log('[SignalVault] Processing request:', requestId, self.mirrorMode ? '(MIRROR MODE)' : '', params.stream ? '(STREAMING)' : '');
                     }
-                    // Mirror mode: call OpenAI first, then audit
-                    if (this.mirrorMode) {
-                        return this.handleMirrorMode(requestId, params);
+                    if (self.mirrorMode) {
+                        return self.handleOpenAIMirror(requestId, params, metadata);
                     }
-                    // Normal mode: pre-flight checks first
-                    return this.handleNormalMode(requestId, params);
+                    return self.handleOpenAINormal(requestId, params, metadata);
                 },
             },
         };
     }
     // ---------------------------------------------------------------------------
-    // Mirror mode — no latency added, audit asynchronously
+    // Anthropic: messages
     // ---------------------------------------------------------------------------
-    async handleMirrorMode(requestId, params) {
+    get messages() {
+        if (!this.anthropic) {
+            throw new Error('[SignalVault] anthropicApiKey not provided or @anthropic-ai/sdk not installed.');
+        }
+        const self = this;
+        return {
+            async create(params, options) {
+                const requestId = (0, uuid_1.v4)();
+                const metadata = { ...self.defaultMetadata, ...(options?.metadata ?? {}) };
+                if (self.debugMode) {
+                    console.log('[SignalVault] Anthropic request:', requestId, self.mirrorMode ? '(MIRROR MODE)' : '', params.stream ? '(STREAMING)' : '');
+                }
+                if (self.mirrorMode) {
+                    return self.handleAnthropicMirror(requestId, params, metadata);
+                }
+                return self.handleAnthropicNormal(requestId, params, metadata);
+            },
+        };
+    }
+    // ---------------------------------------------------------------------------
+    // OpenAI — mirror mode
+    // ---------------------------------------------------------------------------
+    async handleOpenAIMirror(requestId, params, metadata) {
         try {
             const response = await this.openai.chat.completions.create(params);
             if (params.stream) {
-                // Wrap the stream to collect chunks for auditing
-                return this.wrapStreamForAudit(requestId, params, response);
+                return this.wrapStream(requestId, params.model, params.messages, response, async (output, promptTokens, completionTokens) => {
+                    await this.sendAuditEvents(requestId, params.model, params.messages, output, promptTokens, completionTokens, metadata, 'openai');
+                });
             }
-            // Non-streaming: audit in background
             const completion = response;
-            this.sendAudit(requestId, params, completion).catch((err) => {
-                if (this.debugMode) {
+            this.sendAuditEvents(requestId, params.model, params.messages, completion.choices[0]?.message?.content || '', completion.usage?.prompt_tokens || 0, completion.usage?.completion_tokens || 0, metadata, 'openai').catch((err) => {
+                if (this.debugMode)
                     console.error('[SignalVault] Audit failed (non-blocking):', err);
-                }
             });
             return completion;
         }
         catch (error) {
-            if (this.debugMode) {
+            if (this.debugMode)
                 console.error('[SignalVault] OpenAI error:', error);
-            }
             throw error;
         }
     }
     // ---------------------------------------------------------------------------
-    // Normal mode — pre-flight guardrails, then OpenAI, then post-flight
+    // OpenAI — normal mode
     // ---------------------------------------------------------------------------
-    async handleNormalMode(requestId, params) {
+    async handleOpenAINormal(requestId, params, metadata) {
         try {
-            // Pre-flight check
-            const decision = await this.sendRequest(requestId, params);
+            const decision = await this.sendRequest(requestId, params.model, params.messages, metadata, 'openai');
             if (decision.decision === 'block') {
                 throw new Error(`[SignalVault] Request blocked: ${JSON.stringify(decision.violations)}`);
             }
@@ -99,25 +294,76 @@ class SignalVaultClient {
             }
             const response = await this.openai.chat.completions.create(params);
             if (params.stream) {
-                // Wrap stream to collect output for post-flight logging
-                return this.wrapStreamForPostFlight(requestId, params, response);
+                return this.wrapStream(requestId, params.model, params.messages, response, async (output, promptTokens, completionTokens) => {
+                    await this.sendResponseEvent(requestId, params.model, output, promptTokens, completionTokens, metadata, 'openai');
+                });
             }
-            // Non-streaming: post-flight logging
             const completion = response;
-            await this.sendResponse(requestId, completion, params.model);
+            await this.sendResponseEvent(requestId, params.model, completion.choices[0]?.message?.content || '', completion.usage?.prompt_tokens || 0, completion.usage?.completion_tokens || 0, metadata, 'openai');
             return completion;
         }
         catch (error) {
-            if (this.debugMode) {
+            if (this.debugMode)
                 console.error('[SignalVault] Error:', error);
+            throw error;
+        }
+    }
+    // ---------------------------------------------------------------------------
+    // Anthropic — mirror mode
+    // ---------------------------------------------------------------------------
+    async handleAnthropicMirror(requestId, params, metadata) {
+        try {
+            const response = await this.anthropic.messages.create(params);
+            if (params.stream) {
+                return this.wrapAnthropicStream(requestId, params.model, params.messages, response, async (output, inputTokens, outputTokens) => {
+                    await this.sendAuditEvents(requestId, params.model, params.messages, output, inputTokens, outputTokens, metadata, 'anthropic');
+                });
             }
+            const output = response.content?.[0]?.text || '';
+            this.sendAuditEvents(requestId, params.model, params.messages, output, response.usage?.input_tokens || 0, response.usage?.output_tokens || 0, metadata, 'anthropic').catch((err) => {
+                if (this.debugMode)
+                    console.error('[SignalVault] Anthropic audit failed (non-blocking):', err);
+            });
+            return response;
+        }
+        catch (error) {
+            if (this.debugMode)
+                console.error('[SignalVault] Anthropic error:', error);
             throw error;
         }
     }
     // ---------------------------------------------------------------------------
-    // Stream wrappers — collect chunks and send audit/post-flight events
+    // Anthropic — normal mode
     // ---------------------------------------------------------------------------
-    async *wrapStreamForAudit(requestId, params, stream) {
+    async handleAnthropicNormal(requestId, params, metadata) {
+        try {
+            const decision = await this.sendRequest(requestId, params.model, params.messages, metadata, 'anthropic');
+            if (decision.decision === 'block') {
+                throw new Error(`[SignalVault] Request blocked: ${JSON.stringify(decision.violations)}`);
+            }
+            if (decision.decision === 'warn' && this.debugMode) {
+                console.warn('[SignalVault] Warnings:', decision.violations);
+            }
+            const response = await this.anthropic.messages.create(params);
+            if (params.stream) {
+                return this.wrapAnthropicStream(requestId, params.model, params.messages, response, async (output, inputTokens, outputTokens) => {
+                    await this.sendResponseEvent(requestId, params.model, output, inputTokens, outputTokens, metadata, 'anthropic');
+                });
+            }
+            const output = response.content?.[0]?.text || '';
+            await this.sendResponseEvent(requestId, params.model, output, response.usage?.input_tokens || 0, response.usage?.output_tokens || 0, metadata, 'anthropic');
+            return response;
+        }
+        catch (error) {
+            if (this.debugMode)
+                console.error('[SignalVault] Anthropic error:', error);
+            throw error;
+        }
+    }
+    // ---------------------------------------------------------------------------
+    // Unified OpenAI stream wrapper
+    // ---------------------------------------------------------------------------
+    async *wrapStream(requestId, model, messages, stream, onComplete) {
         const chunks = [];
         let promptTokens = 0;
         let completionTokens = 0;
@@ -125,210 +371,138 @@ class SignalVaultClient {
             const content = chunk.choices[0]?.delta?.content || '';
             if (content)
                 chunks.push(content);
-            // Collect usage if provided in final chunk
             if (chunk.usage) {
                 promptTokens = chunk.usage.prompt_tokens || 0;
                 completionTokens = chunk.usage.completion_tokens || 0;
             }
             yield chunk;
         }
-        // Send audit after stream completes
-        const fullOutput = chunks.join('');
-        this.sendStreamAudit(requestId, params, fullOutput, promptTokens, completionTokens).catch((err) => {
-            if (this.debugMode) {
-                console.error('[SignalVault] Stream audit failed:', err);
-            }
+        onComplete(chunks.join(''), promptTokens, completionTokens).catch((err) => {
+            if (this.debugMode)
+                console.error('[SignalVault] Post-stream callback failed:', err);
         });
     }
-    async *wrapStreamForPostFlight(requestId, params, stream) {
+    // ---------------------------------------------------------------------------
+    // Anthropic stream wrapper
+    // ---------------------------------------------------------------------------
+    async *wrapAnthropicStream(requestId, model, messages, stream, onComplete) {
         const chunks = [];
-        let promptTokens = 0;
-        let completionTokens = 0;
-        for await (const chunk of stream) {
-            const content = chunk.choices[0]?.delta?.content || '';
-            if (content)
-                chunks.push(content);
-            if (chunk.usage) {
-                promptTokens = chunk.usage.prompt_tokens || 0;
-                completionTokens = chunk.usage.completion_tokens || 0;
+        let inputTokens = 0;
+        let outputTokens = 0;
+        for await (const event of stream) {
+            if (event.type === 'content_block_delta' && event.delta?.type === 'text_delta') {
+                chunks.push(event.delta.text || '');
             }
-            yield chunk;
-        }
-        // Post-flight logging
-        const fullOutput = chunks.join('');
-        try {
-            await this.sendStreamResponse(requestId, params.model, fullOutput, promptTokens, completionTokens);
-        }
-        catch (err) {
-            if (this.debugMode) {
-                console.error('[SignalVault] Post-flight logging failed:', err);
+            if (event.type === 'message_start' && event.message?.usage) {
+                inputTokens = event.message.usage.input_tokens || 0;
             }
+            if (event.type === 'message_delta' && event.usage) {
+                outputTokens = event.usage.output_tokens || 0;
+            }
+            yield event;
         }
+        onComplete(chunks.join(''), inputTokens, outputTokens).catch((err) => {
+            if (this.debugMode)
+                console.error('[SignalVault] Anthropic post-stream callback failed:', err);
+        });
     }
     // ---------------------------------------------------------------------------
     // API communication
     // ---------------------------------------------------------------------------
-    async sendRequest(requestId, params) {
-        const response = await fetch(`${this.signalvaultBaseUrl}/v1/events`, {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-                Authorization: `Bearer ${this.signalvaultApiKey}`,
-            },
-            body: JSON.stringify({
-                type: 'ai.request',
-                request_id: requestId,
-                environment: this.signalvaultEnvironment,
-                provider: 'openai',
-                model: params.model,
-                metadata: {},
-                payload: { messages: params.messages },
-            }),
-        });
-        if (!response.ok) {
-            if (this.debugMode) {
-                console.error('[SignalVault] API error:', response.status);
+    authHeaders() {
+        return {
+            'Content-Type': 'application/json',
+            Authorization: `Bearer ${this.svApiKey}`,
+        };
+    }
+    async sendRequest(requestId, model, messages, metadata, provider) {
+        try {
+            const response = await fetch(`${this.svBaseUrl}/v1/events`, {
+                method: 'POST',
+                headers: this.authHeaders(),
+                signal: AbortSignal.timeout(this.preflightTimeout),
+                body: JSON.stringify({
+                    type: 'ai.request',
+                    request_id: requestId,
+                    environment: this.svEnvironment,
+                    provider,
+                    model,
+                    metadata,
+                    payload: { messages },
+                }),
+            });
+            if (!response.ok) {
+                if (this.debugMode)
+                    console.error('[SignalVault] API error:', response.status);
+                return { decision: 'allow', violations: [], redactions: [] };
             }
+            return (await response.json());
+        }
+        catch (error) {
+            if (this.debugMode)
+                console.error('[SignalVault] Pre-flight failed (fail-open):', error);
             return { decision: 'allow', violations: [], redactions: [] };
         }
-        return (await response.json());
     }
-    async sendResponse(requestId, response, model) {
+    async sendResponseEvent(requestId, model, output, promptTokens, completionTokens, metadata, provider) {
         try {
-            const output = response.choices[0]?.message?.content || '';
-            await fetch(`${this.signalvaultBaseUrl}/v1/events`, {
+            await fetch(`${this.svBaseUrl}/v1/events`, {
                 method: 'POST',
-                headers: {
-                    'Content-Type': 'application/json',
-                    Authorization: `Bearer ${this.signalvaultApiKey}`,
-                },
+                headers: this.authHeaders(),
+                signal: AbortSignal.timeout(this.bgTimeout),
                 body: JSON.stringify({
                     type: 'ai.response',
                     request_id: requestId,
-                    environment: this.signalvaultEnvironment,
-                    provider: 'openai',
+                    environment: this.svEnvironment,
+                    provider,
                     model,
-                    metadata: {},
+                    metadata,
                     payload: {
                         output,
-                        usage: {
-                            prompt_tokens: response.usage?.prompt_tokens || 0,
-                            completion_tokens: response.usage?.completion_tokens || 0,
-                        },
+                        usage: { prompt_tokens: promptTokens, completion_tokens: completionTokens },
                     },
                 }),
             });
         }
         catch (error) {
-            if (this.debugMode) {
-                console.error('[SignalVault] Failed to send response:', error);
-            }
+            if (this.debugMode)
+                console.error('[SignalVault] Failed to send response event:', error);
         }
     }
-    async sendStreamResponse(requestId, model, output, promptTokens, completionTokens) {
-        await fetch(`${this.signalvaultBaseUrl}/v1/events`, {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-                Authorization: `Bearer ${this.signalvaultApiKey}`,
-            },
-            body: JSON.stringify({
-                type: 'ai.response',
-                request_id: requestId,
-                environment: this.signalvaultEnvironment,
-                provider: 'openai',
-                model,
-                metadata: {},
-                payload: {
-                    output,
-                    usage: { prompt_tokens: promptTokens, completion_tokens: completionTokens },
-                },
-            }),
-        });
-    }
-    async sendAudit(requestId, params, response) {
-        const output = response.choices[0]?.message?.content || '';
-        // Send ai.request event
-        await fetch(`${this.signalvaultBaseUrl}/v1/events`, {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-                Authorization: `Bearer ${this.signalvaultApiKey}`,
-            },
-            body: JSON.stringify({
-                type: 'ai.request',
-                request_id: requestId,
-                environment: this.signalvaultEnvironment,
-                provider: 'openai',
-                model: params.model,
-                metadata: {},
-                payload: { messages: params.messages, monitor_mode: true },
+    async sendAuditEvents(requestId, model, messages, output, promptTokens, completionTokens, metadata, provider) {
+        const base = {
+            request_id: requestId,
+            environment: this.svEnvironment,
+            provider,
+            model,
+            metadata,
+        };
+        await Promise.all([
+            fetch(`${this.svBaseUrl}/v1/events`, {
+                method: 'POST',
+                headers: this.authHeaders(),
+                signal: AbortSignal.timeout(this.bgTimeout),
+                body: JSON.stringify({
+                    ...base,
+                    type: 'ai.request',
+                    payload: { messages, monitor_mode: true },
+                }),
             }),
-        });
-        // Send ai.response event
-        await fetch(`${this.signalvaultBaseUrl}/v1/events`, {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-                Authorization: `Bearer ${this.signalvaultApiKey}`,
-            },
-            body: JSON.stringify({
-                type: 'ai.response',
-                request_id: requestId,
-                environment: this.signalvaultEnvironment,
-                provider: 'openai',
-                model: params.model,
-                metadata: {},
-                payload: {
-                    output,
-                    usage: {
-                        prompt_tokens: response.usage?.prompt_tokens || 0,
-                        completion_tokens: response.usage?.completion_tokens || 0,
+            fetch(`${this.svBaseUrl}/v1/events`, {
+                method: 'POST',
+                headers: this.authHeaders(),
+                signal: AbortSignal.timeout(this.bgTimeout),
+                body: JSON.stringify({
+                    ...base,
+                    type: 'ai.response',
+                    payload: {
+                        output,
+                        usage: { prompt_tokens: promptTokens, completion_tokens: completionTokens },
+                        monitor_mode: true,
                     },
-                    monitor_mode: true,
-                },
-            }),
-        });
-    }
-    async sendStreamAudit(requestId, params, output, promptTokens, completionTokens) {
-        // Send ai.request event
-        await fetch(`${this.signalvaultBaseUrl}/v1/events`, {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-                Authorization: `Bearer ${this.signalvaultApiKey}`,
-            },
-            body: JSON.stringify({
-                type: 'ai.request',
-                request_id: requestId,
-                environment: this.signalvaultEnvironment,
-                provider: 'openai',
-                model: params.model,
-                metadata: {},
-                payload: { messages: params.messages, monitor_mode: true },
-            }),
-        });
-        // Send ai.response event
-        await fetch(`${this.signalvaultBaseUrl}/v1/events`, {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-                Authorization: `Bearer ${this.signalvaultApiKey}`,
-            },
-            body: JSON.stringify({
-                type: 'ai.response',
-                request_id: requestId,
-                environment: this.signalvaultEnvironment,
-                provider: 'openai',
-                model: params.model,
-                metadata: {},
-                payload: {
-                    output,
-                    usage: { prompt_tokens: promptTokens, completion_tokens: completionTokens },
-                    monitor_mode: true,
-                },
+                }),
             }),
-        });
+        ]);
     }
 }
 exports.SignalVaultClient = SignalVaultClient;