@signalvaultio/node 0.3.0 → 0.4.0

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "@signalvaultio/node",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "SignalVault SDK - AI audit logs and guardrails for safe production AI",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "files": [
     "dist",
+    "!dist/__tests__",
     "README.md"
   ],
   "scripts": {
@@ -39,20 +40,20 @@
   },
   "homepage": "https://signalvault.io/docs",
   "peerDependencies": {
-    "openai": "^4.0.0",
-    "@anthropic-ai/sdk": ">=0.20.0"
+    "@anthropic-ai/sdk": ">=0.20.0",
+    "openai": "^4.0.0"
   },
   "peerDependenciesMeta": {
-    "openai": { "optional": true },
-    "@anthropic-ai/sdk": { "optional": true }
-  },
-  "dependencies": {
-    "uuid": "^9.0.0"
+    "openai": {
+      "optional": true
+    },
+    "@anthropic-ai/sdk": {
+      "optional": true
+    }
   },
   "devDependencies": {
     "@types/jest": "^30.0.0",
     "@types/node": "^20.0.0",
-    "@types/uuid": "^9.0.0",
     "jest": "^30.2.0",
     "openai": "^4.0.0",
     "ts-jest": "^29.4.6",

package/dist/__tests__/index.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/__tests__/index.test.js

@@ -1,99 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const index_1 = require("../index");
-describe('SignalVaultClient', () => {
-    describe('construction', () => {
-        it('constructs with openaiApiKey', () => {
-            const client = new index_1.SignalVaultClient({ apiKey: 'sk_test_abc', openaiApiKey: 'sk-fake' });
-            expect(client).toBeDefined();
-            expect(client.chat).toBeDefined();
-            expect(client.chat.completions).toBeDefined();
-            expect(typeof client.chat.completions.create).toBe('function');
-        });
-        it('throws when neither openaiApiKey nor anthropicApiKey is provided', () => {
-            expect(() => new index_1.SignalVaultClient({ apiKey: 'sk_test_abc' })).toThrow('At least one of openaiApiKey or anthropicApiKey is required');
-        });
-        it('defaults to localhost and production', () => {
-            const client = new index_1.SignalVaultClient({ apiKey: 'sk_test_abc', openaiApiKey: 'sk-fake' });
-            expect(client.svBaseUrl).toBe('http://localhost:4000');
-            expect(client.svEnvironment).toBe('production');
-            expect(client.debugMode).toBe(false);
-            expect(client.mirrorMode).toBe(false);
-        });
-        it('accepts custom config', () => {
-            const client = new index_1.SignalVaultClient({
-                apiKey: 'sk_test_abc',
-                openaiApiKey: 'sk-fake',
-                baseUrl: 'https://api.signalvault.io/',
-                environment: 'staging',
-                debug: true,
-                mirrorMode: true,
-            });
-            expect(client.svBaseUrl).toBe('https://api.signalvault.io');
-            expect(client.svEnvironment).toBe('staging');
-            expect(client.debugMode).toBe(true);
-            expect(client.mirrorMode).toBe(true);
-        });
-        it('strips trailing slashes from baseUrl', () => {
-            const client = new index_1.SignalVaultClient({
-                apiKey: 'sk_test_abc',
-                openaiApiKey: 'sk-fake',
-                baseUrl: 'https://example.com///',
-            });
-            expect(client.svBaseUrl).toBe('https://example.com');
-        });
-    });
-    describe('timeout configuration', () => {
-        it('defaults to 2000ms preflight and 10000ms background', () => {
-            const client = new index_1.SignalVaultClient({ apiKey: 'sk_test_abc', openaiApiKey: 'sk-fake' });
-            expect(client.preflightTimeout).toBe(2000);
-            expect(client.bgTimeout).toBe(10000);
-        });
-        it('accepts custom timeouts', () => {
-            const client = new index_1.SignalVaultClient({
-                apiKey: 'sk_test_abc',
-                openaiApiKey: 'sk-fake',
-                preflightTimeout: 500,
-                timeout: 5000,
-            });
-            expect(client.preflightTimeout).toBe(500);
-            expect(client.bgTimeout).toBe(5000);
-        });
-    });
-    describe('metadata', () => {
-        it('defaults to empty metadata', () => {
-            const client = new index_1.SignalVaultClient({ apiKey: 'sk_test_abc', openaiApiKey: 'sk-fake' });
-            expect(client.defaultMetadata).toEqual({});
-        });
-        it('accepts metadata in config', () => {
-            const client = new index_1.SignalVaultClient({
-                apiKey: 'sk_test_abc',
-                openaiApiKey: 'sk-fake',
-                metadata: { user_id: 'u_123', feature: 'chat' },
-            });
-            expect(client.defaultMetadata).toEqual({ user_id: 'u_123', feature: 'chat' });
-        });
-    });
-    describe('Anthropic', () => {
-        it('throws on messages access when anthropicApiKey not provided', () => {
-            const client = new index_1.SignalVaultClient({ apiKey: 'sk_test_abc', openaiApiKey: 'sk-fake' });
-            expect(() => client.messages).toThrow('anthropicApiKey not provided');
-        });
-        it('throws when @anthropic-ai/sdk is not installed', () => {
-            expect(() => new index_1.SignalVaultClient({ apiKey: 'sk_test_abc', anthropicApiKey: 'sk-ant-fake' })).toThrow('@anthropic-ai/sdk is not installed');
-        });
-    });
-    describe('fail-open on preflight timeout', () => {
-        it('sendRequest returns allow decision on fetch error', async () => {
-            const client = new index_1.SignalVaultClient({
-                apiKey: 'sk_test_abc',
-                openaiApiKey: 'sk-fake',
-                baseUrl: 'http://127.0.0.1:1', // unreachable
-                preflightTimeout: 100,
-            });
-            const decision = await client.sendRequest('req-1', 'gpt-4', [], {}, 'openai');
-            expect(decision.decision).toBe('allow');
-            expect(decision.violations).toEqual([]);
-        });
-    });
-});

package/dist/__tests__/tools.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/__tests__/tools.test.js

@@ -1,243 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const index_1 = require("../index");
-describe('Agent tool-use capture', () => {
-    let fetchMock;
-    let client;
-    beforeEach(() => {
-        fetchMock = jest.spyOn(global, 'fetch').mockResolvedValue(new Response(JSON.stringify({ event_id: 'evt_123' }), { status: 200 }));
-        client = new index_1.SignalVaultClient({
-            apiKey: 'sk_test_abc',
-            openaiApiKey: 'sk-fake',
-            baseUrl: 'https://api.example.com',
-        });
-    });
-    afterEach(() => {
-        fetchMock.mockRestore();
-    });
-    // Helper: lets the fire-and-forget tool record promise settle.
-    const flushAsync = () => new Promise((resolve) => setImmediate(resolve));
-    describe('client.tool() wrapper', () => {
-        it('records a successful tool invocation with input/output and timing', async () => {
-            const fetchWeather = client.tool('fetch_weather', async (city) => {
-                return { temp: 12.3, conditions: 'rain', for: city };
-            });
-            const result = await fetchWeather('London');
-            expect(result).toEqual({ temp: 12.3, conditions: 'rain', for: 'London' });
-            await flushAsync();
-            expect(fetchMock).toHaveBeenCalledTimes(1);
-            const [url, init] = fetchMock.mock.calls[0];
-            expect(url).toBe('https://api.example.com/v1/events');
-            const body = JSON.parse(init.body);
-            expect(body.type).toBe('agent.tool_call');
-            expect(body.payload.tool_name).toBe('fetch_weather');
-            expect(body.payload.tool_input).toBe('London');
-            expect(body.payload.tool_output).toEqual({ temp: 12.3, conditions: 'rain', for: 'London' });
-            expect(body.payload.duration_ms).toBeGreaterThanOrEqual(0);
-            expect(body.payload.started_at).toMatch(/^\d{4}-\d{2}-\d{2}T/);
-        });
-        it('records an errored invocation and rethrows', async () => {
-            const failingTool = client.tool('fetch_external', async () => {
-                throw new Error('connection refused');
-            });
-            await expect(failingTool()).rejects.toThrow('connection refused');
-            await flushAsync();
-            expect(fetchMock).toHaveBeenCalledTimes(1);
-            const body = JSON.parse(fetchMock.mock.calls[0][1].body);
-            expect(body.payload.error).toBe('connection refused');
-            expect(body.payload.tool_output).toBeNull();
-        });
-        it('serializes a single object arg as the value, not as an array', async () => {
-            const search = client.tool('search', async (query) => ({ matches: query.k }));
-            await search({ q: 'embeddings', k: 5 });
-            await flushAsync();
-            const body = JSON.parse(fetchMock.mock.calls[0][1].body);
-            expect(body.payload.tool_input).toEqual({ q: 'embeddings', k: 5 });
-        });
-        it('serializes multiple args as an array', async () => {
-            const add = client.tool('add', async (a, b) => a + b);
-            await add(2, 3);
-            await flushAsync();
-            const body = JSON.parse(fetchMock.mock.calls[0][1].body);
-            expect(body.payload.tool_input).toEqual([2, 3]);
-        });
-        it('does not block on the audit network call (fire-and-forget)', async () => {
-            // Make fetch hang so we can verify the wrapper returns before the audit completes
-            fetchMock.mockImplementation(() => new Promise((resolve) => setTimeout(() => resolve(new Response('{}', { status: 200 })), 5000)));
-            const start = Date.now();
-            const tool = client.tool('fast_tool', async () => 42);
-            const result = await tool();
-            const elapsed = Date.now() - start;
-            expect(result).toBe(42);
-            expect(elapsed).toBeLessThan(100); // should NOT wait the 5s audit timeout
-        });
-        it('supports synchronous functions', async () => {
-            const sum = client.tool('sum', (a, b) => a + b);
-            const result = await sum(2, 3);
-            expect(result).toBe(5);
-        });
-    });
-    describe('client.tools.record() manual API', () => {
-        it('posts a tool_call event with the given fields', async () => {
-            await client.tools.record({
-                toolName: 'manual_tool',
-                toolInput: { x: 1 },
-                toolOutput: { y: 2 },
-                durationMs: 50,
-                requestId: 'req-explicit',
-            });
-            expect(fetchMock).toHaveBeenCalledTimes(1);
-            const body = JSON.parse(fetchMock.mock.calls[0][1].body);
-            expect(body.type).toBe('agent.tool_call');
-            expect(body.request_id).toBe('req-explicit');
-            expect(body.payload.tool_name).toBe('manual_tool');
-            expect(body.payload.duration_ms).toBe(50);
-        });
-        it('omits request_id when not provided (orphan tool call)', async () => {
-            await client.tools.record({
-                toolName: 'orphan',
-                durationMs: 10,
-            });
-            const body = JSON.parse(fetchMock.mock.calls[0][1].body);
-            expect(body.request_id).toBeUndefined();
-        });
-    });
-    describe('input sanitization', () => {
-        it('replaces circular references with a marker instead of throwing', async () => {
-            const circular = { name: 'root' };
-            circular.self = circular;
-            const tool = client.tool('circular_tool', async (_arg) => 'ok');
-            await tool(circular);
-            await flushAsync();
-            expect(fetchMock).toHaveBeenCalledTimes(1);
-            const body = JSON.parse(fetchMock.mock.calls[0][1].body);
-            expect(body.payload.tool_input).toEqual({ name: 'root', self: '[Circular]' });
-        });
-        it('serializes BigInt arguments as a string with n suffix', async () => {
-            const tool = client.tool('bigint_tool', async (_n) => 'ok');
-            await tool(BigInt(42));
-            await flushAsync();
-            const body = JSON.parse(fetchMock.mock.calls[0][1].body);
-            expect(body.payload.tool_input).toBe('42n');
-        });
-        it('truncates oversized tool_output with a marker', async () => {
-            // ~300 KB — over the 256 KB cap.
-            const big = 'x'.repeat(300 * 1024);
-            const tool = client.tool('big_output', async () => ({ blob: big }));
-            await tool();
-            await flushAsync();
-            const body = JSON.parse(fetchMock.mock.calls[0][1].body);
-            expect(body.payload.tool_output._signalvault_truncated).toBe(true);
-            expect(body.payload.tool_output._signalvault_original_bytes).toBeGreaterThan(256 * 1024);
-            expect(typeof body.payload.tool_output.preview).toBe('string');
-        });
-        it('truncates a long error message to ~1900 bytes', async () => {
-            const longMsg = 'a'.repeat(5000);
-            const failing = client.tool('long_error', async () => {
-                throw new Error(longMsg);
-            });
-            await expect(failing()).rejects.toThrow();
-            await flushAsync();
-            const body = JSON.parse(fetchMock.mock.calls[0][1].body);
-            const err = body.payload.error;
-            // Allow a generous upper bound to account for the truncation marker.
-            expect(Buffer.byteLength(err, 'utf8')).toBeLessThanOrEqual(1900);
-            expect(err).toMatch(/truncated/);
-        });
-        it('truncates an oversized tool_name and still records the call', async () => {
-            const longName = 'n'.repeat(500);
-            await client.tools.record({
-                toolName: longName,
-                durationMs: 1,
-            });
-            const body = JSON.parse(fetchMock.mock.calls[0][1].body);
-            expect(Buffer.byteLength(body.payload.tool_name, 'utf8')).toBeLessThanOrEqual(200);
-            expect(body.payload.tool_name).toMatch(/truncated/);
-        });
-        it('rejects an empty tool name from the manual API', async () => {
-            await expect(client.tools.record({ toolName: '', durationMs: 1 })).rejects.toThrow(/non-empty string/);
-            expect(fetchMock).not.toHaveBeenCalled();
-        });
-        it('replaces undefined tool_output with null in the body', async () => {
-            const tool = client.tool('void_tool', async () => undefined);
-            await tool();
-            await flushAsync();
-            const body = JSON.parse(fetchMock.mock.calls[0][1].body);
-            expect(body.payload.tool_output).toBeNull();
-        });
-        it('replaces a function value with a [Function] marker (not a crash)', async () => {
-            const tool = client.tool('weird_input', async (_fn) => 'ok');
-            await tool(() => 'hello');
-            await flushAsync();
-            const body = JSON.parse(fetchMock.mock.calls[0][1].body);
-            expect(body.payload.tool_input).toBe('[Function]');
-        });
-        it('falls back to the serialization-error envelope for top-level undefined', async () => {
-            // A bare `undefined` is JSON-serializable as nothing — the replacer leaves
-            // it alone and JSON.stringify returns undefined. We expose this as a
-            // marker so the audit isn't silently dropped.
-            await client.tools.record({
-                toolName: 'undef',
-                toolInput: undefined,
-                durationMs: 1,
-            });
-            const body = JSON.parse(fetchMock.mock.calls[0][1].body);
-            // sanitizePayload(undefined) returns null per the function contract.
-            expect(body.payload.tool_input).toBeNull();
-        });
-    });
-    describe('error logging', () => {
-        let warnSpy;
-        let errorSpy;
-        beforeEach(() => {
-            warnSpy = jest.spyOn(console, 'warn').mockImplementation(() => { });
-            errorSpy = jest.spyOn(console, 'error').mockImplementation(() => { });
-        });
-        afterEach(() => {
-            warnSpy.mockRestore();
-            errorSpy.mockRestore();
-        });
-        it('surfaces 4xx responses to console.warn even with debug=false', async () => {
-            fetchMock.mockResolvedValue(new Response('bad request', { status: 422 }));
-            await client.tools.record({ toolName: 'will_fail', durationMs: 1 });
-            expect(warnSpy).toHaveBeenCalledTimes(1);
-            expect(warnSpy.mock.calls[0][0]).toMatch(/422/);
-            expect(warnSpy.mock.calls[0][0]).toMatch(/Check your apiKey/);
-        });
-        it('does NOT log 5xx responses unless debug is true', async () => {
-            fetchMock.mockResolvedValue(new Response('boom', { status: 503 }));
-            await client.tools.record({ toolName: 'svc_down', durationMs: 1 });
-            expect(warnSpy).not.toHaveBeenCalled();
-            expect(errorSpy).not.toHaveBeenCalled();
-        });
-    });
-    describe('client.withContext() correlation', () => {
-        it('auto-links wrapped tool calls to the surrounding requestId', async () => {
-            const tool = client.tool('search', async (q) => ({ q }));
-            await client.withContext({ requestId: 'turn-abc' }, async () => {
-                await tool('embeddings');
-            });
-            await flushAsync();
-            const body = JSON.parse(fetchMock.mock.calls[0][1].body);
-            expect(body.request_id).toBe('turn-abc');
-        });
-        it('explicit requestId on record() overrides context', async () => {
-            await client.withContext({ requestId: 'context-id' }, async () => {
-                await client.tools.record({
-                    toolName: 'override',
-                    durationMs: 1,
-                    requestId: 'explicit-id',
-                });
-            });
-            const body = JSON.parse(fetchMock.mock.calls[0][1].body);
-            expect(body.request_id).toBe('explicit-id');
-        });
-        it('tools called outside any context are orphans', async () => {
-            const tool = client.tool('orphan_tool', async () => 'ok');
-            await tool();
-            await flushAsync();
-            const body = JSON.parse(fetchMock.mock.calls[0][1].body);
-            expect(body.request_id).toBeUndefined();
-        });
-    });
-});