@vellumai/assistant 0.11.0-staging.1 → 0.11.0-staging.2

package/openapi.yaml

@@ -29334,7 +29334,9 @@ paths:
           required: false
           schema:
             type: string
-          description: Parent conversation ID (required)
+          description:
+            The subagent's own conversation ID. Fallback only — when the daemon knows the subagent (live or
+            rehydrated), it resolves the conversation itself and this parameter is ignored.
       responses:
         "200":
           description: Successful response
@@ -29397,6 +29399,10 @@ paths:
                         - type
                         - content
                       additionalProperties: false
+                  label:
+                    type: string
+                  parentToolUseId:
+                    type: string
                 required:
                   - subagentId
                   - events
@@ -29489,8 +29495,9 @@ paths:
       operationId: subagents_reconcile_get
       summary: Reconcile subagent live status
       description:
-        Returns the live in-memory status of all subagents known to the daemon for a given parent conversation.
-        Subagents not in the response are orphaned.
+        Returns the live in-memory status of all subagents known to the daemon for a given parent conversation,
+        with the identity fields a client needs to rebuild a store entry it never saw spawn (label, the subagent's own
+        conversation id, and the spawning tool-use id). Subagents not in the response are orphaned.
       tags:
         - subagents
       parameters:
@@ -29517,6 +29524,12 @@ paths:
                       properties:
                         status:
                           type: string
+                        label:
+                          type: string
+                        conversationId:
+                          type: string
+                        parentToolUseId:
+                          type: string
                       required:
                         - status
                       additionalProperties: false
@@ -31536,7 +31549,8 @@ paths:
       summary: Register a webhook callback URL
       description:
         Resolves a stable callback URL for a webhook type. On platform-managed assistants, registers the route with
-        the platform gateway. On self-hosted assistants, uses the configured ingress.publicBaseUrl.
+        the platform gateway. Otherwise uses the configured ingress.publicBaseUrl, falling back to the platform gateway
+        when no ingress is configured and the assistant is connected to the platform.
       tags:
         - webhooks
       requestBody:

package/package.json

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

package/src/__tests__/app-conversation-ids-backfill.test.ts

@@ -11,6 +11,7 @@ import {
 } from "../apps/app-store.js";
 import { getDb } from "../persistence/db-connection.js";
 import { initializeDb } from "../persistence/db-init.js";
+import { migrateBackfillAppConversationLineage } from "../persistence/migrations/354-backfill-app-conversation-lineage.js";
 import { rawRun } from "../persistence/raw-query.js";
 
 // Initialize db once for all tests
@@ -57,15 +58,18 @@ function insertMessage(
 }
 
 /** Insert a conversation row so FK constraints are satisfied. */
-function insertConversation(id: string): void {
+function insertConversation(id: string, parentConversationId?: string): void {
   const now = Date.now();
   rawRun(
     "test:insertConversation",
-    `INSERT OR IGNORE INTO conversations (id, title, created_at, updated_at) VALUES (?, ?, ?, ?)`,
+    `INSERT OR IGNORE INTO conversations (
+      id, title, created_at, updated_at, parent_conversation_id
+    ) VALUES (?, ?, ?, ?, ?)`,
     id,
     "test",
     now,
     now,
+    parentConversationId ?? null,
   );
 }
 
@@ -272,3 +276,30 @@ describe("backfillAppConversationIds", () => {
     expect(loaded?.conversationIds).toEqual([existingConvId, backfillConvId]);
   });
 });
+
+describe("migrateBackfillAppConversationLineage", () => {
+  test("adds inherited ancestors to existing direct app associations", () => {
+    const app = createApp(makeAppParams("Lineage App"));
+    const rootConversationId = "conv-lineage-root";
+    const parentConversationId = "conv-lineage-parent";
+    const childConversationId = "conv-lineage-child";
+    insertConversation(rootConversationId);
+    insertConversation(parentConversationId, rootConversationId);
+    insertConversation(childConversationId, parentConversationId);
+    addAppConversationId(app.id, childConversationId);
+
+    migrateBackfillAppConversationLineage();
+    migrateBackfillAppConversationLineage();
+
+    const loaded = getApp(app.id);
+    expect(loaded?.conversationIds).toEqual([
+      childConversationId,
+      parentConversationId,
+      rootConversationId,
+    ]);
+    expect(loaded?.inheritedConversationIds).toEqual([
+      parentConversationId,
+      rootConversationId,
+    ]);
+  });
+});

