@vellumai/assistant 0.8.1 → 0.8.2

package/scripts/sync-web-search-catalog.ts

@@ -1,17 +1,24 @@
 #!/usr/bin/env bun
 /**
- * Generate `meta/web-search-provider-catalog.json` from the canonical
- * `SEARCH_PROVIDER_CATALOG` in
+ * Generate the client-facing web-search-provider catalog JSON from the
+ * canonical `SEARCH_PROVIDER_CATALOG` in
  * `assistant/src/providers/search-provider-catalog.ts`.
  *
- * Companion to `sync-llm-catalog.ts`. The meta JSON is the cross-package
- * artifact consumed by:
+ * Two byte-identical copies are written:
+ *   - `meta/web-search-provider-catalog.json` — primary checked-in artifact,
+ *      consumed by:
+ *        - `cli/src/__tests__/search-provider-env-var-parity.test.ts`
+ *          (drift guard for the CLI's hardcoded env-var mirror).
+ *        - Downstream `vellum-assistant-platform/web/src/lib/generated/
+ *          web-search-provider-catalog.json` (manually sync'd today; the
+ *          scheduled sync workflow is a planned follow-up).
+ *   - `clients/shared/Resources/web-search-provider-catalog.json` — SwiftPM
+ *      resource bundled into `VellumAssistantShared`. SwiftPM cannot reach
+ *      files outside a target's source directory, so this mirror is
+ *      necessary; both files are produced by the same generator and
+ *      asserted equal by the parity test, making drift impossible.
  *
- *   - `cli/src/__tests__/search-provider-env-var-parity.test.ts`
- *     (drift guard for the CLI's hardcoded env-var mirror).
- *   - Downstream `vellum-assistant-platform/web/src/lib/generated/
- *     web-search-provider-catalog.json` (manually sync'd today; scheduled
- *     sync workflow is a planned follow-up).
+ * Companion to `sync-llm-catalog.ts`; same dual-write pattern.
  *
  * Usage:
  *   cd assistant && bun run scripts/sync-web-search-catalog.ts
@@ -20,7 +27,7 @@
  */
 
 import { readFile, writeFile } from "node:fs/promises";
