@vellumai/assistant 0.11.2 → 0.11.3-staging.2

package/src/calls/voice-session-bridge.ts

@@ -17,6 +17,7 @@ import type {
 import { consumeGrantForInvocation } from "../approvals/approval-primitive.js";
 import type {
   ChannelId,
+  ClientOs,
   InterfaceId,
   TurnChannelContext,
   TurnInterfaceContext,
@@ -265,6 +266,22 @@ export interface VoiceTurnOptions {
   userMessageInterface?: InterfaceId;
   /** Source interface for persisted assistant messages. Defaults to userMessageInterface. */
   assistantMessageInterface?: InterfaceId;
+  /**
+   * Analytics attribution for a live-voice turn: which client opened the
+   * session, and that session's id. Persisted into the user message's
+   * `metadata.client` bag, which `turn-events-store` projects onto
+   * `TurnTelemetryEvent.client`, so a live-voice turn is countable per client
+   * and joinable to its session's start/end funnel rows.
+   *
+   * Deliberately separate from {@link userMessageInterface}: that field feeds
+   * `resolveChannelCapabilities` and decides what the turn may do, so it is not
+   * free to carry attribution. Absent for phone calls and for clients that send
+   * no identity on the start frame.
+   */
+  voiceTelemetry?: {
+    sessionId: string;
+    client?: ClientOs;
+  };
   /** Per-turn control prompt. Undefined uses the phone prompt; null disables it. */
   voiceControlPrompt?: string | null;
   /** The transcribed caller utterance or synthetic marker. */
@@ -945,6 +962,27 @@ export async function startVoiceTurn(
         // `isVoiceSessionUserMessage` for why the channel fields cannot carry it.
         voiceSessionTurn: true,
         ...(isHiddenSyntheticPrompt ? { hidden: true } : {}),
+        ...(opts.voiceTelemetry
+          ? {
+              // Projected onto `TurnTelemetryEvent.client` by
+              // `turn-events-store`. `voice_session_id` is what joins these
+              // turn rows to the session's funnel rows, so a session's turn
+              // count is a count of rows carrying its id, never a field
+              // anyone has to keep correct.
+              //
+              // `os` is the standard per-platform dimension the HTTP send
+              // path already fills from the same `detectClientOs()` value, so
+              // a voice turn reports its platform in the column existing turn
+              // analytics read rather than one only voice knows about.
+              client: {
+                voice: true,
+                voice_session_id: opts.voiceTelemetry.sessionId,
+                ...(opts.voiceTelemetry.client
+                  ? { os: opts.voiceTelemetry.client }
+                  : {}),
+              },
+            }
+          : {}),
       },
     });
     return persistResult.id;

package/src/channels/__tests__/gateway-verification-sessions.test.ts

@@ -192,14 +192,14 @@ describe("createOutboundSessionConditional", () => {
     const result = await client.createOutboundSessionConditional({
       channel: "telegram",
       requireSourceSessionPending: "bootstrap-1",
-      ifNoneActive: true,
+      ifNoneActiveForExternalUserId: "user-1",
     });
 
     expect(ipcCalls[0]?.method).toBe("verification_sessions_create_outbound");
     expect(ipcCalls[0]?.params).toEqual({
       channel: "telegram",
       requireSourceSessionPending: "bootstrap-1",
-      ifNoneActive: true,
+      ifNoneActiveForExternalUserId: "user-1",
     });
     expect(result).toEqual(created);
   });
@@ -209,7 +209,7 @@ describe("createOutboundSessionConditional", () => {
 
     const result = await client.createOutboundSessionConditional({
       channel: "telegram",
-      ifNoneActive: true,
+      ifNoneActiveForExternalUserId: "user-1",
     });
 
     expect(result).toEqual({

package/src/channels/config.ts

@@ -75,8 +75,13 @@ const CHANNEL_POLICIES = {
   },
   discord: {
     notification: {
-      // Discord has no outbound transport, so enabling delivery would route
-      // notifications at a callback no transport owns.
+      // Replies to an inbound Discord message do not read this flag: they
+      // route by `replyCallbackUrl` through the channel transport. This gates
+      // proactive notification only, which needs a guardian binding to
+      // address and a destination resolver to reach it. Discord has neither,
+      // and `NotificationChannel` is derived from this flag, so enabling it
+      // early would let the decision engine pick a channel that resolves to
+      // nothing.
       deliveryEnabled: false,
       conversationStrategy: "continue_existing_conversation",
     },

package/src/channels/gateway-verification-sessions.ts

@@ -122,7 +122,8 @@ export async function createOutboundSession(
 
 /**
  * Guarded variant of `createOutboundSession` for callers passing an atomic
- * claim guard (`requireSourceSessionPending` / `ifNoneActive`). The gateway
+ * claim guard (`requireSourceSessionPending` /
+ * `ifNoneActiveForExternalUserId`). The gateway
  * evaluates the guard in the same synchronous section as the mint; a failed
  * guard returns a conflict marker instead of revoking the concurrent
  * winner's session. Throws when the gateway is unreachable (fail-closed).
@@ -160,10 +161,14 @@ export async function getPendingSession(
  */
 export async function findActiveSession(
   channel: string,
+  filter: {
+    expectedExternalUserId?: string;
+    verificationPurpose?: "guardian" | "trusted_contact";
+  } = {},
 ): Promise<VerificationSessionWire | null> {
   return callGateway(
     VERIFICATION_SESSIONS_IPC_METHODS.findActive,
-    { channel },
+    { channel, ...filter },
     SessionLookupIpcResponseSchema,
   );
 }

package/src/channels/types.ts

@@ -207,7 +207,13 @@ export function parseInterfaceId(value: unknown): InterfaceId | null {
  * than polluting the interface vocabulary. Drives only the per-turn
  * `client_os` context line (e.g. app-builder mobile-first for `ios`/`android`).
  */
-export const CLIENT_OS_VALUES = ["web", "ios", "macos", "android"] as const;
+export const CLIENT_OS_VALUES = [
+  "web",
+  "ios",
+  "macos",
+  "windows",
+  "android",
+] as const;
 
 export type ClientOs = (typeof CLIENT_OS_VALUES)[number];
 

package/src/cli/commands/__tests__/cache.test.ts

@@ -12,6 +12,7 @@
  */
 
 import * as nodeFs from "node:fs";
+import { fileURLToPath } from "node:url";
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
 import { Command } from "commander";
@@ -415,8 +416,9 @@ describe("cache set --value", () => {
 describe("cache set --file", () => {
   test("reads JSON from a file", async () => {
     mockIpcResult = { ok: true, result: { key: "file-key" } };
-    const pkgPath = new URL("../../../../package.json", import.meta.url)
-      .pathname;
+    const pkgPath = fileURLToPath(
+      new URL("../../../../package.json", import.meta.url),
+    );
 
     const { exitCode } = await runCommand(["cache", "set", "--file", pkgPath]);
 
@@ -442,8 +444,9 @@ describe("cache set --file", () => {
   test("works in TTY mode (no stdin required)", async () => {
     mockStdinIsTTY = true;
     mockIpcResult = { ok: true, result: { key: "file-tty-key" } };
-    const pkgPath = new URL("../../../../package.json", import.meta.url)
-      .pathname;
+    const pkgPath = fileURLToPath(
+      new URL("../../../../package.json", import.meta.url),
+    );
 
     const { exitCode } = await runCommand(["cache", "set", "--file", pkgPath]);
 

package/src/cli/commands/__tests__/cli-test-harness.ts

@@ -0,0 +1,82 @@
+/**
+ * Shared harness for CLI command tests: registers a command tree on a fresh
+ * Commander program, runs it against captured output sinks, and returns what
+ * the command emitted plus the resulting exit code.
+ *
+ * `process.stdout.write`, `console.log`, and `console.error` are captured for
+ * the duration of the run, so command output lands in the result regardless of
+ * which sink the command writes to; `process.exitCode` is reset afterwards.
+ * The caller passes its own (possibly mock-backed) registration function, so
+ * this helper imports nothing from `src/` beyond what any test file may
+ * import itself (see the test-machinery isolation rules in assistant/CLAUDE.md).
+ */
+
+import { Command } from "commander";
+
+export interface CliCommandRunResult {
+  stdout: string;
+  stderr: string;
+  /** stdout + stderr chunks in emission order, for cross-stream ordering. */
+  events: string[];
+  exitCode: number;
+}
+
+export async function runCliCommand(
+  register: (program: Command) => void,
+  args: string[],
+): Promise<CliCommandRunResult> {
+  const originalStdoutWrite = process.stdout.write.bind(process.stdout);
+  const originalConsoleLog = console.log;
+  const originalConsoleError = console.error;
+  const stdoutChunks: string[] = [];
+  const stderrChunks: string[] = [];
+  const events: string[] = [];
+
+  process.stdout.write = ((chunk: unknown) => {
+    const text = typeof chunk === "string" ? chunk : String(chunk);
+    stdoutChunks.push(text);
+    events.push(text);
+    return true;
+  }) as typeof process.stdout.write;
+  console.log = (...logArgs: unknown[]) => {
+    const text = logArgs.map(String).join(" ") + "\n";
+    stdoutChunks.push(text);
+    events.push(text);
+  };
+  console.error = (...logArgs: unknown[]) => {
+    const text = logArgs.map(String).join(" ") + "\n";
+    stderrChunks.push(text);
+    events.push(text);
+  };
+
+  process.exitCode = 0;
+
+  try {
+    const program = new Command();
+    program.exitOverride();
+    program.configureOutput({
+      writeErr: () => {},
+      writeOut: (str: string) => stdoutChunks.push(str),
+    });
+    register(program);
+    await program.parseAsync(["node", "assistant", ...args]);
+  } catch {
+    if (process.exitCode === 0) {
+      process.exitCode = 1;
+    }
+  } finally {
+    process.stdout.write = originalStdoutWrite;
+    console.log = originalConsoleLog;
+    console.error = originalConsoleError;
+  }
+
+  const exitCode = process.exitCode ?? 0;
+  process.exitCode = 0;
+
+  return {
+    stdout: stdoutChunks.join(""),
+    stderr: stderrChunks.join(""),
+    events,
+    exitCode,
+  };
+}

package/src/cli/commands/__tests__/conversations-wake.test.ts

@@ -1,8 +1,10 @@
 /**
- * CLI plumbing tests for untrusted-content input on `assistant conversations
- * wake`. Inline `--external-content` resolves to the fenced `externalContent`
- * body field and implies `--persist`. The route fences the resulting string
- * (see wake-conversation-routes.test.ts).
+ * CLI plumbing tests for `assistant conversations wake`. Inline
+ * `--external-content` resolves to the fenced `externalContent` body field and
+ * implies `--persist`; a script-mode schedule's environment resolves to the
+ * `cronRunId` and `scheduleId` body fields. The route fences the untrusted
+ * string and applies the schedule's pinned profile (see
+ * wake-conversation-routes.test.ts).
  */
 
 import * as nodeFs from "node:fs";
@@ -88,15 +90,19 @@ function lastBody(): Record<string, unknown> {
 }
 
 let savedRunId: string | undefined;
+let savedScheduleId: string | undefined;
 
 beforeEach(() => {
   lastIpcCall = null;
   loggerCalls.length = 0;
   process.exitCode = 0;
-  // The wake action reads __SCHEDULE_RUN_ID for cost attribution; clear it so
-  // it never leaks a cronRunId into the captured body.
+  // The wake action reads __SCHEDULE_RUN_ID for cost attribution and
+  // __SCHEDULE_ID for the schedule's pinned inference profile; clear both so
+  // they never leak into the captured body.
   savedRunId = process.env.__SCHEDULE_RUN_ID;
+  savedScheduleId = process.env.__SCHEDULE_ID;
   delete process.env.__SCHEDULE_RUN_ID;
+  delete process.env.__SCHEDULE_ID;
 });
 
 describe("conversations wake untrusted-content input", () => {
@@ -149,9 +155,48 @@ describe("conversations wake untrusted-content input", () => {
   });
 });
 
+describe("conversations wake schedule environment", () => {
+  test("script-mode env threads the run id and the schedule id", async () => {
+    process.env.__SCHEDULE_RUN_ID = "run-9";
+    process.env.__SCHEDULE_ID = "sched-9";
+    const code = await runWake([
+      "wake",
+      "conv-6",
+      "--hint",
+      "Digest ready",
+      "--json",
+    ]);
+    expect(code).toBe(0);
+    expect(lastBody()).toMatchObject({
+      cronRunId: "run-9",
+      scheduleId: "sched-9",
+    });
+  });
+
+  test("outside a script run neither field is sent", async () => {
+    const code = await runWake([
+      "wake",
+      "conv-7",
+      "--hint",
+      "Digest ready",
+      "--json",
+    ]);
+    expect(code).toBe(0);
+    expect(lastBody().cronRunId).toBeUndefined();
+    expect(lastBody().scheduleId).toBeUndefined();
+  });
+});
+
 afterEach(() => {
   if (savedRunId !== undefined) {
     process.env.__SCHEDULE_RUN_ID = savedRunId;
+  } else {
+    delete process.env.__SCHEDULE_RUN_ID;
+  }
+  if (savedScheduleId !== undefined) {
+    process.env.__SCHEDULE_ID = savedScheduleId;
+  } else {
+    delete process.env.__SCHEDULE_ID;
   }
   process.exitCode = 0;
 });

package/src/cli/commands/__tests__/inference-models.test.ts

@@ -72,6 +72,20 @@ describe("models list", () => {
     });
   });
 
+  test("bare `models` runs list", async () => {
+    await run(["models"]);
+    expect(lastIpcCall?.method).toBe("inference_models_list");
+    expect(lastIpcCall?.params).toEqual({ queryParams: {} });
+  });
+
+  test("bare `models --provider` runs list with the filter", async () => {
+    await run(["models", "--provider", "gemini"]);
+    expect(lastIpcCall?.method).toBe("inference_models_list");
+    expect(lastIpcCall?.params).toEqual({
+      queryParams: { provider: "gemini" },
+    });
+  });
+
   test("--json emits structured output", async () => {
     mockIpcResult = {
       ok: true,

package/src/cli/commands/__tests__/inference-profiles.test.ts

@@ -82,6 +82,13 @@ describe("profiles list", () => {
     await run(["profiles", "list"]);
     expect(lastIpcCall?.method).toBe("inference_profiles_list");
   });
+
+  test("bare `profiles` runs list", async () => {
+    mockIpcResult = { ok: true, result: { profiles: [] } };
+    const { exitCode } = await run(["profiles"]);
+    expect(lastIpcCall?.method).toBe("inference_profiles_list");
+    expect(exitCode).toBe(0);
+  });
 });
 
 describe("profiles create", () => {
@@ -127,6 +134,7 @@ describe("profiles create", () => {
       "--thinking",
       "on",
       "--allow-unlisted",
+      "--allow-unavailable",
     ]);
     expect(lastIpcCall?.method).toBe("inference_profiles_create");
     expect(lastIpcCall?.params?.body).toEqual({
@@ -139,13 +147,20 @@ describe("profiles create", () => {
       temperature: 0.5,
       thinking: true,
       allowUnlisted: true,
+      allowUnavailable: true,
     });
   });
 
   test("prints the verification hint on success", async () => {
     mockIpcResult = {
       ok: true,
-      result: { ok: true, name: "p", entry: {}, warnings: [] },
+      result: {
+        ok: true,
+        name: "p",
+        entry: {},
+        warnings: [],
+        verify: 'assistant inference send --profile p "Reply with OK"',
+      },
     };
     const { stdout } = await run([
       "profiles",
@@ -160,6 +175,34 @@ describe("profiles create", () => {
     expect(stdout).toContain("assistant inference send --profile p");
   });
 
+  test("--json passes the daemon's verify hint through verbatim", async () => {
+    mockIpcResult = {
+      ok: true,
+      result: {
+        ok: true,
+        name: "p",
+        entry: { provider: "anthropic" },
+        warnings: ["heads up"],
+        verify: 'assistant inference send --profile p "Reply with OK"',
+      },
+    };
+    const { stdout } = await run([
+      "profiles",
+      "create",
+      "p",
+      "--provider",
+      "anthropic",
+      "--model",
+      "claude-opus-4-8",
+      "--json",
+    ]);
+    const parsed = JSON.parse(stdout.trim());
+    expect(parsed.verify).toBe(
+      'assistant inference send --profile p "Reply with OK"',
+    );
+    expect(parsed.warnings).toEqual(["heads up"]);
+  });
+
   test("rejects a non-numeric --max-tokens before calling the daemon", async () => {
     const { exitCode } = await run([
       "profiles",

package/src/cli/commands/__tests__/inference-providers.test.ts

@@ -360,6 +360,13 @@ describe("providers list output", () => {
     expect(stdout).not.toContain("api_key");
   });
 
+  test("bare `providers` runs list", async () => {
+    mockIpcResult = { ok: true, result: { connections: [] } };
+    const { exitCode } = await run(["providers"]);
+    expect(lastIpcCall()?.method).toBe("inference_provider_connections_list");
+    expect(exitCode).toBe(0);
+  });
+
   test("--json output keeps the full wire shape including auth", async () => {
     mockIpcResult = {
       ok: true,