@vellumai/assistant 0.11.2-dev.202608052129.f237b1e → 0.11.2-dev.202608052324.a11da34

package/openapi.yaml

@@ -6585,6 +6585,16 @@ paths:
           description:
             Filter by origin channel. When provided, only conversations with this exact origin_channel value are
             returned. Omit to include all channels.
+        - name: groupId
+          in: query
+          required: false
+          schema:
+            type: string
+          description:
+            Filter to a single group, so each sidebar section can load independently of the paginated list. Pass
+            "system:all" for conversations in no group, "system:pinned" for the Pinned section, or a custom group id. A
+            group-scoped request is ordered by the user's arrangement (display order, then recency) and never has pinned
+            rows appended to it. Omit to span every group.
       responses:
         "200":
           description: Successful response
@@ -34586,13 +34596,14 @@ components:
               type: string
               enum:
                 - ok
-                - missing_default
+                - incomplete
                 - missing_connection
                 - missing_credential
                 - provider_mismatch
                 - unsupported_auth
                 - vellum_unauthenticated
                 - unknown
+                - missing_default
             message:
               type: string
           required:
@@ -34818,6 +34829,7 @@ components:
           type: string
           enum:
             - ok
+            - incomplete
             - missing_connection
             - missing_credential
             - provider_mismatch

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/assistant",
-  "version": "0.11.2-dev.202608052129.f237b1e",
+  "version": "0.11.2-dev.202608052324.a11da34",
   "license": "MIT",
   "type": "module",
   "exports": {

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

@@ -782,6 +782,7 @@ function makeCtx(
     channelCapabilities: undefined,
     commandIntent: undefined,
     trustContext: undefined,
+    toolsDisabledDepth: 0,
 
     allowedToolNames: undefined,
     preactivatedSkillIds: undefined,
@@ -1187,6 +1188,92 @@ describe("session-agent-loop", () => {
         runAgentLoopImpl(ctx, "hello", "msg-1", () => {}),
       ).rejects.toThrow("runAgentLoop called without prior persistUserMessage");
     });
+
+    test("defers workspace Git work when tools are disabled", async () => {
+      const ensureInitialized = mock(async () => {});
+      const commitTurnChanges = mock(async () => {});
+      const ctx = makeCtx({
+        toolsDisabledDepth: 1,
+        getWorkspaceGitService: () => ({ ensureInitialized }),
+        commitTurnChanges,
+      });
+
+      await runAgentLoopImpl(ctx, "hello", "msg-1", () => {});
+
+      expect(ensureInitialized).not.toHaveBeenCalled();
+      expect(commitTurnChanges).not.toHaveBeenCalled();
+
+      await new Promise<void>((resolve) => setImmediate(resolve));
+
+      expect(commitTurnChanges).toHaveBeenCalledTimes(1);
+    });
+
+    test("leaves a deferred commit to an immediate follow-up turn", async () => {
+      const commitTurnChanges = mock(async () => {});
+      const ctx = makeCtx({
+        toolsDisabledDepth: 1,
+        commitTurnChanges,
+      });
+
+      await runAgentLoopImpl(ctx, "hello", "msg-1", () => {});
+      ctx.setProcessing(true);
+      await new Promise<void>((resolve) => setImmediate(resolve));
+
+      expect(commitTurnChanges).not.toHaveBeenCalled();
+      ctx.setProcessing(false);
+    });
+
+    test("initializes workspace Git before hooks when tools can run", async () => {
+      let initialized = false;
+      const ensureInitialized = mock(async () => {
+        initialized = true;
+      });
+      const commitTurnChanges = mock(async () => {});
+      const initializedDuringHook: boolean[] = [];
+      registerPlugin({
+        manifest: {
+          name: "test-workspace-git-ready-before-hook",
+          version: "1.0.0",
+        },
+        hooks: {
+          "user-prompt-submit": async () => {
+            initializedDuringHook.push(initialized);
+          },
+        },
+      });
+      const ctx = makeCtx({
+        getWorkspaceGitService: () => ({ ensureInitialized }),
+        commitTurnChanges,
+      });
+
+      await runAgentLoopImpl(ctx, "hello", "msg-1", () => {});
+
+      expect(ensureInitialized).toHaveBeenCalledTimes(1);
+      expect(commitTurnChanges).toHaveBeenCalledTimes(1);
+      expect(initializedDuringHook).toEqual([true]);
+    });
+
+    test("continues a tool-capable turn when workspace Git initialization fails", async () => {
+      const ensureInitialized = mock(async () => {
+        throw new Error("simulated Git initialization failure");
+      });
+      const events: AssistantEvent[] = [];
+      const ctx = makeCtx({
+        getWorkspaceGitService: () => ({ ensureInitialized }),
+      });
+
+      await runAgentLoopImpl(ctx, "hello", "msg-1", (event) =>
+        events.push(event),
+      );
+
+      expect(ensureInitialized).toHaveBeenCalledTimes(1);
+      expect(events.some((event) => event.type === "message_complete")).toBe(
+        true,
+      );
+      expect(events.some((event) => event.type === "conversation_error")).toBe(
+        false,
+      );
+    });
   });
 
   describe("disk pressure injection context", () => {

package/src/__tests__/conversation-group-tools.test.ts

@@ -257,7 +257,7 @@ describe("conversation_move_to_group tool", () => {
     expect(result.content).toContain("no conversation found");
   });
 
-  test("notes hidden conversation types", async () => {
+  test("tells the model a custom group surfaces a hidden conversation", async () => {
     createConversation({ id: "conv-bg", conversationType: "background" });
     await executeConversationGroupCreate({ name: "Visible" }, ctx);
 
@@ -267,7 +267,37 @@ describe("conversation_move_to_group tool", () => {
     );
 
     expect(result.isError).toBe(false);
-    expect(result.content).toContain("hidden from the sidebar");
+    expect(result.content).toContain("surfaces it into the sidebar");
+  });
+
+  test("does not claim a move to Recents surfaces a hidden conversation", async () => {
+    // Recents is a removal target, not a promotion: the write path leaves an
+    // unpromoted background row hidden there, so saying otherwise would report
+    // an outcome to the model that did not happen.
+    createConversation({ id: "conv-bg-all", conversationType: "background" });
+
+    const result = await executeConversationMoveToGroup(
+      { group: "system:all", conversation_id: "conv-bg-all" },
+      ctx,
+    );
+
+    expect(result.isError).toBe(false);
+    expect(result.content).not.toContain("surfaces it into the sidebar");
+  });
+
+  test("does not claim a move to Background surfaces a hidden conversation", async () => {
+    createConversation({
+      id: "conv-bg-demote",
+      conversationType: "background",
+    });
+
+    const result = await executeConversationMoveToGroup(
+      { group: "system:background", conversation_id: "conv-bg-demote" },
+      ctx,
+    );
+
+    expect(result.isError).toBe(false);
+    expect(result.content).not.toContain("surfaces it into the sidebar");
   });
 
   test("rejects missing group", async () => {

package/src/__tests__/conversation-placement-promotion.test.ts

@@ -0,0 +1,198 @@
+/**
+ * Filing a background or scheduled conversation into a section the user reads
+ * promotes it durably.
+ *
+ * Placement into Pinned or a custom group stamps `surfaced_at`, so the
+ * promotion outlives the placement that caused it: taking the conversation
+ * back out returns it to Recents rather than hiding it. Demotion is the
+ * mirror image, and filing into `system:background` / `system:scheduled`
+ * clears the stamp.
+ *
+ * The cases below pin both edges. Under-promoting hides a conversation the
+ * user deliberately filed somewhere; over-promoting drags hidden automation
+ * into the sidebar, so the "what promotion must not do" block is as
+ * load-bearing as the rest.
+ */
+
+import { beforeEach, describe, expect, test } from "bun:test";
+
+import {
+  batchSetDisplayOrders,
+  createConversation,
+} from "../persistence/conversation-crud.js";
+import { listConversations } from "../persistence/conversation-queries.js";
+import { getDb } from "../persistence/db-connection.js";
+import { initializeDb } from "../persistence/db-init.js";
+import { createGroup } from "../persistence/group-crud.js";
+import { rawRun } from "../persistence/raw-query.js";
+import { conversations } from "../persistence/schema/index.js";
+
+await initializeDb();
+
+function seedRoutedBackground(title: string, type: "background" | "scheduled") {
+  const conv = createConversation({ title, conversationType: type });
+  rawRun(
+    "test:routeToSystemBucket",
+    "UPDATE conversations SET group_id = ? WHERE id = ?",
+    type === "scheduled" ? "system:scheduled" : "system:background",
+    conv.id,
+  );
+  return conv;
+}
+
+/** Titles the sidebar's standard listing would render. */
+function visibleTitles(): string[] {
+  return listConversations({ limit: 100 }).map((c) => c.title ?? "");
+}
+
+function titlesInGroup(groupId: string): string[] {
+  return listConversations({ limit: 100, groupId }).map((c) => c.title ?? "");
+}
+
+beforeEach(() => {
+  getDb().delete(conversations).run();
+});
+
+describe("pinning a background conversation", () => {
+  test("shows it in Pinned", () => {
+    const conv = seedRoutedBackground("bg-job", "background");
+    expect(visibleTitles()).toEqual([]);
+
+    batchSetDisplayOrders([
+      { id: conv.id, displayOrder: 0, groupId: "system:pinned" },
+    ]);
+
+    expect(titlesInGroup("system:pinned")).toEqual(["bg-job"]);
+  });
+
+  test("unpinning lands it in Recents rather than hiding it again", () => {
+    const conv = seedRoutedBackground("bg-job", "background");
+    batchSetDisplayOrders([
+      { id: conv.id, displayOrder: 0, groupId: "system:pinned" },
+    ]);
+
+    batchSetDisplayOrders([
+      { id: conv.id, displayOrder: null, groupId: "system:all" },
+    ]);
+
+    expect(titlesInGroup("system:all")).toEqual(["bg-job"]);
+  });
+});
+
+describe("filing a background conversation into a custom group", () => {
+  test("shows it in that group", () => {
+    const group = createGroup("Car Chat");
+    const conv = seedRoutedBackground("bg-job", "background");
+
+    batchSetDisplayOrders([
+      { id: conv.id, displayOrder: 0, groupId: group.id },
+    ]);
+
+    expect(titlesInGroup(group.id)).toEqual(["bg-job"]);
+  });
+
+  test("removing it from the group lands it in Recents rather than losing it", () => {
+    const group = createGroup("Car Chat");
+    const conv = seedRoutedBackground("bg-job", "background");
+    batchSetDisplayOrders([
+      { id: conv.id, displayOrder: 0, groupId: group.id },
+    ]);
+
+    batchSetDisplayOrders([
+      { id: conv.id, displayOrder: null, groupId: "system:all" },
+    ]);
+
+    expect(titlesInGroup("system:all")).toEqual(["bg-job"]);
+    expect(visibleTitles()).toEqual(["bg-job"]);
+  });
+
+  test("applies to scheduled conversations too", () => {
+    const group = createGroup("Morning Briefs");
+    const conv = seedRoutedBackground("sched-job", "scheduled");
+
+    batchSetDisplayOrders([
+      { id: conv.id, displayOrder: 0, groupId: group.id },
+    ]);
+    batchSetDisplayOrders([
+      { id: conv.id, displayOrder: null, groupId: "system:all" },
+    ]);
+
+    expect(titlesInGroup("system:all")).toEqual(["sched-job"]);
+  });
+});
+
+describe("what promotion must not do", () => {
+  test("filing into system:background still demotes", () => {
+    const conv = seedRoutedBackground("bg-job", "background");
+    // Promote first, so the demotion has something to undo.
+    batchSetDisplayOrders([
+      { id: conv.id, displayOrder: 0, groupId: "system:pinned" },
+    ]);
+    expect(titlesInGroup("system:pinned")).toEqual(["bg-job"]);
+
+    batchSetDisplayOrders([
+      { id: conv.id, displayOrder: null, groupId: "system:background" },
+    ]);
+
+    expect(visibleTitles()).toEqual([]);
+  });
+
+  test("a background conversation nobody placed anywhere stays hidden", () => {
+    seedRoutedBackground("untouched", "background");
+
+    expect(visibleTitles()).toEqual([]);
+  });
+
+  test("moving to system:all does not by itself promote", () => {
+    // Removal is not a promotion: a row that was never filed into a section
+    // the user reads must not become visible just by being moved out of its
+    // system bucket.
+    const conv = seedRoutedBackground("bg-job", "background");
+
+    batchSetDisplayOrders([
+      { id: conv.id, displayOrder: null, groupId: "system:all" },
+    ]);
+
+    expect(visibleTitles()).toEqual([]);
+  });
+
+  test("unpinning through the legacy isPinned path still lands in Recents", () => {
+    // Old clients send `isPinned: false` with no `groupId`, and that branch
+    // restores the row's original system bucket to keep its provenance. It
+    // deliberately does not clear the promotion: unpinning is not a demotion,
+    // so the conversation belongs in Recents afterwards, the same as the
+    // modern path that sends `groupId: "system:all"`.
+    //
+    // The row therefore sits in `system:background` while remaining visible.
+    // That is the intended split: the bucket records where the conversation
+    // came from, `surfaced_at` records that the user promoted it, and only
+    // an explicit demotion clears the latter.
+    const conv = seedRoutedBackground("bg-job", "background");
+    batchSetDisplayOrders([
+      { id: conv.id, displayOrder: 0, groupId: "system:pinned" },
+    ]);
+
+    batchSetDisplayOrders([
+      { id: conv.id, displayOrder: null, isPinned: false },
+    ]);
+
+    expect(visibleTitles()).toEqual(["bg-job"]);
+    expect(titlesInGroup("system:all")).toEqual(["bg-job"]);
+  });
+
+  test("standard conversations are not stamped as surfaced", () => {
+    // They are already visible, so stamping them would leave `surfaced_at`
+    // meaning nothing.
+    const group = createGroup("Car Chat");
+    const conv = createConversation("plain-chat");
+
+    batchSetDisplayOrders([
+      { id: conv.id, displayOrder: 0, groupId: group.id },
+    ]);
+
+    const row = getDb()
+      .all(`SELECT surfaced_at FROM conversations WHERE id = '${conv.id}'`)
+      .at(0) as { surfaced_at: number | null };
+    expect(row.surfaced_at).toBeNull();
+  });
+});

package/src/__tests__/custom-group-listing-visibility.test.ts

@@ -33,7 +33,7 @@ describe("custom-group standard-listing visibility", () => {
   });
 
   function listedIds(): string[] {
-    return listConversations(undefined, "standard").map((c) => c.id);
+    return listConversations({ conversationType: "standard" }).map((c) => c.id);
   }
 
   test("scheduled conversation in a custom group is listed", () => {

package/src/__tests__/profile-availability-incomplete.test.ts

@@ -0,0 +1,113 @@
+/**
+ * `computeProfileAvailability` on profiles that carry no dispatchable pair.
+ *
+ * A rung only wins if its profile carries both a provider and a model
+ * (`usableEntry` in config/llm-resolver.ts). A profile missing either is
+ * skipped and the call site resolves elsewhere, so the profiles read has to
+ * report that state rather than returning "nothing to judge", which clients
+ * render as healthy.
+ */
+
+import { describe, expect, test } from "bun:test";
+
+import {
+  computeProfileAvailability,
+  isUnavailable,
+} from "../providers/inference/connection-availability.js";
+import { describeUnavailableProfile } from "../runtime/routes/inference-profile-availability-guard.js";
+
+describe("incomplete profiles", () => {
+  test("no provider and no model reports both as missing", async () => {
+    const availability = await computeProfileAvailability({});
+    expect(availability?.status).toBe("incomplete");
+    expect(availability?.message).toContain("a provider and a model");
+  });
+
+  test("a model with no provider names the provider", async () => {
+    const availability = await computeProfileAvailability({
+      model: "claude-opus-5",
+    });
+    expect(availability?.status).toBe("incomplete");
+    expect(availability?.message).toContain("a provider");
+    expect(availability?.message).not.toContain("a provider and a model");
+  });
+
+  test("a provider with no model names the model", async () => {
+    const availability = await computeProfileAvailability({
+      provider: "anthropic",
+    });
+    expect(availability?.status).toBe("incomplete");
+    expect(availability?.message).toContain("a model");
+  });
+
+  // The destination is deliberately unnamed: which profile a call site falls
+  // back to depends on the call site, so the message states the effect only.
+  test("the message names the effect without naming a destination", async () => {
+    const availability = await computeProfileAvailability({});
+    expect(availability?.message).toContain("fall back to another profile");
+  });
+});
+
+describe("mix profiles", () => {
+  // A mix carries no provider or model of its own: the resolver expands it to
+  // a seeded arm and judges that arm. Reporting a mix as incomplete would put
+  // a warning on every working mix profile.
+  test("a mix still reports nothing to judge", async () => {
+    const availability = await computeProfileAvailability({
+      mix: [
+        { profile: "balanced", weight: 1 },
+        { profile: "quality", weight: 1 },
+      ],
+    });
+    expect(availability).toBeNull();
+  });
+
+  test("a mix that also names a provider and model is judged normally", async () => {
+    const availability = await computeProfileAvailability({
+      mix: [{ profile: "balanced", weight: 1 }],
+      provider: "anthropic",
+      model: "claude-opus-5",
+    });
+    expect(availability?.status).not.toBe("incomplete");
+  });
+});
+
+describe("selection guards", () => {
+  // The resolver skips an incomplete profile on every turn, so pinning one
+  // means the user's selection is not what runs. Before `incomplete` existed,
+  // a provider without a model reached the auto-resolve branch and could
+  // return `missing_connection`, which these guards already rejected; the new
+  // verdict has to keep that door shut rather than open it.
+  test("an incomplete profile counts as unavailable", async () => {
+    expect(isUnavailable(await computeProfileAvailability({}))).toBe(true);
+    expect(
+      isUnavailable(
+        await computeProfileAvailability({ provider: "anthropic" }),
+      ),
+    ).toBe(true);
+  });
+
+  test("a mix is still not judged, so it is not blocked", async () => {
+    expect(
+      isUnavailable(
+        await computeProfileAvailability({
+          mix: [{ profile: "balanced", weight: 1 }],
+        }),
+      ),
+    ).toBe(false);
+  });
+
+  // `describeUnavailableProfile` interpolates the provider, which an
+  // incomplete profile may not have. Its guidance must not leak "undefined".
+  test("the repair guidance names the fix without inventing a provider", async () => {
+    const availability = await computeProfileAvailability({});
+    const message = await describeUnavailableProfile({
+      availability: availability!,
+      provider: String(undefined),
+      repair: { kind: "repoint", profileName: "half-made" },
+      escapeHatch: false,
+    });
+    expect(message).not.toContain("undefined");
+    expect(message).toContain("provider and a model");
+  });
+});