@vellumai/assistant 0.6.4 → 0.6.6

package/src/tools/tool-manifest.ts

@@ -29,24 +29,6 @@ import { requestSystemPermissionTool } from "./system/request-permission.js";
 import { shellTool } from "./terminal/shell.js";
 import type { Tool } from "./types.js";
 
-// ── External tool registry ───────────────────────────────────────────
-// Skills register their tools here at initialization time so the tool
-// manifest can include them without importing from `../skills/`.
-const externalTools: Tool[] = [];
-
-/**
- * Register tools provided by an external skill. Called during skill
- * initialization.
- */
-export function registerExternalTools(tools: Tool[]): void {
-  externalTools.push(...tools);
-}
-
-/** Return all externally registered tools. */
-export function getExternalTools(): Tool[] {
-  return [...externalTools];
-}
-
 // ── Eager side-effect modules ───────────────────────────────────────
 // These static imports trigger top-level `registerTool()` side effects on
 // first evaluation. The named imports above serve double duty: they give us
@@ -109,9 +91,12 @@ export const explicitTools: Tool[] = [
   recallTool,
   credentialStoreTool,
   notifyParentTool,
-  // Meet tools are registered via registerExternalTools() during skill
-  // initialization — the assistant never imports directly from skills/.
-  ...getExternalTools(),
+  // NOTE: external skill tools (registered via registerExternalTools in
+  // registry.ts) are intentionally NOT included here. `explicitTools` is a
+  // module-level const whose value is fixed at first evaluation, so
+  // external tools registered after this file loads would be missed.
+  // `initializeTools()` in `registry.ts` calls `getExternalTools()`
+  // separately at runtime so late registrations are picked up.
 ];
 
 // ── CES tools (feature-flag gated) ──────────────────────────────────

package/src/tools/types.ts

