@vellumai/assistant 0.11.1-dev.202608032034.aebd2da → 0.11.1-dev.202608032128.6f59e1c

package/openapi.yaml

@@ -21436,6 +21436,7 @@ paths:
                   minLength: 1
                   description: Feed item id (notif:<uuid>) or bare uuid
                 title:
+                  description: New title. An empty value is ignored, never cleared.
                   type: string
                 body:
                   type: string

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/assistant",
-  "version": "0.11.1-dev.202608032034.aebd2da",
+  "version": "0.11.1-dev.202608032128.6f59e1c",
   "license": "MIT",
   "type": "module",
   "exports": {

package/src/__tests__/agent-loop-resume-interrupted.test.ts

@@ -0,0 +1,223 @@
+/**
+ * Cover for the loop's interrupted-call recovery.
+ *
+ * The reported failure: the model runs several tools, the next call streams for
+ * a while and then dies (the upstream killed a generation that blew its decode
+ * deadline), and the loop surfaces the error and ends the turn — leaving the
+ * task half-done until the user types "continue". These tests assert the loop
+ * now carries on by itself, and that it still stops when carrying on would be
+ * pointless.
+ *
+ * The recovery is built into {@link AgentLoop}, not contributed by a plugin, so
+ * these run it as the loop's own behavior. The default plugin stack is
+ * registered because the loop fires hook chains during a turn regardless.
+ */
+
+import { beforeEach, describe, expect, test } from "bun:test";
+
+import type { AgentEvent } from "../agent/loop.js";
+import { AgentLoop } from "../agent/loop.js";
+import type { LLMCallSite } from "../config/schemas/llm.js";
+import { resetPluginRegistryAndRegisterDefaults } from "../plugins/defaults/index.js";
+import type {
+  Message,
+  Provider,
+  ProviderResponse,
+  SendMessageOptions,
+  ToolDefinition,
+} from "../providers/types.js";
+import { ProviderError } from "../util/errors.js";
+
+const tools: ToolDefinition[] = [
+  {
+    name: "read_file",
+    description: "Read a file",
+    input_schema: { type: "object", properties: { path: { type: "string" } } },
+  },
+];
+
+const userMessage: Message = {
+  role: "user",
+  content: [{ type: "text", text: "finish the course page" }],
+};
+
+/** The rejection from the reported turn, thrown from inside a live stream. */
+function midStreamRejection(): ProviderError {
+  return new ProviderError(
+    "OpenAI-compatible API error (unknown status): litellm.MidStreamFallbackError: " +
+      "litellm.APIConnectionError: OpenAIException - Decode wall clock timeout after 600s",
+    "openai-compatible",
+  );
+}
+
+/** A scripted turn: return a response, or stream `thinking` and then throw. */
+type Turn =
+  | { kind: "reply"; response: ProviderResponse }
+  | { kind: "interrupt"; thinking: string }
+  | { kind: "refuse" };
+
+function scriptedProvider(turns: Turn[]): {
+  provider: Provider;
+  callCount: () => number;
+} {
+  let index = 0;
+  const provider: Provider = {
+    name: "openai-compatible",
+    async sendMessage(
+      _messages: Message[],
+      options?: SendMessageOptions,
+    ): Promise<ProviderResponse> {
+      const turn = turns[Math.min(index, turns.length - 1)]!;
+      index++;
+      if (turn.kind === "refuse") {
+        // Rejected before generating: nothing ever streams.
+        throw midStreamRejection();
+      }
+      if (turn.kind === "interrupt") {
+        options?.onEvent?.({ type: "thinking_delta", thinking: turn.thinking });
+        throw midStreamRejection();
+      }
+      for (const block of turn.response.content) {
+        if (block.type === "text") {
+          options?.onEvent?.({ type: "text_delta", text: block.text });
+        }
+      }
+      return turn.response;
+    },
+  };
+  return { provider, callCount: () => index };
+}
+
+function reply(text: string): Turn {
+  return {
+    kind: "reply",
+    response: {
+      content: [{ type: "text", text }],
+      model: "glm-5.2",
+      usage: { inputTokens: 10, outputTokens: 5 },
+      stopReason: "end_turn",
+    },
+  };
+}
+
+function callsTool(id: string): Turn {
+  return {
+    kind: "reply",
+    response: {
+      content: [
+        { type: "tool_use", id, name: "read_file", input: { path: "app.js" } },
+      ],
+      model: "glm-5.2",
+      usage: { inputTokens: 10, outputTokens: 5 },
+      stopReason: "tool_use",
+    },
+  };
+}
+
+function runLoop(provider: Provider, callSite: LLMCallSite = "mainAgent") {
+  const events: AgentEvent[] = [];
+  const loop = new AgentLoop({
+    provider,
+    systemPrompt: "system",
+    conversationId: "conv-resume-e2e",
+    tools,
+    toolExecutor: async () => ({ content: "file data", isError: false }),
+  });
+  return loop
+    .run({
+      requestId: "req-resume-e2e",
+      messages: [userMessage],
+      callSite,
+      onEvent: (event) => {
+        events.push(event);
+      },
+      trust: { sourceChannel: "vellum", trustClass: "unknown" },
+    })
+    .then((result) => ({ ...result, events }));
+}
+
+function assistantTextOf(history: Message[]): string {
+  return history
+    .filter((message) => message.role === "assistant")
+    .flatMap((message) => message.content)
+    .map((block) => (block.type === "text" ? block.text : ""))
+    .join("");
+}
+
+describe("AgentLoop — a call interrupted mid-generation", () => {
+  beforeEach(() => {
+    resetPluginRegistryAndRegisterDefaults();
+  });
+
+  test("carries on instead of ending the turn", async () => {
+    const { provider, callCount } = scriptedProvider([
+      callsTool("call-1"),
+      { kind: "interrupt", thinking: "Now I need to understand the layout" },
+      reply("Done — the page is wired up."),
+    ]);
+
+    const { history, events } = await runLoop(provider);
+
+    // The turn finished on its own: tool call, interrupted call, resumed call.
+    expect(callCount()).toBe(3);
+    expect(assistantTextOf(history)).toContain("Done — the page is wired up.");
+    expect(events.filter((event) => event.type === "error")).toHaveLength(0);
+  });
+
+  test("keeps the tool work the interrupted turn had already done", async () => {
+    const { provider } = scriptedProvider([
+      callsTool("call-1"),
+      { kind: "interrupt", thinking: "reading the file" },
+      reply("Summary of the file."),
+    ]);
+
+    const { history } = await runLoop(provider);
+
+    // The resumed call re-sends the same history, so the completed tool call
+    // and its result are still there rather than being replayed or dropped.
+    const toolUses = history
+      .flatMap((message) => message.content)
+      .filter((block) => block.type === "tool_use");
+    const toolResults = history
+      .flatMap((message) => message.content)
+      .filter((block) => block.type === "tool_result");
+    expect(toolUses).toHaveLength(1);
+    expect(toolResults).toHaveLength(1);
+  });
+
+  test("surfaces the error when the resumed call is interrupted too", async () => {
+    const { provider, callCount } = scriptedProvider([
+      { kind: "interrupt", thinking: "starting" },
+    ]);
+
+    const { events } = await runLoop(provider);
+
+    // One resume, then the error stands rather than looping.
+    expect(callCount()).toBe(2);
+    expect(events.filter((event) => event.type === "error")).toHaveLength(1);
+  });
+
+  test("does not resume a background call site", async () => {
+    // A compaction, subagent, or other background call answers to a caller
+    // that owns its own failure handling; nobody is sitting there to type
+    // "continue" at it.
+    const { provider, callCount } = scriptedProvider([
+      { kind: "interrupt", thinking: "summarizing" },
+    ]);
+
+    await runLoop(provider, "compactionAgent");
+
+    expect(callCount()).toBe(1);
+  });
+
+  test("does not resume a request the provider refused outright", async () => {
+    // Nothing streamed, so re-sending the identical request would fail the same
+    // way; the error surfaces on the first rejection.
+    const { provider, callCount } = scriptedProvider([{ kind: "refuse" }]);
+
+    const { events } = await runLoop(provider);
+
+    expect(callCount()).toBe(1);
+    expect(events.filter((event) => event.type === "error")).toHaveLength(1);
+  });
+});

package/src/__tests__/conversation-agent-loop.test.ts

@@ -3022,12 +3022,20 @@ describe("session-agent-loop", () => {
       }));
 
       // GIVEN a real loop whose provider streams a delta — landing a debounced
