@vellumai/assistant 0.11.3 → 0.11.4-dev.202608190019.b94dbf2

package/src/inbound/__tests__/oauth-callback-url.test.ts

@@ -0,0 +1,83 @@
+/**
+ * Tests for the shared OAuth callback URL resolver.
+ *
+ * The property that matters is stability: every caller and every attempt
+ * must get the same redirect URI. Dynamic client registration and Client
+ * ID Metadata Documents both pin `redirect_uris` when the client is
+ * registered, and the authorization server matches the value exactly on
+ * each authorization request, so a URI that varies per attempt makes both
+ * mechanisms unusable.
+ */
+
+import { afterEach, describe, expect, mock, test } from "bun:test";
+
+const resolveCallbackUrl = mock(
+  async () => "https://ingress.example/webhooks/oauth/callback",
+);
+
+mock.module("../platform-callback-registration.js", () => ({
+  resolveCallbackUrl,
+}));
+
+mock.module("../public-ingress-urls.js", () => ({
+  getOAuthCallbackUrl: () => "https://direct.example/webhooks/oauth/callback",
+}));
+
+mock.module("../../config/loader.js", () => ({
+  loadConfig: () => ({}),
+}));
+
+const { OAUTH_CALLBACK_PATH, resolveOauthCallbackUrl } =
+  await import("../oauth-callback-url.js");
+
+afterEach(() => {
+  resolveCallbackUrl.mockClear();
+});
+
+describe("resolveOauthCallbackUrl", () => {
+  test("returns whatever the shared resolver decides", async () => {
+    await expect(resolveOauthCallbackUrl()).resolves.toEqual(
+      "https://ingress.example/webhooks/oauth/callback",
+    );
+  });
+
+  test("registers the shared callback path, not a per-caller one", async () => {
+    await resolveOauthCallbackUrl();
+    const [, callbackPath] = resolveCallbackUrl.mock.calls[0] as unknown[];
+    expect(callbackPath).toEqual(OAUTH_CALLBACK_PATH);
+    expect(OAUTH_CALLBACK_PATH).toEqual("webhooks/oauth/callback");
+  });
+
+  test("every call resolves to the same URL, path, and registration type", async () => {
+    // The URI a client registers and the URI it later authorizes with are
+    // the same string, which is what an exact-match redirect_uri check
+    // needs. Nothing about the caller can vary it: the function takes no
+    // arguments.
+    const first = await resolveOauthCallbackUrl();
+    const second = await resolveOauthCallbackUrl();
+    expect(first).toEqual(second);
+
+    const [, pathA, typeA] = resolveCallbackUrl.mock.calls[0] as unknown[];
+    const [, pathB, typeB] = resolveCallbackUrl.mock.calls[1] as unknown[];
+    expect(pathA).toEqual(pathB);
+    expect(typeA).toEqual(typeB);
+  });
+
+  test("registers one route type so the platform holds a single admin row", async () => {
+    await resolveOauthCallbackUrl();
+    const [, , type] = resolveCallbackUrl.mock.calls[0] as unknown[];
+    expect(type).toEqual("oauth");
+  });
+
+  test("propagates the resolver's failure rather than inventing a URL", async () => {
+    // No ingress and no platform connection means there is no URL that
+    // would work. Returning a plausible one produces an authorization
+    // request whose callback silently never arrives.
+    resolveCallbackUrl.mockImplementationOnce(async () => {
+      throw new Error("No public base URL configured.");
+    });
+    await expect(resolveOauthCallbackUrl()).rejects.toThrow(
+      /No public base URL/,
+    );
+  });
+});

package/src/inbound/oauth-callback-url.ts