package/src/__tests__/app-conversation-ids.test.ts

@@ -7,8 +7,16 @@ import {
   addAppConversationId,
   createApp,
   getApp,
+  isDirectAppConversation,
+  linkAppToConversationLineage,
   listAppsByConversation,
 } from "../apps/app-store.js";
+import {
+  deleteConversation,
+  removeSubagentConversation,
+  setConversation,
+  setSubagentConversation,
+} from "../daemon/conversation-registry.js";
 
 // ---------------------------------------------------------------------------
 // Helpers
@@ -16,6 +24,41 @@ import {
 
 let testDataDir: string;
 
+/**
+ * The registry stores live `Conversation` instances; lineage resolution only
+ * reads `parentConversationId`, so a minimal stand-in is enough.
+ */
+type RegistryConversation = Parameters<typeof setConversation>[1];
+
+const registeredTopLevel: string[] = [];
+const registeredSubagents: [string, RegistryConversation][] = [];
+
+function stubConversation(parentConversationId?: string): RegistryConversation {
+  return { parentConversationId } as unknown as RegistryConversation;
+}
+
+/** Register a resident top-level conversation, optionally forked from a parent. */
+function registerConversation(id: string, parentId?: string): void {
+  setConversation(id, stubConversation(parentId));
+  registeredTopLevel.push(id);
+}
+
+/** Register a live subagent conversation forked from `parentId`. */
+function registerSubagent(id: string, parentId: string): void {
+  const conversation = stubConversation(parentId);
+  setSubagentConversation(id, conversation);
+  registeredSubagents.push([id, conversation]);
+}
+
+function clearRegisteredConversations(): void {
+  for (const id of registeredTopLevel.splice(0)) {
+    deleteConversation(id);
+  }
+  for (const [id, conversation] of registeredSubagents.splice(0)) {
+    removeSubagentConversation(id, conversation);
+  }
+}
+
 function freshTempDir(): string {
   return join(
     tmpdir(),
@@ -41,6 +84,7 @@ beforeEach(() => {
 });
 
 afterEach(() => {
+  clearRegisteredConversations();
   if (existsSync(testDataDir)) {
     rmSync(testDataDir, { recursive: true, force: true });
   }
@@ -149,3 +193,163 @@ describe("listAppsByConversation", () => {
     expect(result).toEqual([]);
   });
 });
+
+// ---------------------------------------------------------------------------
+// linkAppToConversationLineage
+// ---------------------------------------------------------------------------
+
+describe("linkAppToConversationLineage", () => {
+  test("an app created in a forked conversation carries the fork and its parent", () => {
+    registerConversation("conv-visible");
+    registerSubagent("conv-fork", "conv-visible");
+
+    const app = createApp(makeAppParams("Continuation App"));
+    linkAppToConversationLineage(app.id, "conv-fork");
+
+    expect(getApp(app.id)?.conversationIds).toEqual([
+      "conv-fork",
+      "conv-visible",
+    ]);
+  });
+
+  test("the user-visible ancestor lists an app created by a background subagent", () => {
+    registerConversation("conv-visible");
+    registerSubagent("conv-fork", "conv-visible");
+
+    const app = createApp(makeAppParams("Continuation App"));
+    linkAppToConversationLineage(app.id, "conv-fork");
+
+    const visible = listAppsByConversation("conv-visible");
+    expect(visible).toHaveLength(1);
+    expect(visible[0].id).toBe(app.id);
+  });
+
+  test("walks nested subagents up to the user-visible thread", () => {
+    registerConversation("conv-visible");
+    registerSubagent("conv-outer", "conv-visible");
+    registerSubagent("conv-inner", "conv-outer");
+
+    const app = createApp(makeAppParams("Nested App"));
+    linkAppToConversationLineage(app.id, "conv-inner");
+
+    expect(getApp(app.id)?.conversationIds).toEqual([
+      "conv-inner",
+      "conv-outer",
+      "conv-visible",
+    ]);
+  });
+
+  test("re-linking the same lineage is idempotent", () => {
+    registerConversation("conv-visible");
+    registerSubagent("conv-fork", "conv-visible");
+
+    const app = createApp(makeAppParams("Repeat App"));
+    linkAppToConversationLineage(app.id, "conv-fork");
+    linkAppToConversationLineage(app.id, "conv-fork");
+
+    expect(getApp(app.id)?.conversationIds).toEqual([
+      "conv-fork",
+      "conv-visible",
+    ]);
+  });
+
+  test("a lineage of one behaves exactly like addAppConversationId", () => {
+    registerConversation("conv-plain");
+
+    const linked = createApp(makeAppParams("Linked App"));
+    const direct = createApp(makeAppParams("Direct App"));
+    linkAppToConversationLineage(linked.id, "conv-plain");
+    addAppConversationId(direct.id, "conv-plain");
+
+    expect(getApp(linked.id)?.conversationIds).toEqual(["conv-plain"]);
+    expect(getApp(direct.id)?.conversationIds).toEqual(
+      getApp(linked.id)?.conversationIds,
+    );
+    expect(listAppsByConversation("conv-plain")).toHaveLength(2);
+  });
+
+  test("an unregistered conversation links only itself", () => {
+    const app = createApp(makeAppParams("Orphan App"));
+    linkAppToConversationLineage(app.id, "conv-gone");
+
+    expect(getApp(app.id)?.conversationIds).toEqual(["conv-gone"]);
+  });
+
+  test("a non-existent app is a no-op", () => {
+    registerConversation("conv-visible");
+    registerSubagent("conv-fork", "conv-visible");
+
+    expect(() =>
+      linkAppToConversationLineage("nonexistent-id", "conv-fork"),
+    ).not.toThrow();
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Direct vs inherited associations
+// ---------------------------------------------------------------------------
+
+describe("isDirectAppConversation", () => {
+  test("the seed conversation is direct and its ancestors are inherited", () => {
+    registerConversation("conv-visible");
+    registerSubagent("conv-fork", "conv-visible");
+
+    const app = createApp(makeAppParams("Continuation App"));
+    linkAppToConversationLineage(app.id, "conv-fork");
+
+    const loaded = getApp(app.id)!;
+    expect(loaded.inheritedConversationIds).toEqual(["conv-visible"]);
+    expect(isDirectAppConversation(loaded, "conv-fork")).toBe(true);
+    expect(isDirectAppConversation(loaded, "conv-visible")).toBe(false);
+  });
+
+  test("an inherited association still lists the app in the ancestor thread", () => {
+    registerConversation("conv-visible");
+    registerSubagent("conv-fork", "conv-visible");
+
+    const app = createApp(makeAppParams("Continuation App"));
+    linkAppToConversationLineage(app.id, "conv-fork");
+
+    expect(listAppsByConversation("conv-visible").map((a) => a.id)).toEqual([
+      app.id,
+    ]);
+  });
+
+  test("a record carrying no inherited list treats every association as direct", () => {
+    const app = createApp(makeAppParams("Plain App"));
+    addAppConversationId(app.id, "conv-plain");
+
+    const loaded = getApp(app.id)!;
+    expect(loaded.inheritedConversationIds).toBeUndefined();
+    expect(isDirectAppConversation(loaded, "conv-plain")).toBe(true);
+  });
+
+  test("a direct association supersedes an earlier inherited one", () => {
+    registerConversation("conv-visible");
+    registerSubagent("conv-fork", "conv-visible");
+
+    const app = createApp(makeAppParams("Adopted App"));
+    linkAppToConversationLineage(app.id, "conv-fork");
+    // The user later works on the same app in the thread they can see.
+    expect(addAppConversationId(app.id, "conv-visible")).toBe(false);
+
+    const loaded = getApp(app.id)!;
+    expect(loaded.conversationIds).toEqual(["conv-fork", "conv-visible"]);
+    expect(loaded.inheritedConversationIds).toEqual([]);
+    expect(isDirectAppConversation(loaded, "conv-visible")).toBe(true);
+  });
+
+  test("an inherited link never demotes an existing direct association", () => {
+    registerConversation("conv-visible");
+    registerSubagent("conv-fork", "conv-visible");
+
+    const app = createApp(makeAppParams("Foreground App"));
+    addAppConversationId(app.id, "conv-visible");
+    linkAppToConversationLineage(app.id, "conv-fork");
+
+    const loaded = getApp(app.id)!;
+    expect(loaded.conversationIds).toEqual(["conv-visible", "conv-fork"]);
+    expect(loaded.inheritedConversationIds).toBeUndefined();
+    expect(isDirectAppConversation(loaded, "conv-visible")).toBe(true);
+  });
+});

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

@@ -0,0 +1,279 @@
+import type { Database } from "bun:sqlite";
+import { beforeEach, describe, expect, test } from "bun:test";
+
+import {
+  createConversation,
+  getDisplayMetaForConversations,
+} from "../persistence/conversation-crud.js";
+import { ensureGroupMigration } from "../persistence/conversation-group-migration.js";
+import { getDb } from "../persistence/db-connection.js";
+import { initializeDb } from "../persistence/db-init.js";
+import { executeConversationGroupCreate } from "../tools/conversation-groups/group_create.js";
+import { executeConversationGroupList } from "../tools/conversation-groups/group_list.js";
+import { executeConversationMoveToGroup } from "../tools/conversation-groups/move_to_group.js";
+import type { ToolContext } from "../tools/types.js";
+
+await initializeDb();
+ensureGroupMigration();
+
+function getRawDb(): Database {
+  return (getDb() as unknown as { $client: Database }).$client;
+}
+
+const ctx: ToolContext = {
+  workingDir: "/tmp",
+  conversationId: "test-conversation",
+  trustClass: "guardian",
+};
+
+function clearState(): void {
+  const raw = getRawDb();
+  raw.run("DELETE FROM conversations");
+  raw.run("DELETE FROM conversation_groups WHERE is_system_group = 0");
+}
+
+function extractGroupId(content: string): string {
+  const match = content.match(/id: ([0-9a-f-]{36})/);
+  expect(match).not.toBeNull();
+  return match![1];
+}
+
+function groupIdOf(conversationId: string): string | null {
+  return (
+    getDisplayMetaForConversations([conversationId]).get(conversationId)
+      ?.groupId ?? null
+  );
+}
+
+// ── conversation_group_list ─────────────────────────────────────────
+
+describe("conversation_group_list tool", () => {
+  beforeEach(clearState);
+
+  test("lists system groups", async () => {
+    const result = await executeConversationGroupList({}, ctx);
+
+    expect(result.isError).toBe(false);
+    expect(result.content).toContain("Pinned (id: system:pinned)");
+    expect(result.content).toContain("Recents (id: system:all)");
+    expect(result.content).toContain("[system group]");
+  });
+
+  test("lists custom groups after creation", async () => {
+    await executeConversationGroupCreate({ name: "Work" }, ctx);
+
+    const result = await executeConversationGroupList({}, ctx);
+    expect(result.isError).toBe(false);
+    expect(result.content).toContain("Work");
+  });
+});
+
+// ── conversation_group_create ───────────────────────────────────────
+
+describe("conversation_group_create tool", () => {
+  beforeEach(clearState);
+
+  test("creates a custom group", async () => {
+    const result = await executeConversationGroupCreate(
+      { name: "Travel planning" },
+      ctx,
+    );
+
+    expect(result.isError).toBe(false);
+    expect(result.content).toContain('Created group "Travel planning"');
+  });
+
+  test("trims the name", async () => {
+    const result = await executeConversationGroupCreate(
+      { name: "  Padded  " },
+      ctx,
+    );
+
+    expect(result.isError).toBe(false);
+    expect(result.content).toContain('Created group "Padded"');
+  });
+
+  test("reuses an existing group with the same name (case-insensitive)", async () => {
+    const first = await executeConversationGroupCreate({ name: "Work" }, ctx);
+    const firstId = extractGroupId(first.content);
+
+    const second = await executeConversationGroupCreate({ name: "work" }, ctx);
+    expect(second.isError).toBe(false);
+    expect(second.content).toContain("already exists");
+    expect(second.content).toContain(firstId);
+  });
+
+  test("rejects system group names", async () => {
+    const result = await executeConversationGroupCreate(
+      { name: "pinned" },
+      ctx,
+    );
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain("system group");
+  });
+
+  test("rejects missing name", async () => {
+    const result = await executeConversationGroupCreate({}, ctx);
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain("name is required");
+  });
+});
+
+// ── conversation_move_to_group ──────────────────────────────────────
+
+describe("conversation_move_to_group tool", () => {
+  beforeEach(clearState);
+
+  test("moves a conversation into a custom group by name", async () => {
+    createConversation({ id: "conv-1", title: "Trip ideas" });
+    await executeConversationGroupCreate({ name: "Travel" }, ctx);
+
+    const result = await executeConversationMoveToGroup(
+      { group: "travel", conversation_id: "conv-1" },
+      ctx,
+    );
+
+    expect(result.isError).toBe(false);
+    expect(result.content).toContain('Moved "Trip ideas" to group "Travel"');
+    expect(groupIdOf("conv-1")).not.toBe("system:all");
+  });
+
+  test("moves a conversation by group id", async () => {
+    createConversation({ id: "conv-2" });
+    const created = await executeConversationGroupCreate({ name: "Work" }, ctx);
+    const groupId = extractGroupId(created.content);
+
+    const result = await executeConversationMoveToGroup(
+      { group: groupId, conversation_id: "conv-2" },
+      ctx,
+    );
+
+    expect(result.isError).toBe(false);
+    expect(groupIdOf("conv-2")).toBe(groupId);
+  });
+
+  test("defaults to the current conversation", async () => {
+    createConversation({ id: "test-conversation", title: "This chat" });
+    await executeConversationGroupCreate({ name: "Inbox" }, ctx);
+
+    const result = await executeConversationMoveToGroup(
+      { group: "Inbox" },
+      ctx,
+    );
+
+    expect(result.isError).toBe(false);
+    expect(result.content).toContain('Moved "This chat" to group "Inbox"');
+  });
+
+  test("moving to Pinned pins the conversation", async () => {
+    createConversation({ id: "conv-pin" });
+
+    const result = await executeConversationMoveToGroup(
+      { group: "Pinned", conversation_id: "conv-pin" },
+      ctx,
+    );
+
+    expect(result.isError).toBe(false);
+    expect(result.content).toContain("pinned");
+    expect(groupIdOf("conv-pin")).toBe("system:pinned");
+    const pinned = getRawDb()
+      .query("SELECT is_pinned FROM conversations WHERE id = ?")
+      .get("conv-pin") as { is_pinned: number };
+    expect(pinned.is_pinned).toBe(1);
+  });
+
+  test("preserves display_order across a move", async () => {
+    createConversation({ id: "conv-ord" });
+    getRawDb().run(
+      "UPDATE conversations SET display_order = 7 WHERE id = 'conv-ord'",
+    );
+    await executeConversationGroupCreate({ name: "Ordered" }, ctx);
+
+    const result = await executeConversationMoveToGroup(
+      { group: "Ordered", conversation_id: "conv-ord" },
+      ctx,
+    );
+
+    expect(result.isError).toBe(false);
+    const row = getRawDb()
+      .query("SELECT display_order FROM conversations WHERE id = ?")
+      .get("conv-ord") as { display_order: number | null };
+    expect(row.display_order).toBe(7);
+  });
+
+  test("no-op when already in the target group", async () => {
+    createConversation({ id: "conv-3", title: "Settled" });
+
+    const result = await executeConversationMoveToGroup(
+      { group: "Recents", conversation_id: "conv-3" },
+      ctx,
+    );
+
+    expect(result.isError).toBe(false);
+    expect(result.content).toContain("already in group");
+  });
+
+  test("errors on unknown group with available list", async () => {
+    createConversation({ id: "conv-4" });
+
+    const result = await executeConversationMoveToGroup(
+      { group: "Nonexistent", conversation_id: "conv-4" },
+      ctx,
+    );
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain('No group named "Nonexistent"');
+    expect(result.content).toContain("Available groups:");
+  });
+
+  test("errors on ambiguous group name", async () => {
+    // Two custom groups whose names differ only by case
+    await executeConversationGroupCreate({ name: "Alpha" }, ctx);
+    // Bypass the tool's dedup to create the case-variant directly
+    getRawDb().run(
+      "INSERT INTO conversation_groups (id, name, sort_position, is_system_group, created_at, updated_at) VALUES ('dup-group-id', 'alpha', 99, 0, 0, 0)",
+    );
+    createConversation({ id: "conv-5" });
+
+    const result = await executeConversationMoveToGroup(
+      { group: "ALPHA", conversation_id: "conv-5" },
+      ctx,
+    );
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain("ambiguous");
+    expect(result.content).toContain("Retry with the group id");
+  });
+
+  test("errors on unknown conversation", async () => {
+    const result = await executeConversationMoveToGroup(
+      { group: "Recents", conversation_id: "missing-conv" },
+      ctx,
+    );
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain("no conversation found");
+  });
+
+  test("notes hidden conversation types", async () => {
+    createConversation({ id: "conv-bg", conversationType: "background" });
+    await executeConversationGroupCreate({ name: "Visible" }, ctx);
+
+    const result = await executeConversationMoveToGroup(
+      { group: "Visible", conversation_id: "conv-bg" },
+      ctx,
+    );
+
+    expect(result.isError).toBe(false);
+    expect(result.content).toContain("hidden from the sidebar");
+  });
+
+  test("rejects missing group", async () => {
+    const result = await executeConversationMoveToGroup({}, ctx);
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain("group is required");
+  });
+});