@vellumai/assistant 0.11.2-dev.202608051734.355dff7 → 0.11.2-dev.202608051933.deffc0f

package/src/__tests__/host-transfer-proxy-targeted.test.ts

@@ -709,7 +709,7 @@ describe("HostTransferProxy — targetClientId", () => {
       );
 
       expect(result.isError).toBe(true);
-      expect(result.content).toContain("does not match");
+      expect(result.content).toContain("signed in as a different user");
       expect(sentMessages).toHaveLength(0);
     });
 
@@ -738,7 +738,7 @@ describe("HostTransferProxy — targetClientId", () => {
       );
 
       expect(result.isError).toBe(true);
-      expect(result.content).toContain("does not match");
+      expect(result.content).toContain("no authenticated actor");
       expect(sentMessages).toHaveLength(0);
     });
 
@@ -767,7 +767,9 @@ describe("HostTransferProxy — targetClientId", () => {
       );
 
       expect(result.isError).toBe(true);
-      expect(result.content).toContain("does not match");
+      expect(result.content).toContain(
+        "registered without an authenticated user",
+      );
       expect(sentMessages).toHaveLength(0);
     });
 
@@ -863,7 +865,7 @@ describe("HostTransferProxy — targetClientId", () => {
       );
 
       expect(result.isError).toBe(true);
-      expect(result.content).toContain("does not match");
+      expect(result.content).toContain("signed in as a different user");
       expect(sentMessages).toHaveLength(0);
     });
 

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__/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__/stt-language-catalog-parity.test.ts

@@ -129,3 +129,41 @@ describe("web STT language catalog stays in sync with the daemon roster", () =>
     expect(nonExtended).toEqual(expected);
   });
 });
+
+/**
+ * The settings skill accepts plain language names ("tamil", "hindi") and its
+ * tool description advertises that, so a roster code with no English-name
+ * alias is reachable only by someone who knows the raw BCP-47 code. Adding a
+ * language to the roster without its alias is the easy half-step, so pin the
+ * two together the same way the catalog copies are pinned.
+ */
+const SETTINGS_TOOL_SOURCE = readFileSync(
+  join(
+    REPO_ROOT,
+    "assistant/src/config/bundled-skills/settings/tools/voice-config-update.ts",
+  ),
+  "utf-8",
+);
+
+describe("settings-skill language aliases", () => {
+  test("every roster language is reachable by an English name", () => {
+    const aliasBlockStart = SETTINGS_TOOL_SOURCE.indexOf(
+      "const STT_LANGUAGE_ALIASES",
+    );
+    expect(aliasBlockStart).toBeGreaterThan(-1);
+    const aliasBlockEnd = SETTINGS_TOOL_SOURCE.indexOf("};", aliasBlockStart);
+    const aliasBlock = SETTINGS_TOOL_SOURCE.slice(
+      aliasBlockStart,
+      aliasBlockEnd,
+    );
+    // Every value in the alias map, i.e. the codes a plain name can reach.
+    const aliasedCodes = new Set(
+      [...aliasBlock.matchAll(/:\s*"([a-z-]+)"/g)].map((match) => match[1]),
+    );
+
+    const unreachable = DEEPGRAM_NOVA3_MONOLINGUAL_CODES.filter(
+      (code) => !aliasedCodes.has(code),
+    );
+    expect(unreachable).toEqual([]);
+  });
+});

package/src/__tests__/subagent-tool-gate-mode.test.ts

@@ -116,6 +116,7 @@ function makeSetupCtx(overrides: Partial<Conversation> = {}): Conversation {
     conversationId: "conv-test",
     currentRequestId: "req-1",
     workingDir: "/tmp/test",
+    getTurnActorPrincipalId: () => undefined,
     abortController: null,
     sendToClient: mock(() => {}),
     pendingSurfaceActions: new Map(),