@@ -0,0 +1,61 @@
+/**
+ * Public URL resolution for the assistant's shared OAuth callback route.
+ *
+ * Every browser-based OAuth flow in the daemon redirects back to one path,
+ * `webhooks/oauth/callback`, which the gateway serves and forwards to
+ * `POST /v1/internal/oauth/callback`. The runtime matches the arriving
+ * `state` against `security/oauth-callback-registry.ts` and resolves the
+ * waiting flow, so one route multiplexes every concurrent handshake and no
+ * caller needs a listener of its own.
+ *
+ * Which base URL is correct depends on how the assistant is reachable: a
+ * platform pod and a platform-connected assistant are served through a
+ * managed callback route, a self-hosted deployment through its configured
+ * public ingress. `resolveCallbackUrl` owns that decision, and this is the
+ * OAuth-shaped entry point to it, mirroring `plugin-api/webhook-url.ts`
+ * for plugin ingress.
+ */
+
+import { loadConfig } from "../config/loader.js";
+import { resolveCallbackUrl } from "./platform-callback-registration.js";
+import { getOAuthCallbackUrl } from "./public-ingress-urls.js";
+
+/**
+ * Path the gateway serves the shared OAuth callback on.
+ *
+ * Fixed rather than caller-supplied. Every flow is demultiplexed by OAuth
+ * `state`, so a per-caller path would buy nothing and would need its own
+ * gateway route and its own platform registration.
+ */
+export const OAUTH_CALLBACK_PATH = "webhooks/oauth/callback";
+
+/**
+ * Registration type recorded with the platform.
+ *
+ * The platform keys a callback route by `(path, type)`, and there is one
+ * OAuth route, so one type describes it. Registering the same path under
+ * several types would produce duplicate admin rows pointing at the same
+ * URL.
+ */
+const OAUTH_REGISTRATION_TYPE = "oauth";
+
+/**
+ * Resolve the redirect URI an authorization server should send the user
+ * back to.
+ *
+ * Takes no arguments on purpose: every caller shares one route, so there
+ * is nothing to vary. That is what makes the URI stable across callers and
+ * across attempts, which is what an exact-match `redirect_uri` check needs.
+ *
+ * @throws when no public ingress is configured and the assistant is not
+ *   connected to the platform. There is no URL that would work in that
+ *   case, and returning a plausible one produces an authorization request
+ *   whose callback silently never arrives.
+ */
+export async function resolveOauthCallbackUrl(): Promise<string> {
+  return resolveCallbackUrl(
+    () => getOAuthCallbackUrl(loadConfig()),
+    OAUTH_CALLBACK_PATH,
+    OAUTH_REGISTRATION_TYPE,
+  );
+}

package/src/ipc/gateway-client.test.ts

