@vellumai/assistant 0.8.1 → 0.8.3

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

@@ -0,0 +1,195 @@
+/**
+ * Integration tests for the agent loop's `provider_error` recording path.
+ *
+ * When the `llmCall` pipeline 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.
+ *
+ * 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.
+ *  - 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).
+ *  - Skips emission on user-aborted runs — there is no provider rejection
+ *    worth recording when the user cancelled.
+ */
+
+import { describe, expect, test } from "bun:test";
+
+import type { AgentEvent } from "../agent/loop.js";
+import { AgentLoop } from "../agent/loop.js";
+import type {
+  Message,
+  Provider,
+  ProviderResponse,
+  SendMessageOptions,
+  ToolDefinition,
+} from "../providers/types.js";
+import { ProviderError } from "../util/errors.js";
+
+/**
+ * Build a provider that throws on every `sendMessage` call. Records what
+ * the loop attempted to send so the test can assert `rawRequest` carries
+ * the right payload.
+ */
+function makeThrowingProvider(
+  name: string,
+  throwFn: () => Error,
+): {
+  provider: Provider;
+  calls: Array<{
+    messages: Message[];
+    tools?: ToolDefinition[];
+    systemPrompt?: string;
+  }>;
+} {
+  const calls: Array<{
+    messages: Message[];
+    tools?: ToolDefinition[];
+    systemPrompt?: string;
+  }> = [];
+  const provider: Provider = {
+    name,
+    async sendMessage(
+      messages: Message[],
+      tools?: ToolDefinition[],
+      systemPrompt?: string,
+      _options?: SendMessageOptions,
+    ): Promise<ProviderResponse> {
+      calls.push({ messages: [...messages], tools, systemPrompt });
+      throw throwFn();
+    },
+  };
+  return { provider, calls };
+}
+
+describe("AgentLoop provider_error event emission", () => {
+  test("emits provider_error with loop-level rawRequest when provider throws ProviderError", async () => {
+    const thrown = new ProviderError(
+      "Anthropic API error (429): rate limited",
+      "anthropic",
+      429,
+      { retryAfterMs: 1500 },
+    );
+    const { provider, calls } = makeThrowingProvider("anthropic", () => thrown);
+
+    const events: AgentEvent[] = [];
+    const loop = new AgentLoop(provider, "you are a helpful assistant");
+
+    await loop.run(
+      [{ role: "user", content: [{ type: "text", text: "hi" }] }],
+      (e) => {
+        events.push(e);
+      },
+    );
+
+    expect(calls).toHaveLength(1);
+
+    const providerErrorEvent = events.find((e) => e.type === "provider_error");
+    expect(providerErrorEvent).toBeDefined();
+    if (providerErrorEvent?.type !== "provider_error") {
+      throw new Error("type narrowing");
+    }
+    expect(providerErrorEvent.error).toBe(thrown);
+    expect(providerErrorEvent.actualProvider).toBe("anthropic");
+
+    // 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");
+  });
+
+  test("error event still fires after provider_error (outer catch behavior unchanged)", async () => {
+    const thrown = new ProviderError(
+      "Gemini API error (500): internal",
+      "gemini",
+      500,
+    );
+    const { provider } = makeThrowingProvider("gemini", () => thrown);
+
+    const events: AgentEvent[] = [];
+    const loop = new AgentLoop(provider, "system");
+
+    await loop.run(
+      [{ role: "user", content: [{ type: "text", text: "hi" }] }],
+      (e) => {
+        events.push(e);
+      },
+    );
+
+    const providerErrorIdx = events.findIndex(
+      (e) => e.type === "provider_error",
+    );
+    const errorIdx = events.findIndex((e) => e.type === "error");
+    expect(providerErrorIdx).toBeGreaterThanOrEqual(0);
+    expect(errorIdx).toBeGreaterThanOrEqual(0);
+    // Recording-first ordering is load-bearing: a consumer that sees the
+    // generic `error` event and shuts the stream down must have already
+    // received the `provider_error` row for the rejected call.
+    expect(providerErrorIdx).toBeLessThan(errorIdx);
+  });
+
+  test("falls back to provider.name when a non-ProviderError is thrown", async () => {
+    const thrown = new Error("unexpected SDK boom");
+    const { provider } = makeThrowingProvider("openai", () => thrown);
+
+    const events: AgentEvent[] = [];
+    const loop = new AgentLoop(provider, "system");
+
+    await loop.run(
+      [{ role: "user", content: [{ type: "text", text: "hi" }] }],
+      (e) => {
+        events.push(e);
+      },
+    );
+
+    const providerErrorEvent = events.find((e) => e.type === "provider_error");
+    expect(providerErrorEvent).toBeDefined();
+    if (providerErrorEvent?.type !== "provider_error") {
+      throw new Error("type narrowing");
+    }
+    // The thrown Error has no `.provider` field, so the event falls back to
+    // the dispatching provider's `name` — keeps the persisted log row's
+    // `provider` column populated even for surprise errors.
+    expect(providerErrorEvent.actualProvider).toBe("openai");
+    expect(providerErrorEvent.error).toBe(thrown);
+  });
+
+  test("does NOT emit provider_error on user-aborted runs", async () => {
+    const controller = new AbortController();
+    const thrown = new Error("aborted");
+    const { provider } = makeThrowingProvider("anthropic", () => {
+      // Pre-abort then throw so the loop's catch sees `signal.aborted === true`.
+      controller.abort();
+      return thrown;
+    });
+
+    const events: AgentEvent[] = [];
+    const loop = new AgentLoop(provider, "system");
+
+    await loop.run(
+      [{ role: "user", content: [{ type: "text", text: "hi" }] }],
+      (e) => {
+        events.push(e);
+      },
+      controller.signal,
+    );
+
+    const providerErrorEvent = events.find((e) => e.type === "provider_error");
+    // Cancellation should never produce a recording row — there's no
+    // provider rejection worth logging when the user pulled the plug.
+    expect(providerErrorEvent).toBeUndefined();
+  });
+});

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);
+  });
+});