@vellumai/assistant 0.11.2 → 0.11.3-dev.202608080427.92f668a

package/src/tools/tool-approval-handler.ts

@@ -39,6 +39,7 @@ import { computeToolApprovalDigest } from "../security/tool-approval-digest.js";
 import { recordToolDenied, recordToolError } from "../telemetry/tool-audit.js";
 import { getLogger } from "../util/logger.js";
 import { resolveExecutionTarget } from "./execution-target.js";
+import { safeTimeoutMs } from "./execution-timeout.js";
 import { channelCoordinatesFromToolContext } from "./policy-context.js";
 import { getAllTools, getTool, getToolOwner } from "./registry.js";
 import { isSideEffectTool } from "./side-effects.js";
@@ -127,9 +128,39 @@ export function buildInactiveToolMessage(args: {
 
 /** Default polling interval for inline grant wait (ms). */
 const TC_GRANT_WAIT_INTERVAL_MS = 500;
-/** Default maximum wait time for inline grant wait (ms). */
+/**
+ * Fallback maximum wait for the inline grant wait (ms), used only when the
+ * deployed config cannot be read. The governing budget is
+ * `timeouts.permissionTimeoutSec` (see {@link resolveInlineGrantWaitMs}).
+ */
 export const TC_GRANT_WAIT_MAX_MS = 60_000;
 
+/**
+ * Resolve the wait budget for an escalated tool grant.
+ *
+ * A guardian answering an escalated tool call is making the same decision as a
+ * local user answering a permission prompt, so both paths spend the same
+ * budget: `timeouts.permissionTimeoutSec` (read by `permissions/prompter.ts`).
+ * If anything, this path needs the larger share of it: the prompter's user
+ * already has the prompt on screen, while the guardian is notified
+ * out-of-band and has to context-switch before deciding.
+ *
+ * Falls back to {@link TC_GRANT_WAIT_MAX_MS} rather than the tool-execution
+ * default on a non-positive value, so a bad config can never collapse the
+ * window to zero and auto-deny every escalation.
+ *
+ * Exported because the grant resolver sizes its `inline_wait_active` staleness
+ * threshold off this same budget: if the two drift, an approval arriving while
+ * a waiter is still live gets misread as a dead waiter and the requester is
+ * told to retry a call that is about to resume on its own.
+ */
+export function resolveInlineGrantWaitMs(): number {
+  return safeTimeoutMs(
+    getConfig().timeouts.permissionTimeoutSec,
+    TC_GRANT_WAIT_MAX_MS,
+  );
+}
+
 /**
  * Inline wait result for trusted-contact grant polling.
  * - `granted`: a grant was minted and consumed within the wait window.
@@ -152,13 +183,16 @@ export type InlineGrantWaitOutcome =
  * and atomically consume the grant).
  *
  * Only called for trusted_contact actors with valid guardian bindings.
+ *
+ * `options.maxWaitMs` overrides the wait budget; omitting it spends the
+ * configured one from {@link resolveInlineGrantWaitMs}.
  */
 export async function waitForInlineGrant(
   escalationRequestId: string,
   consumeParams: Parameters<typeof consumeGrantForInvocation>[0],
   options?: { maxWaitMs?: number; intervalMs?: number; signal?: AbortSignal },
 ): Promise<InlineGrantWaitOutcome> {
-  const maxWait = options?.maxWaitMs ?? TC_GRANT_WAIT_MAX_MS;
+  const maxWait = options?.maxWaitMs ?? resolveInlineGrantWaitMs();
   const interval = options?.intervalMs ?? TC_GRANT_WAIT_INTERVAL_MS;
   const signal = options?.signal;
   const deadline = Date.now() + maxWait;
@@ -592,9 +626,16 @@ export type PreExecutionGateResult =
     }
   | { allowed: false; result: ToolExecutionResult };
 
-/** Configuration for the inline grant wait behavior. */
+/**
+ * Overrides for the inline grant wait behavior. Production leaves this empty
+ * so the wait spends the configured budget; tests inject short waits to keep
+ * escalation cases fast.
+ */
 export interface InlineGrantWaitConfig {
-  /** Maximum time to wait for guardian approval (ms). Defaults to TC_GRANT_WAIT_MAX_MS. */
+  /**
+   * Maximum time to wait for guardian approval (ms). Defaults to the budget
+   * from {@link resolveInlineGrantWaitMs}.
+   */
   maxWaitMs?: number;
   /** Polling interval during the wait (ms). Defaults to TC_GRANT_WAIT_INTERVAL_MS. */
   intervalMs?: number;

package/src/tools/types.ts

@@ -1,5 +1,6 @@
 import { z } from "zod";
 
+import type { AnsweredQuestion } from "../api/events/question-answered.js";
 import type { InterfaceId } from "../channels/types.js";
 import type { LLMCallSite } from "../config/schemas/llm.js";
 import type { ToolActivityMetadata } from "../daemon/message-types/web-activity.js";
@@ -133,6 +134,14 @@ export interface ToolExecutionResult {
   /** Structured activity metadata for client rendering (web search, web fetch, etc).
    *  Populated by daemon-internal tools; plugins must not set this. */
   activityMetadata?: ToolActivityMetadata;
+  /**
+   * Typed side channel from the `ask_question` executor to the agent loop: the
+   * questions asked and the answers the user gave. The loop forwards it on the
+   * `tool_result` event and persists it on the tool_use block, so the answered
+   * card renders live and survives a history reopen instead of the decision
+   * disappearing with the interactive prompt. Set only by `ask_question`.
+   */
+  answeredQuestion?: AnsweredQuestion;
 }
 
 export type ProxyToolResolver = (
@@ -407,6 +416,14 @@ export interface ToolContext {
    * @legacy
    */
   overrideProfile?: string;
+  /**
+   * The firing's `cron_runs.id` when a schedule triggered this turn, `null`
+   * otherwise. Tools that spawn further LLM work (`subagent_spawn`,
+   * `subagent_message`) forward it so the delegated usage rows carry the same
+   * stamp and attribute to the firing rather than dropping out of schedule
+   * cost reporting.
+   */
+  cronRunId?: string | null;
   /**
    * The LLM call site of the turn currently executing this tool (`mainAgent`,
    * `heartbeatAgent`, scheduled work, etc.). `subagent_spawn` reads it to
@@ -418,10 +435,12 @@ export interface ToolContext {
   invokingCallSite?: LLMCallSite;
   /**
    * Canonical principal ID of the actor on whose behalf this tool invocation
-   * is running. Sourced from `conversation.trustContext.guardianPrincipalId`.
+   * is running — the turn's actor principal, falling back to the trust
+   * context's `guardianPrincipalId` (see `resolveTurnActorPrincipalId`).
    * Used by host proxies to bind cross-client targeted execution to the same
-   * authenticated user identity. May be undefined for legacy/internal flows
-   * with no resolved actor identity.
+   * authenticated user identity, so it must resolve to the SAME principal a
+   * desktop client registers with on its SSE stream. May be undefined for
+   * legacy/internal flows with no resolved actor identity.
    * @legacy
    */
   sourceActorPrincipalId?: string;

package/src/tools/ui-surface/surface-shape-docs.ts

@@ -132,7 +132,7 @@ export const SURFACE_SHAPE_DOCS: Record<string, SurfaceShapeDoc> = {
   oauth_connect: {
     purpose: "managed OAuth connection button for an integration account",
     shape:
-      "{ providerKey, displayName?, description?, logoUrl? } — managed OAuth connection CTA; use when the task needs a managed integration account (Google, Linear, GitHub, ...) instead of settings or shell OAuth. Do not include OAuth scopes; managed providers use the platform's configured scopes",
+      "{ providerKey, requestedScopes?, displayName?, description?, logoUrl? }: managed OAuth connection CTA; use when the task needs a managed integration account (Google, Linear, GitHub, ...) instead of settings or shell OAuth. requestedScopes is an optional FULL replacement set of OAuth scopes: when set, the connection is granted exactly these scopes instead of the platform defaults, so include every scope the connection should keep; omit it to use the platform's default scopes",
     missingContent: (data) =>
       isNonEmptyString(data.providerKey)
         ? null

package/src/tools/ui-surface/visual-validation.ts

@@ -79,8 +79,10 @@ export const WIDGET_TOKEN_PROPERTIES: readonly string[] = [
   // System / status
   "--system-positive-strong",
   "--system-positive-weak",
+  "--system-positive-on-weak",
   "--system-negative-strong",
   "--system-negative-weak",
+  "--system-negative-on-weak",
   "--system-negative-hover",
   "--system-mid-strong",
   "--system-mid-weak",

package/src/tts/__tests__/provider-adapters.test.ts

@@ -549,6 +549,81 @@ describe("ElevenLabs TTS provider adapter", () => {
 
     const body = JSON.parse(capturedBody);
     expect(body.model_id).toBe("eleven_flash_v2_5");
+    expect("language_code" in body).toBe(false);
+  });
+
+  test("synthesizeStream sends language_code when the effective model supports enforcement", async () => {
+    let capturedBody = "";
+
+    globalThis.fetch = mock(
+      async (_input: RequestInfo | URL, init?: RequestInit) => {
+        capturedBody = init?.body as string;
+        return new Response(streamOf(new Uint8Array([0x01])), { status: 200 });
+      },
+    ) as unknown as typeof globalThis.fetch;
+
+    const provider = createElevenLabsProvider();
+    await provider.synthesizeStream!(makeRequest({ language: "hi" }), () => {});
+
+    const body = JSON.parse(capturedBody);
+    expect(body.model_id).toBe("eleven_flash_v2_5");
+    expect(body.language_code).toBe("hi");
+  });
+
+  test("maps the tl subtag to the fil code the v2.5 roster spells Filipino with", async () => {
+    let capturedBody = "";
+
+    globalThis.fetch = mock(
+      async (_input: RequestInfo | URL, init?: RequestInit) => {
+        capturedBody = init?.body as string;
+        return new Response(streamOf(new Uint8Array([0x01])), { status: 200 });
+      },
+    ) as unknown as typeof globalThis.fetch;
+
+    const provider = createElevenLabsProvider();
+    await provider.synthesizeStream!(makeRequest({ language: "tl" }), () => {});
+
+    const body = JSON.parse(capturedBody);
+    expect(body.model_id).toBe("eleven_flash_v2_5");
+    expect(body.language_code).toBe("fil");
+  });
+
+  test("omits language_code for a language the v2.5 models do not support", async () => {
+    let capturedBody = "";
+
+    globalThis.fetch = mock(
+      async (_input: RequestInfo | URL, init?: RequestInit) => {
+        capturedBody = init?.body as string;
+        return new Response(streamOf(new Uint8Array([0x01])), { status: 200 });
+      },
+    ) as unknown as typeof globalThis.fetch;
+
+    const provider = createElevenLabsProvider();
+    await provider.synthesizeStream!(makeRequest({ language: "he" }), () => {});
+
+    const body = JSON.parse(capturedBody);
+    expect(body.model_id).toBe("eleven_flash_v2_5");
+    expect("language_code" in body).toBe(false);
+  });
+
+  test("omits language_code when the configured model does not support enforcement", async () => {
+    mockElevenLabsConfig.voiceModelId = "eleven_multilingual_v2";
+    seedTtsConfig();
+    let capturedBody = "";
+
+    globalThis.fetch = mock(
+      async (_input: RequestInfo | URL, init?: RequestInit) => {
+        capturedBody = init?.body as string;
+        return new Response(streamOf(new Uint8Array([0x01])), { status: 200 });
+      },
+    ) as unknown as typeof globalThis.fetch;
+
+    const provider = createElevenLabsProvider();
+    await provider.synthesizeStream!(makeRequest({ language: "hi" }), () => {});
+
+    const body = JSON.parse(capturedBody);
+    expect(body.model_id).toBe("eleven_multilingual_v2");
+    expect("language_code" in body).toBe(false);
   });
 
   test("synthesizeStream respects configured voiceModelId over flash default", async () => {
@@ -1179,6 +1254,22 @@ describe("Deepgram TTS provider adapter", () => {
     expect(body.text).toBe("Hello world");
   });
 
+  test("request voiceId overrides the configured Deepgram model", async () => {
+    let capturedUrl = "";
+    globalThis.fetch = mock(async (input: RequestInfo | URL) => {
+      capturedUrl = typeof input === "string" ? input : input.toString();
+      return new Response(new Uint8Array([0x49, 0x44, 0x33]), { status: 200 });
+    }) as unknown as typeof globalThis.fetch;
+
+    const provider = createDeepgramProvider();
+    await provider.synthesize(makeRequest({ voiceId: "aura-2-thalia-en" }));
+    expect(capturedUrl).toContain("model=aura-2-thalia-en");
+
+    // A blank request voiceId falls back to the configured model.
+    await provider.synthesize(makeRequest({ voiceId: "  " }));
+    expect(capturedUrl).toContain("model=aura-asteria-en");
+  });
+
   test("uses linear16 encoding with container=none and sample_rate=16000 when outputFormat is pcm", async () => {
     const audioPayload = new Uint8Array([0x00, 0x01, 0x02]);
     let capturedUrl = "";
@@ -1685,6 +1776,42 @@ describe("xAI TTS provider adapter", () => {
     expect(body.voice_id).toBe("ara");
   });
 
+  test("request language overrides config language", async () => {
+    const audioPayload = new Uint8Array([0x49, 0x44, 0x33]);
+    let capturedBody = "";
+
+    globalThis.fetch = mock(
+      async (_input: RequestInfo | URL, init?: RequestInit) => {
+        capturedBody = init?.body as string;
+        return new Response(audioPayload, { status: 200 });
+      },
+    ) as unknown as typeof globalThis.fetch;
+
+    const provider = createXaiProvider();
+    await provider.synthesize(makeRequest({ language: "hi" }));
+
+    const body = JSON.parse(capturedBody);
+    expect(body.language).toBe("hi");
+  });
+
+  test("keeps configured language for a request code outside the code-switching roster", async () => {
+    const audioPayload = new Uint8Array([0x49, 0x44, 0x33]);
+    let capturedBody = "";
+
+    globalThis.fetch = mock(
+      async (_input: RequestInfo | URL, init?: RequestInit) => {
+        capturedBody = init?.body as string;
+        return new Response(audioPayload, { status: 200 });
+      },
+    ) as unknown as typeof globalThis.fetch;
+
+    const provider = createXaiProvider();
+    await provider.synthesize(makeRequest({ language: "th" }));
+
+    const body = JSON.parse(capturedBody);
+    expect(body.language).toBe("auto");
+  });
+
   test("wav config format produces codec=wav without bit_rate", async () => {
     mockXaiConfig.format = "wav";
     seedTtsConfig();
@@ -1902,6 +2029,26 @@ describe("xAI TTS provider adapter", () => {
       expect(capturedSocketOptions().url).toContain("sample_rate=22050");
     });
 
+    test("request language overrides config language in the stream URL", async () => {
+      const provider = createXaiProvider();
+      await provider.synthesizeStream!(
+        makeRequest({ language: "es" }),
+        () => {},
+      );
+
+      expect(capturedSocketOptions().url).toContain("language=es");
+    });
+
+    test("keeps configured language in the stream URL for an out-of-roster request code", async () => {
+      const provider = createXaiProvider();
+      await provider.synthesizeStream!(
+        makeRequest({ language: "th" }),
+        () => {},
+      );
+
+      expect(capturedSocketOptions().url).toContain("language=auto");
+    });
+
     test("mp3 requests carry codec=mp3 and bit_rate and resolve audio/mpeg", async () => {
       const provider = createXaiProvider();
       const result = await provider.synthesizeStream!(makeRequest(), () => {});