vellum 0.2.12 → 0.2.13

package/bun.lock

@@ -11,7 +11,7 @@
         "@huggingface/transformers": "^3.8.1",
         "@qdrant/js-client-rest": "^1.16.2",
         "@sentry/node": "^10.38.0",
-        "@vellumai/cli": "0.1.12",
+        "@vellumai/cli": "0.1.13",
         "@vellumai/vellum-gateway": "0.1.10",
         "agentmail": "^0.1.0",
         "archiver": "^7.0.1",
@@ -542,7 +542,7 @@
 
     "@typescript-eslint/visitor-keys": ["@typescript-eslint/visitor-keys@8.56.0", "", { "dependencies": { "@typescript-eslint/types": "8.56.0", "eslint-visitor-keys": "^5.0.0" } }, "sha512-q+SL+b+05Ud6LbEE35qe4A99P+htKTKVbyiNEe45eCbJFyh/HVK9QXwlrbz+Q4L8SOW4roxSVwXYj4DMBT7Ieg=="],
 
-    "@vellumai/cli": ["@vellumai/cli@0.1.12", "", { "dependencies": { "ink": "^6.7.0", "react": "^19.2.4", "react-devtools-core": "^6.1.2" }, "bin": { "vellum-cli": "src/index.ts" } }, "sha512-6httUd8UEnlhCpqSaROGITwp485jG6EB5ILC4VyWrs2tow6sYHxDFc6eaNBqjS54m33I+rbvIwcKOyiGRPTORA=="],
+    "@vellumai/cli": ["@vellumai/cli@0.1.13", "", { "dependencies": { "ink": "^6.7.0", "react": "^19.2.4", "react-devtools-core": "^6.1.2" }, "bin": { "vellum-cli": "src/index.ts" } }, "sha512-zoES1ddavpHZljC/uPkelJvIsen77aTtFwfLYAA4zdtCCf3zktS2+TaDVQxB1Eh+dbRi3Tgc+XCXbq7S86kFiQ=="],
 
     "@vellumai/vellum-gateway": ["@vellumai/vellum-gateway@0.1.10", "", { "dependencies": { "file-type": "^21.3.0", "pino": "^9.6.0", "pino-pretty": "^13.1.3", "zod": "^4.3.6" } }, "sha512-a41fGexW8RpWL4RTfZ3EM+XJMvz7t26D1axu2xAtZioXW3ZWMLGuogHnIJsgglzESl49E6VmmUsUGeD+dseV2w=="],
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vellum",
-  "version": "0.2.12",
+  "version": "0.2.13",
   "type": "module",
   "bin": {
     "vellum": "./src/index.ts"
@@ -29,7 +29,7 @@
     "@huggingface/transformers": "^3.8.1",
     "@qdrant/js-client-rest": "^1.16.2",
     "@sentry/node": "^10.38.0",
-    "@vellumai/cli": "0.1.12",
+    "@vellumai/cli": "0.1.13",
     "@vellumai/vellum-gateway": "0.1.10",
     "agentmail": "^0.1.0",
     "archiver": "^7.0.1",

package/src/__tests__/call-orchestrator.test.ts

@@ -29,6 +29,8 @@ mock.module('../util/logger.js', () => ({
 
 // ── Config mock ─────────────────────────────────────────────────────
 
+let mockCallModel: string | undefined = undefined;
+
 mock.module('../config/loader.js', () => ({
   getConfig: () => ({
     apiKeys: { anthropic: 'test-key' },
@@ -41,6 +43,7 @@ mock.module('../config/loader.js', () => ({
       silenceTimeoutSeconds: 30,
       disclosure: { enabled: false, text: '' },
       safety: { denyCategories: [] },
+      model: mockCallModel,
     },
   }),
 }));
@@ -192,6 +195,7 @@ function setupOrchestrator(task?: string) {
 describe('call-orchestrator', () => {
   beforeEach(() => {
     resetTables();
+    mockCallModel = undefined;
     // Reset the stream mock to default behaviour
     mockStreamFn.mockImplementation(() => createMockStream(['Hello', ' there']));
   });
@@ -451,4 +455,58 @@ describe('call-orchestrator', () => {
     // Second destroy should not throw
     expect(() => orchestrator.destroy()).not.toThrow();
   });
+
+  // ── Model override from config ──────────────────────────────────────
+
+  test('uses default model when calls.model is not set', async () => {
+    mockCallModel = undefined;
+    mockStreamFn.mockImplementation((...args: unknown[]) => {
+      const firstArg = args[0] as { model: string };
+      expect(firstArg.model).toBe('claude-sonnet-4-20250514');
+      return createMockStream(['Default model response.']);
+    });
+
+    const { orchestrator } = setupOrchestrator();
+    await orchestrator.handleCallerUtterance('Hello');
+    orchestrator.destroy();
+  });
+
+  test('uses calls.model override from config when set', async () => {
+    mockCallModel = 'claude-haiku-4-5-20251001';
+    mockStreamFn.mockImplementation((...args: unknown[]) => {
+      const firstArg = args[0] as { model: string };
+      expect(firstArg.model).toBe('claude-haiku-4-5-20251001');
+      return createMockStream(['Override model response.']);
+    });
+
+    const { orchestrator } = setupOrchestrator();
+    await orchestrator.handleCallerUtterance('Hello');
+    orchestrator.destroy();
+  });
+
+  test('treats empty string calls.model as unset and falls back to default', async () => {
+    mockCallModel = '';
+    mockStreamFn.mockImplementation((...args: unknown[]) => {
+      const firstArg = args[0] as { model: string };
+      expect(firstArg.model).toBe('claude-sonnet-4-20250514');
+      return createMockStream(['Fallback model response.']);
+    });
+
+    const { orchestrator } = setupOrchestrator();
+    await orchestrator.handleCallerUtterance('Hello');
+    orchestrator.destroy();
+  });
+
+  test('treats whitespace-only calls.model as unset and falls back to default', async () => {
+    mockCallModel = '   ';
+    mockStreamFn.mockImplementation((...args: unknown[]) => {
+      const firstArg = args[0] as { model: string };
+      expect(firstArg.model).toBe('claude-sonnet-4-20250514');
+      return createMockStream(['Fallback model response.']);
+    });
+
+    const { orchestrator } = setupOrchestrator();
+    await orchestrator.handleCallerUtterance('Hello');
+    orchestrator.destroy();
+  });
 });

package/src/__tests__/config-schema.test.ts

@@ -55,6 +55,7 @@ import { _setBackend } from '../security/secure-keys.js';
 import { loadConfig, invalidateConfigCache } from '../config/loader.js';
 import { AssistantConfigSchema } from '../config/schema.js';
 import { DEFAULT_CONFIG } from '../config/defaults.js';
+import { buildElevenLabsVoiceSpec, resolveVoiceQualityProfile } from '../calls/voice-quality.js';
 
 // ---------------------------------------------------------------------------
 // Helpers
@@ -655,6 +656,23 @@ describe('AssistantConfigSchema', () => {
       safety: {
         denyCategories: [],
       },
+      voice: {
+        mode: 'twilio_standard',
+        language: 'en-US',
+        transcriptionProvider: 'Deepgram',
+        fallbackToStandardOnError: true,
+        elevenlabs: {
+          voiceId: '',
+          voiceModelId: 'turbo_v2_5',
+          stability: 0.5,
+          similarityBoost: 0.75,
+          style: 0.0,
+          useSpeakerBoost: true,
+          agentId: '',
+          apiBaseUrl: 'https://api.elevenlabs.io',
+          registerCallTimeoutMs: 5000,
+        },
+      },
     });
   });
 
@@ -745,6 +763,261 @@ describe('AssistantConfigSchema', () => {
     });
     expect(result.success).toBe(false);
   });
+
+  // ── Calls voice config ──────────────────────────────────────────────
+
+  test('config without calls.voice parses correctly and produces defaults', () => {
+    const result = AssistantConfigSchema.parse({});
+    expect(result.calls.voice.mode).toBe('twilio_standard');
+    expect(result.calls.voice.language).toBe('en-US');
+    expect(result.calls.voice.transcriptionProvider).toBe('Deepgram');
+    expect(result.calls.voice.fallbackToStandardOnError).toBe(true);
+    expect(result.calls.voice.elevenlabs.voiceId).toBe('');
+    expect(result.calls.voice.elevenlabs.voiceModelId).toBe('turbo_v2_5');
+    expect(result.calls.voice.elevenlabs.stability).toBe(0.5);
+    expect(result.calls.voice.elevenlabs.similarityBoost).toBe(0.75);
+    expect(result.calls.voice.elevenlabs.style).toBe(0.0);
+    expect(result.calls.voice.elevenlabs.useSpeakerBoost).toBe(true);
+    expect(result.calls.voice.elevenlabs.agentId).toBe('');
+    expect(result.calls.voice.elevenlabs.apiBaseUrl).toBe('https://api.elevenlabs.io');
+    expect(result.calls.voice.elevenlabs.registerCallTimeoutMs).toBe(5000);
+  });
+
+  test('accepts valid calls.voice overrides', () => {
+    const result = AssistantConfigSchema.parse({
+      calls: {
+        voice: {
+          mode: 'twilio_elevenlabs_tts',
+          language: 'es-ES',
+          transcriptionProvider: 'Google',
+          fallbackToStandardOnError: false,
+          elevenlabs: {
+            voiceId: 'abc123',
+            stability: 0.8,
+          },
+        },
+      },
+    });
+    expect(result.calls.voice.mode).toBe('twilio_elevenlabs_tts');
+    expect(result.calls.voice.language).toBe('es-ES');
+    expect(result.calls.voice.transcriptionProvider).toBe('Google');
+    expect(result.calls.voice.fallbackToStandardOnError).toBe(false);
+    expect(result.calls.voice.elevenlabs.voiceId).toBe('abc123');
+    expect(result.calls.voice.elevenlabs.stability).toBe(0.8);
+    // Defaults preserved for unset fields
+    expect(result.calls.voice.elevenlabs.voiceModelId).toBe('turbo_v2_5');
+    expect(result.calls.voice.elevenlabs.similarityBoost).toBe(0.75);
+  });
+
+  test('rejects invalid calls.voice.mode', () => {
+    const result = AssistantConfigSchema.safeParse({
+      calls: { voice: { mode: 'invalid_mode' } },
+    });
+    expect(result.success).toBe(false);
+    if (!result.success) {
+      const msgs = result.error.issues.map(i => i.message);
+      expect(msgs.some(m => m.includes('calls.voice.mode'))).toBe(true);
+    }
+  });
+
+  test('rejects invalid calls.voice.transcriptionProvider', () => {
+    const result = AssistantConfigSchema.safeParse({
+      calls: { voice: { transcriptionProvider: 'AWS' } },
+    });
+    expect(result.success).toBe(false);
+    if (!result.success) {
+      const msgs = result.error.issues.map(i => i.message);
+      expect(msgs.some(m => m.includes('calls.voice.transcriptionProvider'))).toBe(true);
+    }
+  });
+
+  test('rejects calls.voice.elevenlabs.stability out of range', () => {
+    const result = AssistantConfigSchema.safeParse({
+      calls: { voice: { elevenlabs: { stability: 1.5 } } },
+    });
+    expect(result.success).toBe(false);
+  });
+
+  test('rejects calls.voice.elevenlabs.registerCallTimeoutMs below 1000', () => {
+    const result = AssistantConfigSchema.safeParse({
+      calls: { voice: { elevenlabs: { registerCallTimeoutMs: 500 } } },
+    });
+    expect(result.success).toBe(false);
+  });
+
+  test('rejects calls.voice.elevenlabs.registerCallTimeoutMs above 15000', () => {
+    const result = AssistantConfigSchema.safeParse({
+      calls: { voice: { elevenlabs: { registerCallTimeoutMs: 20000 } } },
+    });
+    expect(result.success).toBe(false);
+  });
+
+  test('accepts optional calls.model', () => {
+    const result = AssistantConfigSchema.parse({
+      calls: { model: 'claude-haiku-4-5-20251001' },
+    });
+    expect(result.calls.model).toBe('claude-haiku-4-5-20251001');
+  });
+
+  test('calls.model is undefined by default', () => {
+    const result = AssistantConfigSchema.parse({});
+    expect(result.calls.model).toBeUndefined();
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Tests: Voice quality profile resolver
+// ---------------------------------------------------------------------------
+
+describe('resolveVoiceQualityProfile', () => {
+  test('returns correct profile for twilio_standard', () => {
+    const config = AssistantConfigSchema.parse({});
+    const profile = resolveVoiceQualityProfile(config);
+    expect(profile.mode).toBe('twilio_standard');
+    expect(profile.ttsProvider).toBe('Google');
+    expect(profile.voice).toBe('Google.en-US-Journey-O');
+    expect(profile.transcriptionProvider).toBe('Deepgram');
+    expect(profile.fallbackToStandardOnError).toBe(true);
+    expect(profile.validationErrors).toEqual([]);
+  });
+
+  test('returns correct profile for twilio_elevenlabs_tts with valid voiceId', () => {
+    const config = AssistantConfigSchema.parse({
+      calls: {
+        voice: {
+          mode: 'twilio_elevenlabs_tts',
+          elevenlabs: { voiceId: 'test-voice-id' },
+        },
+      },
+    });
+    const profile = resolveVoiceQualityProfile(config);
+    expect(profile.mode).toBe('twilio_elevenlabs_tts');
+    expect(profile.ttsProvider).toBe('ElevenLabs');
+    expect(profile.voice).toBe('test-voice-id-turbo_v2_5-0.5_0.75_0');
+    expect(profile.validationErrors).toEqual([]);
+  });
+
+  test('falls back for twilio_elevenlabs_tts with empty voiceId and fallback enabled', () => {
+    const config = AssistantConfigSchema.parse({
+      calls: {
+        voice: {
+          mode: 'twilio_elevenlabs_tts',
+          fallbackToStandardOnError: true,
+          elevenlabs: { voiceId: '' },
+        },
+      },
+    });
+    const profile = resolveVoiceQualityProfile(config);
+    expect(profile.mode).toBe('twilio_standard');
+    expect(profile.ttsProvider).toBe('Google');
+    expect(profile.voice).toBe('Google.en-US-Journey-O');
+    expect(profile.validationErrors.length).toBe(1);
+    expect(profile.validationErrors[0]).toContain('falling back');
+  });
+
+  test('returns errors for twilio_elevenlabs_tts with empty voiceId and fallback disabled', () => {
+    const config = AssistantConfigSchema.parse({
+      calls: {
+        voice: {
+          mode: 'twilio_elevenlabs_tts',
+          fallbackToStandardOnError: false,
+          elevenlabs: { voiceId: '' },
+        },
+      },
+    });
+    const profile = resolveVoiceQualityProfile(config);
+    expect(profile.mode).toBe('twilio_elevenlabs_tts');
+    expect(profile.validationErrors.length).toBe(1);
+    expect(profile.validationErrors[0]).toContain('voiceId is required');
+  });
+
+  test('returns correct profile for elevenlabs_agent with valid agentId', () => {
+    const config = AssistantConfigSchema.parse({
+      calls: {
+        voice: {
+          mode: 'elevenlabs_agent',
+          elevenlabs: { agentId: 'agent-123', voiceId: 'v1' },
+        },
+      },
+    });
+    const profile = resolveVoiceQualityProfile(config);
+    expect(profile.mode).toBe('elevenlabs_agent');
+    expect(profile.ttsProvider).toBe('ElevenLabs');
+    expect(profile.voice).toBe('v1-turbo_v2_5-0.5_0.75_0');
+    expect(profile.agentId).toBe('agent-123');
+    expect(profile.validationErrors).toEqual([]);
+  });
+
+  test('falls back for elevenlabs_agent with empty agentId and fallback enabled', () => {
+    const config = AssistantConfigSchema.parse({
+      calls: {
+        voice: {
+          mode: 'elevenlabs_agent',
+          fallbackToStandardOnError: true,
+          elevenlabs: { agentId: '' },
+        },
+      },
+    });
+    const profile = resolveVoiceQualityProfile(config);
+    expect(profile.mode).toBe('twilio_standard');
+    expect(profile.validationErrors.length).toBe(1);
+    expect(profile.validationErrors[0]).toContain('agentId is empty');
+  });
+
+  test('returns errors for elevenlabs_agent with empty agentId and fallback disabled', () => {
+    const config = AssistantConfigSchema.parse({
+      calls: {
+        voice: {
+          mode: 'elevenlabs_agent',
+          fallbackToStandardOnError: false,
+          elevenlabs: { agentId: '' },
+        },
+      },
+    });
+    const profile = resolveVoiceQualityProfile(config);
+    expect(profile.mode).toBe('elevenlabs_agent');
+    expect(profile.validationErrors.length).toBe(1);
+    expect(profile.validationErrors[0]).toContain('agentId is required');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Tests: buildElevenLabsVoiceSpec
+// ---------------------------------------------------------------------------
+
+describe('buildElevenLabsVoiceSpec', () => {
+  test('produces correct voice string with all params', () => {
+    const spec = buildElevenLabsVoiceSpec({
+      voiceId: 'abc123',
+      voiceModelId: 'turbo_v2_5',
+      stability: 0.5,
+      similarityBoost: 0.75,
+      style: 0.0,
+    });
+    expect(spec).toBe('abc123-turbo_v2_5-0.5_0.75_0');
+  });
+
+  test('returns empty string when voiceId is empty', () => {
+    const spec = buildElevenLabsVoiceSpec({
+      voiceId: '',
+      voiceModelId: 'turbo_v2_5',
+      stability: 0.5,
+      similarityBoost: 0.75,
+      style: 0.0,
+    });
+    expect(spec).toBe('');
+  });
+
+  test('formats custom parameters correctly', () => {
+    const spec = buildElevenLabsVoiceSpec({
+      voiceId: 'myVoice',
+      voiceModelId: 'eleven_multilingual_v2',
+      stability: 0.8,
+      similarityBoost: 0.9,
+      style: 0.3,
+    });
+    expect(spec).toBe('myVoice-eleven_multilingual_v2-0.8_0.9_0.3');
+  });
 });
 
 // ---------------------------------------------------------------------------
@@ -994,6 +1267,11 @@ describe('loadConfig with schema validation', () => {
     expect(config.calls.userConsultTimeoutSeconds).toBe(120);
     expect(config.calls.disclosure.enabled).toBe(true);
     expect(config.calls.safety.denyCategories).toEqual([]);
+    expect(config.calls.voice.mode).toBe('twilio_standard');
+    expect(config.calls.voice.language).toBe('en-US');
+    expect(config.calls.voice.transcriptionProvider).toBe('Deepgram');
+    expect(config.calls.voice.elevenlabs.voiceId).toBe('');
+    expect(config.calls.model).toBeUndefined();
   });
 });
 

package/src/__tests__/elevenlabs-client.test.ts

@@ -0,0 +1,209 @@
+import { describe, test, expect, beforeEach, afterEach, mock } from 'bun:test';
+
+mock.module('../util/logger.js', () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+}));
+
+import {
+  ElevenLabsClient,
+  ElevenLabsError,
+  type ElevenLabsClientOptions,
+  type ElevenLabsRegisterCallRequest,
+} from '../calls/elevenlabs-client.js';
+
+// ── Helpers ────────────────────────────────────────────────────────────
+
+const DEFAULT_OPTIONS: ElevenLabsClientOptions = {
+  apiBaseUrl: 'https://api.elevenlabs.io',
+  apiKey: 'test-api-key-secret',
+  timeoutMs: 5000,
+};
+
+const DEFAULT_REQUEST: ElevenLabsRegisterCallRequest = {
+  agent_id: 'agent-123',
+  from_number: '+15551111111',
+  to_number: '+15552222222',
+  direction: 'outbound',
+};
+
+let originalFetch: typeof globalThis.fetch;
+
+beforeEach(() => {
+  originalFetch = globalThis.fetch;
+});
+
+afterEach(() => {
+  globalThis.fetch = originalFetch;
+});
+
+// ── Tests ──────────────────────────────────────────────────────────────
+
+describe('ElevenLabsClient', () => {
+  describe('registerCall', () => {
+    test('successful register-call returns TwiML', async () => {
+      const twimlResponse = '<?xml version="1.0"?><Response><Connect><Stream url="wss://el.io/stream"/></Connect></Response>';
+
+      globalThis.fetch = mock(async () =>
+        new Response(twimlResponse, { status: 200 }),
+      ) as unknown as typeof globalThis.fetch;
+
+      const client = new ElevenLabsClient(DEFAULT_OPTIONS);
+      const result = await client.registerCall(DEFAULT_REQUEST);
+
+      expect(result.twiml).toBe(twimlResponse);
+    });
+
+    test('passes xi-api-key header in request', async () => {
+      let capturedHeaders: Headers | null = null;
+
+      globalThis.fetch = mock(async (url: string | URL | Request, init?: RequestInit) => {
+        capturedHeaders = new Headers(init?.headers);
+        return new Response('<Response/>', { status: 200 });
+      }) as unknown as typeof globalThis.fetch;
+
+      const client = new ElevenLabsClient(DEFAULT_OPTIONS);
+      await client.registerCall(DEFAULT_REQUEST);
+
+      expect(capturedHeaders).not.toBeNull();
+      expect(capturedHeaders!.get('xi-api-key')).toBe('test-api-key-secret');
+      expect(capturedHeaders!.get('Content-Type')).toBe('application/json');
+    });
+
+    test('sends correct URL and request body', async () => {
+      let capturedUrl = '';
+      let capturedBody = '';
+
+      globalThis.fetch = mock(async (url: string | URL | Request, init?: RequestInit) => {
+        capturedUrl = typeof url === 'string' ? url : url instanceof URL ? url.toString() : url.url;
+        capturedBody = typeof init?.body === 'string' ? init.body : '';
+        return new Response('<Response/>', { status: 200 });
+      }) as unknown as typeof globalThis.fetch;
+
+      const client = new ElevenLabsClient(DEFAULT_OPTIONS);
+      await client.registerCall(DEFAULT_REQUEST);
+
+      expect(capturedUrl).toBe('https://api.elevenlabs.io/v1/convai/twilio/register-call');
+      const parsed = JSON.parse(capturedBody);
+      expect(parsed.agent_id).toBe('agent-123');
+      expect(parsed.from_number).toBe('+15551111111');
+      expect(parsed.to_number).toBe('+15552222222');
+      expect(parsed.direction).toBe('outbound');
+    });
+
+    test('non-2xx response throws ELEVENLABS_HTTP_ERROR', async () => {
+      globalThis.fetch = mock(async () =>
+        new Response('Internal Server Error', { status: 500 }),
+      ) as unknown as typeof globalThis.fetch;
+
+      const client = new ElevenLabsClient(DEFAULT_OPTIONS);
+
+      try {
+        await client.registerCall(DEFAULT_REQUEST);
+        expect(true).toBe(false); // Should not reach here
+      } catch (err) {
+        expect(err).toBeInstanceOf(ElevenLabsError);
+        const elErr = err as ElevenLabsError;
+        expect(elErr.code).toBe('ELEVENLABS_HTTP_ERROR');
+        expect(elErr.statusCode).toBe(500);
+        expect(elErr.message).toContain('500');
+      }
+    });
+
+    test('empty response throws ELEVENLABS_INVALID_RESPONSE', async () => {
+      globalThis.fetch = mock(async () =>
+        new Response('', { status: 200 }),
+      ) as unknown as typeof globalThis.fetch;
+
+      const client = new ElevenLabsClient(DEFAULT_OPTIONS);
+
+      try {
+        await client.registerCall(DEFAULT_REQUEST);
+        expect(true).toBe(false); // Should not reach here
+      } catch (err) {
+        expect(err).toBeInstanceOf(ElevenLabsError);
+        const elErr = err as ElevenLabsError;
+        expect(elErr.code).toBe('ELEVENLABS_INVALID_RESPONSE');
+      }
+    });
+
+    test('whitespace-only response throws ELEVENLABS_INVALID_RESPONSE', async () => {
+      globalThis.fetch = mock(async () =>
+        new Response('   \n  ', { status: 200 }),
+      ) as unknown as typeof globalThis.fetch;
+
+      const client = new ElevenLabsClient(DEFAULT_OPTIONS);
+
+      try {
+        await client.registerCall(DEFAULT_REQUEST);
+        expect(true).toBe(false); // Should not reach here
+      } catch (err) {
+        expect(err).toBeInstanceOf(ElevenLabsError);
+        const elErr = err as ElevenLabsError;
+        expect(elErr.code).toBe('ELEVENLABS_INVALID_RESPONSE');
+      }
+    });
+
+    test('timeout throws ELEVENLABS_TIMEOUT', async () => {
+      globalThis.fetch = mock(async (_url: string | URL | Request, init?: RequestInit) => {
+        // Wait longer than the timeout
+        return new Promise<Response>((resolve, reject) => {
+          const timer = setTimeout(() => resolve(new Response('<Response/>', { status: 200 })), 10000);
+          init?.signal?.addEventListener('abort', () => {
+            clearTimeout(timer);
+            reject(new DOMException('The operation was aborted.', 'AbortError'));
+          });
+        });
+      }) as unknown as typeof globalThis.fetch;
+
+      const client = new ElevenLabsClient({ ...DEFAULT_OPTIONS, timeoutMs: 50 });
+
+      try {
+        await client.registerCall(DEFAULT_REQUEST);
+        expect(true).toBe(false); // Should not reach here
+      } catch (err) {
+        expect(err).toBeInstanceOf(ElevenLabsError);
+        const elErr = err as ElevenLabsError;
+        expect(elErr.code).toBe('ELEVENLABS_TIMEOUT');
+        expect(elErr.message).toContain('50ms');
+      }
+    });
+
+    test('network error throws ELEVENLABS_HTTP_ERROR', async () => {
+      globalThis.fetch = mock(async () => {
+        throw new TypeError('Failed to fetch');
+      }) as unknown as typeof globalThis.fetch;
+
+      const client = new ElevenLabsClient(DEFAULT_OPTIONS);
+
+      try {
+        await client.registerCall(DEFAULT_REQUEST);
+        expect(true).toBe(false); // Should not reach here
+      } catch (err) {
+        expect(err).toBeInstanceOf(ElevenLabsError);
+        const elErr = err as ElevenLabsError;
+        expect(elErr.code).toBe('ELEVENLABS_HTTP_ERROR');
+        expect(elErr.message).toContain('Failed to fetch');
+      }
+    });
+
+    test('API key is not included in logged data', async () => {
+      // The ElevenLabsClient logs agent_id and direction, but should never log the API key.
+      // We verify this by checking the request structure, not the log output.
+      let capturedBody = '';
+
+      globalThis.fetch = mock(async (_url: string | URL | Request, init?: RequestInit) => {
+        capturedBody = typeof init?.body === 'string' ? init.body : '';
+        return new Response('<Response/>', { status: 200 });
+      }) as unknown as typeof globalThis.fetch;
+
+      const client = new ElevenLabsClient(DEFAULT_OPTIONS);
+      await client.registerCall(DEFAULT_REQUEST);
+
+      // The request body should not contain the API key
+      expect(capturedBody).not.toContain('test-api-key-secret');
+    });
+  });
+});

package/src/__tests__/trust-store.test.ts

@@ -741,6 +741,7 @@ describe('Trust Store', () => {
         'host_file_edit',
         'host_file_read',
         'host_file_write',
+        'memory_search',
         'scaffold_managed_skill',
         'skill_load',
         'ui_dismiss',