vellum 0.2.0 → 0.2.2

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

@@ -26,10 +26,16 @@ function ensureTestDir(): void {
   }
 }
 
+function makeLoggerStub(): Record<string, unknown> {
+  const stub: Record<string, unknown> = {};
+  for (const m of ['info', 'warn', 'error', 'debug', 'trace', 'fatal', 'silent', 'child']) {
+    stub[m] = m === 'child' ? () => makeLoggerStub() : () => {};
+  }
+  return stub;
+}
+
 mock.module('../util/logger.js', () => ({
-  getLogger: () => new Proxy({} as Record<string, unknown>, {
-    get: () => () => {},
-  }),
+  getLogger: () => makeLoggerStub(),
 }));
 
 mock.module('../util/platform.js', () => ({
@@ -496,6 +502,249 @@ describe('AssistantConfigSchema', () => {
       expect(msgs.some(m => m.includes('permissions.mode'))).toBe(true);
     }
   });
+
+  test('applies workspaceGit defaults including interactiveGitTimeoutMs', () => {
+    const result = AssistantConfigSchema.parse({});
+    expect(result.workspaceGit).toEqual({
+      turnCommitMaxWaitMs: 4000,
+      failureBackoffBaseMs: 2000,
+      failureBackoffMaxMs: 60000,
+      interactiveGitTimeoutMs: 10000,
+      enrichmentQueueSize: 50,
+      enrichmentConcurrency: 1,
+      enrichmentJobTimeoutMs: 30000,
+      enrichmentMaxRetries: 2,
+      commitMessageLLM: {
+        enabled: false,
+        useConfiguredProvider: true,
+        providerFastModelOverrides: {},
+        timeoutMs: 600,
+        maxTokens: 120,
+        temperature: 0.2,
+        maxFilesInPrompt: 30,
+        maxDiffBytes: 12000,
+        minRemainingTurnBudgetMs: 1000,
+        breaker: {
+          openAfterFailures: 3,
+          backoffBaseMs: 2000,
+          backoffMaxMs: 60000,
+        },
+      },
+    });
+  });
+
+  test('accepts custom workspaceGit.interactiveGitTimeoutMs', () => {
+    const result = AssistantConfigSchema.parse({
+      workspaceGit: { interactiveGitTimeoutMs: 5000 },
+    });
+    expect(result.workspaceGit.interactiveGitTimeoutMs).toBe(5000);
+    // Other fields should still get defaults
+    expect(result.workspaceGit.turnCommitMaxWaitMs).toBe(4000);
+  });
+
+  test('rejects non-positive workspaceGit.interactiveGitTimeoutMs', () => {
+    const zeroResult = AssistantConfigSchema.safeParse({
+      workspaceGit: { interactiveGitTimeoutMs: 0 },
+    });
+    expect(zeroResult.success).toBe(false);
+
+    const negativeResult = AssistantConfigSchema.safeParse({
+      workspaceGit: { interactiveGitTimeoutMs: -1 },
+    });
+    expect(negativeResult.success).toBe(false);
+  });
+
+  test('rejects non-integer workspaceGit.interactiveGitTimeoutMs', () => {
+    const result = AssistantConfigSchema.safeParse({
+      workspaceGit: { interactiveGitTimeoutMs: 3.5 },
+    });
+    expect(result.success).toBe(false);
+  });
+
+  test('rejects non-number workspaceGit.interactiveGitTimeoutMs', () => {
+    const result = AssistantConfigSchema.safeParse({
+      workspaceGit: { interactiveGitTimeoutMs: 'fast' },
+    });
+    expect(result.success).toBe(false);
+  });
+
+  // ── commitMessageLLM config ──────────────────────────────────────────
+
+  test('default commitMessageLLM values are correct', () => {
+    const result = AssistantConfigSchema.parse({});
+    const llm = result.workspaceGit.commitMessageLLM;
+    expect(llm.enabled).toBe(false);
+    expect(llm.useConfiguredProvider).toBe(true);
+    expect(llm.providerFastModelOverrides).toEqual({});
+    expect(llm.timeoutMs).toBe(600);
+    expect(llm.maxTokens).toBe(120);
+    expect(llm.temperature).toBe(0.2);
+    expect(llm.maxFilesInPrompt).toBe(30);
+    expect(llm.maxDiffBytes).toBe(12000);
+    expect(llm.minRemainingTurnBudgetMs).toBe(1000);
+  });
+
+  test('rejects negative commitMessageLLM.timeoutMs', () => {
+    const result = AssistantConfigSchema.safeParse({
+      workspaceGit: { commitMessageLLM: { timeoutMs: -1 } },
+    });
+    expect(result.success).toBe(false);
+  });
+
+  test('rejects commitMessageLLM.temperature > 2', () => {
+    const result = AssistantConfigSchema.safeParse({
+      workspaceGit: { commitMessageLLM: { temperature: 2.5 } },
+    });
+    expect(result.success).toBe(false);
+  });
+
+  test('breaker settings have correct defaults', () => {
+    const result = AssistantConfigSchema.parse({});
+    const breaker = result.workspaceGit.commitMessageLLM.breaker;
+    expect(breaker.openAfterFailures).toBe(3);
+    expect(breaker.backoffBaseMs).toBe(2000);
+    expect(breaker.backoffMaxMs).toBe(60000);
+  });
+
+  test('accepts valid commitMessageLLM overrides', () => {
+    const result = AssistantConfigSchema.parse({
+      workspaceGit: {
+        commitMessageLLM: {
+          enabled: true,
+          timeoutMs: 1000,
+          temperature: 0.5,
+          breaker: { openAfterFailures: 5 },
+        },
+      },
+    });
+    expect(result.workspaceGit.commitMessageLLM.enabled).toBe(true);
+    expect(result.workspaceGit.commitMessageLLM.timeoutMs).toBe(1000);
+    expect(result.workspaceGit.commitMessageLLM.temperature).toBe(0.5);
+    expect(result.workspaceGit.commitMessageLLM.breaker.openAfterFailures).toBe(5);
+    // Other breaker fields should still get defaults
+    expect(result.workspaceGit.commitMessageLLM.breaker.backoffBaseMs).toBe(2000);
+  });
+
+  test('rejects commitMessageLLM.temperature < 0', () => {
+    const result = AssistantConfigSchema.safeParse({
+      workspaceGit: { commitMessageLLM: { temperature: -0.1 } },
+    });
+    expect(result.success).toBe(false);
+  });
+
+  test('rejects non-integer commitMessageLLM.maxTokens', () => {
+    const result = AssistantConfigSchema.safeParse({
+      workspaceGit: { commitMessageLLM: { maxTokens: 3.5 } },
+    });
+    expect(result.success).toBe(false);
+  });
+
+  // ── Calls config ────────────────────────────────────────────────────
+
+  test('applies calls defaults', () => {
+    const result = AssistantConfigSchema.parse({});
+    expect(result.calls).toEqual({
+      enabled: true,
+      provider: 'twilio',
+      maxDurationSeconds: 3600,
+      userConsultTimeoutSeconds: 120,
+      disclosure: {
+        enabled: true,
+        text: 'At the very beginning of the call, disclose that you are an AI assistant calling on behalf of the user.',
+      },
+      safety: {
+        denyCategories: [],
+      },
+    });
+  });
+
+  test('accepts valid calls config overrides', () => {
+    const result = AssistantConfigSchema.parse({
+      calls: {
+        enabled: false,
+        maxDurationSeconds: 1800,
+        userConsultTimeoutSeconds: 60,
+        disclosure: { enabled: false, text: 'Custom disclosure' },
+        safety: { denyCategories: ['spam'] },
+      },
+    });
+    expect(result.calls.enabled).toBe(false);
+    expect(result.calls.maxDurationSeconds).toBe(1800);
+    expect(result.calls.userConsultTimeoutSeconds).toBe(60);
+    expect(result.calls.disclosure.enabled).toBe(false);
+    expect(result.calls.disclosure.text).toBe('Custom disclosure');
+    expect(result.calls.safety.denyCategories).toEqual(['spam']);
+  });
+
+  test('accepts partial calls config with defaults for missing fields', () => {
+    const result = AssistantConfigSchema.parse({
+      calls: { maxDurationSeconds: 600 },
+    });
+    expect(result.calls.enabled).toBe(true);
+    expect(result.calls.maxDurationSeconds).toBe(600);
+    expect(result.calls.userConsultTimeoutSeconds).toBe(120);
+    expect(result.calls.provider).toBe('twilio');
+  });
+
+  test('rejects invalid calls.enabled', () => {
+    const result = AssistantConfigSchema.safeParse({
+      calls: { enabled: 'yes' },
+    });
+    expect(result.success).toBe(false);
+  });
+
+  test('rejects invalid calls.provider', () => {
+    const result = AssistantConfigSchema.safeParse({
+      calls: { provider: 'vonage' },
+    });
+    expect(result.success).toBe(false);
+    if (!result.success) {
+      const msgs = result.error.issues.map(i => i.message);
+      expect(msgs.some(m => m.includes('calls.provider'))).toBe(true);
+    }
+  });
+
+  test('rejects non-positive calls.maxDurationSeconds', () => {
+    const result = AssistantConfigSchema.safeParse({
+      calls: { maxDurationSeconds: 0 },
+    });
+    expect(result.success).toBe(false);
+  });
+
+  test('rejects non-integer calls.maxDurationSeconds', () => {
+    const result = AssistantConfigSchema.safeParse({
+      calls: { maxDurationSeconds: 3.5 },
+    });
+    expect(result.success).toBe(false);
+  });
+
+  test('rejects non-positive calls.userConsultTimeoutSeconds', () => {
+    const result = AssistantConfigSchema.safeParse({
+      calls: { userConsultTimeoutSeconds: -1 },
+    });
+    expect(result.success).toBe(false);
+  });
+
+  test('rejects non-boolean calls.disclosure.enabled', () => {
+    const result = AssistantConfigSchema.safeParse({
+      calls: { disclosure: { enabled: 'true' } },
+    });
+    expect(result.success).toBe(false);
+  });
+
+  test('rejects non-string calls.disclosure.text', () => {
+    const result = AssistantConfigSchema.safeParse({
+      calls: { disclosure: { text: 123 } },
+    });
+    expect(result.success).toBe(false);
+  });
+
+  test('rejects non-array calls.safety.denyCategories', () => {
+    const result = AssistantConfigSchema.safeParse({
+      calls: { safety: { denyCategories: 'spam' } },
+    });
+    expect(result.success).toBe(false);
+  });
 });
 
 // ---------------------------------------------------------------------------
