@signalvaultio/node 0.5.0 → 0.5.2

package/dist/index.d.ts

@@ -2,7 +2,7 @@ import type OpenAI from 'openai';
 import { ToolsAPI } from './tools';
 export type { ToolRecordOptions, ToolsAPI } from './tools';
 /** Kept in sync with package.json by a unit test. */
-export declare const SDK_VERSION = "0.5.0";
+export declare const SDK_VERSION = "0.5.2";
 /**
  * Normalizes the base URL and refuses plaintext HTTP to anything but the local
  * machine. The API key and full prompts travel in every request, so an

package/dist/index.js

@@ -5,7 +5,7 @@ exports.normalizeBaseUrl = normalizeBaseUrl;
 const crypto_1 = require("crypto");
 const tools_1 = require("./tools");
 /** Kept in sync with package.json by a unit test. */
-exports.SDK_VERSION = '0.5.0';
+exports.SDK_VERSION = '0.5.2';
 const DEFAULT_BASE_URL = 'https://api.signalvault.io';
 const LOCAL_HOSTS = new Set(['localhost', '127.0.0.1', '::1', '[::1]']);
 /** Longest Retry-After the SDK will wait out before retrying a background event once. */
@@ -38,25 +38,67 @@ function assertNodeEnvironment() {
  * `http://` URL would expose both before the server could redirect to HTTPS.
  */
 function normalizeBaseUrl(raw) {
+    // Errors never quote `raw`: it may contain credentials.
     let url;
     try {
         url = new URL(raw);
     }
     catch {
-        throw new Error(`[SignalVault] baseUrl is not a valid URL: ${raw}`);
+        throw new Error('[SignalVault] baseUrl is not a valid URL.');
+    }
+    if (url.username || url.password) {
+        throw new Error('[SignalVault] baseUrl must not contain credentials (user:password@). Pass the key as apiKey.');
     }
     if (url.protocol === 'http:' && !LOCAL_HOSTS.has(url.hostname)) {
         throw new Error('[SignalVault] baseUrl must use https:// (plain http:// is only allowed for localhost). ' +
             'Your API key and prompts would otherwise be sent unencrypted.');
     }
     if (url.search || url.hash) {
-        throw new Error(`[SignalVault] baseUrl must not contain a query or fragment: ${raw}`);
+        throw new Error('[SignalVault] baseUrl must not contain a query or fragment.');
     }
     if (url.protocol !== 'https:' && url.protocol !== 'http:') {
         throw new Error(`[SignalVault] baseUrl must be an https:// URL, got ${url.protocol}`);
     }
     return raw.replace(/\/+$/, '');
 }
+/**
+ * Strips surrounding whitespace and refuses keys that can't go in a header.
+ * A key read from a file or a secret often ends in a newline. Sent as is,
+ * every request fails before it leaves the process, so with failMode 'open'
+ * every call would go through unchecked. Errors never include the key.
+ */
+function normalizeApiKey(raw) {
+    if (typeof raw !== 'string') {
+        throw new TypeError(`[SignalVault] apiKey must be a string, got ${raw === null ? 'null' : typeof raw}.`);
+    }
+    const key = raw.trim();
+    if (!key) {
+        throw new Error('[SignalVault] apiKey is empty.');
+    }
+    if (/[^\x21-\x7e]/.test(key)) {
+        throw new Error('[SignalVault] apiKey contains whitespace, control or non-ASCII characters. Check how the key is loaded.');
+    }
+    return key;
+}
+/**
+ * One line describing an error and its causes, for debug output. Never
+ * includes `secret`, and never throws.
+ */
+function describeError(error, secret) {
+    const parts = [];
+    let current = error;
+    for (let depth = 0; current !== undefined && current !== null && depth < 5; depth++) {
+        try {
+            parts.push(current instanceof Error ? `${current.name}: ${current.message}` : String(current));
+            current = current instanceof Error ? current.cause : undefined;
+        }
+        catch {
+            parts.push('<unprintable error>');
+            break;
+        }
+    }
+    return parts.join(' <- ').split(secret).join('[redacted]');
+}
 /** Thrown when a guardrail rule blocks the request. */
 class SignalVaultBlockedError extends Error {
     constructor(requestId, violations, dashboardUrl) {
@@ -122,6 +164,39 @@ function anthropicOutputText(response) {
         .map((b) => b.text)
         .join('');
 }
+const ANTHROPIC_USAGE_KEYS = [
+    'input_tokens',
+    'cache_creation_input_tokens',
+    'cache_read_input_tokens',
+    'output_tokens',
+];
+/** `usage.cache_creation`: the cache writes by cache lifetime, priced differently. */
+const CACHE_CREATION_KEYS = ['ephemeral_5m_input_tokens', 'ephemeral_1h_input_tokens'];
+function copyCounts(target, source, keys) {
+    for (const key of keys) {
+        const n = source?.[key];
+        if (typeof n === 'number' && Number.isFinite(n) && n >= 0)
+            target[key] = n;
+    }
+    return target;
+}
+/**
+ * Anthropic usage under Anthropic's own names, as the proxy records it. The
+ * server adds the cache counts to `input_tokens`; renamed to `prompt_tokens`,
+ * which for OpenAI already includes cached tokens, they would be lost. Later
+ * sources override earlier ones, but only with a count.
+ */
+function anthropicUsage(...sources) {
+    const usage = { input_tokens: 0, output_tokens: 0 };
+    let cacheCreation = {};
+    for (const source of sources) {
+        copyCounts(usage, source, ANTHROPIC_USAGE_KEYS);
+        cacheCreation = copyCounts(cacheCreation, source?.cache_creation, CACHE_CREATION_KEYS);
+    }
+    if (Object.keys(cacheCreation).length)
+        usage.cache_creation = cacheCreation;
+    return usage;
+}
 function parseRetryAfterMs(response) {
     const raw = response?.headers?.get?.('retry-after');
     if (!raw)
@@ -236,7 +311,7 @@ class SignalVaultClient {
         if (config.failMode !== undefined && config.failMode !== 'open' && config.failMode !== 'closed') {
             throw new Error("[SignalVault] failMode must be 'open' or 'closed'.");
         }
-        this.svApiKey = config.apiKey;
+        this.svApiKey = normalizeApiKey(config.apiKey);
         this.svBaseUrl = normalizeBaseUrl(config.baseUrl || DEFAULT_BASE_URL);
         this.svEnvironment = config.environment || 'production';
         this.debugMode = config.debug || false;
@@ -282,8 +357,9 @@ class SignalVaultClient {
     track(promise) {
         const tracked = promise
             .catch((err) => {
-            if (this.debugMode)
-                console.error('[SignalVault] Background event failed:', err);
+            if (this.debugMode) {
+                console.error('[SignalVault] Background event failed:', describeError(err, this.svApiKey));
+            }
         })
             .finally(() => this.pending.delete(tracked));
         this.pending.add(tracked);
@@ -462,10 +538,13 @@ class SignalVaultClient {
         const model = params.model;
         const messages = params.messages;
         if (params.stream) {
-            return this.wrapStream(response, usage.injected, (output, promptTokens, completionTokens) => this.sendAuditEvents(requestId, model, messages, output, promptTokens, completionTokens, metadata, 'openai'));
+            return this.wrapStream(response, usage.injected, (output, promptTokens, completionTokens) => this.sendAuditEvents(requestId, model, messages, output, { prompt_tokens: promptTokens, completion_tokens: completionTokens }, metadata, 'openai'));
         }
         const completion = response;
-        this.track(this.sendAuditEvents(requestId, model, messages, completion.choices[0]?.message?.content || '', completion.usage?.prompt_tokens || 0, completion.usage?.completion_tokens || 0, metadata, 'openai'));
+        this.track(this.sendAuditEvents(requestId, model, messages, completion.choices[0]?.message?.content || '', {
+            prompt_tokens: completion.usage?.prompt_tokens || 0,
+            completion_tokens: completion.usage?.completion_tokens || 0,
+        }, metadata, 'openai'));
         return completion;
     }
     // ---------------------------------------------------------------------------
@@ -479,11 +558,14 @@ class SignalVaultClient {
         const usage = withStreamUsage(params);
         const response = await this.openai.chat.completions.create(usage.params);
         if (params.stream) {
-            return this.wrapStream(response, usage.injected, (output, promptTokens, completionTokens) => this.sendResponseEvent(requestId, model, output, promptTokens, completionTokens, metadata, 'openai', fallback));
+            return this.wrapStream(response, usage.injected, (output, promptTokens, completionTokens) => this.sendResponseEvent(requestId, model, output, { prompt_tokens: promptTokens, completion_tokens: completionTokens }, metadata, 'openai', fallback));
         }
         const completion = response;
         // Background: the audit of the response must not delay returning it.
-        this.track(this.sendResponseEvent(requestId, model, completion.choices[0]?.message?.content || '', completion.usage?.prompt_tokens || 0, completion.usage?.completion_tokens || 0, metadata, 'openai', fallback));
+        this.track(this.sendResponseEvent(requestId, model, completion.choices[0]?.message?.content || '', {
+            prompt_tokens: completion.usage?.prompt_tokens || 0,
+            completion_tokens: completion.usage?.completion_tokens || 0,
+        }, metadata, 'openai', fallback));
         return completion;
     }
     // ---------------------------------------------------------------------------
@@ -493,9 +575,9 @@ class SignalVaultClient {
         const response = await this.anthropic.messages.create(params);
         const messages = anthropicMessagesForAudit(params);
         if (params.stream) {
-            return this.wrapAnthropicStream(response, (output, inputTokens, outputTokens) => this.sendAuditEvents(requestId, params.model, messages, output, inputTokens, outputTokens, metadata, 'anthropic'));
+            return this.wrapAnthropicStream(response, (output, usage) => this.sendAuditEvents(requestId, params.model, messages, output, usage, metadata, 'anthropic'));
         }
-        this.track(this.sendAuditEvents(requestId, params.model, messages, anthropicOutputText(response), response.usage?.input_tokens || 0, response.usage?.output_tokens || 0, metadata, 'anthropic'));
+        this.track(this.sendAuditEvents(requestId, params.model, messages, anthropicOutputText(response), anthropicUsage(response.usage), metadata, 'anthropic'));
         return response;
     }
     // ---------------------------------------------------------------------------
@@ -507,9 +589,9 @@ class SignalVaultClient {
         const fallback = this.fallbackRequest(decision, requestId, params.model, messages, metadata, 'anthropic');
         const response = await this.anthropic.messages.create(params);
         if (params.stream) {
-            return this.wrapAnthropicStream(response, (output, inputTokens, outputTokens) => this.sendResponseEvent(requestId, params.model, output, inputTokens, outputTokens, metadata, 'anthropic', fallback));
+            return this.wrapAnthropicStream(response, (output, usage) => this.sendResponseEvent(requestId, params.model, output, usage, metadata, 'anthropic', fallback));
         }
-        this.track(this.sendResponseEvent(requestId, params.model, anthropicOutputText(response), response.usage?.input_tokens || 0, response.usage?.output_tokens || 0, metadata, 'anthropic', fallback));
+        this.track(this.sendResponseEvent(requestId, params.model, anthropicOutputText(response), anthropicUsage(response.usage), metadata, 'anthropic', fallback));
         return response;
     }
     // ---------------------------------------------------------------------------
@@ -547,24 +629,24 @@ class SignalVaultClient {
     }
     async *wrapAnthropicStream(stream, onComplete) {
         const chunks = [];
-        let inputTokens = 0;
-        let outputTokens = 0;
+        let usage = anthropicUsage();
         try {
             for await (const event of stream) {
                 if (event.type === 'content_block_delta' && event.delta?.type === 'text_delta') {
                     chunks.push(event.delta.text || '');
                 }
+                // message_delta may repeat the input and cache counts; its values win.
                 if (event.type === 'message_start' && event.message?.usage) {
-                    inputTokens = event.message.usage.input_tokens || 0;
+                    usage = anthropicUsage(usage, event.message.usage);
                 }
                 if (event.type === 'message_delta' && event.usage) {
-                    outputTokens = event.usage.output_tokens || 0;
+                    usage = anthropicUsage(usage, event.usage);
                 }
                 yield event;
             }
         }
         finally {
-            this.track(onComplete(chunks.join(''), inputTokens, outputTokens));
+            this.track(onComplete(chunks.join(''), usage));
         }
     }
     // ---------------------------------------------------------------------------
@@ -699,8 +781,9 @@ class SignalVaultClient {
             }
         }
         catch (error) {
-            if (this.debugMode)
-                console.error('[SignalVault] Event send failed:', error);
+            if (this.debugMode) {
+                console.error('[SignalVault] Event send failed:', describeError(error, this.svApiKey));
+            }
             if (!isTimeout(error))
                 retryDelayMs = 250 + Math.random() * 500;
         }
@@ -712,8 +795,9 @@ class SignalVaultClient {
                     return result;
             }
             catch (error) {
-                if (this.debugMode)
-                    console.error('[SignalVault] Event retry failed:', error);
+                if (this.debugMode) {
+                    console.error('[SignalVault] Event retry failed:', describeError(error, this.svApiKey));
+                }
             }
         }
         this.logUndelivered(result);
@@ -734,8 +818,9 @@ class SignalVaultClient {
         }
         catch (error) {
             const timedOut = isTimeout(error);
-            if (this.debugMode)
-                console.error('[SignalVault] Pre-flight failed:', error);
+            if (this.debugMode) {
+                console.error('[SignalVault] Pre-flight failed:', describeError(error, this.svApiKey));
+            }
             return this.unavailable(requestId, timedOut ? 'timeout' : 'network', timedOut
                 ? `SignalVault pre-flight check timed out after ${this.preflightTimeout}ms`
                 : 'SignalVault API is unreachable');
@@ -766,7 +851,7 @@ class SignalVaultClient {
             dashboard_url: typeof data.dashboard_url === 'string' ? data.dashboard_url : undefined,
         };
     }
-    async sendResponseEvent(requestId, model, output, promptTokens, completionTokens, metadata, provider, fallbackRequest) {
+    async sendResponseEvent(requestId, model, output, usage, metadata, provider, fallbackRequest) {
         if (fallbackRequest === null)
             return;
         if (fallbackRequest) {
@@ -783,7 +868,7 @@ class SignalVaultClient {
             metadata,
             payload: {
                 output,
-                usage: { prompt_tokens: promptTokens, completion_tokens: completionTokens },
+                usage,
             },
         });
     }
@@ -792,7 +877,7 @@ class SignalVaultClient {
      * purpose — the server rejects an ai.response whose ai.request it has not
      * stored yet, so sending both at once can lose the response.
      */
-    async sendAuditEvents(requestId, model, messages, output, promptTokens, completionTokens, metadata, provider) {
+    async sendAuditEvents(requestId, model, messages, output, usage, metadata, provider) {
         const base = {
             request_id: requestId,
             environment: this.svEnvironment,
@@ -810,7 +895,7 @@ class SignalVaultClient {
             type: 'ai.response',
             payload: {
                 output,
-                usage: { prompt_tokens: promptTokens, completion_tokens: completionTokens },
+                usage,
                 monitor_mode: true,
             },
         });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@signalvaultio/node",
-  "version": "0.5.0",
+  "version": "0.5.2",
   "description": "SignalVault SDK - AI audit logs and guardrails for safe production AI",
   "type": "commonjs",
   "main": "./dist/index.js",