@vellumai/assistant 0.12.2 → 0.12.3-staging.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/assistant",
-  "version": "0.12.2",
+  "version": "0.12.3-staging.2",
   "license": "MIT",
   "type": "module",
   "exports": {

package/scripts/smoke-desktop-browser-cli.ts

@@ -14,26 +14,18 @@ import { registerBrowserCommand } from "../src/cli/commands/browser.js";
 import { DesktopAutomationLease } from "../src/desktop/desktop-automation-lease.js";
 import {
   desktopChromePath,
-  desktopDependencyInstaller,
+  desktopDependencies,
 } from "../src/desktop/desktop-dependencies.js";
 import { DesktopSessionManager } from "../src/desktop/desktop-session-manager.js";
 import { getAssistantSocketPath } from "../src/ipc/socket-path.js";
 
-if (
-  process.platform !== "linux" ||
-  !process.argv[2] ||
-  !process.env.ASSISTANT_IPC_SOCKET_DIR
-) {
+if (process.platform !== "linux" || !process.env.ASSISTANT_IPC_SOCKET_DIR) {
   throw new Error(
-    "Run in disposable Linux with desktop packages, a temporary ASSISTANT_IPC_SOCKET_DIR and a Chrome executable argument or --install for a cold install.",
+    "Run in a disposable Linux assistant image with a temporary ASSISTANT_IPC_SOCKET_DIR.",
   );
 }
-const coldInstall = process.argv[2] === "--install";
-const executable = coldInstall ? desktopChromePath() : process.argv[2];
-if (coldInstall) {
-  assert.equal(desktopDependencyInstaller.getStatus().state, "required");
-  assert.equal(Bun.which("Xtigervnc"), null);
-}
+const executable = desktopChromePath();
+assert.equal(desktopDependencies.getStatus().state, "ready");
 const directory = await mkdtemp(join(tmpdir(), "desktop-browser-cli-"));
 const manager = new DesktopSessionManager({
   resolveChromePath: async () => executable,
@@ -42,10 +34,9 @@ const manager = new DesktopSessionManager({
   renderWallpaper: async () => null,
 });
 const control = new DesktopAutomationLease({
+  notify: async () => {},
   enabled: () => true,
-  ready: () =>
-    !coldInstall || desktopDependencyInstaller.getStatus().state === "ready",
-  ensureReady: (signal) => desktopDependencyInstaller.ensureReady(signal),
+  ready: () => desktopDependencies.getStatus().state === "ready",
   manager: () => manager,
 });
 const context = {
@@ -181,16 +172,10 @@ try {
     "--allow-private-network",
   );
   assert.equal(navigations, 1);
-  if (coldInstall) {
-    assert.equal(desktopDependencyInstaller.getStatus().state, "ready");
-    assert(
-      setupNotifications >= 3,
-      "Installation progress must reach the viewer",
-    );
-    console.error(
-      "PASS: one CLI navigate installed desktop and Chrome from scratch, then loaded the requested page once",
-    );
-  }
+  assert.equal(setupNotifications, 0);
+  console.error(
+    "PASS: baked desktop opened the requested page without installation",
+  );
   const snapshot = await cli("snapshot");
   await cli(
     "type",

package/scripts/smoke-desktop-window-theme.ts

@@ -91,15 +91,14 @@ try {
     `<bindings xmlns="http://openbox.org/3.4/rc">${mouse}${keyboard}</bindings>`,
   );
   const configDir = join(directory, "managed & theme");
-  const config = writeDesktopWindowTheme(configDir, home, "#53b7aa");
+  const config = writeDesktopWindowTheme(configDir, home);
   const expanded = run("xmllint", "--xinclude", config);
   assert(
     expanded.includes("NextWindow") && expanded.includes("Move"),
     "Relative includes must retain the actual keyboard and mouse bindings",
   );
   assert.equal(await readFile(sourcePath, "utf8"), source);
-  writeDesktopWindowTheme(configDir, home, "#bc7799");
-  writeDesktopWindowTheme(configDir, home, "#53b7aa");
+  writeDesktopWindowTheme(configDir, home);
   assert.equal(await readFile(sourcePath, "utf8"), source);
   const blocked = join(directory, "blocked");
   await writeFile(blocked, "not a directory");

package/scripts/sync-llm-catalog.ts

@@ -86,6 +86,9 @@ function projectModel(model: CatalogModel): Record<string, unknown> {
   if (model.supportsToolUse !== undefined) {
     projected.supportsToolUse = model.supportsToolUse;
   }
+  if (model.supportsText !== undefined) {
+    projected.supportsText = model.supportsText;
+  }
   if (model.pricing !== undefined) {
     projected.pricing = model.pricing;
   }

package/scripts/voice-ttft-spike.ts

@@ -15,7 +15,7 @@
  *   full-quality  quality-optimized, full prompt + tools (pre-flag brain)
  *
  * Run with the daemon's environment so the managed connection resolves:
- *   VELLUM_WORKSPACE_DIR=<daemon workspace> CES_LOCAL_SOCKET=<socket> \
+ *   VELLUM_WORKSPACE_DIR=<daemon workspace> \
  *     bun run scripts/voice-ttft-spike.ts [--trials 3] [--variants a,b]
  *
  * Outside the daemon env, credentials fall back to the encrypted file
@@ -217,7 +217,7 @@ async function main(): Promise<void> {
     if (!provider) {
       console.error(
         `${spec.name}: no provider resolved (managed credentials missing? ` +
-          `run with the daemon's VELLUM_WORKSPACE_DIR + CES_LOCAL_SOCKET)`,
+          `run with the daemon's VELLUM_WORKSPACE_DIR)`,
       );
       continue;
     }

package/src/__tests__/agent-loop-output-hooks.test.ts

@@ -6,7 +6,7 @@
  */
 import { beforeEach, describe, expect, test } from "bun:test";
 
-import type { AgentEvent } from "../agent/loop.js";
+import type { AgentEvent, PreparedModelCall } from "../agent/loop.js";
 import { AgentLoop } from "../agent/loop.js";
 import type {
   PostModelCallContext,
@@ -18,12 +18,14 @@ import type {
   ContentBlock,
   Message,
   ProviderResponse,
+  ToolDefinition,
 } from "../providers/types.js";
 import {
   createMockProvider,
   textResponse,
   toolUseResponse,
 } from "./helpers/mock-provider.js";
+import { setConfig } from "./helpers/set-config.js";
 
 const userMessage: Message = {
   role: "user",
@@ -91,6 +93,7 @@ function registerOutputHookPlugin(hooks: {
 describe("agent loop output hooks", () => {
   beforeEach(() => {
     resetPluginRegistryAndRegisterDefaults();
+    setConfig("llm", {});
   });
 
   test("post-model-call transforms the persisted message content", async () => {
@@ -403,6 +406,152 @@ describe("agent loop output hooks", () => {
     expect(calls[0].options?.config?.overrideProfile).toBe("fast-profile");
   });
 
+  test("prepared model call carries the post-hook route and wire tool surface", async () => {
+    registerOutputHookPlugin({
+      preModelCall: (ctx) => {
+        ctx.systemPrompt = `${ctx.systemPrompt ?? ""} [EDITED]`;
+        ctx.modelProfile = "fast-profile";
+      },
+    });
+    const tool: ToolDefinition = {
+      name: "dynamic_tool",
+      description: "Dynamic",
+      input_schema: { type: "object" },
+    };
+    const { provider, calls } = createMockProvider([textResponse("hi")]);
+    Object.assign(provider, { supportsNativeWebSearch: true });
+    const loop = new AgentLoop({
+      provider,
+      systemPrompt: "base prompt",
+      conversationId: "test-conversation",
+      config: { enableNativeWebSearch: true },
+      resolveTools: () => [tool],
+    });
+    let prepared: PreparedModelCall | undefined;
+
+    await loop.run({
+      requestId: "test-request",
+      messages: [userMessage],
+      onEvent: collect([]),
+      callSite: "mainAgent",
+      overrideProfile: "conversation-profile",
+      forceOverrideProfile: true,
+      onModelCallPrepared: (value) => {
+        prepared = value;
+      },
+      trust: { sourceChannel: "vellum", trustClass: "unknown" },
+    });
+
+    expect(prepared).toMatchObject({
+      callSite: "mainAgent",
+      overrideProfile: "fast-profile",
+      forceOverrideProfile: true,
+      systemPrompt: "base prompt [EDITED]",
+    });
+    expect(prepared?.tools.map((item) => item.name)).toEqual([
+      "dynamic_tool",
+      "web_search",
+    ]);
+    expect(calls[0].tools).toEqual(prepared?.tools);
+  });
+
+  test("prepared model call carries the finalized cache policy", async () => {
+    setConfig("llm", {
+      callSites: { mainAgent: { disableCache: true } },
+    });
+    const { provider } = createMockProvider([textResponse("hi")]);
+    const loop = new AgentLoop({
+      provider,
+      systemPrompt: "base prompt",
+      conversationId: "test-conversation",
+    });
+    let prepared: PreparedModelCall | undefined;
+
+    await loop.run({
+      requestId: "test-request",
+      messages: [userMessage],
+      onEvent: collect([]),
+      callSite: "mainAgent",
+      onModelCallPrepared: (value) => {
+        prepared = value;
+      },
+      trust: { sourceChannel: "vellum", trustClass: "unknown" },
+    });
+
+    expect(prepared?.disableCache).toBe(true);
+  });
+
+  test("prepared model call preserves explicit system-prompt removal", async () => {
+    registerOutputHookPlugin({
+      preModelCall: (ctx) => {
+        ctx.systemPrompt = null;
+      },
+    });
+    const { provider, calls } = createMockProvider([textResponse("hi")]);
+    const loop = new AgentLoop({
+      provider,
+      systemPrompt: "base prompt",
+      conversationId: "test-conversation",
+    });
+    let prepared: PreparedModelCall | undefined;
+
+    await loop.run({
+      requestId: "test-request",
+      messages: [userMessage],
+      onEvent: collect([]),
+      callSite: "mainAgent",
+      onModelCallPrepared: (value) => {
+        prepared = value;
+      },
+      trust: { sourceChannel: "vellum", trustClass: "unknown" },
+    });
+
+    expect(prepared?.systemPrompt).toBeNull();
+    expect(calls[0].options?.systemPrompt).toBeUndefined();
+  });
+
+  test("inference routing preserves the semantic call site for hooks and events", async () => {
+    const preModelCallSites: Array<string | null> = [];
+    const postModelCallSites: Array<string | null> = [];
+    registerOutputHookPlugin({
+      preModelCall: (ctx) => {
+        preModelCallSites.push(ctx.callSite);
+      },
+      postModelCall: (ctx) => {
+        postModelCallSites.push(ctx.callSite);
+      },
+    });
+    const { provider, calls } = createMockProvider([textResponse("hi")]);
+    const loop = new AgentLoop({
+      provider,
+      systemPrompt: "system",
+      conversationId: "test-conversation",
+    });
+    const events: AgentEvent[] = [];
+    let prepared: PreparedModelCall | undefined;
+
+    await loop.run({
+      requestId: "test-request",
+      messages: [userMessage],
+      onEvent: collect(events),
+      callSite: "callAgent",
+      inferenceCallSite: "mainAgent",
+      onModelCallPrepared: (value) => {
+        prepared = value;
+      },
+      trust: { sourceChannel: "vellum", trustClass: "unknown" },
+    });
+
+    expect(calls[0].options?.config?.callSite).toBe("mainAgent");
+    expect(prepared?.callSite).toBe("mainAgent");
+    expect(preModelCallSites).toEqual(["callAgent"]);
+    expect(postModelCallSites).toEqual(["callAgent"]);
+    expect(events).toContainEqual({
+      type: "llm_call_started",
+      callSite: "callAgent",
+    });
+  });
+
   test("pre-model-call seeds modelProfile from the resolved override and clearing it drops the override", async () => {
     // GIVEN a hook that observes the seeded override and then clears it
     let seeded: string | null | undefined;

package/src/__tests__/agent-loop-provider-error-recording.test.ts

@@ -3,17 +3,19 @@
  *
  * When the provider call throws (provider rejected the request before
  * returning a usable response), the loop must emit a `provider_error` event
- * carrying the loop-level raw request and the thrown error so downstream
- * consumers can persist an `llm_request_logs` row. Without this, rejected
- * calls leave nothing in the LLM inspector — only a pino log line.
+ * carrying the inspectable wire request (when the throw attached one) and
+ * the thrown error so downstream consumers can persist an `llm_request_logs`
+ * row. Without this, rejected calls leave nothing in the LLM inspector —
+ * only a pino log line.
  *
  * Coverage:
- *  - Emits `provider_error` with `rawRequest`, `error`, and `actualProvider`
- *    when the provider throws a `ProviderError`.
- *  - `rawRequest` carries the message history, tools, and system prompt the
- *    loop attempted to send — so the row replays/debugs cleanly.
- *  - `actualProvider` echoes `ProviderError.provider` when available, falling
- *    back to `provider.name` for non-ProviderError throws.
+ *  - Emits `provider_error` with `error` and `actualProvider` when the
+ *    provider throws a `ProviderError`.
+ *  - `rawRequest` is `ProviderError.rawRequest` when present, and stays
+ *    unset when the throw did not attach a wire payload. The loop does
+ *    not invent a messages/tools/systemPrompt snapshot.
+ *  - `actualProvider` echoes `ProviderError.provider` when available, even
+ *    if the wrapping `provider.name` is a different default transport.
  *  - The error is still re-thrown internally (the existing `error` event
  *    still fires after the new `provider_error` event), preserving the
  *    outer-catch behavior (abort/Sentry/break).
@@ -73,7 +75,7 @@ function makeThrowingProvider(
 }
 
 describe("AgentLoop provider_error event emission", () => {
-  test("emits provider_error with loop-level rawRequest when provider throws ProviderError", async () => {
+  test("emits provider_error without inventing a rawRequest snapshot", async () => {
     const thrown = new ProviderError(
       "Anthropic API error (429): rate limited",
       "anthropic",
@@ -107,16 +109,81 @@ describe("AgentLoop provider_error event emission", () => {
     }
     expect(providerErrorEvent.error).toBe(thrown);
     expect(providerErrorEvent.actualProvider).toBe("anthropic");
+    expect(providerErrorEvent.rawRequest).toBeUndefined();
+  });
+
+  test("forwards ProviderError.rawRequest on the provider_error event", async () => {
+    const wirePayload = {
+      model: "qwen/qwen3-8b",
+      directions: { serious: 0.8 },
+    };
+    const thrown = new ProviderError(
+      "Vellum API error (400): directions are not loaded",
+      "vellum",
+      400,
+      {
+        rawRequest: wirePayload,
+        rawBody: '{"detail":"directions are not loaded"}',
+      },
+    );
+    const { provider } = makeThrowingProvider("fireworks", () => thrown);
+
+    const events: AgentEvent[] = [];
+    const loop = new AgentLoop({
+      provider: provider,
+      systemPrompt: "system",
+      conversationId: "test-conversation",
+    });
+
+    await loop.run({
+      requestId: "test-request",
+      messages: [{ role: "user", content: [{ type: "text", text: "hi" }] }],
+      onEvent: (e) => {
+        events.push(e);
+      },
+      trust: { sourceChannel: "vellum", trustClass: "unknown" },
+    });
+
+    const providerErrorEvent = events.find((e) => e.type === "provider_error");
+    expect(providerErrorEvent).toBeDefined();
+    if (providerErrorEvent?.type !== "provider_error") {
+      throw new Error("type narrowing");
+    }
+    expect(providerErrorEvent.actualProvider).toBe("vellum");
+    expect(providerErrorEvent.rawRequest).toEqual(wirePayload);
+  });
+
+  test("actualProvider uses ProviderError.provider, not the wrapper name", async () => {
+    const thrown = new ProviderError(
+      "Vellum API error (400): directions are not loaded",
+      "vellum",
+      400,
+    );
+    const { provider } = makeThrowingProvider("fireworks", () => thrown);
+
+    const events: AgentEvent[] = [];
+    const loop = new AgentLoop({
+      provider: provider,
+      systemPrompt: "system",
+      conversationId: "test-conversation",
+    });
+
+    await loop.run({
+      requestId: "test-request",
+      messages: [{ role: "user", content: [{ type: "text", text: "hi" }] }],
+      onEvent: (e) => {
+        events.push(e);
+      },
+      trust: { sourceChannel: "vellum", trustClass: "unknown" },
+    });
 
-    // rawRequest should carry the loop-level abstract shape: messages,
-    // tools, systemPrompt, and the provider name we tried to dispatch
-    // through. The provider-specific shape (e.g. Gemini's `contents`) is
-    // never built because the provider threw before returning it.
-    const raw = providerErrorEvent.rawRequest as Record<string, unknown>;
-    expect(raw.provider).toBe("anthropic");
-    expect(raw.systemPrompt).toBe("you are a helpful assistant");
-    expect(Array.isArray(raw.messages)).toBe(true);
-    expect((raw.messages as Message[])[0].role).toBe("user");
+    const providerErrorEvent = events.find((e) => e.type === "provider_error");
+    expect(providerErrorEvent).toBeDefined();
+    if (providerErrorEvent?.type !== "provider_error") {
+      throw new Error("type narrowing");
+    }
+    expect(providerErrorEvent.actualProvider).toBe("vellum");
+    expect(providerErrorEvent.rawRequest).toBeUndefined();
   });
 
   test("error event still fires after provider_error (outer catch behavior unchanged)", async () => {
@@ -185,6 +252,7 @@ describe("AgentLoop provider_error event emission", () => {
     // `provider` column populated even for surprise errors.
     expect(providerErrorEvent.actualProvider).toBe("openai");
     expect(providerErrorEvent.error).toBe(thrown);
+    expect(providerErrorEvent.rawRequest).toBeUndefined();
   });
 
   test("does NOT emit provider_error on user-aborted runs", async () => {