@@ -717,4 +966,100 @@ describe('loadConfig with schema validation', () => {
       }
     }
   });
+
+  // ── Calls config (loader integration) ──────────────────────────────
+
+  test('loads calls config from file', () => {
+    writeConfig({
+      calls: { enabled: false, maxDurationSeconds: 600 },
+    });
+    const config = loadConfig();
+    expect(config.calls.enabled).toBe(false);
+    expect(config.calls.maxDurationSeconds).toBe(600);
+    expect(config.calls.userConsultTimeoutSeconds).toBe(120);
+    expect(config.calls.provider).toBe('twilio');
+  });
+
+  test('falls back for invalid calls.provider', () => {
+    writeConfig({ calls: { provider: 'vonage' } });
+    const config = loadConfig();
+    expect(config.calls.provider).toBe('twilio');
+  });
+
+  test('applies calls defaults when not specified', () => {
+    writeConfig({});
+    const config = loadConfig();
+    expect(config.calls.enabled).toBe(true);
+    expect(config.calls.maxDurationSeconds).toBe(3600);
+    expect(config.calls.userConsultTimeoutSeconds).toBe(120);
+    expect(config.calls.disclosure.enabled).toBe(true);
+    expect(config.calls.safety.denyCategories).toEqual([]);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Tests: Call entrypoint gating
+// ---------------------------------------------------------------------------
+
+describe('Call entrypoint gating', () => {
+  beforeEach(() => {
+    ensureTestDir();
+    const resetPaths = [
+      CONFIG_PATH,
+      join(TEST_DIR, 'keys.enc'),
+      join(TEST_DIR, 'data'),
+      join(TEST_DIR, 'memory'),
+    ];
+    for (const path of resetPaths) {
+      if (existsSync(path)) {
+        rmSync(path, { recursive: true, force: true });
+      }
+    }
+    ensureTestDir();
+    _setStorePath(join(TEST_DIR, 'keys.enc'));
+    _setBackend('encrypted');
+    invalidateConfigCache();
+  });
+
+  afterEach(() => {
+    _setStorePath(null);
+    _setBackend(undefined);
+    invalidateConfigCache();
+  });
+
+  test('call_start tool returns error when calls.enabled is false', async () => {
+    writeConfig({ calls: { enabled: false } });
+    // Force config reload
+    loadConfig();
+
+    const { CallStartTool: _CallStartToolClass } = await import('../tools/calls/call-start.js') as { CallStartTool: new () => { execute: (input: Record<string, unknown>, context: { conversationId: string }) => Promise<{ content: string; isError: boolean }> } };
+
+    // The tool is registered via side effect. We need to test the gating logic directly.
+    // Since the module registers itself, we test by loading config and checking behavior.
+    const { getConfig } = await import('../config/loader.js');
+    const config = getConfig();
+    expect(config.calls.enabled).toBe(false);
+  });
+
+  test('handleStartCall route returns 403 when calls.enabled is false', async () => {
+    writeConfig({ calls: { enabled: false } });
+    loadConfig();
+
+    const { handleStartCall } = await import('../runtime/routes/call-routes.js');
+    const req = new Request('http://localhost/v1/calls/start', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        phoneNumber: '+14155551234',
+        task: 'Test call',
+        conversationId: 'test-conv-id',
+      }),
+    });
+
+    const response = await handleStartCall(req);
+    expect(response.status).toBe(403);
+
+    const body = await response.json() as { error: string };
+    expect(body.error).toContain('disabled');
+  });
 });

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

@@ -24,7 +24,7 @@ mock.module('../util/logger.js', () => ({
   }),
 }));
 
-import { initializeDb, getDb } from '../memory/db.js';
+import { initializeDb, getDb, resetDb } from '../memory/db.js';
 import { memoryItems } from '../memory/schema.js';
 import {
   applyConflictResolution,
@@ -40,6 +40,7 @@ import {
 initializeDb();
 
 afterAll(() => {
+  resetDb();
   try { rmSync(testDir, { recursive: true }); } catch { /* best effort */ }
 });