@@ -31,6 +31,8 @@ export interface ToolExecutionStartEvent extends ToolLifecycleEventBase {
 export interface ToolPermissionPromptEvent extends ToolLifecycleEventBase {
   type: "permission_prompt";
   riskLevel: string;
+  /** Classifier-provided reason explaining why the risk level was assigned (bash/host_bash only). */
+  riskReason?: string;
   reason: string;
   allowlistOptions: AllowlistOption[];
   scopeOptions: ScopeOption[];
@@ -41,6 +43,8 @@ export interface ToolPermissionPromptEvent extends ToolLifecycleEventBase {
 export interface ToolPermissionDeniedEvent extends ToolLifecycleEventBase {
   type: "permission_denied";
   riskLevel: string;
+  /** Classifier-provided reason explaining why the risk level was assigned (bash/host_bash only). */
+  riskReason?: string;
   decision: "deny" | "always_deny";
   reason: string;
   durationMs: number;
@@ -163,6 +167,8 @@ export interface ToolContext {
   callSessionId?: string;
   /** True when the tool invocation was triggered by a user clicking a surface action button (not a regular message). */
   triggeredBySurfaceAction?: boolean;
+  /** True when the user explicitly approved this tool invocation via the interactive permission prompt (not auto-approved by trust rules or temporary overrides). */
+  approvedViaPrompt?: boolean;
   /**
    * True when the invocation is inside a scheduled task run whose
    * `required_tools` array pre-authorized this tool at task-creation time.
@@ -201,6 +207,18 @@ export interface ToolContext {
    * to cdp-inspect or local Playwright.
    */
   transportInterface?: InterfaceId;
+  /**
+   * True when the host browser proxy's sender was overridden by a
+   * registry-routed extension connection (ChromeExtensionRegistry WebSocket).
+   * The CDP factory uses this to distinguish between an SSE-backed proxy
+   * (macOS, no extension) and an extension-backed proxy: only the latter
+   * should suppress desktop-auto cdp-inspect when temporarily unavailable,
+   * because the extension transport was explicitly expected and the
+   * disconnection is transient. An SSE-backed proxy that reports
+   * unavailable (e.g. non-interactive turn) should NOT suppress
+   * cdp-inspect — the proxy was never expected to service browser requests.
+   */
+  hostBrowserRegistryRouted?: boolean;
 }
 
 export interface DiffInfo {
@@ -228,11 +246,22 @@ export interface ToolExecutionResult {
   sensitiveBindings?: SensitiveOutputBinding[];
   /**
    * When true, the agent loop should yield control back to the user after
-   * returning this result. Used by interactive surfaces (tables with action
-   * buttons, file uploads) to force-stop the loop so the LLM cannot bypass
-   * the "wait for user action" instruction.
+   * returning this result — tool results are pushed to history and the loop
+   * breaks without another LLM call. Two callers set this: interactive
+   * surfaces (tables with action buttons, file uploads) that force-stop the
+   * loop so the LLM cannot bypass the "wait for user action" instruction,
+   * and tools like `remember` that expose a `finish_turn` parameter letting
+   * the LLM voluntarily end its turn.
    */
   yieldToUser?: boolean;
+  /** Risk level from the classifier (populated during permission check). */
+  riskLevel?: string;
+  /** Human-readable reason for the risk classification. */
+  riskReason?: string;
+  /** Whether the daemon is running in a containerized (Docker) environment. */
+  isContainerized?: boolean;
+  /** Scope options ladder for the rule editor (narrowest to broadest). */
+  riskScopeOptions?: Array<{ pattern: string; label: string }>;
   /**
    * When present, indicates that a CES tool returned an `approval_required`
    * response. The executor uses the approval bridge to prompt the guardian,
@@ -264,6 +293,10 @@ export interface ProxyApprovalRequest {
     matchingPatterns?: string[];
   };
   sessionId: string;
+  /** HTTP method (plain HTTP only; undefined for HTTPS CONNECT tunnels). */
+  method?: string;
+  /** Curated non-sensitive headers (plain HTTP only). */
+  requestHeaders?: Record<string, string>;
 }
 
 /** Callback for proxy policy decisions requiring user confirmation. Returns true if approved. */
@@ -287,12 +320,14 @@ export interface Tool {
   defaultRiskLevel: RiskLevel;
   /** When set to 'proxy', the tool is forwarded to a connected client rather than executed locally. */
   executionMode?: "local" | "proxy";
-  /** Whether this tool is a core built-in, provided by a skill, or from an MCP server. */
-  origin?: "core" | "skill" | "mcp";
+  /** Whether this tool is a core built-in, provided by a skill, contributed by a plugin, or from an MCP server. */
+  origin?: "core" | "skill" | "mcp" | "plugin";
   /** If origin is 'skill', the ID of the owning skill. */
   ownerSkillId?: string;
   /** If origin is 'mcp', the ID of the owning MCP server. */
   ownerMcpServerId?: string;
+  /** If origin is 'plugin', the name of the owning plugin. */
+  ownerPluginId?: string;
   /** Content-hash of the owning skill's source at registration time. */
   ownerSkillVersionHash?: string;
   /** Whether the owning skill is bundled with the daemon (trusted first-party). */

package/src/tools/verification-control-plane-policy.ts

@@ -28,7 +28,7 @@ const VERIFICATION_PATH_REGEX = /\/v1\/channel-verification-sessions/;
 const COMMAND_TOOLS = new Set(["bash", "host_bash"]);
 
 /** Tools whose `input.url` (string) may contain verification endpoint paths. */
-const URL_TOOLS = new Set(["network_request", "web_fetch", "browser_navigate"]);
+const URL_TOOLS = new Set(["network_request", "web_fetch"]);
 
 /**
  * Normalize a string to defeat common URL obfuscation techniques before matching:

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

@@ -35,6 +35,14 @@ let mockDeepgramConfig = {
   format: "mp3" as "mp3" | "wav" | "opus",
 };
 
+let mockXaiConfig = {
+  voiceId: "eve",
+  language: "auto",
+  format: "mp3" as "mp3" | "wav",
+  sampleRate: 24000,
+  bitRate: 128000,
+};
+
 mock.module("../../config/loader.js", () => ({
   getConfig: () => ({
     services: {
@@ -43,6 +51,7 @@ mock.module("../../config/loader.js", () => ({
           elevenlabs: mockElevenLabsConfig,
           "fish-audio": mockFishAudioConfig,
           deepgram: mockDeepgramConfig,
+          xai: mockXaiConfig,
         },
       },
     },
@@ -53,9 +62,13 @@ mock.module("../../config/loader.js", () => ({
 
 let mockApiKey: string | null = "test-elevenlabs-api-key";
 let mockDeepgramApiKey: string | null = "test-deepgram-api-key";
+let mockXaiApiKey: string | null = "test-xai-api-key";
 
 mock.module("../../security/secure-keys.js", () => ({
-  getSecureKeyAsync: async () => mockApiKey,
+  getSecureKeyAsync: async (key?: string) => {
+    if (key === "credential/xai/api_key") return mockXaiApiKey;
+    return mockApiKey;
+  },
   getProviderKeyAsync: async (provider: string) => {
     if (provider === "deepgram") return mockDeepgramApiKey;
     return mockApiKey;
@@ -110,6 +123,7 @@ import {
   _resetBuiltinRegistration,
   registerBuiltinTtsProviders,
 } from "../providers/register-builtins.js";
+import { createXaiProvider, XaiTtsError } from "../providers/xai-provider.js";
 import type { TtsSynthesisRequest } from "../types.js";
 
 // ---------------------------------------------------------------------------
@@ -141,6 +155,14 @@ beforeEach(() => {
     model: "aura-asteria-en",
     format: "mp3",
   };
+  mockXaiApiKey = "test-xai-api-key";
+  mockXaiConfig = {
+    voiceId: "eve",
+    language: "auto",
+    format: "mp3",
+    sampleRate: 24000,
+    bitRate: 128000,
+  };
   mockSynthesizeWithFishAudio.mockClear();
 });
 
@@ -759,32 +781,237 @@ describe("Deepgram TTS provider adapter", () => {
   });
 });
 
+// ===========================================================================
+// xAI TTS provider adapter
+// ===========================================================================
+
+describe("xAI TTS provider adapter", () => {
+  // -- Interface conformance -----------------------------------------------
+
+  test("has correct provider ID", () => {
+    const provider = createXaiProvider();
+    expect(provider.id).toBe("xai");
+  });
+
+  test("advertises mp3 and wav format support without streaming", () => {
+    const provider = createXaiProvider();
+    expect(provider.capabilities).toEqual({
+      supportsStreaming: false,
+      supportedFormats: ["mp3", "wav"],
+    });
+  });
+
+  // -- Request mapping -----------------------------------------------------
+
+  test("synthesize posts to /v1/tts with correct auth and default body", async () => {
+    const audioPayload = new Uint8Array([0x49, 0x44, 0x33]);
+    let capturedUrl = "";
+    let capturedHeaders: Headers | null = null;
+    let capturedBody = "";
+
+    globalThis.fetch = mock(
+      async (input: RequestInfo | URL, init?: RequestInit) => {
+        capturedUrl = typeof input === "string" ? input : input.toString();
+        capturedHeaders = new Headers(init?.headers);
+        capturedBody = init?.body as string;
+        return new Response(audioPayload, {
+          status: 200,
+          headers: { "Content-Type": "audio/mpeg" },
+        });
+      },
+    ) as unknown as typeof globalThis.fetch;
+
+    const provider = createXaiProvider();
+    await provider.synthesize(makeRequest());
+
+    expect(capturedUrl).toBe("https://api.x.ai/v1/tts");
+    expect(capturedHeaders!.get("Authorization")).toBe(
+      "Bearer test-xai-api-key",
+    );
+    expect(capturedHeaders!.get("Content-Type")).toBe("application/json");
+
+    const body = JSON.parse(capturedBody);
+    expect(body.text).toBe("Hello world");
+    expect(body.voice_id).toBe("eve");
+    expect(body.language).toBe("auto");
+    expect(body.output_format).toEqual({
+      codec: "mp3",
+      sample_rate: 24000,
+      bit_rate: 128000,
+    });
+  });
+
+  test("request voiceId overrides config voiceId", 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({ voiceId: "rex" }));
+
+    const body = JSON.parse(capturedBody);
+    expect(body.voice_id).toBe("rex");
+  });
+
+  test("uses configured voiceId when request has none", async () => {
+    mockXaiConfig.voiceId = "ara";
+    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());
+
+    const body = JSON.parse(capturedBody);
+    expect(body.voice_id).toBe("ara");
+  });
+
+  test("wav config format produces codec=wav without bit_rate", async () => {
+    mockXaiConfig.format = "wav";
+    const audioPayload = new Uint8Array([0x52, 0x49, 0x46, 0x46]);
+    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();
+    const result = await provider.synthesize(makeRequest());
+
+    const body = JSON.parse(capturedBody);
+    expect(body.output_format).toEqual({
+      codec: "wav",
+      sample_rate: 24000,
+    });
+    expect(body.output_format.bit_rate).toBeUndefined();
+    expect(result.contentType).toBe("audio/wav");
+  });
+
+  test("outputFormat=pcm uses codec=pcm and 16 kHz sample rate", async () => {
+    const audioPayload = new Uint8Array([0x00, 0x01, 0x02]);
+    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();
+    const result = await provider.synthesize(
+      makeRequest({ outputFormat: "pcm" }),
+    );
+
+    const body = JSON.parse(capturedBody);
+    expect(body.output_format).toEqual({
+      codec: "pcm",
+      sample_rate: 16000,
+    });
+    expect(body.output_format.bit_rate).toBeUndefined();
+    expect(result.contentType).toBe("audio/pcm");
+  });
+
+  // -- Content type / format -----------------------------------------------
+
+  test("returns audio/mpeg content type for mp3 format", async () => {
+    const audioPayload = new Uint8Array([0x49, 0x44, 0x33]);
+    mockFetchReturning(audioPayload);
+
+    const provider = createXaiProvider();
+    const result = await provider.synthesize(makeRequest());
+
+    expect(result.contentType).toBe("audio/mpeg");
+    expect(result.audio.byteLength).toBeGreaterThan(0);
+  });
+
+  // -- Required config validation ------------------------------------------
+
+  test("throws XAI_TTS_NO_API_KEY when API key is missing", async () => {
+    mockXaiApiKey = null;
+
+    const provider = createXaiProvider();
+
+    try {
+      await provider.synthesize(makeRequest());
+      throw new Error("Expected synthesize to throw");
+    } catch (err) {
+      expect(err).toBeInstanceOf(XaiTtsError);
+      expect((err as XaiTtsError).code).toBe("XAI_TTS_NO_API_KEY");
+      expect((err as XaiTtsError).message).toContain("API key not configured");
+    }
+  });
+
+  // -- Error handling ------------------------------------------------------
+
+  test("throws XAI_TTS_HTTP_ERROR on non-200 response", async () => {
+    mockFetchError(401, "Unauthorized");
+
+    const provider = createXaiProvider();
+
+    try {
+      await provider.synthesize(makeRequest());
+      throw new Error("Expected synthesize to throw");
+    } catch (err) {
+      expect(err).toBeInstanceOf(XaiTtsError);
+      expect((err as XaiTtsError).code).toBe("XAI_TTS_HTTP_ERROR");
+      expect((err as XaiTtsError).statusCode).toBe(401);
+      expect((err as XaiTtsError).message).toContain("Unauthorized");
+    }
+  });
+
+  test("throws XAI_TTS_EMPTY_RESPONSE on empty audio body", async () => {
+    mockFetchReturning(new Uint8Array(0));
+
+    const provider = createXaiProvider();
+
+    try {
+      await provider.synthesize(makeRequest());
+      throw new Error("Expected synthesize to throw");
+    } catch (err) {
+      expect(err).toBeInstanceOf(XaiTtsError);
+      expect((err as XaiTtsError).code).toBe("XAI_TTS_EMPTY_RESPONSE");
+    }
+  });
+});
+
 // ===========================================================================
 // Built-in registration
 // ===========================================================================
 
 describe("registerBuiltinTtsProviders", () => {
-  test("registers elevenlabs, fish-audio, and deepgram providers", () => {
+  test("registers every catalog provider ID", () => {
     registerBuiltinTtsProviders();
 
     const providers = listTtsProviders();
     const ids = providers.map((p) => p.id);
-    expect(ids).toContain("elevenlabs");
-    expect(ids).toContain("fish-audio");
-    expect(ids).toContain("deepgram");
+    for (const id of listCatalogProviderIds()) {
+      expect(ids).toContain(id);
+    }
   });
 
   test("providers are discoverable via getTtsProvider after registration", () => {
     registerBuiltinTtsProviders();
 
-    const el = getTtsProvider("elevenlabs");
-    expect(el.id).toBe("elevenlabs");
-
-    const fa = getTtsProvider("fish-audio");
-    expect(fa.id).toBe("fish-audio");
-
-    const dg = getTtsProvider("deepgram");
-    expect(dg.id).toBe("deepgram");
+    for (const id of listCatalogProviderIds()) {
+      const provider = getTtsProvider(id);
+      expect(provider.id).toBe(id);
+    }
   });
 
   test("idempotent — calling twice does not throw", () => {

package/src/tts/provider-catalog.ts

@@ -158,6 +158,24 @@ const CATALOG: readonly TtsProviderCatalogEntry[] = [
       },
     ],
   },
+  {
+    id: "xai",
+    displayName: "xAI",
+    callMode: "synthesized-play",
+    allowNativeFallback: false,
+    capabilities: {
+      supportsStreaming: false,
+      supportedFormats: ["mp3", "wav"],
+    },
+    secretRequirements: [
+      {
+        credentialStoreKey: "credential/xai/api_key",
+        displayName: "xAI API Key",
+        setCommand:
+          "assistant credentials set --service xai --field api_key <key>",
+      },
+    ],
+  },
 ] as const;
 
 /** Index for O(1) lookup by provider ID. */

package/src/tts/providers/index.ts

@@ -13,6 +13,7 @@ import type { TtsProvider, TtsProviderId } from "../types.js";
 import { createDeepgramProvider } from "./deepgram-provider.js";
 import { createElevenLabsProvider } from "./elevenlabs-provider.js";
 import { createFishAudioProvider } from "./fish-audio-provider.js";
+import { createXaiProvider } from "./xai-provider.js";
 
 // ---------------------------------------------------------------------------
 // Factory type
@@ -39,4 +40,5 @@ export const providerFactories: ReadonlyMap<TtsProviderId, TtsProviderFactory> =
     ["elevenlabs", createElevenLabsProvider],
     ["fish-audio", createFishAudioProvider],
     ["deepgram", createDeepgramProvider],
+    ["xai", createXaiProvider],
   ]);