-      // partial flush on the reserved row — then rejects, so the loop emits
-      // `provider_error` and `error` and exits with no `message_complete`.
+      // partial flush on the reserved row — then rejects. The loop resumes a
+      // call that died after it had started streaming, so the second attempt
+      // is scripted to fail before streaming anything: that keeps exactly one
+      // row carrying partial content, and the turn then exits via
+      // `provider_error` with no `message_complete`.
+      let attempt = 0;
       const ctx = makeCtx({
         loopProvider: {
           name: "mock-provider",
           async sendMessage(_messages, options) {
+            attempt++;
+            if (attempt > 1) {
+              throw new Error("upstream 500");
+            }
             options?.onEvent?.({ type: "text_delta", text: "hello world" });
             await new Promise((resolve) => setTimeout(resolve, 1100));
             throw new Error("upstream 500");
@@ -3051,11 +3059,12 @@ describe("session-agent-loop", () => {
         .split("\n");
       expect(orphanLines).toHaveLength(1);
       expect(updateMessageContentMock).toHaveBeenCalledTimes(0);
-      expect(deleteMessageByIdMock).toHaveBeenCalledTimes(1);
-      const deleteCall = deleteMessageByIdMock.mock.calls[0] as unknown as [
-        string,
-      ];
-      expect(deleteCall[0]).toBe("msg-orphan-with-partial");
+      // Scoped to the row under test: the resumed attempt reserves a row of
+      // its own, which its own cleanup deletes.
+      const deletedIds = deleteMessageByIdMock.mock.calls.map(
+        (call) => (call as unknown as [string])[0],
+      );
+      expect(deletedIds).toContain("msg-orphan-with-partial");
     });
   });
 

package/src/__tests__/workspace-migration-137-repair-retired-fireworks-minimax-model-id.test.ts

@@ -47,15 +47,15 @@ afterEach(() => {
 });
 
 describe("137-repair-retired-fireworks-minimax-model-id migration", () => {
-  test("has correct migration id and is registered last", () => {
+  test("has correct migration id and is registered", () => {
     expect(repairRetiredFireworksMinimaxModelIdMigration.id).toBe(
       "137-repair-retired-fireworks-minimax-model-id",
     );
-    // getLastWorkspaceMigrationId() reports the final entry as the registry
-    // ceiling, so the highest id must stay last.
-    expect(WORKSPACE_MIGRATIONS[WORKSPACE_MIGRATIONS.length - 1]?.id).toBe(
-      "137-repair-retired-fireworks-minimax-model-id",
-    );
+    expect(
+      WORKSPACE_MIGRATIONS.some(
+        (m) => m.id === "137-repair-retired-fireworks-minimax-model-id",
+      ),
+    ).toBe(true);
   });
 
   test("repairs the retired ID in default, call sites, and profiles", () => {

package/src/__tests__/workspace-migration-138-backfill-home-feed-titles.test.ts

@@ -0,0 +1,373 @@
+/**
+ * Tests for workspace migration `138-backfill-home-feed-titles`.
+ *
+ * The migration gives every item in `<workspace>/data/home-feed.json` a
+ * non-empty `title`, derived from the item's own `summary` when the
+ * field is missing or blank.
+ *
+ * Cases covered:
+ *   1. Missing file, malformed JSON, and a non-object root are no-ops.
+ *   2. Title-less items gain a first-sentence title from the summary.
+ *   3. Items that already have a title are untouched.
+ *   4. A long summary truncates to 60 characters with an ellipsis, the
+ *      same cap the notification pipeline's derivation applies.
+ *   5. Markdown-rich and multi-line summaries yield a single line of
+ *      plain text.
+ *   6. `version`, `updatedAt`, and unrelated item fields are preserved.
+ *   7. A second run writes nothing.
+ */
+
+import {
+  existsSync,
+  mkdirSync,
+  mkdtempSync,
+  readFileSync,
+  rmSync,
+  statSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+
+import { backfillHomeFeedTitlesMigration } from "../workspace/migrations/138-backfill-home-feed-titles.js";
+import { WORKSPACE_MIGRATIONS } from "../workspace/migrations/registry.js";
+import { getLastWorkspaceMigrationId } from "../workspace/migrations/runner.js";
+
+let workspaceDir: string;
+let feedPath: string;
+
+beforeEach(() => {
+  workspaceDir = mkdtempSync(join(tmpdir(), "vellum-migration-138-test-"));
+  feedPath = join(workspaceDir, "data", "home-feed.json");
+});
+
+afterEach(() => {
+  if (existsSync(workspaceDir)) {
+    rmSync(workspaceDir, { recursive: true, force: true });
+  }
+});
+
+function writeFeedFile(contents: unknown): void {
+  mkdirSync(join(workspaceDir, "data"), { recursive: true });
+  writeFileSync(feedPath, JSON.stringify(contents, null, 2), "utf-8");
+}
+
+function readFeedFile(): {
+  version: number;
+  items: Array<Record<string, unknown>>;
+  updatedAt: string;
+} {
+  return JSON.parse(readFileSync(feedPath, "utf-8"));
+}
+
+function makeItem(
+  overrides: Record<string, unknown> & { id: string },
+): Record<string, unknown> {
+  return {
+    type: "notification",
+    priority: 50,
+    summary: "Something happened.",
+    timestamp: "2026-08-01T12:00:00.000Z",
+    status: "new",
+    createdAt: "2026-08-01T12:00:00.000Z",
+    ...overrides,
+  };
+}
+
+function writeFeed(items: Array<Record<string, unknown>>): void {
+  writeFeedFile({
+    version: 2,
+    updatedAt: "2026-08-01T12:00:00.000Z",
+    items,
+  });
+}
+
+describe("workspace migration 138-backfill-home-feed-titles", () => {
+  test("has the expected id and description", () => {
+    expect(backfillHomeFeedTitlesMigration.id).toBe(
+      "138-backfill-home-feed-titles",
+    );
+    expect(backfillHomeFeedTitlesMigration.description).toContain("title");
+  });
+
+  // getLastWorkspaceMigrationId() reports the final array entry as the
+  // registry ceiling to the identity and rollback routes, so the
+  // highest-numbered migration must sit last in the registry.
+  test("the registry ceiling stays at the highest-numbered migration", () => {
+    const numericId = (id: string) => Number.parseInt(id, 10);
+    const highest = Math.max(
+      ...WORKSPACE_MIGRATIONS.map((m) => numericId(m.id)).filter(
+        Number.isFinite,
+      ),
+    );
+    const last = getLastWorkspaceMigrationId(WORKSPACE_MIGRATIONS);
+    expect(last).not.toBeNull();
+    expect(numericId(last!)).toBe(highest);
+  });
+
+  test("missing file is a no-op (no error, no file created)", () => {
+    expect(existsSync(feedPath)).toBe(false);
+
+    expect(() =>
+      backfillHomeFeedTitlesMigration.run(workspaceDir),
+    ).not.toThrow();
+
+    expect(existsSync(feedPath)).toBe(false);
+  });
+
+  test("derives a title from the summary's first sentence", () => {
+    writeFeed([
+      makeItem({
+        id: "a-1",
+        summary: "Alice replied to your thread. She needs an answer.",
+      }),
+      makeItem({ id: "a-2", summary: "Deploy finished!" }),
+      makeItem({ id: "a-3", summary: "Ready to review? The draft is up." }),
+    ]);
+
+    backfillHomeFeedTitlesMigration.run(workspaceDir);
+
+    const titles = readFeedFile().items.map((item) => item.title);
+    expect(titles).toEqual([
+      "Alice replied to your thread.",
+      "Deploy finished!",
+      "Ready to review?",
+    ]);
+  });
+
+  test("backfills items whose title is missing, empty, blank, or not a string", () => {
+    writeFeed([
+      makeItem({ id: "missing", summary: "First item summary." }),
+      makeItem({ id: "empty", title: "", summary: "Second item summary." }),
+      makeItem({ id: "blank", title: "   ", summary: "Third item summary." }),
+      makeItem({ id: "wrong-type", title: null, summary: "Fourth summary." }),
+    ]);
+
+    backfillHomeFeedTitlesMigration.run(workspaceDir);
+
+    const titles = readFeedFile().items.map((item) => item.title);
+    expect(titles).toEqual([
+      "First item summary.",
+      "Second item summary.",
+      "Third item summary.",
+      "Fourth summary.",
+    ]);
+  });
+
+  test("leaves items that already have a title untouched", () => {
+    writeFeed([
+      makeItem({
+        id: "titled",
+        title: "Existing headline",
+        summary: "A completely different summary sentence.",
+      }),
+      makeItem({ id: "untitled", summary: "Needs a headline." }),
+    ]);
+
+    backfillHomeFeedTitlesMigration.run(workspaceDir);
+
+    const items = readFeedFile().items;
+    expect(items[0]!.title).toBe("Existing headline");
+    expect(items[1]!.title).toBe("Needs a headline.");
+  });
+
+  test("truncates a long summary to 60 characters with an ellipsis", () => {
+    const summary =
+      "Bob shared a very long document that keeps going well past the limit";
+    writeFeed([makeItem({ id: "long", summary })]);
+
+    backfillHomeFeedTitlesMigration.run(workspaceDir);
+
+    const title = readFeedFile().items[0]!.title as string;
+    expect(title).toBe(
+      "Bob shared a very long document that keeps going well past t…",
+    );
+    // The ellipsis sits past the cap, so the retained text is exactly 60.
+    expect(title.slice(0, -1).length).toBe(60);
+  });
+
+  test("truncates a long first sentence rather than the whole summary", () => {
+    writeFeed([
+      makeItem({
+        id: "long-sentence",
+        summary:
+          "This opening sentence runs well beyond the sixty character cap on derived titles. Then another.",
+      }),
+    ]);
+
+    backfillHomeFeedTitlesMigration.run(workspaceDir);
+
+    const title = readFeedFile().items[0]!.title as string;
+    expect(title).toBe(
+      "This opening sentence runs well beyond the sixty character c…",
+    );
+  });
+
+  test("flattens a markdown-rich multi-line summary into one plain line", () => {
+    writeFeed([
+      makeItem({
+        id: "markdown",
+        summary:
+          "## Nightly run\n\n- **Deploy** finished\n- Tests passed\n\nSee the `report` for details.",
+      }),
+    ]);
+
+    backfillHomeFeedTitlesMigration.run(workspaceDir);
+
+    expect(readFeedFile().items[0]!.title).toBe(
+      "Nightly run Deploy finished Tests passed See the report for…",
+    );
+  });
+
+  test("unwraps inline markdown before taking the first sentence", () => {
+    writeFeed([
+      makeItem({
+        id: "inline",
+        summary:
+          "**Alice** shared the [design doc](https://example.com/doc). Review it soon.",
+      }),
+    ]);
+
+    backfillHomeFeedTitlesMigration.run(workspaceDir);
+
+    expect(readFeedFile().items[0]!.title).toBe("Alice shared the design doc.");
+  });
+
+  test("collapses a newline-only summary run into single spaces", () => {
+    writeFeed([
+      makeItem({ id: "newlines", summary: "Backup complete\n\nNo errors" }),
+    ]);
+
+    backfillHomeFeedTitlesMigration.run(workspaceDir);
+
+    expect(readFeedFile().items[0]!.title).toBe("Backup complete No errors");
+  });
+
+  test("skips an item whose summary is markdown structure only", () => {
+    writeFeed([makeItem({ id: "structure-only", summary: "##\n\n- \n\n> " })]);
+
+    backfillHomeFeedTitlesMigration.run(workspaceDir);
+
+    expect(readFeedFile().items[0]!.title).toBeUndefined();
+  });
+
+  test("preserves version, updatedAt, and unrelated item fields", () => {
+    writeFeedFile({
+      version: 2,
+      updatedAt: "2026-08-01T12:00:00.000Z",
+      items: [
+        makeItem({
+          id: "keep-fields",
+          summary: "Payment failed.",
+          urgency: "high",
+          conversationId: "conv-abc",
+          actions: [{ label: "Retry", kind: "prompt" }],
+          detailPanel: { kind: "text", body: "Details" },
+        }),
+      ],
+    });
+
+    backfillHomeFeedTitlesMigration.run(workspaceDir);
+
+    const out = readFeedFile();
+    expect(out.version).toBe(2);
+    expect(out.updatedAt).toBe("2026-08-01T12:00:00.000Z");
+
+    const item = out.items[0]!;
+    expect(item.title).toBe("Payment failed.");
+    expect(item.id).toBe("keep-fields");
+    expect(item.type).toBe("notification");
+    expect(item.priority).toBe(50);
+    expect(item.status).toBe("new");
+    expect(item.urgency).toBe("high");
+    expect(item.conversationId).toBe("conv-abc");
+    expect(item.actions).toEqual([{ label: "Retry", kind: "prompt" }]);
+    expect(item.detailPanel).toEqual({ kind: "text", body: "Details" });
+  });
+
+  test("idempotent: a second run writes nothing", () => {
+    writeFeed([
+      makeItem({ id: "a-1", summary: "Alice replied to your thread." }),
+      makeItem({ id: "a-2", title: "Already titled", summary: "Body text." }),
+    ]);
+
+    backfillHomeFeedTitlesMigration.run(workspaceDir);
+    const afterFirst = readFileSync(feedPath, "utf-8");
+    const afterFirstStat = statSync(feedPath);
+
+    backfillHomeFeedTitlesMigration.run(workspaceDir);
+
+    expect(readFileSync(feedPath, "utf-8")).toBe(afterFirst);
+    expect(statSync(feedPath).mtimeMs).toBe(afterFirstStat.mtimeMs);
+  });
+
+  test("a fully titled feed is left byte-identical", () => {
+    writeFeed([makeItem({ id: "a-1", title: "Titled", summary: "Body." })]);
+    const before = readFileSync(feedPath, "utf-8");
+    const beforeStat = statSync(feedPath);
+
+    backfillHomeFeedTitlesMigration.run(workspaceDir);
+
+    expect(readFileSync(feedPath, "utf-8")).toBe(before);
+    expect(statSync(feedPath).mtimeMs).toBe(beforeStat.mtimeMs);
+  });
+
+  test("malformed JSON does not throw and leaves the file alone", () => {
+    mkdirSync(join(workspaceDir, "data"), { recursive: true });
+    writeFileSync(feedPath, "{not valid json", "utf-8");
+    const before = readFileSync(feedPath, "utf-8");
+
+    expect(() =>
+      backfillHomeFeedTitlesMigration.run(workspaceDir),
+    ).not.toThrow();
+
+    expect(readFileSync(feedPath, "utf-8")).toBe(before);
+  });
+
+  test("non-object root is a no-op", () => {
+    writeFeedFile([1, 2, 3]);
+    const before = readFileSync(feedPath, "utf-8");
+
+    expect(() =>
+      backfillHomeFeedTitlesMigration.run(workspaceDir),
+    ).not.toThrow();
+
+    expect(readFileSync(feedPath, "utf-8")).toBe(before);
+  });
+
+  test("items that cannot yield a title are skipped without throwing", () => {
+    writeFeedFile({
+      version: 2,
+      updatedAt: "2026-08-01T12:00:00.000Z",
+      items: [
+        "not an object",
+        makeItem({ id: "no-summary", summary: undefined }),
+        makeItem({ id: "blank-summary", summary: "   " }),
+        makeItem({ id: "ok", summary: "Has a summary." }),
+      ],
+    });
+
+    expect(() =>
+      backfillHomeFeedTitlesMigration.run(workspaceDir),
+    ).not.toThrow();
+
+    const items: unknown[] = readFeedFile().items;
+    expect(items[0]).toBe("not an object");
+    expect((items[1] as Record<string, unknown>).title).toBeUndefined();
+    expect((items[2] as Record<string, unknown>).title).toBeUndefined();
+    expect((items[3] as Record<string, unknown>).title).toBe("Has a summary.");
+  });
+
+  test("down() is a no-op (forward-only migration)", () => {
+    writeFeed([makeItem({ id: "a-1", summary: "Alice replied." })]);
+    backfillHomeFeedTitlesMigration.run(workspaceDir);
+    const after = readFileSync(feedPath, "utf-8");
+
+    expect(() =>
+      backfillHomeFeedTitlesMigration.down(workspaceDir),
+    ).not.toThrow();
+
+    expect(readFileSync(feedPath, "utf-8")).toBe(after);
+  });
+});