@vellumai/assistant 0.6.6 → 0.7.0

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

@@ -85,7 +85,7 @@ describe("AssistantConfigSchema", () => {
     // llm.default.{provider,model} (see PR 19 of unify-llm-callsites).
     expect(result.services.inference.mode).toBe("your-own");
     expect(result.llm.default.provider).toBe("anthropic");
-    expect(result.llm.default.model).toBe("claude-sonnet-4-6");
+    expect(result.llm.default.model).toBe("claude-opus-4-7");
     expect(result.services["image-generation"].provider).toBe("gemini");
     expect(result.services["image-generation"].model).toBe(
       "gemini-3.1-flash-image-preview",
@@ -170,10 +170,11 @@ describe("AssistantConfigSchema", () => {
     expect(result.llm).toBeDefined();
     expect(result.llm.default).toEqual({
       provider: "anthropic",
-      model: "claude-sonnet-4-6",
+      model: "claude-opus-4-7",
       maxTokens: 64000,
       effort: "max",
       speed: "standard",
+      verbosity: "medium",
       temperature: null,
       thinking: { enabled: true, streamThinking: true },
       contextWindow: {
@@ -193,6 +194,7 @@ describe("AssistantConfigSchema", () => {
       openrouter: { only: [] },
     });
     expect(result.llm.profiles).toEqual({});
+    expect(result.llm.profileOrder).toEqual([]);
     expect(result.llm.callSites).toEqual({});
     expect(result.llm.pricingOverrides).toEqual([]);
   });
@@ -226,6 +228,7 @@ describe("AssistantConfigSchema", () => {
         profiles: {
           fast: { speed: "fast" as const, effort: "low" as const },
         },
+        profileOrder: ["fast"],
         callSites: {
           mainAgent: { profile: "fast" },
           commitMessage: { maxTokens: 256 },
@@ -240,6 +243,7 @@ describe("AssistantConfigSchema", () => {
       speed: "fast",
       effort: "low",
     });
+    expect(result.llm.profileOrder).toEqual(["fast"]);
     expect(result.llm.callSites?.mainAgent).toEqual({ profile: "fast" });
     expect(result.llm.callSites?.commitMessage).toEqual({ maxTokens: 256 });
   });
@@ -305,7 +309,7 @@ describe("AssistantConfigSchema", () => {
       (result.services.inference as Record<string, unknown>).model,
     ).toBeUndefined();
     expect(result.llm.default.provider).toBe("anthropic");
-    expect(result.llm.default.model).toBe("claude-sonnet-4-6");
+    expect(result.llm.default.model).toBe("claude-opus-4-7");
   });
 
   test("partial llm config (empty `llm: {}`) doesn't trigger full config reset", () => {
@@ -320,7 +324,7 @@ describe("AssistantConfigSchema", () => {
     });
     expect(result.llm.default.maxTokens).toBe(32000);
     expect(result.llm.default.provider).toBe("anthropic");
-    expect(result.llm.default.model).toBe("claude-sonnet-4-6");
+    expect(result.llm.default.model).toBe("claude-opus-4-7");
   });
 
   test("llm.default with one missing field still parses (defaults applied)", () => {
@@ -670,178 +674,6 @@ describe("AssistantConfigSchema", () => {
     }
   });
 
-  test("defaults permissions.mode to workspace", () => {
-    const result = AssistantConfigSchema.parse({});
-    expect(result.permissions).toEqual({
-      mode: "workspace",
-      hostAccess: false,
-      autoApproveUpTo: {
-        conversation: "low",
-        background: "medium",
-        headless: "none",
-      },
-    });
-  });
-
-  test("accepts explicit permissions.mode strict", () => {
-    const result = AssistantConfigSchema.parse({
-      permissions: { mode: "strict" },
-    });
-    expect(result.permissions.mode).toBe("strict");
-  });
-
-  test("rejects permissions.mode legacy", () => {
-    expect(() =>
-      AssistantConfigSchema.parse({
-        permissions: { mode: "legacy" },
-      }),
-    ).toThrow();
-  });
-
-  test("accepts explicit permissions.mode workspace", () => {
-    const result = AssistantConfigSchema.parse({
-      permissions: { mode: "workspace" },
-    });
-    expect(result.permissions.mode).toBe("workspace");
-  });
-
-  test("rejects invalid permissions.mode", () => {
-    const result = AssistantConfigSchema.safeParse({
-      permissions: { mode: "permissive" },
-    });
-    expect(result.success).toBe(false);
-    if (!result.success) {
-      const msgs = result.error.issues.map((i) => i.message);
-      expect(msgs.some((m) => m.includes("permissions.mode"))).toBe(true);
-    }
-  });
-
-  test("defaults autoApproveUpTo to per-context object when not specified", () => {
-    const result = AssistantConfigSchema.parse({
-      permissions: { mode: "workspace" },
-    });
-    expect(result.permissions.autoApproveUpTo).toEqual({
-      conversation: "low",
-      background: "medium",
-      headless: "none",
-    });
-  });
-
-  test("accepts autoApproveUpTo none", () => {
-    const result = AssistantConfigSchema.parse({
-      permissions: { autoApproveUpTo: "none" },
-    });
-    expect(result.permissions.autoApproveUpTo).toBe("none");
-  });
-
-  test("accepts autoApproveUpTo low", () => {
-    const result = AssistantConfigSchema.parse({
-      permissions: { autoApproveUpTo: "low" },
-    });
-    expect(result.permissions.autoApproveUpTo).toBe("low");
-  });
-
-  test("accepts autoApproveUpTo medium", () => {
-    const result = AssistantConfigSchema.parse({
-      permissions: { autoApproveUpTo: "medium" },
-    });
-    expect(result.permissions.autoApproveUpTo).toBe("medium");
-  });
-
-  test("accepts autoApproveUpTo high", () => {
-    const result = AssistantConfigSchema.parse({
-      permissions: { autoApproveUpTo: "high" },
-    });
-    expect(result.permissions.autoApproveUpTo).toBe("high");
-  });
-
-  test("rejects invalid autoApproveUpTo string", () => {
-    const result = AssistantConfigSchema.safeParse({
-      permissions: { autoApproveUpTo: "everything" },
-    });
-    expect(result.success).toBe(false);
-  });
-
-  test("autoApproveUpTo round-trips through JSON serialization", () => {
-    const original = AssistantConfigSchema.parse({
-      permissions: { autoApproveUpTo: "medium" },
-    });
-    const json = JSON.stringify(original);
-    const parsed = AssistantConfigSchema.parse(JSON.parse(json));
-    expect(parsed.permissions.autoApproveUpTo).toBe("medium");
-  });
-
-  test("accepts autoApproveUpTo as per-context object", () => {
-    const result = AssistantConfigSchema.parse({
-      permissions: {
-        autoApproveUpTo: {
-          conversation: "low",
-          background: "medium",
-          headless: "none",
-        },
-      },
-    });
-    expect(result.permissions.autoApproveUpTo).toEqual({
-      conversation: "low",
-      background: "medium",
-      headless: "none",
-    });
-  });
-
-  test("per-context object applies defaults for omitted keys", () => {
-    const result = AssistantConfigSchema.parse({
-      permissions: {
-        autoApproveUpTo: {},
-      },
-    });
-    expect(result.permissions.autoApproveUpTo).toEqual({
-      conversation: "low",
-      background: "medium",
-      headless: "none",
-    });
-  });
-
-  test("per-context object rejects invalid enum values", () => {
-    const result = AssistantConfigSchema.safeParse({
-      permissions: {
-        autoApproveUpTo: { conversation: "extreme" },
-      },
-    });
-    expect(result.success).toBe(false);
-  });
-
-  test("per-context object accepts high enum value", () => {
-    const result = AssistantConfigSchema.parse({
-      permissions: {
-        autoApproveUpTo: { conversation: "high" },
-      },
-    });
-    expect(result.permissions.autoApproveUpTo).toEqual({
-      conversation: "high",
-      background: "medium",
-      headless: "none",
-    });
-  });
-
-  test("per-context object round-trips through JSON serialization", () => {
-    const original = AssistantConfigSchema.parse({
-      permissions: {
-        autoApproveUpTo: {
-          conversation: "none",
-          background: "low",
-          headless: "medium",
-        },
-      },
-    });
-    const json = JSON.stringify(original);
-    const parsed = AssistantConfigSchema.parse(JSON.parse(json));
-    expect(parsed.permissions.autoApproveUpTo).toEqual({
-      conversation: "none",
-      background: "low",
-      headless: "medium",
-    });
-  });
-
   test("applies workspaceGit defaults including interactiveGitTimeoutMs", () => {
     const result = AssistantConfigSchema.parse({});
     expect(result.workspaceGit).toEqual({
@@ -2267,7 +2099,7 @@ describe("loadConfig with schema validation", () => {
     writeConfig({});
     const config = loadConfig();
     expect(config.llm.default.provider).toBe("anthropic");
-    expect(config.llm.default.model).toBe("claude-sonnet-4-6");
+    expect(config.llm.default.model).toBe("claude-opus-4-7");
     expect(config.llm.default.maxTokens).toBe(64000);
     expect(config.llm.default.thinking).toEqual({
       enabled: true,
@@ -2380,32 +2212,6 @@ describe("loadConfig with schema validation", () => {
     expect(config.auditLog.retentionDays).toBe(0);
   });
 
-  test("defaults permissions.mode to workspace when not specified", () => {
-    writeConfig({});
-    const config = loadConfig();
-    expect(config.permissions).toEqual({
-      mode: "workspace",
-      hostAccess: false,
-      autoApproveUpTo: {
-        conversation: "low",
-        background: "medium",
-        headless: "none",
-      },
-    });
-  });
-
-  test("loads explicit permissions.mode strict", () => {
-    writeConfig({ permissions: { mode: "strict" } });
-    const config = loadConfig();
-    expect(config.permissions.mode).toBe("strict");
-  });
-
-  test("falls back for invalid permissions.mode", () => {
-    writeConfig({ permissions: { mode: "yolo" } });
-    const config = loadConfig();
-    expect(config.permissions.mode).toBe("workspace");
-  });
-
   // ── Calls config (loader integration) ──────────────────────────────
 
   test("loads calls config from file", () => {
@@ -2577,26 +2383,29 @@ describe("Call entrypoint gating", () => {
     expect(config.calls.enabled).toBe(false);
   });
 
-  test("handleStartCall route returns 403 when calls.enabled is false", async () => {
+  test("calls_start route throws ForbiddenError 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: { message: string } };
-    expect(body.error.message).toContain("disabled");
+    const { ROUTES } = await import("../runtime/routes/call-routes.js");
+    const { RouteError } = await import("../runtime/routes/errors.js");
+    const startRoute = ROUTES.find((r) => r.operationId === "calls_start");
+    expect(startRoute).toBeDefined();
+
+    try {
+      await startRoute!.handler({
+        body: {
+          phoneNumber: "+14155551234",
+          task: "Test call",
+          conversationId: "test-conv-id",
+        },
+      });
+      throw new Error("Expected handler to throw");
+    } catch (err) {
+      expect(err).toBeInstanceOf(RouteError);
+      const routeErr = err as InstanceType<typeof RouteError>;
+      expect(routeErr.statusCode).toBe(403);
+      expect(routeErr.message).toContain("disabled");
+    }
   });
 });

package/src/__tests__/confirmation-request-guardian-bridge.test.ts

@@ -10,8 +10,6 @@
 
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
-import { _setOverridesForTesting } from "../config/assistant-feature-flags.js";
-
 mock.module("../util/logger.js", () => ({
   getLogger: () =>
     new Proxy({} as Record<string, unknown>, {
@@ -72,13 +70,15 @@ mock.module("../runtime/channel-verification-service.js", () => ({
   },
 }));
 
-import type { TrustContext } from "../daemon/conversation-runtime-assembly.js";
+
+import type { TrustContext } from "../daemon/trust-context.js";
 import {
   createCanonicalGuardianRequest,
   generateCanonicalRequestCode,
   listCanonicalGuardianDeliveries,
 } from "../memory/canonical-guardian-store.js";
-import { getDb, initializeDb } from "../memory/db.js";
+import { getDb } from "../memory/db-connection.js";
+import { initializeDb } from "../memory/db-init.js";
 import { bridgeConfirmationRequestToGuardian } from "../runtime/confirmation-request-guardian-bridge.js";
 
 initializeDb();
@@ -135,7 +135,6 @@ describe("bridgeConfirmationRequestToGuardian", () => {
     resetTables();
     emittedSignals.length = 0;
     mockOnConversationCreatedCallbacks.length = 0;
-    _setOverridesForTesting({});
   });
 
   test("emits guardian.question for trusted-contact sessions", () => {
@@ -226,26 +225,6 @@ describe("bridgeConfirmationRequestToGuardian", () => {
     expect(emittedSignals).toHaveLength(0);
   });
 
-  test("skips trusted-contact bridging entirely under permission-controls-v2", () => {
-    _setOverridesForTesting({ "permission-controls-v2": true });
-
-    const canonicalRequest = makeCanonicalRequest();
-    const trustContext = makeTrustedContactContext();
-
-    const result = bridgeConfirmationRequestToGuardian({
-      canonicalRequest,
-      trustContext,
-      conversationId: "conv-1",
-      toolName: "bash",
-    });
-
-    expect("skipped" in result && result.skipped).toBe(true);
-    if ("skipped" in result) {
-      expect(result.reason).toBe("v2_model_mediated");
-    }
-    expect(emittedSignals).toHaveLength(0);
-  });
-
   test("skips when no guardian binding exists for channel", () => {
     const canonicalRequest = makeCanonicalRequest({ sourceChannel: "phone" });
     const trustContext = makeTrustedContactContext({

package/src/__tests__/contact-store-user-file.test.ts

@@ -11,7 +11,8 @@ import {
   generateUserFileSlug,
   upsertContact,
 } from "../contacts/contact-store.js";
-import { getDb, getSqlite, initializeDb } from "../memory/db.js";
+import { getDb, getSqlite } from "../memory/db-connection.js";
+import { initializeDb } from "../memory/db-init.js";
 import { migrateNormalizeUserFileByPrincipal } from "../memory/migrations/220-normalize-user-file-by-principal.js";
 
 initializeDb();

package/src/__tests__/contacts-tools.test.ts

@@ -33,31 +33,31 @@ mock.module("../config/env.js", () => ({
   getGatewayPort: () => 0,
 }));
 
-mock.module("../runtime/auth/token-service.js", () => ({
-  mintEdgeRelayToken: () => "test-token",
-}));
-
 // contact-search now calls cliIpcCall instead of the gateway HTTP.
 // Mock the IPC client to dispatch search_contacts to the real store
 // (backed by the test DB) without needing a running IPC server.
 mock.module("../ipc/cli-client.js", () => ({
   cliIpcCall: async (method: string, params?: Record<string, unknown>) => {
     const store = await import("../contacts/contact-store.js");
+    const body = (params?.body ?? params ?? {}) as Record<string, unknown>;
+    const pathParams = (params?.pathParams ?? {}) as Record<string, string>;
     if (method === "search_contacts") {
-      return { ok: true, result: store.searchContacts(params ?? {}) };
+      return { ok: true, result: store.searchContacts(body) };
     }
     if (method === "upsert_contact") {
-      return { ok: true, result: store.upsertContact(params as never) };
+      const contact = store.upsertContact(body as never);
+      return { ok: true, result: { ok: true, contact } };
     }
-    if (method === "get_contact") {
-      return {
-        ok: true,
-        result: store.getContact((params as { id: string }).id) ?? null,
-      };
+    if (method === "getContact") {
+      const id = pathParams.id ?? (body as { id?: string }).id;
+      const contact = id ? store.getContact(id) : null;
+      if (!contact) return { ok: false, error: `Contact "${id}" not found` };
+      return { ok: true, result: { ok: true, contact } };
     }
     if (method === "merge_contacts") {
-      const { keepId, mergeId } = params as { keepId: string; mergeId: string };
-      return { ok: true, result: store.mergeContacts(keepId, mergeId) };
+      const { keepId, mergeId } = body as { keepId: string; mergeId: string };
+      const contact = store.mergeContacts(keepId, mergeId);
+      return { ok: true, result: { ok: true, contact } };
     }
     return { ok: false, error: `Unknown IPC method: ${method}` };
   },
@@ -68,13 +68,10 @@ import type { Database } from "bun:sqlite";
 import { executeContactMerge } from "../config/bundled-skills/contacts/tools/contact-merge.js";
 import { executeContactSearch } from "../config/bundled-skills/contacts/tools/contact-search.js";
 import { executeContactUpsert } from "../config/bundled-skills/contacts/tools/contact-upsert.js";
-import { getDb, initializeDb, resetDb } from "../memory/db.js";
-import {
-  handleGetContact,
-  handleListContacts,
-  handleMergeContacts,
-  handleUpsertContact,
-} from "../runtime/routes/contact-routes.js";
+import { getDb, resetDb } from "../memory/db-connection.js";
+import { initializeDb } from "../memory/db-init.js";
+import { ROUTES } from "../runtime/routes/contact-routes.js";
+import { RouteError } from "../runtime/routes/errors.js";
 import type { ToolContext } from "../tools/types.js";
 
 initializeDb();
@@ -90,18 +87,48 @@ beforeAll(() => {
       const url = new URL(req.url);
       const path = url.pathname;
 
-      if (path === "/v1/contacts/merge" && req.method === "POST") {
-        return handleMergeContacts(req);
-      }
-      if (path === "/v1/contacts" && req.method === "GET") {
-        return handleListContacts(url);
-      }
-      if (path === "/v1/contacts" && req.method === "POST") {
-        return handleUpsertContact(req);
+      try {
+        if (path === "/v1/contacts/merge" && req.method === "POST") {
+          const mergeRoute = ROUTES.find(
+            (r) => r.operationId === "merge_contacts",
+          )!;
+          const body = (await req.json()) as Record<string, unknown>;
+          const result = mergeRoute.handler({ body });
+          return Response.json(result);
+        }
+        if (path === "/v1/contacts" && req.method === "GET") {
+          const listRoute = ROUTES.find(
+            (r) => r.operationId === "listContacts",
+          )!;
+          const qp: Record<string, string> = {};
+          url.searchParams.forEach((v, k) => {
+            qp[k] = v;
+          });
+          const result = listRoute.handler({ queryParams: qp });
+          return Response.json(result);
+        }
+        if (path === "/v1/contacts" && req.method === "POST") {
+          const upsertRoute = ROUTES.find(
+            (r) => r.operationId === "upsert_contact",
+          )!;
+          const body = (await req.json()) as Record<string, unknown>;
+          const result = upsertRoute.handler({ body });
+          return Response.json(result);
+        }
+      } catch (err) {
+        if (err instanceof RouteError) {
+          return Response.json(
+            { error: err.message },
+            { status: err.statusCode },
+          );
+        }
+        throw err;
       }
       const idMatch = path.match(/^\/v1\/contacts\/([^/]+)$/);
       if (idMatch && req.method === "GET") {
-        return handleGetContact(idMatch[1]);
+        const getRoute = ROUTES.find((r) => r.operationId === "getContact")!;
+        const result = getRoute.handler({ pathParams: { id: idMatch[1] } });
+        return Response.json(result);
       }
       return new Response("Not found", { status: 404 });
     },

package/src/__tests__/contacts-write.test.ts

@@ -12,16 +12,6 @@ import { existsSync, readFileSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
-// Route trust-store file writes at the test workspace's protected dir
-// instead of the real ~/.vellum/protected/trust.json. Must be set before
-// importing ../permissions/trust-store.js so getGatewaySecurityDir() picks
-// up the override at module load time. Matches the pattern in
-// checker.test.ts, trust-store.test.ts, etc.
-process.env.GATEWAY_SECURITY_DIR = join(
-  process.env.VELLUM_WORKSPACE_DIR!,
-  "protected",
-);
-
 mock.module("../util/logger.js", () => ({
   getLogger: () =>
     new Proxy({} as Record<string, unknown>, {
@@ -33,13 +23,8 @@ import {
   createGuardianBinding,
   upsertContactChannel,
 } from "../contacts/contacts-write.js";
-import { getSqlite, initializeDb } from "../memory/db.js";
-import {
-  clearAllRules,
-  clearCache as clearTrustCache,
-  getAllRules,
-} from "../permissions/trust-store.js";
-
+import { getSqlite } from "../memory/db-connection.js";
+import { initializeDb } from "../memory/db-init.js";
 initializeDb();
 
 function resetContactTables(): void {
@@ -121,23 +106,13 @@ describe("createGuardianBinding seeds users/<slug>.md", () => {
   });
 });
 
-// Invariants:
-//
-//  1. `upsertContactChannel` must not seed `users/<slug>.md`. Seeding
-//     there fires the users/ directory watcher on every inbound message
-//     from a new contact and evicts live conversations. Seeding is
-//     restricted to the guardian-creation path.
-//
-//  2. `createGuardianBinding` must invalidate the trust cache so the
-//     dynamic `default:allow-file_*-guardian-persona` rules from
-//     `permissions/defaults.ts` are backfilled for guardians created
-//     at runtime. Otherwise the model prompts on its first
-//     `file_edit users/<slug>.md`.
+// Invariant: `upsertContactChannel` must not seed `users/<slug>.md`. Seeding
+// there fires the users/ directory watcher on every inbound message
+// from a new contact and evicts live conversations. Seeding is
+// restricted to the guardian-creation path.
 describe("guardian persona seeding and trust-cache invariants", () => {
   beforeEach(() => {
     resetContactTables();
-    clearAllRules();
-    clearTrustCache();
   });
 
   test("upsertContactChannel does NOT seed users/<slug>.md for non-guardian contacts", () => {
@@ -164,34 +139,4 @@ describe("guardian persona seeding and trust-cache invariants", () => {
     expect(existsSync(personaPath)).toBe(false);
   });
 
-  test("createGuardianBinding backfills the guardian-persona auto-allow rule via clearTrustCache", () => {
-    // Warm the trust cache BEFORE a guardian exists so the initial
-    // loadFromDisk → backfillDefaults → getDefaultRuleTemplates round
-    // sees no guardian and emits no guardian-persona rule.
-    const beforeRules = getAllRules();
-    const guardianRuleBefore = beforeRules.find(
-      (r) => r.id === "default:allow-file_edit-guardian-persona",
-    );
-    expect(guardianRuleBefore).toBeUndefined();
-
-    createGuardianBinding({
-      channel: "telegram",
-      guardianExternalUserId: "Carol",
-      guardianDeliveryChatId: "chat-carol",
-      guardianPrincipalId: "principal-carol",
-      verifiedVia: "challenge",
-    });
-
-    // After createGuardianBinding, clearTrustCache() should have been
-    // invoked, so the next getAllRules() call re-runs loadFromDisk and
-    // backfills the dynamic guardian-persona rule pointing at the
-    // newly-resolved users/<slug>.md.
-    const afterRules = getAllRules();
-    const guardianRuleAfter = afterRules.find(
-      (r) => r.id === "default:allow-file_edit-guardian-persona",
-    );
-    expect(guardianRuleAfter).toBeDefined();
-    expect(guardianRuleAfter?.decision).toBe("allow");
-    expect(guardianRuleAfter?.pattern).toContain("users/carol.md");
-  });
 });