-import { join, resolve } from "node:path";
+import { join, relative, resolve } from "node:path";
 
 import {
   SEARCH_PROVIDER_CATALOG,
@@ -28,7 +35,10 @@ import {
 } from "../src/providers/search-provider-catalog.js";
 
 const ROOT = resolve(import.meta.dir, "../..");
-const OUTPUT_PATH = join(ROOT, "meta/web-search-provider-catalog.json");
+const OUTPUT_PATHS = [
+  join(ROOT, "meta/web-search-provider-catalog.json"),
+  join(ROOT, "clients/shared/Resources/web-search-provider-catalog.json"),
+] as const;
 
 /**
  * Bumped when the *shape* of the client catalog JSON changes in a way
@@ -84,24 +94,36 @@ async function main(): Promise<void> {
   const next = generate();
 
   if (checkMode) {
-    let current = "";
-    try {
-      current = await readFile(OUTPUT_PATH, "utf8");
-    } catch {
-      // File doesn't exist yet — treat as stale.
-    }
-    if (current !== next) {
-      console.error(
-        `\n${OUTPUT_PATH} is out of sync with SEARCH_PROVIDER_CATALOG.\n` +
-          `Run: cd assistant && bun run sync:web-search-catalog\n`,
-      );
-      process.exit(1);
+    let anyStale = false;
+    for (const path of OUTPUT_PATHS) {
+      const rel = relative(ROOT, path);
+      let existing = "";
+      try {
+        existing = await readFile(path, "utf-8");
+      } catch {
+        console.error(
+          `${rel} does not exist. Run: bun run sync:web-search-catalog`,
+        );
+        anyStale = true;
+        continue;
+      }
+      if (existing !== next) {
+        console.error(
+          `${rel} is stale. Run: bun run sync:web-search-catalog`,
+        );
+        anyStale = true;
+        continue;
+      }
+      console.log(`${rel} is up to date.`);
     }
+    if (anyStale) process.exit(1);
     return;
   }
 
-  await writeFile(OUTPUT_PATH, next, "utf8");
-  console.log(`Wrote ${OUTPUT_PATH}`);
+  for (const path of OUTPUT_PATHS) {
+    await writeFile(path, next, "utf-8");
+    console.log(`Wrote ${relative(ROOT, path)}`);
+  }
 }
 
 await main();

package/src/__tests__/agent-image-optimize.test.ts

@@ -14,10 +14,18 @@ describe("shouldRescaleImage", () => {
     expect(shouldRescaleImage({ width: 1200, height: 800 }, 50_000)).toBe(
       false,
     );
-    // Even a large file is fine as long as dimensions are within limits —
-    // Anthropic's constraint is per-side pixels, not bytes.
+  });
+
+  it("rescales when raw bytes would inflate past Anthropic's 5 MB base64 cap", () => {
+    // Regression: an oversized image retained across compaction was rejected
+    // with "image.source.base64: image exceeds 5 MB maximum" even though
+    // dimensions were within the 1568 px cap. base64 inflates raw bytes by
+    // 4/3, so anything over ~3.5 MB raw risks crossing the 5 MB API limit.
     expect(shouldRescaleImage({ width: 1568, height: 1568 }, 5_000_000)).toBe(
-      false,
+      true,
+    );
+    expect(shouldRescaleImage({ width: 1200, height: 800 }, 4_000_000)).toBe(
+      true,
     );
   });
 

package/src/__tests__/agent-wake-disk-pressure-callsite.test.ts

@@ -0,0 +1,131 @@
+/**
+ * Regression test: `classifyDiskPressureTurnPolicy` must receive the
+ * caller-supplied `callSite` from `wakeAgentForOpportunity`, not a
+ * hardcoded `"mainAgent"`.
+ *
+ * Today the disk-pressure classifier's `isBackgroundTurn` branches on
+ * `isDirectWake` before it consults `callSite`, so the hardcoded value
+ * did not produce a runtime regression. But the metadata recorded the
+ * wrong call site for any wake initiated by a background job (e.g.
+ * memory-v2 consolidation), and the inconsistency would bite the moment
+ * policy ever branches on `callSite` for wake turns. This test pins the
+ * forwarded value so the contract stays honest.
+ */
+
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+import type {
+  DiskPressureTurnMetadata,
+  DiskPressureTurnPolicyDecision,
+} from "../daemon/disk-pressure-policy.js";
+import type { Message } from "../providers/types.js";
+
+mock.module("../memory/conversation-crud.js", () => ({
+  getConversationOverrideProfile: () => undefined,
+}));
+
+mock.module("../config/loader.js", () => ({
+  getConfig: () => ({ llm: {} }),
+}));
+
+mock.module("../config/llm-context-resolution.js", () => ({
+  resolveEffectiveContextWindow: () => ({ maxInputTokens: 200_000 }),
+}));
+
+const classifyCalls: DiskPressureTurnMetadata[] = [];
+mock.module("../daemon/disk-pressure-policy.js", () => ({
+  classifyDiskPressureTurnPolicy: (
+    _status: unknown,
+    metadata: DiskPressureTurnMetadata,
+  ): DiskPressureTurnPolicyDecision => {
+    classifyCalls.push(metadata);
+    return { action: "allow-normal" };
+  },
+}));
+
+mock.module("../daemon/disk-pressure-guard.js", () => ({
+  getDiskPressureStatus: () => ({
+    enabled: false,
+    state: "disabled",
+    locked: false,
+    acknowledged: false,
+    overrideActive: false,
+    effectivelyLocked: false,
+    lockId: null,
+    usagePercent: null,
+    thresholdPercent: 95,
+    path: null,
+    lastCheckedAt: null,
+    blockedCapabilities: [],
+    error: null,
+  }),
+}));
+
+import {
+  __resetWakeChainForTests,
+  wakeAgentForOpportunity,
+  type WakeTarget,
+} from "../runtime/agent-wake.js";
+
+function makeTarget(): WakeTarget {
+  const history: Message[] = [];
+  let processing = false;
+  return {
+    conversationId: "conv-wake-callsite",
+    agentLoop: {
+      run: (async (messages: Message[]) =>
+        messages) as WakeTarget["agentLoop"]["run"],
+    },
+    getMessages: () => history,
+    pushMessage: (msg) => {
+      history.push(msg);
+    },
+    emitAgentEvent: () => {},
+    isProcessing: () => processing,
+    markProcessing: (on) => {
+      processing = on;
+    },
+    persistTailMessage: async () => {},
+  };
+}
+
+beforeEach(() => {
+  __resetWakeChainForTests();
+  classifyCalls.length = 0;
+});
+
+describe("wakeAgentForOpportunity — disk-pressure callSite forwarding", () => {
+  test("forwards opts.callSite to classifyDiskPressureTurnPolicy", async () => {
+    const target = makeTarget();
+
+    await wakeAgentForOpportunity(
+      {
+        conversationId: target.conversationId,
+        hint: "consolidate buffer",
+        source: "memory_v2_consolidation",
+        callSite: "memoryV2Consolidation",
+      },
+      { resolveTarget: async () => target },
+    );
+
+    expect(classifyCalls).toHaveLength(1);
+    expect(classifyCalls[0]!.callSite).toBe("memoryV2Consolidation");
+    expect(classifyCalls[0]!.isDirectWake).toBe(true);
+  });
+
+  test("defaults to mainAgent when opts.callSite is omitted", async () => {
+    const target = makeTarget();
+
+    await wakeAgentForOpportunity(
+      {
+        conversationId: target.conversationId,
+        hint: "resume",
+        source: "scheduler",
+      },
+      { resolveTarget: async () => target },
+    );
+
+    expect(classifyCalls).toHaveLength(1);
+    expect(classifyCalls[0]!.callSite).toBe("mainAgent");
+  });
+});

package/src/__tests__/anthropic-provider.test.ts

@@ -223,6 +223,22 @@ describe("AnthropicProvider — Cache-Control Characterization", () => {
     expect(system[1].cache_control).toEqual({ type: "ephemeral", ttl: "1h" });
   });
 
+  test("omits empty dynamic system block after cache boundary", async () => {
+    const staticBlock = "You are a helpful assistant.";
+    const prompt = staticBlock + SYSTEM_PROMPT_CACHE_BOUNDARY;
+
+    await provider.sendMessage([userMsg("Hi")], undefined, prompt);
+
+    const system = lastStreamParams!.system as Array<{
+      type: string;
+      text: string;
+      cache_control?: { type: string; ttl?: string };
+    }>;
+    expect(system).toHaveLength(1);
+    expect(system[0].text).toBe(staticBlock);
+    expect(system[0].cache_control).toEqual({ type: "ephemeral", ttl: "1h" });
+  });
+
   test("drops static system block cache_control when total would exceed 4", async () => {
     const staticBlock = "You are a helpful assistant.";
     const dynamicBlock = "User workspace files here.";
@@ -2346,6 +2362,35 @@ describe("OpenRouterProvider — Anthropic dispatch", () => {
     expect(lastStreamParams!.reasoning).toBeUndefined();
   });
 
+  test("sends OpenRouter app-attribution headers on Anthropic-compatible requests", async () => {
+    const { OpenRouterProvider } =
+      await import("../providers/openrouter/client.js");
+    const provider = new OpenRouterProvider(
+      "or-key",
+      "anthropic/claude-sonnet-4.6",
+    );
+    await provider.sendMessage([userMsg("hi")], undefined, undefined, {
+      config: {
+        usageAttributionHeaders: {
+          "Vellum-Organization-Id": "org-123",
+        },
+      },
+    });
+
+    expect(_lastStreamOptions?.headers).toEqual(
+      expect.objectContaining({
+        "HTTP-Referer": "https://www.vellum.ai",
+        "X-OpenRouter-Title": "Vellum Assistant",
+        "X-OpenRouter-Categories": "personal-agent,cli-agent",
+        "Vellum-Organization-Id": "org-123",
+      }),
+    );
+    expect(lastStreamParams).not.toHaveProperty("HTTP-Referer");
+    expect(lastStreamParams).not.toHaveProperty("X-OpenRouter-Title");
+    expect(lastStreamParams).not.toHaveProperty("X-OpenRouter-Categories");
+    expect(lastStreamParams).not.toHaveProperty("usageAttributionHeaders");
+  });
+
   test("per-request model override routes based on the overridden model", async () => {
     const { OpenRouterProvider } =
       await import("../providers/openrouter/client.js");

package/src/__tests__/app-builder-tool-scripts.test.ts

@@ -22,15 +22,18 @@ function makeApp(overrides: Partial<AppDefinition> = {}): AppDefinition {
 }
 
 function makeMockStore(overrides: Partial<AppStore> = {}): AppStore {
+  const files = new Set<string>();
   return {
     getApp: () => makeApp(),
     listApps: () => [makeApp()],
-    appFileExists: () => false,
+    appFileExists: (_appId: string, path: string) => files.has(path),
     createApp: (params) =>
       makeApp({ name: params.name, description: params.description }),
     updateApp: (id, updates) => makeApp({ id, ...updates }),
     deleteApp: () => {},
-    writeAppFile: () => {},
+    writeAppFile: (_appId: string, path: string) => {
+      files.add(path);
+    },
     ...overrides,
   };
 }
@@ -107,7 +110,10 @@ describe("app-builder skill tool scripts", () => {
         isError: false,
       });
       const result = await appCreateScript.run(
-        { name: "Auto App" },
+        {
+          name: "Auto App",
+          source_files: { "src/main.tsx": "// real code" },
+        },
         makeContext({ proxyToolResolver: proxy }),
       );
       expect(result.isError).toBe(false);

package/src/__tests__/app-executors.test.ts

@@ -1,13 +1,31 @@
-import { describe, expect, mock, test } from "bun:test";
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+type CompileResult = {
+  ok: boolean;
+  errors: string[];
+  warnings: string[];
+  durationMs: number;
+};
+
+let compileResultOverride: CompileResult = {
+  ok: true,
+  errors: [],
+  warnings: [],
+  durationMs: 0,
+};
 
 mock.module("../bundler/app-compiler.js", () => ({
-  compileApp: async () => ({
+  compileApp: async () => compileResultOverride,
+}));
+
+beforeEach(() => {
+  compileResultOverride = {
     ok: true,
     errors: [],
     warnings: [],
     durationMs: 0,
-  }),
-}));
+  };
+});
 
 import type { AppDefinition } from "../memory/app-store.js";
 import type { AppStore } from "../tools/apps/executors.js";
@@ -102,6 +120,204 @@ describe("executeAppCreate", () => {
     expect(files["src/main.tsx"]).toBeDefined();
     expect(files["src/main.tsx"]).toContain("import { render } from 'preact'");
     expect(files["src/main.tsx"]).toContain('{"Hello, New App!"}');
+    // next_steps directive must be present so the model keeps writing
+    // real source files instead of treating the scaffold as done.
+    const parsed = JSON.parse(result.content);
+    expect(parsed.next_steps).toContain("placeholder src/main.tsx");
+    expect(parsed.next_steps).toContain("app_refresh");
+  });
+
+  test("skips auto_open on scaffold even when proxy resolver is available", async () => {
+    const files: Record<string, string> = {};
+    const app = makeMultifileApp({ name: "New App" });
+    const store: AppStore = {
+      ...mockStore(app, files),
+      createApp: () => app,
+    };
+    let proxyCalled = false;
+    const proxyResolver = async () => {
+      proxyCalled = true;
+      return { content: JSON.stringify({ opened: true }), isError: false };
+    };
+
+    const result = await executeAppCreate(
+      { name: "New App" },
+      store,
+      proxyResolver,
+    );
+
+    expect(result.isError).toBe(false);
+    expect(proxyCalled).toBe(false);
+    const parsed = JSON.parse(result.content);
+    expect(parsed.auto_opened).toBeUndefined();
+    expect(parsed.next_steps).toContain("placeholder src/main.tsx");
+    expect(parsed.next_steps).toContain("app_refresh");
+  });
+
+  test("omits next_steps when main.tsx was pre-written before app_create", async () => {
+    // The agent's supported workflow is to write the real source files first
+    // and then call app_create. In that case the placeholder directive would
+    // be false and risk triggering a destructive rewrite of correct code.
+    const files: Record<string, string> = {
+      "src/main.tsx": "// real code from the agent",
+    };
+    const app = makeMultifileApp({ name: "Pre-written App" });
+    const store: AppStore = {
+      ...mockStore(app, files),
+      createApp: () => app,
+    };
+
+    const result = await executeAppCreate({ name: "Pre-written App" }, store);
+
+    expect(result.isError).toBe(false);
+    // The pre-written file must be preserved
+    expect(files["src/main.tsx"]).toBe("// real code from the agent");
+    const parsed = JSON.parse(result.content);
+    expect(parsed.next_steps).toBeUndefined();
+  });
+
+  test("includes next_steps when compile fails on the scaffold", async () => {
+    compileResultOverride = {
+      ok: false,
+      errors: ["unexpected token"],
+      warnings: [],
+      durationMs: 3,
+    };
+    const files: Record<string, string> = {};
+    const app = makeMultifileApp({ name: "Broken App" });
+    const store: AppStore = {
+      ...mockStore(app, files),
+      createApp: () => app,
+    };
+
+    const result = await executeAppCreate({ name: "Broken App" }, store);
+
+    expect(result.isError).toBe(false);
+    const parsed = JSON.parse(result.content);
+    expect(parsed.compile_errors).toEqual(["unexpected token"]);
+    expect(parsed.next_steps).toContain("placeholder src/main.tsx");
+    expect(parsed.next_steps).toContain("app_refresh");
+  });
+
+  test("omits next_steps when compile fails on pre-written files", async () => {
+    compileResultOverride = {
+      ok: false,
+      errors: ["unexpected token"],
+      warnings: [],
+      durationMs: 3,
+    };
+    const files: Record<string, string> = {
+      "src/main.tsx": "// agent's real (but broken) code",
+    };
+    const app = makeMultifileApp({ name: "Broken Pre-written App" });
+    const store: AppStore = {
+      ...mockStore(app, files),
+      createApp: () => app,
+    };
+
+    const result = await executeAppCreate(
+      { name: "Broken Pre-written App" },
+      store,
+    );
+
+    expect(result.isError).toBe(false);
+    const parsed = JSON.parse(result.content);
+    expect(parsed.compile_errors).toEqual(["unexpected token"]);
+    expect(parsed.next_steps).toBeUndefined();
+  });
+
+  test("suppresses auto_open when only scaffold exists", async () => {
+    const files: Record<string, string> = {};
+    const app = makeMultifileApp({ name: "New App" });
+    const store: AppStore = {
+      ...mockStore(app, files),
+      createApp: () => app,
+    };
+    let proxyCalledWith: Record<string, unknown> | undefined;
+    const proxyResolver = async (
+      toolName: string,
+      input: Record<string, unknown>,
+    ) => {
+      proxyCalledWith = { toolName, input };
+      return { content: JSON.stringify({ opened: true }), isError: false };
+    };
+
+    const result = await executeAppCreate(
+      { name: "New App" },
+      store,
+      proxyResolver,
+    );
+
+    expect(result.isError).toBe(false);
+    const parsed = JSON.parse(result.content);
+    expect(proxyCalledWith).toBeUndefined();
+    expect(parsed.auto_opened).toBeUndefined();
+    expect(parsed.next_steps).toContain("placeholder src/main.tsx");
+  });
+
+  test("fires auto_open when source_files includes main.tsx", async () => {
+    const files: Record<string, string> = {};
+    const app = makeMultifileApp({ name: "Real App" });
+    const store: AppStore = {
+      ...mockStore(app, files),
+      createApp: () => app,
+    };
+    let proxyCalledWith: Record<string, unknown> | undefined;
+    const proxyResolver = async (
+      toolName: string,
+      input: Record<string, unknown>,
+    ) => {
+      proxyCalledWith = { toolName, input };
+      return { content: JSON.stringify({ opened: true }), isError: false };
+    };
+
+    const result = await executeAppCreate(
+      {
+        name: "Real App",
+        source_files: {
+          "src/main.tsx":
+            "import { render } from 'preact';\nrender(<div>Real</div>, document.getElementById('app')!);",
+          "src/styles.css": "body { margin: 0; }",
+        },
+      },
+      store,
+      proxyResolver,
+    );
+
+    expect(result.isError).toBe(false);
+    const parsed = JSON.parse(result.content);
+    expect(proxyCalledWith).toBeDefined();
+    expect(parsed.auto_opened).toBe(true);
+    expect(parsed.next_steps).toBeUndefined();
+    expect(files["src/main.tsx"]).toContain("Real");
+    expect(files["src/styles.css"]).toContain("margin");
+  });
+
+  test("source_files are written and prevent scaffold", async () => {
+    const files: Record<string, string> = {};
+    const app = makeMultifileApp({ name: "Inline App" });
+    const store: AppStore = {
+      ...mockStore(app, files),
+      createApp: () => app,
+    };
+
+    const result = await executeAppCreate(
+      {
+        name: "Inline App",
+        source_files: {
+          "src/main.tsx": "// custom app code",
+          "src/components/App.tsx": "// App component",
+        },
+      },
+      store,
+    );
+
+    expect(result.isError).toBe(false);
+    expect(files["src/main.tsx"]).toBe("// custom app code");
+    expect(files["src/components/App.tsx"]).toBe("// App component");
+    expect(files["src/index.html"]).toBeDefined();
+    const parsed = JSON.parse(result.content);
+    expect(parsed.next_steps).toBeUndefined();
   });
 
   test("rejects retired html shortcut", async () => {

package/src/__tests__/auto-analysis-end-to-end.test.ts

@@ -585,3 +585,38 @@ describe("indexer v1/v2 mutual exclusion for graph_extract", () => {
     );
   });
 });
+
+// ─────────────────────────────────────────────────────────────────
+// Indexer v1/v2 mutual exclusion: build_conversation_summary feeds
+// v1-only readers (fetchRecentSummaries, semantic search). When
+// memory.v2.enabled is on, the summary writes are unread, so the
+// indexer must not enqueue them.
+// ─────────────────────────────────────────────────────────────────
+
+describe("indexer v1/v2 mutual exclusion for build_conversation_summary", () => {
+  const originalV2Enabled = TEST_CONFIG.memory.v2.enabled;
+
+  afterEach(() => {
+    TEST_CONFIG.memory.v2.enabled = originalV2Enabled;
+  });
+
+  test("v2 active (config on) → build_conversation_summary not enqueued", async () => {
+    TEST_CONFIG.memory.v2.enabled = true;
+
+    const source = createConversation("summary-v2-active");
+    await indexMessages(source.id, 2);
+
+    expect(countJobsOfType("build_conversation_summary", source.id)).toBe(0);
+  });
+
+  test("config gate off → build_conversation_summary enqueued", async () => {
+    TEST_CONFIG.memory.v2.enabled = false;
+
+    const source = createConversation("summary-v2-config-off");
+    await indexMessages(source.id, 2);
+
+    expect(
+      countJobsOfType("build_conversation_summary", source.id),
+    ).toBeGreaterThanOrEqual(1);
+  });
+});

package/src/__tests__/bundled-asset.test.ts

@@ -101,18 +101,18 @@ describe("resolveBundledDir", () => {
       const macosDir = join(tempDir, "Contents", "MacOS");
       const resourcesDir = join(tempDir, "Contents", "Resources");
       mkdirSync(macosDir, { recursive: true });
-      mkdirSync(join(resourcesDir, "compact-prompts"), { recursive: true });
+      mkdirSync(join(resourcesDir, "templates"), { recursive: true });
       // Also create at execDir level
-      mkdirSync(join(macosDir, "compact-prompts"), { recursive: true });
+      mkdirSync(join(macosDir, "templates"), { recursive: true });
 
       process.execPath = join(macosDir, "vellum-daemon");
 
       const result = resolveBundledDir(
-        "/$bunfs/root/src/context/prompts",
-        "..",
-        "compact-prompts",
+        "/$bunfs/root/src/prompts",
+        "templates",
+        "templates",
       );
-      expect(result).toBe(join(resourcesDir, "compact-prompts"));
+      expect(result).toBe(join(resourcesDir, "templates"));
     });
 
     test("works with different bundleName values", () => {