@vellumai/assistant 0.11.2 → 0.11.3-staging.2

package/src/__tests__/llm-resolver-override-or-default.test.ts

@@ -2,6 +2,7 @@ import { describe, expect, test } from "bun:test";
 
 import { CODE_DEFAULT_PROFILE_ENTRIES } from "../config/default-profile-catalog.js";
 import {
+  composeCallSiteTweak,
   type ResolutionFallbackReason,
   resolveCallSiteConfig,
   resolveDefaultProfileKey,
@@ -178,6 +179,146 @@ describe("fallback and completeness", () => {
   });
 });
 
+describe("composeCallSiteTweak", () => {
+  // `CallSiteDefaultConfig` supports a shipped `model` (and the provider it
+  // implies). No entry sets one today, so these pin the invariant the merge
+  // depends on rather than waiting for the first entry that would break it.
+  test("a workspace entry owns selection: a shipped model/provider is dropped", () => {
+    const tweak = composeCallSiteTweak(
+      { model: "shipped-model", provider: "openai", effort: "low" },
+      { profile: "mine" },
+    );
+    expect("model" in tweak).toBe(false);
+    expect("provider" in tweak).toBe(false);
+    // The shipped tuning still layers in.
+    expect(tweak.effort).toBe("low");
+  });
+
+  test("with no workspace entry the shipped fragment applies whole", () => {
+    const tweak = composeCallSiteTweak(
+      { model: "shipped-model", provider: "openai", effort: "low" },
+      undefined,
+    );
+    expect(tweak.model).toBe("shipped-model");
+    expect(tweak.provider).toBe("openai");
+  });
+
+  test("a workspace provider/model still applies", () => {
+    const tweak = composeCallSiteTweak(
+      { model: "shipped-model", effort: "low" },
+      { provider: "anthropic", model: "chosen-model" },
+    );
+    expect(tweak.model).toBe("chosen-model");
+    expect(tweak.provider).toBe("anthropic");
+    expect(tweak.effort).toBe("low");
+  });
+
+  test("profile and logitBias never reach the fragment", () => {
+    const tweak = composeCallSiteTweak(
+      { effort: "low" },
+      { profile: "mine", logitBias: "suppress-cjk", maxTokens: 10 },
+    );
+    expect("profile" in tweak).toBe(false);
+    expect("logitBias" in tweak).toBe(false);
+    expect(tweak.maxTokens).toBe(10);
+  });
+});
+
+describe("shipped call-site tuning", () => {
+  // A workspace entry that only repoints the profile must not cost the call
+  // site the tuning it ships with. `recall` carries a full set: a token
+  // budget, effort, sampling, thinking, and cache posture.
+  test("a profile-only entry keeps the shipped tuning and takes the new model", () => {
+    const shipped = resolveCallSiteConfig(
+      "recall",
+      LLMSchema.parse({ profiles: { mine: completeCustom }, ...anthropicDp }),
+    );
+    const repointed = resolveCallSiteConfig(
+      "recall",
+      LLMSchema.parse({
+        profiles: { mine: completeCustom },
+        callSites: { recall: { profile: "mine" } },
+        ...anthropicDp,
+      }),
+    );
+
+    // The pin is what selects the model.
+    expect(repointed.model).toBe("gpt-5.5");
+    expect(repointed.model).not.toBe(shipped.model);
+
+    // Everything the call site ships with survives the repoint.
+    expect(repointed.maxTokens).toBe(4096);
+    expect(repointed.effort).toBe("low");
+    expect(repointed.temperature).toBe(0);
+    expect(repointed.disableCache).toBe(true);
+    expect(repointed.thinking.enabled).toBe(false);
+    expect(repointed.thinking.streamThinking).toBe(false);
+  });
+
+  test("a profile-only entry keeps a shipped nested budget", () => {
+    const resolved = resolveCallSiteConfig(
+      "memoryRouter",
+      LLMSchema.parse({
+        profiles: { mine: completeCustom },
+        callSites: { memoryRouter: { profile: "mine" } },
+        ...anthropicDp,
+      }),
+    );
+    expect(resolved.contextWindow.maxInputTokens).toBe(1000000);
+  });
+
+  test("an explicit workspace field beats the shipped one, field by field", () => {
+    const resolved = resolveCallSiteConfig(
+      "recall",
+      LLMSchema.parse({
+        profiles: { mine: completeCustom },
+        callSites: {
+          recall: { profile: "mine", maxTokens: 512, effort: "high" },
+        },
+        ...anthropicDp,
+      }),
+    );
+    // The two fields the entry names come from the entry.
+    expect(resolved.maxTokens).toBe(512);
+    expect(resolved.effort).toBe("high");
+    // The ones it does not name still come from the shipped tuning.
+    expect(resolved.temperature).toBe(0);
+    expect(resolved.disableCache).toBe(true);
+    expect(resolved.thinking.enabled).toBe(false);
+  });
+
+  test("a provider/model entry keeps the shipped tuning too", () => {
+    const resolved = resolveCallSiteConfig(
+      "recall",
+      LLMSchema.parse({
+        profiles: { mine: completeCustom },
+        callSites: {
+          recall: { provider: "openai", model: "gpt-5.5" },
+        },
+        ...anthropicDp,
+      }),
+    );
+    expect(resolved.model).toBe("gpt-5.5");
+    expect(resolved.maxTokens).toBe(4096);
+    expect(resolved.effort).toBe("low");
+    expect(resolved.disableCache).toBe(true);
+  });
+
+  test("a call site with no shipped tuning is unaffected", () => {
+    const resolved = resolveCallSiteConfig(
+      "conversationSummarization",
+      LLMSchema.parse({
+        profiles: { mine: completeCustom },
+        callSites: { conversationSummarization: { profile: "mine" } },
+        ...anthropicDp,
+      }),
+    );
+    expect(resolved.model).toBe("gpt-5.5");
+    expect(resolved.maxTokens).toBe(completeCustom.maxTokens);
+    expect(resolved.effort).toBe(completeCustom.effort);
+  });
+});
+
 describe("composition", () => {
   test("base + winner + site-tweak composition (nested tweaks combine leaf-wise)", () => {
     const llm = LLMSchema.parse({

package/src/__tests__/llm-usage-store.test.ts

@@ -2024,6 +2024,61 @@ describe("queryUnreportedUsageEvents", () => {
     expect(events[1].parentTurnIndex).toBeNull();
   });
 
+  // -------------------------------------------------------------------------
+  // Delegated-work decomposition (subagentRole + subagentSpawnMode). Every
+  // subagent variety emits under `llm_call_site = "subagentSpawn"`, so these
+  // two orthogonal columns, stamped on the conversation row at spawn, are
+  // what make advisor consults, forks and regular spawns separable.
+  // -------------------------------------------------------------------------
+
+  test("surfaces subagentRole and subagentSpawnMode from the child conversation", () => {
+    const db = getDb();
+    db.run(
+      `INSERT INTO conversations (id, conversation_type, created_at, updated_at, parent_conversation_id, subagent_role, subagent_spawn_mode) VALUES ('advisor-child', 'background', 1000, 1000, 'parent-1', 'advisor', 'advisor_consult')`,
+    );
+    insertEventAt(2000, { conversationId: "advisor-child" });
+
+    const events = queryUnreportedUsageEvents(0, undefined, 100);
+    expect(events).toHaveLength(1);
+    expect(events[0].subagentRole).toBe("advisor");
+    expect(events[0].subagentSpawnMode).toBe("advisor_consult");
+  });
+
+  test("role and spawn mode are independent: a general subagent can be regular or forked", () => {
+    const db = getDb();
+    db.run(
+      `INSERT INTO conversations (id, conversation_type, created_at, updated_at, subagent_role, subagent_spawn_mode) VALUES ('plain-child', 'background', 1000, 1000, 'general', 'regular')`,
+    );
+    db.run(
+      `INSERT INTO conversations (id, conversation_type, created_at, updated_at, subagent_role, subagent_spawn_mode) VALUES ('forked-child', 'background', 1000, 1000, 'general', 'fork')`,
+    );
+    insertEventAt(2000, { conversationId: "plain-child" });
+    insertEventAt(3000, { conversationId: "forked-child" });
+
+    const events = queryUnreportedUsageEvents(0, undefined, 100);
+    expect(events).toHaveLength(2);
+    expect(events[0].subagentRole).toBe("general");
+    expect(events[0].subagentSpawnMode).toBe("regular");
+    expect(events[1].subagentRole).toBe("general");
+    expect(events[1].subagentSpawnMode).toBe("fork");
+  });
+
+  test("subagent fields are null for ordinary conversations and no-conversation events", () => {
+    const db = getDb();
+    db.run(
+      `INSERT INTO conversations (id, conversation_type, created_at, updated_at) VALUES ('conv-plain', 'standard', 500, 500)`,
+    );
+    insertEventAt(1000, { conversationId: "conv-plain" });
+    insertEventAt(2000, { conversationId: null });
+
+    const events = queryUnreportedUsageEvents(0, undefined, 100);
+    expect(events).toHaveLength(2);
+    expect(events[0].subagentRole).toBeNull();
+    expect(events[0].subagentSpawnMode).toBeNull();
+    expect(events[1].subagentRole).toBeNull();
+    expect(events[1].subagentSpawnMode).toBeNull();
+  });
+
   test("surfaces llmCallCount on unreported events", () => {
     insertEventAt(1000, { llmCallCount: 4 });
     insertEventAt(2000, {});

package/src/__tests__/manual-token-reconciliation.test.ts

@@ -139,6 +139,51 @@ describe("syncManualTokenConnection", () => {
     warnings.length = 0;
   });
 
+  // ---- Discord server bot: one required field ----
+
+  test("connects discord_channel once the bot token is stored", async () => {
+    // Seeding the provider without this reconciliation leaves it listed and
+    // permanently disconnected, which is worse than not listing it: the
+    // setup skill stores the token and nothing ever reflects that.
+    setCredentialResult("discord_channel", "bot_token", {
+      value: "bot-token-value",
+      unreachable: false,
+    });
+
+    await syncManualTokenConnection("discord_channel");
+
+    expect(createdConnections.map((c) => c.provider)).toContain(
+      "discord_channel",
+    );
+  });
+
+  test("removes the discord_channel connection when the bot token is gone", async () => {
+    seedConnection("discord_channel");
+    setCredentialResult("discord_channel", "bot_token", {
+      value: undefined,
+      unreachable: false,
+    });
+
+    await syncManualTokenConnection("discord_channel");
+
+    expect(deletedConnectionIds).toContain("conn-discord_channel");
+  });
+
+  test("leaves the discord_channel row alone when the backend is unreachable", async () => {
+    // An unreachable credential store is not evidence the token is gone, so
+    // reconciliation must not read it as a disconnection.
+    seedConnection("discord_channel");
+    setCredentialResult("discord_channel", "bot_token", {
+      value: undefined,
+      unreachable: true,
+    });
+
+    await syncManualTokenConnection("discord_channel");
+
+    expect(deletedConnectionIds).not.toContain("conn-discord_channel");
+    expect(connectionStore["discord_channel"]).toBeDefined();
+  });
+
   // ---- Slack: reachable backend, missing tokens -> removes row ----
 
   test("removes slack_channel connection when bot token is missing and backend is reachable", async () => {

package/src/__tests__/mcp-tool-annotations-risk.test.ts

@@ -0,0 +1,133 @@
+import { describe, expect, jest, mock, test } from "bun:test";
+
+// Mock secure-keys so McpOAuthProvider doesn't try to access the credential store
+mock.module("../security/secure-keys.js", () => ({
+  getSecureKeyAsync: jest.fn().mockResolvedValue(null),
+  setSecureKeyAsync: jest.fn().mockResolvedValue(true),
+  deleteSecureKeyAsync: jest.fn().mockResolvedValue("deleted"),
+}));
+
+mock.module("../config/env-registry.js", () => ({
+  getDebugStdoutLogs: () => false,
+  getIsContainerized: () => false,
+  getIsPlatform: () => false,
+  isPlatformRemote: () => false,
+  getWorkspaceDirOverride: () => undefined,
+  getBackupDirOverride: () => undefined,
+  getBackupKeyPathOverride: () => undefined,
+  getCpuLimit: () => undefined,
+  getMinikubeStorageSize: () => undefined,
+  getProfilerRunId: () => undefined,
+  getProfilerMode: () => undefined,
+  getProfilerMaxBytes: () => undefined,
+  getProfilerMaxRuns: () => undefined,
+  getProfilerMinFreeMb: () => undefined,
+  checkUnrecognizedEnvVars: () => [],
+}));
+
+const { McpClient } = await import("../mcp/client.js");
+const { createMcpTool } = await import("../tools/mcp/mcp-tool-factory.js");
+const { RiskLevel } = await import("../permissions/types.js");
+
+type ServerRisk = "low" | "medium" | "high";
+
+function serverConfig(defaultRiskLevel: ServerRisk) {
+  return {
+    transport: { type: "stdio" as const, command: "echo", args: [] },
+    enabled: true,
+    defaultRiskLevel,
+    maxTools: 100,
+  };
+}
+
+function toolWithAnnotations(readOnlyHint?: boolean) {
+  return {
+    name: "get-summary",
+    description: "Read a summary",
+    inputSchema: { type: "object", properties: {} },
+    ...(readOnlyHint === undefined ? {} : { annotations: { readOnlyHint } }),
+  };
+}
+
+describe("MCP tool risk from readOnlyHint annotations", () => {
+  const fakeManager = { callTool: jest.fn() } as never;
+
+  test("readOnlyHint true on a medium-risk server lowers risk to Low", () => {
+    const tool = createMcpTool(
+      toolWithAnnotations(true),
+      "fathom",
+      serverConfig("medium"),
+      fakeManager,
+    );
+
+    expect(tool.defaultRiskLevel).toBe(RiskLevel.Low);
+  });
+
+  test("readOnlyHint true on a high-risk server leaves risk at High", () => {
+    const tool = createMcpTool(
+      toolWithAnnotations(true),
+      "untrusted",
+      serverConfig("high"),
+      fakeManager,
+    );
+
+    expect(tool.defaultRiskLevel).toBe(RiskLevel.High);
+  });
+
+  test("missing annotations keeps the server default risk", () => {
+    const tool = createMcpTool(
+      toolWithAnnotations(undefined),
+      "fathom",
+      serverConfig("medium"),
+      fakeManager,
+    );
+
+    expect(tool.defaultRiskLevel).toBe(RiskLevel.Medium);
+  });
+
+  test("readOnlyHint false on a low-risk server keeps risk at Low", () => {
+    const tool = createMcpTool(
+      toolWithAnnotations(false),
+      "trusted",
+      serverConfig("low"),
+      fakeManager,
+    );
+
+    expect(tool.defaultRiskLevel).toBe(RiskLevel.Low);
+  });
+});
+
+describe("McpClient.listTools annotations passthrough", () => {
+  test("carries server-declared annotations into McpToolInfo", async () => {
+    const client = new McpClient("test-server");
+
+    const listToolsSpy = jest.fn().mockResolvedValue({
+      tools: [
+        {
+          name: "get-summary",
+          description: "Read a summary",
+          inputSchema: { type: "object", properties: {} },
+          annotations: { readOnlyHint: true, title: "Get summary" },
+        },
+        {
+          name: "delete-recording",
+          description: "Delete a recording",
+          inputSchema: { type: "object", properties: {} },
+        },
+      ],
+    });
+
+    (client as unknown as { connected: boolean }).connected = true;
+    (client as unknown as { client: unknown }).client = {
+      listTools: listToolsSpy,
+    };
+
+    const tools = await client.listTools();
+
+    expect(tools[0]?.annotations).toEqual({
+      readOnlyHint: true,
+      title: "Get summary",
+    });
+    expect(tools[1]?.annotations).toBeUndefined();
+  });
+});

package/src/__tests__/media-stream-server-integration.test.ts

@@ -406,6 +406,8 @@ mock.module("../calls/access-request-wait.js", () => ({
 // Now import the module under test.
 // ---------------------------------------------------------------------------
 
+import { GATEWAY_TUNNEL_LOST_WS_CLOSE_CODE } from "@vellumai/service-contracts/ingress";
+
 import { revokeScopedApprovalGrantsForContext } from "../approvals/scoped-approval-grants.js";
 import { CallController } from "../calls/call-controller.js";
 import { postPointerMessageSafe } from "../calls/call-pointer-messages.js";
@@ -746,6 +748,40 @@ describe("MediaStreamCallSession", () => {
       );
     });
 
+    test("tunnel-lost close code decodes to a readable failure detail", () => {
+      const mock = createMockWs();
+      mockSessions.set("call-1", {
+        id: "call-1",
+        conversationId: "conv-1",
+        status: "in_progress",
+        startedAt: Date.now() - 60000,
+        toNumber: "+16175550142",
+        initiatedFromConversationId: "conv-origin",
+      });
+
+      const session = new MediaStreamCallSession(mock.ws, "call-1");
+      // The gateway's close reason is dropped in relay, so only the code
+      // arrives; it must decode to something a human can act on.
+      session.handleTransportClosed(GATEWAY_TUNNEL_LOST_WS_CLOSE_CODE);
+
+      expect(updateCallSession).toHaveBeenCalledWith(
+        "call-1",
+        expect.objectContaining({
+          status: "failed",
+          lastError:
+            "Media stream WebSocket closed unexpectedly: public ingress tunnel disconnected",
+        }),
+      );
+      expect(postPointerMessageSafe).toHaveBeenCalledWith(
+        "conv-origin",
+        "failed",
+        "+16175550142",
+        expect.objectContaining({
+          reason: "public ingress tunnel disconnected",
+        }),
+      );
+    });
+
     test("close on already-terminal session is a no-op", () => {
       const mock = createMockWs();
       mockSessions.set("call-1", {

package/src/__tests__/migration-export-http.test.ts

@@ -563,7 +563,7 @@ describe("integration: existing routes unaffected", () => {
   test("GET /v1/health still works (not intercepted by migration routes)", async () => {
     const { handleDetailedHealth } =
       await import("../runtime/routes/identity-routes.js");
-    const res = handleDetailedHealth();
+    const res = await handleDetailedHealth();
     const body = (await res.json()) as Record<string, unknown>;
 
     expect(res.status).toBe(200);

package/src/__tests__/migration-import-commit-http.test.ts

@@ -1171,7 +1171,7 @@ describe("integration: existing routes unaffected", () => {
   test("GET /v1/health still works", async () => {
     const { handleDetailedHealth } =
       await import("../runtime/routes/identity-routes.js");
-    const res = handleDetailedHealth();
+    const res = await handleDetailedHealth();
     const body = (await res.json()) as Record<string, unknown>;
 
     expect(res.status).toBe(200);

package/src/__tests__/migration-import-preflight-http.test.ts

@@ -737,7 +737,7 @@ describe("integration: existing routes unaffected", () => {
   test("GET /v1/health still works", async () => {
     const { handleDetailedHealth } =
       await import("../runtime/routes/identity-routes.js");
-    const res = handleDetailedHealth();
+    const res = await handleDetailedHealth();
     const body = (await res.json()) as Record<string, unknown>;
 
     expect(res.status).toBe(200);

package/src/__tests__/migration-validate-http.test.ts

@@ -634,7 +634,7 @@ describe("integration: existing routes unaffected", () => {
   test("GET /v1/health still works (not intercepted by migration routes)", async () => {
     const { handleDetailedHealth } =
       await import("../runtime/routes/identity-routes.js");
-    const res = handleDetailedHealth();
+    const res = await handleDetailedHealth();
     const body = (await res.json()) as Record<string, unknown>;
 
     expect(res.status).toBe(200);

package/src/__tests__/mtime-cache.test.ts

@@ -14,6 +14,7 @@ import {
   mkdirSync,
   readFileSync,
   rmSync,
+  symlinkSync,
   utimesSync,
   writeFileSync,
 } from "node:fs";
@@ -507,17 +508,17 @@ describe("workspace hooks (<workspace>/hooks/)", () => {
     writePackageJson(dir, { ...SIMPLE_PKG, name: "ordering-plugin" });
     writeHook(
       dir,
-      "pre-model-call",
+      "conversation-deleted",
       `export default () => ({ tag: "plugin" });`,
     );
     writeWorkspaceHook(
-      "pre-model-call",
+      "conversation-deleted",
       `export default () => ({ tag: "workspace" });`,
     );
 
     await populateCacheAtBoot();
 
-    const hooks = await getUserHooksFor("pre-model-call");
+    const hooks = await getUserHooksFor("conversation-deleted");
     expect(hooks).toHaveLength(2);
     const results = hooks.map((fn) =>
       (fn as unknown as () => { tag: string })(),
@@ -1004,4 +1005,65 @@ describe("plugin root validation (ATL-983)", () => {
     // The evil plugin's init hook must NOT have run.
     expect(existsSync(evilMarker)).toBe(false);
   });
+
+  test("a symlinked plugin root escaping the plugins dir is not activated at boot", async () => {
+    // A real plugin outside the plugins directory, linked in under a name the
+    // boot scan reads. Hook resolution follows the link, so discovery is the
+    // only thing between boot and code from anywhere on disk.
+    const escapee = join(ROOT, "outside", "escapee");
+    mkdirSync(escapee, { recursive: true });
+    writePackageJson(escapee, { ...SIMPLE_PKG, name: "escapee" });
+    const escapeeMarker = join(ROOT, "escapee-init.log");
+    rmSync(escapeeMarker, { force: true });
+    writeMarkerHook(escapee, "init", escapeeMarker, "init");
+    writeHook(
+      escapee,
+      "user-prompt-submit",
+      `export default () => ({ tag: "escapee" });`,
+    );
+    symlinkSync(escapee, join(PLUGINS_DIR, "escapee"));
+
+    // A contained plugin in the same scan, so a boot that discovered nothing
+    // at all cannot pass this test.
+    const keeper = freshPluginDir("keeper");
+    writePackageJson(keeper, { ...SIMPLE_PKG, name: "keeper" });
+    writeHook(
+      keeper,
+      "user-prompt-submit",
+      `export default () => ({ tag: "keeper" });`,
+    );
+
+    await populateCacheAtBoot();
+
+    expect(
+      (await getUserHooksFor("user-prompt-submit")).map(
+        (fn) => (fn as unknown as () => { tag: string })().tag,
+      ),
+    ).toEqual(["keeper"]);
+    expect(existsSync(escapeeMarker)).toBe(false);
+  });
+
+  test("a symlinked plugin root staying inside the plugins dir is activated at boot", async () => {
+    // A symlinked plugin root is supported (see `plugins/source-fingerprint.ts`)
+    // as long as it resolves inside the plugins directory. The link target sits
+    // in a dot-prefixed store directory, which carries no package.json and is
+    // therefore not an install of its own.
+    const target = join(PLUGINS_DIR, ".store", "alias");
+    mkdirSync(target, { recursive: true });
+    writePackageJson(target, { ...SIMPLE_PKG, name: "alias" });
+    writeHook(
+      target,
+      "user-prompt-submit",
+      `export default () => ({ tag: "alias" });`,
+    );
+    symlinkSync(target, join(PLUGINS_DIR, "alias"));
+
+    await populateCacheAtBoot();
+
+    expect(
+      (await getUserHooksFor("user-prompt-submit")).map(
+        (fn) => (fn as unknown as () => { tag: string })().tag,
+      ),
+    ).toEqual(["alias"]);
+  });
 });