@@ -143,7 +143,7 @@ describe("ipcClassifyRisk retry", () => {
   const CLASSIFY_OK = {
     risk: "low",
     reason: "safe",
-    matchType: "none",
+    matchType: "registry",
     scopeOptions: [],
   };
   const emptyParams = {} as unknown as Parameters<typeof ipcClassifyRisk>[0];

package/src/ipc/gateway-client.ts

@@ -10,16 +10,17 @@
  * deterministic fallback for long AF_UNIX paths.
  */
 
+import {
+  type ClassifyRiskIpcParams,
+  type ClassifyRiskIpcResponse,
+  ClassifyRiskIpcResponseSchema,
+} from "@vellumai/gateway-client";
 import {
   ipcCall as packageIpcCall,
   IpcCallError,
   PersistentIpcClient as PackagePersistentIpcClient,
 } from "@vellumai/gateway-client/ipc-client";
 
-import type {
-  ClassificationResult,
-  ClassifyRiskParams,
-} from "../permissions/ipc-risk-types.js";
 import { getLogger } from "../util/logger.js";
 import { abortableSleep, computeRetryDelay } from "../util/retry.js";
 import { resolveIpcSocketPath } from "./socket-path.js";
@@ -173,37 +174,29 @@ const CLASSIFY_RISK_ATTEMPT_TIMEOUT_MS = 1_500; // per-attempt cap (< 5s default
  * When a `signal` is supplied, retries stop as soon as it aborts.
  */
 export async function ipcClassifyRisk(
-  params: ClassifyRiskParams,
+  params: ClassifyRiskIpcParams,
   signal?: AbortSignal,
-): Promise<ClassificationResult | undefined> {
+): Promise<ClassifyRiskIpcResponse | undefined> {
   for (let attempt = 0; ; attempt++) {
     try {
       const result = await ipcCallPersistent(
         "classify_risk",
-        params as unknown as Record<string, unknown>,
+        params,
         CLASSIFY_RISK_ATTEMPT_TIMEOUT_MS,
       );
 
-      // Returned-but-malformed responses are deterministic, not transient:
+      // A returned-but-malformed response is deterministic, not transient:
       // fail closed immediately (no retry).
-      if (!result || typeof result !== "object" || Array.isArray(result)) {
-        log.warn(
-          { result },
-          "ipcClassifyRisk: gateway returned non-object response",
-        );
-        return undefined;
-      }
-
-      const obj = result as Record<string, unknown>;
-      if (typeof obj.risk !== "string") {
+      const parsed = ClassifyRiskIpcResponseSchema.safeParse(result);
+      if (!parsed.success) {
         log.warn(
-          { result },
-          "ipcClassifyRisk: gateway response missing 'risk' field",
+          { result, issues: parsed.error.issues },
+          "ipcClassifyRisk: gateway response does not match the classify_risk contract",
         );
         return undefined;
       }
 
-      return result as ClassificationResult;
+      return parsed.data;
     } catch (err) {
       // A structured gateway error means the gateway was reachable and
       // deterministically rejected the request — not a transient blip.

package/src/ipc/gateway-flag-listener.ts

@@ -1,6 +1,7 @@
 import { connect, type Socket } from "node:net";
 
 import { refreshOverridesFromGateway } from "../config/assistant-feature-flags.js";
+import { getBalancedModelExperimentArm } from "../config/balanced-model-experiment.js";
 import { reconcileFlagGatedProfiles } from "../config/sync-gated-profiles.js";
 import { SYNC_TAGS } from "../daemon/message-types/sync.js";
 import { publishConfigChanged } from "../runtime/sync/resource-sync-events.js";
@@ -19,13 +20,26 @@ const log = getLogger("gateway-flag-listener");
  * when the refresh confirmed flags loaded from the gateway — a transient IPC
  * failure leaves the cache unset and resolves `os-beta` to its registry default
  * `false`, which would remove the user's profile and reset their selection.
+ *
+ * A new balanced-model experiment arm gets the same broadcast. It repoints what
+ * the managed Balanced profile resolves to without moving anything on disk, so
+ * the reconcile reports no change and clients would otherwise keep rendering
+ * the previous model beside a profile already running the new one.
  */
 function refreshFlagsAndReconcileProfiles(context: string): void {
+  const balancedArmBefore = getBalancedModelExperimentArm();
   refreshOverridesFromGateway()
     .then((loaded) => {
-      if (loaded && reconcileFlagGatedProfiles()) {
-        // Reuse the config-changed broadcast clients already consume so the
-        // profile picker reflects the added/removed managed profile.
+      if (!loaded) {
+        return;
+      }
+      const profilesChanged = reconcileFlagGatedProfiles();
+      const balancedArmChanged =
+        getBalancedModelExperimentArm() !== balancedArmBefore;
+      if (profilesChanged || balancedArmChanged) {
+        // Reuse the config-changed broadcast clients already consume: web
+        // routes the `assistant:self:config` sync tag to the effective profile
+        // catalog and the call-site catalog, both derived from config.
         publishConfigChanged();
       }
     })

package/src/live-voice/__tests__/live-voice-agent-turn.test.ts

@@ -1,16 +1,13 @@
 import { describe, expect, mock, test } from "bun:test";
 
-import { sanitizeForTts } from "../../calls/tts-text-sanitizer.js";
 import type {
   VoiceTurnCallbacks,
   VoiceTurnOptions,
 } from "../../calls/voice-session-bridge.js";
-import type { LiveVoiceFrontModelConfig } from "../../config/schemas/live-voice.js";
 import type {
   StreamingTranscriber,
   SttStreamServerEvent,
 } from "../../stt/types.js";
-import type { VoiceFrontDecider } from "../front-decision.js";
 import {
   LiveVoiceSession,
   type LiveVoiceTtsStreamer,
@@ -96,8 +93,6 @@ function createSessionHarness(
     createTurnId?: () => string;
     emitMetrics?: boolean;
     streamTtsAudio?: LiveVoiceTtsStreamer;
-    frontModelConfig?: Partial<LiveVoiceFrontModelConfig>;
-    frontDecider?: VoiceFrontDecider;
   } = {},
 ) {
   const transcriber =
@@ -119,10 +114,6 @@ function createSessionHarness(
     ...(options.streamTtsAudio
       ? { streamTtsAudio: options.streamTtsAudio }
       : {}),
-    ...(options.frontModelConfig
-      ? { frontModelConfig: options.frontModelConfig }
-      : {}),
-    ...(options.frontDecider ? { frontDecider: options.frontDecider } : {}),
   });
 
   return { frames, session, startVoiceTurn, transcriber };
@@ -468,7 +459,7 @@ describe("LiveVoiceSession assistant turn", () => {
     });
   });
 
-  test("records tool_use_start on the active turn and publishes what it is doing", async () => {
+  test("publishes tool activity while the turn is running", async () => {
     let callbacks: VoiceTurnCallbacks | undefined;
     const startVoiceTurn = mock(async (options: VoiceTurnOptions) => {
       callbacks = options.callbacks;
@@ -488,12 +479,6 @@ describe("LiveVoiceSession assistant turn", () => {
     callbacks?.tool_use_start?.("some_tool");
     await waitForFrameCount(frames, 4);
 
-    const activeTurn = (
-      session as unknown as {
-        activeAssistantTurn: { toolUseStarted: boolean } | null;
-      }
-    ).activeAssistantTurn;
-    expect(activeTurn?.toolUseStarted).toBe(true);
     // One activity frame, so a silent stretch of tool work is visible on the
     // surfaces that show the session. An unrecognized tool still gets a line.
     expect(frames.at(-1)).toMatchObject({
@@ -560,90 +545,6 @@ describe("LiveVoiceSession assistant turn", () => {
   });
 });
 
-describe("LiveVoiceSession tool-use spoken ack", () => {
-  const ACK_TIMEOUT_MS = 40;
-  // Every ack is front-model-phrased; the generated text passes through the
-  // same TTS sanitizer as regular segments. The stub varies its phrasing by
-  // trigger so the two ack kinds stay distinguishable in assertions.
-  const TOOL_ACK = "Let me look that up.";
-  const FIRST_DELTA_ACK = "Sure — one moment.";
-  const EXPECTED_TOOL_ACK = sanitizeForTts(TOOL_ACK).trim();
-  const EXPECTED_FIRST_DELTA_ACK = sanitizeForTts(FIRST_DELTA_ACK).trim();
-
-  const ackDecider: VoiceFrontDecider = {
-    generateAckText: async (input) =>
-      input.toolName ? TOOL_ACK : FIRST_DELTA_ACK,
-    generateProgressText: async () => null,
-  };
-
-  function createAckHarness() {
-    const { startVoiceTurn, getCallbacks } = createCapturingTurnStarter();
-    const { streamTtsAudio, ttsTexts } = createRecordingTtsStreamer();
-    const harness = createSessionHarness({
-      startVoiceTurn,
-      streamTtsAudio,
-      frontModelConfig: { ackFirstDeltaTimeoutMs: ACK_TIMEOUT_MS },
-      frontDecider: ackDecider,
-    });
-    return { ...harness, getCallbacks, ttsTexts };
-  }
-
-  test("tool_use_start before any delta speaks an immediate tool ack and cancels the timer", async () => {
-    const { frames, session, getCallbacks, ttsTexts } = createAckHarness();
-
-    await startReleasedTurn(session, getCallbacks);
-    getCallbacks()?.tool_use_start?.("web_search");
-    await waitFor(() => ttsTexts.length === 1);
-    expect(ttsTexts).toEqual([EXPECTED_TOOL_ACK]);
-
-    // The pending first-delta timer was cancelled: letting its budget elapse
-    // speaks no second ack.
-    await new Promise((resolve) => setTimeout(resolve, ACK_TIMEOUT_MS + 40));
-    expect(ttsTexts).toEqual([EXPECTED_TOOL_ACK]);
-
-    // The ack is audio-only — no caption frame carries it.
-    expect(frames.some((frame) => frame.type === "assistant_text_delta")).toBe(
-      false,
-    );
-
-    emitTextDelta(getCallbacks, "Hello there.");
-    emitMessageComplete(getCallbacks);
-    await waitFor(() => frames.some((frame) => frame.type === "tts_done"));
-    expect(ttsTexts).toEqual([EXPECTED_TOOL_ACK, "Hello there."]);
-  });
-
-  test("tool_use_start after the first delta speaks no ack", async () => {
-    const { frames, session, getCallbacks, ttsTexts } = createAckHarness();
-
-    await startReleasedTurn(session, getCallbacks);
-    emitTextDelta(getCallbacks, "Hello there.");
-    getCallbacks()?.tool_use_start?.("web_search");
-    emitMessageComplete(getCallbacks);
-    await waitFor(() => frames.some((frame) => frame.type === "tts_done"));
-    await new Promise((resolve) => setTimeout(resolve, ACK_TIMEOUT_MS + 40));
-
-    expect(ttsTexts).toEqual(["Hello there."]);
-  });
-
-  test("tool_use_start after a first-delta ack already spoke adds no second ack", async () => {
-    const { frames, session, getCallbacks, ttsTexts } = createAckHarness();
-
-    await startReleasedTurn(session, getCallbacks);
-    // Let the slow-first-delta timer speak the turn's one ack first.
-    await waitFor(() => ttsTexts.length === 1);
-    expect(ttsTexts).toEqual([EXPECTED_FIRST_DELTA_ACK]);
-
-    getCallbacks()?.tool_use_start?.("web_search");
-    await flushAsyncCallbacks();
-    expect(ttsTexts).toEqual([EXPECTED_FIRST_DELTA_ACK]);
-
-    emitTextDelta(getCallbacks, "Hello there.");
-    emitMessageComplete(getCallbacks);
-    await waitFor(() => frames.some((frame) => frame.type === "tts_done"));
-    expect(ttsTexts).toEqual([EXPECTED_FIRST_DELTA_ACK, "Hello there."]);
-  });
-});
-
 describe("LiveVoiceSession room reveal", () => {
   function createMarkerHarness() {
     const { startVoiceTurn, getCallbacks } = createCapturingTurnStarter();
@@ -651,9 +552,6 @@ describe("LiveVoiceSession room reveal", () => {
     const harness = createSessionHarness({
       startVoiceTurn,
       streamTtsAudio,
-      // Deltas are emitted immediately in these runs; a long ack budget keeps
-      // filler phrases out of the recorded TTS text.
-      frontModelConfig: { ackFirstDeltaTimeoutMs: 10_000 },
     });
     return { ...harness, getCallbacks, ttsTexts };
   }
@@ -689,7 +587,6 @@ describe("LiveVoiceSession room reveal", () => {
     const harness = createSessionHarness({
       startVoiceTurn,
       streamTtsAudio,
-      frontModelConfig: { ackFirstDeltaTimeoutMs: 10_000 },
     });
     return {
       ...harness,

package/src/live-voice/__tests__/live-voice-events.test.ts

@@ -4,7 +4,6 @@ import type {
   VoiceTurnCallbacks,
   VoiceTurnOptions,
 } from "../../calls/voice-session-bridge.js";
-import { VOICE_NO_SETUP_FLOWS_RULE } from "../../calls/voice-session-bridge.js";
 import type {
   StreamingTranscriber,
   SttStreamServerEvent,
@@ -254,14 +253,14 @@ describe("LiveVoiceSession archive and metrics events", () => {
       userMessageInterface: "macos",
       assistantMessageInterface: "macos",
       // Pins the full production control prompt for the FRONT-DOOR leg (the
-      // first leg of every routed turn): the speech-first rule (which now
-      // permits a surface, since the room reveals one by itself) and the
-      // shared no-setup-flows rule (no OAuth/browser flows mid-call). The [-1]
-      // room-minimize teaching is deliberately absent — only the escalated
-      // leg learns it (see live-voice-triage-escalate.test.ts).
+      // first leg of every routed turn): the speech-first rule, and nothing
+      // else. This leg is toolless, so both the screen-reveal and setup-flow
+      // teachings are deliberately absent. It has nothing to show and no
+      // connection to run, and its capability digest already routes anything
+      // needing a tool to the escalated leg (see
+      // live-voice-triage-escalate.test.ts).
       voiceControlPrompt:
-        "You are speaking in a local live voice session. Keep replies brief and conversational. Speech is the main channel: say the answer, and do not narrate a surface instead of answering. You can also put something on screen when it genuinely helps (a form, a list to pick from, a progress card for long work); the call overlay minimizes by itself once you finish speaking, so the user sees it without doing anything. Never tell the user you cannot show them something. Reply in the language the caller is speaking; if they switch languages, switch with them. " +
-        VOICE_NO_SETUP_FLOWS_RULE,
+        "You are speaking in a local live voice session. Keep replies brief and conversational. Speech is the main channel: say the answer, and do not narrate a surface instead of answering. You can also put something on screen when it genuinely helps (a form, a list to pick from, a progress card for long work); the call overlay minimizes by itself once you finish speaking, so the user sees it without doing anything. Never tell the user you cannot show them something. Reply in the language the caller is speaking; if they switch languages, switch with them. ",
     });
     callbacks?.assistant_text_delta?.(makeTextDelta("Hello there."));
     callbacks?.message_complete?.(makeMessageComplete());