@vellumai/assistant 0.12.0-staging.1 → 0.12.0

package/src/__tests__/app-builder-icon-names.test.ts

@@ -0,0 +1,29 @@
+/**
+ * The app-builder skill lists the icon names a model may put in
+ * `preview.icon`, and `@vellumai/app-icons` is what the executor accepts.
+ * The skill is prose, so nothing types it against the package; this pins
+ * the two lists to each other.
+ */
+
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { describe, expect, test } from "bun:test";
+
+import { APP_ICON_NAMES } from "@vellumai/app-icons";
+
+const SKILL_PATH = join(
+  import.meta.dir,
+  "../config/bundled-skills/app-builder/SKILL.md",
+);
+
+describe("app-builder skill icon names", () => {
+  test("lists exactly the registry's names, in its order", () => {
+    const skill = readFileSync(SKILL_PATH, "utf8");
+    const line = skill
+      .split("\n")
+      .find((l) => l.startsWith("**App icon names**"));
+    expect(line).toBeDefined();
+    const listed = [...line!.matchAll(/`([a-z0-9-]+)`/g)].map((m) => m[1]);
+    expect(listed).toEqual([...APP_ICON_NAMES]);
+  });
+});

package/src/__tests__/assistant-attachment-directive.test.ts

@@ -218,6 +218,9 @@ describe("resolveSandboxDirective", () => {
     expect(result.draft!.mimeType).toBe("text/plain");
     expect(result.draft!.sizeBytes).toBe(11);
     expect(result.draft!.kind).toBe("document");
+    // The resolved path, not the named one: callers that surface the file
+    // need to know where it actually is.
+    expect(result.draft!.sourcePath).toBe(filePath);
   });
 
   test("uses directive filename override when provided", () => {
@@ -360,6 +363,7 @@ describe("resolveHostDirective", () => {
     expect(result.draft!.filename).toBe("doc.txt");
     expect(result.draft!.mimeType).toBe("text/plain");
     expect(result.draft!.sizeBytes).toBe(12);
+    expect(result.draft!.sourcePath).toBe(filePath);
   });
 
   test("skips when user denies", async () => {

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

@@ -230,6 +230,7 @@ mock.module("../daemon/conversation-attachments.js", () => ({
     assistantAttachments: [],
     emittedAttachments: [],
     directiveWarnings: [],
+    persistedFiles: [],
   }),
   approveHostAttachmentRead: async () => true,
   formatAttachmentWarnings: () => "",

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

@@ -339,6 +339,7 @@ const resolveAssistantAttachmentsMock = mock(async () => ({
   assistantAttachments: [],
   emittedAttachments: [],
   directiveWarnings: [],
+  persistedFiles: [],
 }));
 mock.module("../daemon/conversation-attachments.js", () => ({
   resolveAssistantAttachments: resolveAssistantAttachmentsMock,

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

@@ -584,6 +584,7 @@ const resolveAssistantAttachmentsMock = mock(async () => ({
   assistantAttachments: [],
   emittedAttachments: [],
   directiveWarnings: [],
+  persistedFiles: [],
 }));
 mock.module("../daemon/conversation-attachments.js", () => ({
   resolveAssistantAttachments: resolveAssistantAttachmentsMock,
@@ -1036,6 +1037,7 @@ beforeEach(() => {
     assistantAttachments: [],
     emittedAttachments: [],
     directiveWarnings: [],
+    persistedFiles: [],
   }));
   mockMessageById = null;
   resetConversationNoticesForTests();

package/src/__tests__/conversation-attachments.test.ts

@@ -187,6 +187,148 @@ describe("resolveAssistantAttachments", () => {
     // fileBacked flag is always true now
     expect(emitted.fileBacked).toBe(true);
   });
+
+  test("persistedFiles carries only directives that resolved and persisted", async () => {
+    const conv = createConversation("test-conv-persisted");
+    const msg = await addMessage(conv.id, "assistant", "hello");
+
+    const accepted: AssistantAttachmentDraft = {
+      sourceType: "sandbox_file",
+      filename: "plan.md",
+      mimeType: "text/markdown",
+      dataBase64: makeBase64(64),
+      sizeBytes: 64,
+      kind: "document",
+      sourcePath: "notes/plan.md",
+    };
+    const oversized: AssistantAttachmentDraft = {
+      sourceType: "sandbox_file",
+      filename: "huge.bin",
+      mimeType: "application/octet-stream",
+      dataBase64: makeBase64(64),
+      sizeBytes: 64,
+      kind: "document",
+      sourcePath: "notes/huge.bin",
+    };
+    const toolBlock: AssistantAttachmentDraft = {
+      sourceType: "tool_block",
+      filename: "tool-output.png",
+      mimeType: "image/png",
+      dataBase64: makeBase64(64),
+      sizeBytes: 64,
+      kind: "image",
+    };
+
+    mock.module("../daemon/assistant-attachments.js", () => ({
+      // The missing file's directive produces a warning and no draft.
+      resolveDirectives: () =>
+        Promise.resolve({
+          drafts: [accepted, oversized],
+          warnings: [
+            'Skipped sandbox attachment "notes/missing.md": file not found.',
+          ],
+        }),
+      contentBlocksToDrafts: () => [toolBlock],
+      deduplicateDrafts: (d: AssistantAttachmentDraft[]) => d,
+      validateDrafts: (d: AssistantAttachmentDraft[]) => ({
+        accepted: d.filter((draft) => draft.filename !== "huge.bin"),
+        warnings: ['Skipped attachment "huge.bin": too large.'],
+      }),
+    }));
+
+    const { resolveAssistantAttachments: resolve } =
+      await import("../daemon/conversation-attachments.js");
+
+    const result = await resolve(
+      [
+        {
+          source: "sandbox" as const,
+          path: "notes/plan.md",
+          filename: "plan.md",
+          mimeType: "text/markdown",
+        },
+        {
+          source: "sandbox" as const,
+          path: "notes/missing.md",
+          filename: undefined,
+          mimeType: undefined,
+        },
+        {
+          source: "sandbox" as const,
+          path: "notes/huge.bin",
+          filename: undefined,
+          mimeType: undefined,
+        },
+      ],
+      [
+        {
+          type: "image",
+          source: { type: "base64", media_type: "image/png", data: "" },
+        },
+      ],
+      [],
+      "/tmp",
+      async () => true,
+      msg.id,
+    );
+
+    // The rejected directive, the failed validation, and the tool block
+    // (which has no file of its own) are all absent.
+    expect(result.persistedFiles).toEqual([
+      {
+        sourcePath: "notes/plan.md",
+        displayName: "plan.md",
+        sourceType: "sandbox_file",
+      },
+    ]);
+  });
+
+  test("persistedFiles is empty when there is no message to persist against", async () => {
+    const accepted: AssistantAttachmentDraft = {
+      sourceType: "sandbox_file",
+      filename: "plan.md",
+      mimeType: "text/markdown",
+      dataBase64: makeBase64(64),
+      sizeBytes: 64,
+      kind: "document",
+      sourcePath: "notes/plan.md",
+    };
+
+    mock.module("../daemon/assistant-attachments.js", () => ({
+      resolveDirectives: () =>
+        Promise.resolve({ drafts: [accepted], warnings: [] }),
+      contentBlocksToDrafts: () => [],
+      deduplicateDrafts: (d: AssistantAttachmentDraft[]) => d,
+      validateDrafts: (d: AssistantAttachmentDraft[]) => ({
+        accepted: d,
+        warnings: [],
+      }),
+    }));
+
+    const { resolveAssistantAttachments: resolve } =
+      await import("../daemon/conversation-attachments.js");
+
+    // No assistant message id: the draft is emitted for this turn only and
+    // nothing is stored, so it is not a persisted file.
+    const result = await resolve(
+      [
+        {
+          source: "sandbox" as const,
+          path: "notes/plan.md",
+          filename: "plan.md",
+          mimeType: "text/markdown",
+        },
+      ],
+      [],
+      [],
+      "/tmp",
+      async () => true,
+      undefined,
+    );
+
+    expect(result.emittedAttachments).toHaveLength(1);
+    expect(result.persistedFiles).toEqual([]);
+  });
 });
 
 describe("approveHostAttachmentRead", () => {

package/src/__tests__/conversation-delete-activation-progress.test.ts

@@ -0,0 +1,145 @@
+/**
+ * The activation checklist records which task was launched into which
+ * conversation in a workspace file no database cascade reaches. A delete that
+ * skipped it would leave the task's row stuck on Working, pointing at a
+ * conversation the user can no longer open and offering no way to launch the
+ * task again.
+ *
+ * The cleanup hangs off the shared delete primitives rather than the route, so
+ * every caller (route, retrospective GC, cleanup jobs) cleans up, and it is
+ * best-effort like the rest of the post-transaction cleanup: these tests wait
+ * for it rather than awaiting it.
+ */
+import { describe, expect, mock, test } from "bun:test";
+
+// Keep the rest of the module real; only the Qdrant collection drop is
+// replaced, so `clearAll` does not reach for a lexical index that is not
+// running here.
+const actualLexical =
+  await import("../persistence/job-handlers/message-lexical.js");
+mock.module("../persistence/job-handlers/message-lexical.js", () => ({
+  ...actualLexical,
+  clearMessagesLexicalIndex: async () => {},
+}));
+
+import {
+  markActivationTurnComplete,
+  readActivationProgress,
+  startActivationTask,
+} from "../activation/progress-store.js";
+import type { ActivationTaskProgress } from "../api/responses/activation.js";
+import {
+  clearAll,
+  createConversation,
+  deleteConversation,
+  deleteConversationGently,
+} from "../persistence/conversation-crud.js";
+import { initializeDb } from "../persistence/db-init.js";
+
+await initializeDb();
+
+function taskRecord(taskId: string): ActivationTaskProgress | undefined {
+  return readActivationProgress().tasks[taskId];
+}
+
+async function waitFor(predicate: () => boolean): Promise<void> {
+  const deadline = Date.now() + 5_000;
+  while (Date.now() < deadline) {
+    if (predicate()) {
+      return;
+    }
+    await Bun.sleep(10);
+  }
+  throw new Error("Timed out waiting for the activation checklist to settle");
+}
+
+/** A conversation with a `started` checklist task pointing at it. */
+async function seedStartedTask(taskId: string): Promise<string> {
+  const conversation = createConversation(`activation-${taskId}`);
+  await startActivationTask({ taskId, conversationId: conversation.id });
+  expect(taskRecord(taskId)).toMatchObject({
+    status: "started",
+    conversationId: conversation.id,
+  });
+  return conversation.id;
+}
+
+/** A conversation whose checklist task already finished in it. */
+async function seedDoneTask(taskId: string): Promise<string> {
+  const conversationId = await seedStartedTask(taskId);
+  await markActivationTurnComplete({
+    conversationId,
+    toolCallCount: 2,
+    endedAwaitingUser: false,
+    artifacts: [],
+  });
+  expect(taskRecord(taskId)).toMatchObject({ status: "done", stepCount: 2 });
+  return conversationId;
+}
+
+describe("deleteConversation releases the checklist task", () => {
+  test("a started task returns to Todo and can be launched again", async () => {
+    const taskId = "delete-started";
+    const conversationId = await seedStartedTask(taskId);
+    const other = await seedStartedTask("delete-started-other");
+
+    deleteConversation(conversationId);
+    await waitFor(() => taskRecord(taskId) === undefined);
+
+    // Scoped to the conversation being deleted.
+    expect(taskRecord("delete-started-other")).toMatchObject({
+      status: "started",
+      conversationId: other,
+    });
+
+    // Todo again, so the row is launchable.
+    const relaunched = createConversation("activation-relaunch");
+    await startActivationTask({ taskId, conversationId: relaunched.id });
+    expect(taskRecord(taskId)).toMatchObject({
+      status: "started",
+      conversationId: relaunched.id,
+    });
+  });
+
+  test("a finished task keeps its history and loses only the dead link", async () => {
+    const taskId = "delete-done";
+    const conversationId = await seedDoneTask(taskId);
+
+    deleteConversation(conversationId);
+    await waitFor(() => taskRecord(taskId)?.conversationId === "");
+
+    expect(taskRecord(taskId)).toMatchObject({
+      status: "done",
+      stepCount: 2,
+      conversationId: "",
+    });
+  });
+});
+
+describe("deleteConversationGently releases the checklist task", () => {
+  test("the off-loop path clears the same state as the synchronous one", async () => {
+    const taskId = "delete-gently";
+    const conversationId = await seedStartedTask(taskId);
+
+    await deleteConversationGently(conversationId);
+    await waitFor(() => taskRecord(taskId) === undefined);
+  });
+});
+
+describe("clearAll releases every checklist task", () => {
+  test("started tasks go, finished ones keep their history", async () => {
+    await seedStartedTask("clear-all-started");
+    await seedDoneTask("clear-all-done");
+
+    await clearAll();
+    await waitFor(
+      () => readActivationProgress().tasks["clear-all-started"] === undefined,
+    );
+
+    expect(taskRecord("clear-all-done")).toMatchObject({
+      status: "done",
+      stepCount: 2,
+      conversationId: "",
+    });
+  });
+});

package/src/__tests__/conversation-event-sink.test.ts

@@ -0,0 +1,50 @@
+import { describe, expect, mock, test } from "bun:test";
+
+const published: Array<{ type: string; conversationId: string | undefined }> =
+  [];
+mock.module("../runtime/assistant-event-hub.js", () => ({
+  broadcastMessage: (msg: { type: string }, conversationId?: string) => {
+    published.push({ type: msg.type, conversationId });
+  },
+}));
+
+const { conversationEventSink } =
+  await import("../daemon/conversation-event-sink.js");
+
+/**
+ * The scoping guarantee the hub depends on: attribution comes from the
+ * emitting conversation, so an event carrying no conversation of its own is
+ * still filtered, seq-stamped and replayed like every other one.
+ */
+describe("conversationEventSink", () => {
+  test("scopes an event whose payload names no conversation", () => {
+    published.length = 0;
+
+    conversationEventSink("conv-parent")({
+      type: "subagent_status_changed",
+      subagentId: "sa-1",
+      status: "running",
+    } as never);
+
+    expect(published).toEqual([
+      { type: "subagent_status_changed", conversationId: "conv-parent" },
+    ]);
+  });
+
+  test("scopes every event to the emitting conversation, not the payload's", () => {
+    published.length = 0;
+    const sink = conversationEventSink("conv-parent");
+
+    sink({ type: "subagent_spawned", subagentId: "sa-1" } as never);
+    sink({
+      type: "subagent_event",
+      subagentId: "sa-1",
+      conversationId: "conv-parent",
+    } as never);
+
+    expect(published.map((p) => p.conversationId)).toEqual([
+      "conv-parent",
+      "conv-parent",
+    ]);
+  });
+});

package/src/__tests__/conversation-process-app-control-preactivation.test.ts

@@ -161,6 +161,12 @@ function makeFakeContext(opts: {
       trustClass: "guardian" as const,
       guardianPrincipalId: "user-1",
     },
+    setTrustContext(
+      this: { trustContext?: TrustContext },
+      trustContext: TrustContext | null,
+    ) {
+      this.trustContext = trustContext ?? undefined;
+    },
     setTransportHints() {},
     applyHostEnvFromTransport() {},
     ensureHostProxiesForTurn() {},
@@ -409,8 +415,10 @@ describe("drainQueue preactivation re-add for host-proxy interfaces", () => {
       "U-contact",
     );
     expect(ctx.currentTurnTrustContext?.sourceChannel).toBe("slack");
-    // The slot itself is left alone; only the turn's view is corrected.
-    expect(ctx.trustContext?.trustClass).toBe("guardian");
+    // The drain is where a queued message commits to a run, so the resting
+    // slot names the sender too: history is scoped from it, and a slot still
+    // naming the guardian would hand the contact's turn the guardian's rows.
+    expect(ctx.trustContext).toBe(contactTrust);
   });
 
   test("buildPassthroughBatch refuses to coalesce two channel senders", async () => {