vellum 0.2.1 → 0.2.2

package/src/__tests__/computer-use-tools.test.ts

@@ -0,0 +1,250 @@
+import { describe, test, expect } from 'bun:test';
+import {
+  allComputerUseTools,
+  computerUseClickTool,
+  computerUseDoubleClickTool,
+  computerUseRightClickTool,
+  computerUseTypeTextTool,
+  computerUseKeyTool,
+  computerUseScrollTool,
+  computerUseDragTool,
+  computerUseWaitTool,
+  computerUseOpenAppTool,
+  computerUseRunAppleScriptTool,
+  computerUseDoneTool,
+  computerUseRespondTool,
+} from '../tools/computer-use/definitions.js';
+import { requestComputerControlTool } from '../tools/computer-use/request-computer-control.js';
+import { forwardComputerUseProxyTool } from '../tools/computer-use/skill-proxy-bridge.js';
+import type { ToolContext } from '../tools/types.js';
+
+interface JsonSchema {
+  type?: string;
+  required?: string[];
+  properties?: Record<string, unknown>;
+}
+
+/** Cast a tool definition's input_schema to a usable JSON Schema shape. */
+function schema(tool: { getDefinition(): { input_schema: object } }): JsonSchema {
+  return tool.getDefinition().input_schema as JsonSchema;
+}
+
+const ctx: ToolContext = {
+  workingDir: '/tmp',
+  sessionId: 'test-session',
+  conversationId: 'test-conversation',
+};
+
+// ── Tool definitions ────────────────────────────────────────────────
+
+describe('computer-use tool definitions', () => {
+  test('allComputerUseTools contains 12 tools', () => {
+    expect(allComputerUseTools.length).toBe(12);
+  });
+
+  test('all tools have proxy execution mode', () => {
+    for (const tool of allComputerUseTools) {
+      expect(tool.executionMode).toBe('proxy');
+    }
+    expect(requestComputerControlTool.executionMode).toBe('proxy');
+  });
+
+  test('all tools belong to computer-use category', () => {
+    for (const tool of allComputerUseTools) {
+      expect(tool.category).toBe('computer-use');
+    }
+    expect(requestComputerControlTool.category).toBe('computer-use');
+  });
+
+  test('all tools have unique names', () => {
+    const names = allComputerUseTools.map((t) => t.name);
+    expect(new Set(names).size).toBe(names.length);
+  });
+
+  test('all tools have descriptions', () => {
+    for (const tool of allComputerUseTools) {
+      expect(tool.description.length).toBeGreaterThan(0);
+    }
+  });
+});
+
+// ── Click tool variants ─────────────────────────────────────────────
+
+describe('click tool variants', () => {
+  for (const [tool, label] of [
+    [computerUseClickTool, 'click'],
+    [computerUseDoubleClickTool, 'double_click'],
+    [computerUseRightClickTool, 'right_click'],
+  ] as const) {
+    test(`${tool.name} has correct name`, () => {
+      expect(tool.name).toBe(`computer_use_${label}`);
+    });
+
+    test(`${tool.name} schema requires reasoning`, () => {
+      expect(schema(tool).required).toContain('reasoning');
+    });
+
+    test(`${tool.name} schema supports element_id and coordinates`, () => {
+      const props = schema(tool).properties as Record<string, { type: string }>;
+      expect(props.element_id.type).toBe('integer');
+      expect(props.x.type).toBe('integer');
+      expect(props.y.type).toBe('integer');
+    });
+
+    test(`${tool.name} execute throws proxy error`, () => {
+      expect(() => tool.execute({}, ctx)).toThrow('Proxy tool');
+    });
+  }
+});
+
+// ── type_text ───────────────────────────────────────────────────────
+
+describe('computer_use_type_text', () => {
+  test('requires text and reasoning', () => {
+    expect(schema(computerUseTypeTextTool).required).toContain('text');
+    expect(schema(computerUseTypeTextTool).required).toContain('reasoning');
+  });
+
+  test('execute throws proxy error', () => {
+    expect(() => computerUseTypeTextTool.execute({}, ctx)).toThrow('Proxy tool');
+  });
+});
+
+// ── key ─────────────────────────────────────────────────────────────
+
+describe('computer_use_key', () => {
+  test('requires key and reasoning', () => {
+    expect(schema(computerUseKeyTool).required).toContain('key');
+    expect(schema(computerUseKeyTool).required).toContain('reasoning');
+  });
+
+  test('execute throws proxy error', () => {
+    expect(() => computerUseKeyTool.execute({}, ctx)).toThrow('Proxy tool');
+  });
+});
+
+// ── scroll ──────────────────────────────────────────────────────────
+
+describe('computer_use_scroll', () => {
+  test('requires direction, amount, and reasoning', () => {
+    expect(schema(computerUseScrollTool).required).toContain('direction');
+    expect(schema(computerUseScrollTool).required).toContain('amount');
+    expect(schema(computerUseScrollTool).required).toContain('reasoning');
+  });
+
+  test('direction enum includes up, down, left, right', () => {
+    const props = schema(computerUseScrollTool).properties as Record<string, { enum?: string[] }>;
+    expect(props.direction.enum).toEqual(['up', 'down', 'left', 'right']);
+  });
+});
+
+// ── drag ────────────────────────────────────────────────────────────
+
+describe('computer_use_drag', () => {
+  test('supports source and destination coordinates', () => {
+    const props = schema(computerUseDragTool).properties as Record<string, { type: string }>;
+    expect(props.element_id.type).toBe('integer');
+    expect(props.to_element_id.type).toBe('integer');
+    expect(props.x.type).toBe('integer');
+    expect(props.y.type).toBe('integer');
+    expect(props.to_x.type).toBe('integer');
+    expect(props.to_y.type).toBe('integer');
+  });
+
+  test('requires reasoning only', () => {
+    expect(schema(computerUseDragTool).required).toEqual(['reasoning']);
+  });
+});
+
+// ── wait ────────────────────────────────────────────────────────────
+
+describe('computer_use_wait', () => {
+  test('requires duration_ms and reasoning', () => {
+    expect(schema(computerUseWaitTool).required).toContain('duration_ms');
+    expect(schema(computerUseWaitTool).required).toContain('reasoning');
+  });
+});
+
+// ── open_app ────────────────────────────────────────────────────────
+
+describe('computer_use_open_app', () => {
+  test('requires app_name and reasoning', () => {
+    expect(schema(computerUseOpenAppTool).required).toContain('app_name');
+    expect(schema(computerUseOpenAppTool).required).toContain('reasoning');
+  });
+});
+
+// ── run_applescript ─────────────────────────────────────────────────
+
+describe('computer_use_run_applescript', () => {
+  test('requires script and reasoning', () => {
+    expect(schema(computerUseRunAppleScriptTool).required).toContain('script');
+    expect(schema(computerUseRunAppleScriptTool).required).toContain('reasoning');
+  });
+
+  test('description warns against do shell script', () => {
+    expect(computerUseRunAppleScriptTool.description).toContain('do shell script');
+    expect(computerUseRunAppleScriptTool.description).toContain('blocked');
+  });
+});
+
+// ── done ────────────────────────────────────────────────────────────
+
+describe('computer_use_done', () => {
+  test('requires summary', () => {
+    expect(schema(computerUseDoneTool).required).toContain('summary');
+  });
+});
+
+// ── respond ─────────────────────────────────────────────────────────
+
+describe('computer_use_respond', () => {
+  test('requires answer and reasoning', () => {
+    expect(schema(computerUseRespondTool).required).toContain('answer');
+    expect(schema(computerUseRespondTool).required).toContain('reasoning');
+  });
+});
+
+// ── request_computer_control ────────────────────────────────────────
+
+describe('computer_use_request_control', () => {
+  test('requires task parameter', () => {
+    expect(schema(requestComputerControlTool).required).toContain('task');
+  });
+
+  test('execute throws proxy error', () => {
+    expect(() => requestComputerControlTool.execute({}, ctx)).toThrow('surfaceProxyResolver');
+  });
+});
+
+// ── skill-proxy-bridge ──────────────────────────────────────────────
+
+describe('forwardComputerUseProxyTool', () => {
+  test('returns error when no proxy resolver available', async () => {
+    const result = await forwardComputerUseProxyTool('computer_use_click', {}, ctx);
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain('no proxy resolver available');
+    expect(result.content).toContain('computer_use_click');
+  });
+
+  test('delegates to proxy resolver when available', async () => {
+    const ctxWithProxy: ToolContext = {
+      ...ctx,
+      proxyToolResolver: async (name: string, input: Record<string, unknown>) => ({
+        content: `Forwarded ${name} with ${JSON.stringify(input)}`,
+        isError: false,
+      }),
+    };
+
+    const result = await forwardComputerUseProxyTool(
+      'computer_use_screenshot',
+      { reasoning: 'test' },
+      ctxWithProxy,
+    );
+
+    expect(result.isError).toBe(false);
+    expect(result.content).toContain('Forwarded computer_use_screenshot');
+    expect(result.content).toContain('test');
+  });
+});

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', () => ({
@@ -508,6 +514,22 @@ describe('AssistantConfigSchema', () => {
       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,
+        },
+      },
     });
   });
 
@@ -545,6 +567,184 @@ describe('AssistantConfigSchema', () => {
     });
     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);
+  });
 });
 
 // ---------------------------------------------------------------------------
@@ -766,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 */ }
 });