@vellumai/assistant 0.5.16 → 0.6.1

package/src/__tests__/skills-uninstall.test.ts

@@ -60,7 +60,7 @@ describe("assistant skills uninstall", () => {
 
     // GIVEN a skill is installed locally
     installFakeSkill("weather");
-    writeSkillsIndex("- weather\n- google-oauth-app-setup\n");
+    writeSkillsIndex("- weather\n- vellum-self-knowledge\n");
 
     // WHEN we uninstall the skill
     uninstallSkillLocally("weather");
@@ -73,7 +73,7 @@ describe("assistant skills uninstall", () => {
     expect(index).not.toContain("weather");
 
     // AND other skills should remain in the index
-    expect(index).toContain("google-oauth-app-setup");
+    expect(index).toContain("vellum-self-knowledge");
   });
 
   test("errors when skill is not installed", () => {

package/src/__tests__/skills.test.ts

@@ -642,7 +642,7 @@ describe("ingress-dependent setup skills declare public-ingress intentionally",
       "utf-8",
     );
     expect(content).toContain("avoid-when:");
-    expect(content.toLowerCase()).toContain("managed/containerized");
+    expect(content.toLowerCase()).toContain("platform-managed");
   });
 });
 

package/src/__tests__/slack-inbound-verification.test.ts

@@ -8,7 +8,7 @@
  * 4. Notify the guardian of the access attempt
  * 5. When the user replies with the code in the DM, verify and activate
  */
-import { afterAll, beforeEach, describe, expect, mock, test } from "bun:test";
+import { beforeEach, describe, expect, mock, test } from "bun:test";
 
 // ---------------------------------------------------------------------------
 // Test isolation: in-memory SQLite via temp directory
@@ -56,16 +56,12 @@ mock.module("../runtime/gateway-client.js", () => ({
 }));
 
 import { createGuardianBinding } from "../contacts/contacts-write.js";
-import { getDb, initializeDb, resetDb } from "../memory/db.js";
+import { getDb, initializeDb } from "../memory/db.js";
 import { findActiveSession } from "../runtime/channel-verification-service.js";
 import { handleChannelInbound } from "../runtime/routes/channel-routes.js";
 
 initializeDb();
 
-afterAll(() => {
-  resetDb();
-});
-
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------

package/src/__tests__/strip-memory-injections.test.ts

@@ -0,0 +1,187 @@
+import { describe, expect, test } from "bun:test";
+
+import { stripExistingMemoryInjections } from "../memory/graph/conversation-graph-memory.js";
+import type { ContentBlock, Message } from "../providers/types.js";
+
+// ---------------------------------------------------------------------------
+// stripExistingMemoryInjections — removes memory-injected blocks from the
+// front of the last user message while preserving user-attached content.
+// ---------------------------------------------------------------------------
+
+function userMsg(...content: ContentBlock[]): Message {
+  return { role: "user", content };
+}
+
+function assistantMsg(text: string): Message {
+  return { role: "assistant", content: [{ type: "text", text }] };
+}
+
+const textBlock = (text: string): ContentBlock => ({ type: "text", text });
+
+const imageBlock: ContentBlock = {
+  type: "image",
+  source: { type: "base64", media_type: "image/png", data: "iVBORw0KGgo=" },
+};
+
+const memoryTextBlock: ContentBlock = {
+  type: "text",
+  text: "<memory __injected>\nSome recalled context\n</memory>",
+};
+
+const memoryImageMarker: ContentBlock = {
+  type: "text",
+  text: "<memory_image __injected>\nA photo of a sunset",
+};
+
+const memoryImageClose: ContentBlock = {
+  type: "text",
+  text: "</memory_image>",
+};
+
+// Legacy 2-block format (persisted in older conversations)
+const legacyMemoryImageMarker: ContentBlock = {
+  type: "text",
+  text: "<memory_image>A photo of a sunset</memory_image>",
+};
+
+const memoryImage: ContentBlock = {
+  type: "image",
+  source: {
+    type: "base64",
+    media_type: "image/jpeg",
+    data: "/9j/4AAQ==",
+  },
+};
+
+describe("stripExistingMemoryInjections", () => {
+  test("no-op when content has no memory blocks", () => {
+    const messages = [userMsg(textBlock("hello"), imageBlock)];
+    const result = stripExistingMemoryInjections(messages);
+    expect(result).toEqual(messages);
+  });
+
+  test("no-op for empty messages array", () => {
+    const result = stripExistingMemoryInjections([]);
+    expect(result).toEqual([]);
+  });
+
+  test("no-op when last message is assistant role", () => {
+    const messages = [userMsg(textBlock("hi")), assistantMsg("hey")];
+    const result = stripExistingMemoryInjections(messages);
+    expect(result).toEqual(messages);
+  });
+
+  test("strips memory text block", () => {
+    const messages = [userMsg(memoryTextBlock, textBlock("hello"))];
+    const result = stripExistingMemoryInjections(messages);
+    expect(result[0].content).toEqual([textBlock("hello")]);
+  });
+
+  test("strips 3-block memory image (marker + image + close)", () => {
+    const messages = [
+      userMsg(memoryTextBlock, memoryImageMarker, memoryImage, memoryImageClose, textBlock("hi")),
+    ];
+    const result = stripExistingMemoryInjections(messages);
+    expect(result[0].content).toEqual([textBlock("hi")]);
+  });
+
+  test("strips multiple 3-block memory image groups", () => {
+    const messages = [
+      userMsg(
+        memoryTextBlock,
+        memoryImageMarker,
+        memoryImage,
+        memoryImageClose,
+        memoryImageMarker,
+        memoryImage,
+        memoryImageClose,
+        textBlock("hello"),
+      ),
+    ];
+    const result = stripExistingMemoryInjections(messages);
+    expect(result[0].content).toEqual([textBlock("hello")]);
+  });
+
+  test("strips legacy 2-block memory image (no closing tag)", () => {
+    const messages = [
+      userMsg(memoryTextBlock, legacyMemoryImageMarker, memoryImage, textBlock("hi")),
+    ];
+    const result = stripExistingMemoryInjections(messages);
+    expect(result[0].content).toEqual([textBlock("hi")]);
+  });
+
+  test("preserves user-attached image when it is the only content", () => {
+    const messages = [userMsg(imageBlock)];
+    const result = stripExistingMemoryInjections(messages);
+    expect(result[0].content).toEqual([imageBlock]);
+  });
+
+  test("preserves user-attached image with text", () => {
+    const messages = [userMsg(imageBlock, textBlock("what is this?"))];
+    const result = stripExistingMemoryInjections(messages);
+    expect(result[0].content).toEqual([
+      imageBlock,
+      textBlock("what is this?"),
+    ]);
+  });
+
+  test("preserves user image after stripping 3-block memory blocks", () => {
+    const messages = [
+      userMsg(
+        memoryTextBlock,
+        memoryImageMarker,
+        memoryImage,
+        memoryImageClose,
+        imageBlock,
+        textBlock("look at this"),
+      ),
+    ];
+    const result = stripExistingMemoryInjections(messages);
+    expect(result[0].content).toEqual([
+      imageBlock,
+      textBlock("look at this"),
+    ]);
+  });
+
+  test("preserves user image-only message after stripping memory blocks", () => {
+    const messages = [userMsg(memoryTextBlock, imageBlock)];
+    const result = stripExistingMemoryInjections(messages);
+    expect(result[0].content).toEqual([imageBlock]);
+  });
+
+  test("does not modify earlier messages", () => {
+    const earlier = userMsg(textBlock("first"));
+    const messages = [earlier, assistantMsg("ok"), userMsg(memoryTextBlock, textBlock("second"))];
+    const result = stripExistingMemoryInjections(messages);
+    expect(result[0]).toBe(earlier);
+    expect(result[2].content).toEqual([textBlock("second")]);
+  });
+
+  test("does not strip user text that equals </memory_image>", () => {
+    const messages = [userMsg(textBlock("</memory_image>"))];
+    const result = stripExistingMemoryInjections(messages);
+    expect(result[0].content).toEqual([textBlock("</memory_image>")]);
+  });
+
+  test("does not strip </memory_image> after memory text block (no image context)", () => {
+    const messages = [
+      userMsg(memoryTextBlock, textBlock("</memory_image>"), textBlock("hello")),
+    ];
+    const result = stripExistingMemoryInjections(messages);
+    expect(result[0].content).toEqual([textBlock("</memory_image>"), textBlock("hello")]);
+  });
+
+  test("strips images-first then text (actual injectMemoryBlock order)", () => {
+    const messages = [
+      userMsg(
+        memoryImageMarker,
+        memoryImage,
+        memoryImageClose,
+        memoryTextBlock,
+        textBlock("hello"),
+      ),
+    ];
+    const result = stripExistingMemoryInjections(messages);
+    expect(result[0].content).toEqual([textBlock("hello")]);
+  });
+});

package/src/__tests__/subagent-detail.test.ts

@@ -0,0 +1,84 @@
+/**
+ * Tests for parseSubagentMessages — verifies that tool result content is
+ * correctly extracted from both string and array formats.
+ */
+
+import { describe, expect, test } from "bun:test";
+
+import { parseSubagentMessages } from "../runtime/routes/subagents-routes.js";
+
+function msg(role: string, content: unknown[]) {
+  return { role, content: JSON.stringify(content) };
+}
+
+describe("parseSubagentMessages", () => {
+  test("extracts string tool_result content", () => {
+    const messages = [
+      msg("user", [{ type: "text", text: "Do something" }]),
+      msg("assistant", [
+        { type: "tool_use", id: "t1", name: "web_search", input: { query: "test" } },
+      ]),
+      msg("user", [
+        { type: "tool_result", tool_use_id: "t1", content: "Search results here" },
+      ]),
+    ];
+
+    const result = parseSubagentMessages("sub-1", messages);
+    const toolResult = result.events.find((e) => e.type === "tool_result");
+    expect(toolResult).toBeDefined();
+    expect(toolResult!.content).toBe("Search results here");
+    expect(toolResult!.toolName).toBe("web_search");
+  });
+
+  test("extracts array-format tool_result content", () => {
+    const messages = [
+      msg("user", [{ type: "text", text: "Do something" }]),
+      msg("assistant", [
+        { type: "tool_use", id: "t2", name: "file_read", input: { file_path: "/tmp/test.txt" } },
+      ]),
+      msg("user", [
+        {
+          type: "tool_result",
+          tool_use_id: "t2",
+          content: [
+            { type: "text", text: "Line 1 of file" },
+            { type: "text", text: "Line 2 of file" },
+          ],
+        },
+      ]),
+    ];
+
+    const result = parseSubagentMessages("sub-1", messages);
+    const toolResult = result.events.find((e) => e.type === "tool_result");
+    expect(toolResult).toBeDefined();
+    expect(toolResult!.content).toBe("Line 1 of file\nLine 2 of file");
+    expect(toolResult!.toolName).toBe("file_read");
+  });
+
+  test("handles null tool_result content gracefully", () => {
+    const messages = [
+      msg("user", [{ type: "text", text: "Do something" }]),
+      msg("assistant", [
+        { type: "tool_use", id: "t3", name: "bash", input: { command: "echo hi" } },
+      ]),
+      msg("user", [
+        { type: "tool_result", tool_use_id: "t3", content: null },
+      ]),
+    ];
+
+    const result = parseSubagentMessages("sub-1", messages);
+    const toolResult = result.events.find((e) => e.type === "tool_result");
+    expect(toolResult).toBeDefined();
+    expect(toolResult!.content).toBe("");
+  });
+
+  test("extracts objective from first user message", () => {
+    const messages = [
+      msg("user", [{ type: "text", text: "Research vampire lore" }]),
+      msg("assistant", [{ type: "text", text: "On it." }]),
+    ];
+
+    const result = parseSubagentMessages("sub-1", messages);
+    expect(result.objective).toBe("Research vampire lore");
+  });
+});

package/src/__tests__/subagent-disposal.test.ts

@@ -0,0 +1,308 @@
+import { describe, expect, test } from "bun:test";
+
+import type { ServerMessage } from "../daemon/message-protocol.js";
+import { SubagentManager } from "../subagent/manager.js";
+import type { SubagentState } from "../subagent/types.js";
+
+/** Minimal shape matching the private ManagedSubagent interface for test injection. */
+interface FakeManagedSubagent {
+  conversation: {
+    abort: () => void;
+    dispose: () => void;
+    messages: Array<{
+      role: string;
+      content: Array<{ type: string; text: string }>;
+    }>;
+    sendToClient: (msg: ServerMessage) => void;
+    persistUserMessage?: (msg: string) => string;
+    runAgentLoop?: () => Promise<void>;
+    enqueueMessage?: () => { rejected: boolean; queued: boolean };
+    usageStats: {
+      inputTokens: number;
+      outputTokens: number;
+      estimatedCost: number;
+    };
+  } | null;
+  state: SubagentState;
+  parentSendToClient: (msg: ServerMessage) => void;
+  retainedUntil?: number;
+  hadEnqueuedMessages?: boolean;
+}
+
+/** Type-safe accessor for SubagentManager's private internals via bracket notation. */
+interface ManagerInternals {
+  subagents: Map<string, FakeManagedSubagent>;
+  parentToChildren: Map<string, Set<string>>;
+  runSubagent: (subagentId: string, objective: string) => Promise<void>;
+  sweepTerminal: () => void;
+  stopSweep: () => void;
+}
+
+function asInternals(manager: SubagentManager): ManagerInternals {
+  return manager as unknown as ManagerInternals;
+}
+
+function makeFakeConversation(): NonNullable<
+  FakeManagedSubagent["conversation"]
+> {
+  return {
+    abort: () => {},
+    dispose: () => {},
+    messages: [],
+    sendToClient: () => {},
+    usageStats: { inputTokens: 100, outputTokens: 50, estimatedCost: 0.005 },
+  };
+}
+
+function injectFakeSubagent(
+  manager: SubagentManager,
+  subagentId: string,
+  state: SubagentState,
+  parentSendToClient?: (msg: ServerMessage) => void,
+  conversation?: FakeManagedSubagent["conversation"],
+): void {
+  const internals = asInternals(manager);
+
+  internals.subagents.set(subagentId, {
+    conversation: conversation === undefined ? makeFakeConversation() : conversation,
+    state,
+    parentSendToClient: parentSendToClient ?? (() => {}),
+  });
+
+  const parentId = state.config.parentConversationId;
+  if (!internals.parentToChildren.has(parentId)) {
+    internals.parentToChildren.set(parentId, new Set());
+  }
+  internals.parentToChildren.get(parentId)!.add(subagentId);
+}
+
+function makeState(
+  subagentId: string,
+  overrides: Partial<SubagentState> = {},
+): SubagentState {
+  return {
+    config: {
+      id: subagentId,
+      parentConversationId: "parent-sess-1",
+      label: "Test subagent",
+      objective: "Do something",
+    },
+    status: "running",
+    conversationId: "conv-sub-1",
+    createdAt: Date.now(),
+    usage: { inputTokens: 0, outputTokens: 0, estimatedCost: 0 },
+    ...overrides,
+  };
+}
+
+describe("SubagentManager terminal disposal", () => {
+  test("completed subagent has conversation === null but state is preserved", async () => {
+    const manager = new SubagentManager();
+    const subagentId = "sub-1";
+    const state = makeState(subagentId);
+    injectFakeSubagent(manager, subagentId, state);
+
+    const managed = asInternals(manager).subagents.get(subagentId)!;
+    managed.conversation!.persistUserMessage = () => "msg-1";
+    managed.conversation!.runAgentLoop = async () => {};
+
+    await asInternals(manager).runSubagent(subagentId, "Do something");
+
+    expect(state.status).toBe("completed");
+    expect(managed.conversation).toBeNull();
+    // State is still accessible via getState.
+    expect(manager.getState(subagentId)).toBeDefined();
+    expect(manager.getState(subagentId)!.status).toBe("completed");
+    expect(managed.retainedUntil).toBeGreaterThan(Date.now());
+
+    // Cleanup
+    asInternals(manager).stopSweep();
+  });
+
+  test("failed subagent releases live conversation", async () => {
+    const manager = new SubagentManager();
+    const subagentId = "sub-1";
+    const state = makeState(subagentId);
+    injectFakeSubagent(manager, subagentId, state);
+
+    const managed = asInternals(manager).subagents.get(subagentId)!;
+    managed.conversation!.persistUserMessage = () => "msg-1";
+    managed.conversation!.runAgentLoop = async () => {
+      throw new Error("LLM error");
+    };
+
+    await asInternals(manager).runSubagent(subagentId, "Do something");
+
+    expect(state.status).toBe("failed");
+    expect(managed.conversation).toBeNull();
+    expect(manager.getState(subagentId)).toBeDefined();
+
+    asInternals(manager).stopSweep();
+  });
+
+  test("aborted subagent releases conversation when runSubagent catches", async () => {
+    const manager = new SubagentManager();
+    const subagentId = "sub-1";
+    const state = makeState(subagentId, { status: "aborted" });
+    injectFakeSubagent(manager, subagentId, state);
+
+    const managed = asInternals(manager).subagents.get(subagentId)!;
+    managed.conversation!.persistUserMessage = () => "msg-1";
+    managed.conversation!.runAgentLoop = async () => {
+      throw new Error("Conversation aborted");
+    };
+
+    await asInternals(manager).runSubagent(subagentId, "Do something");
+
+    expect(managed.conversation).toBeNull();
+
+    asInternals(manager).stopSweep();
+  });
+
+  test("sendMessage returns 'terminal' after conversation is released", async () => {
+    const manager = new SubagentManager();
+    const subagentId = "sub-1";
+    const state = makeState(subagentId);
+    injectFakeSubagent(manager, subagentId, state);
+
+    const managed = asInternals(manager).subagents.get(subagentId)!;
+    managed.conversation!.persistUserMessage = () => "msg-1";
+    managed.conversation!.runAgentLoop = async () => {};
+
+    await asInternals(manager).runSubagent(subagentId, "Do something");
+
+    expect(managed.conversation).toBeNull();
+    const result = await manager.sendMessage(subagentId, "hello");
+    expect(result).toBe("terminal");
+
+    asInternals(manager).stopSweep();
+  });
+
+  test("parent disposal removes terminal child state", () => {
+    const manager = new SubagentManager();
+    injectFakeSubagent(
+      manager,
+      "sub-1",
+      makeState("sub-1", { status: "completed" }),
+      undefined,
+      null, // already released
+    );
+    asInternals(manager).subagents.get("sub-1")!.retainedUntil =
+      Date.now() + 1000;
+
+    // Verify the terminal subagent exists.
+    expect(manager.getState("sub-1")).toBeDefined();
+
+    // Parent disposal should remove it.
+    manager.abortAllForParent("parent-sess-1");
+
+    expect(manager.getState("sub-1")).toBeUndefined();
+    expect(manager.getChildrenOf("parent-sess-1")).toHaveLength(0);
+  });
+
+  test("TTL sweep removes expired terminal entries but not active subagents", () => {
+    const manager = new SubagentManager();
+
+    // Terminal entry with expired retention.
+    injectFakeSubagent(
+      manager,
+      "sub-expired",
+      makeState("sub-expired", { status: "completed" }),
+      undefined,
+      null,
+    );
+    asInternals(manager).subagents.get("sub-expired")!.retainedUntil =
+      Date.now() - 1000; // already expired
+
+    // Active subagent — no retainedUntil.
+    injectFakeSubagent(
+      manager,
+      "sub-active",
+      makeState("sub-active", { status: "running" }),
+    );
+
+    // Terminal but not yet expired.
+    injectFakeSubagent(
+      manager,
+      "sub-fresh",
+      makeState("sub-fresh", { status: "completed" }),
+      undefined,
+      null,
+    );
+    asInternals(manager).subagents.get("sub-fresh")!.retainedUntil =
+      Date.now() + 60_000;
+
+    asInternals(manager).sweepTerminal();
+
+    expect(manager.getState("sub-expired")).toBeUndefined();
+    expect(manager.getState("sub-active")).toBeDefined();
+    expect(manager.getState("sub-fresh")).toBeDefined();
+
+    asInternals(manager).stopSweep();
+  });
+
+  test("dispose handles already-released conversation gracefully", () => {
+    const manager = new SubagentManager();
+    injectFakeSubagent(
+      manager,
+      "sub-1",
+      makeState("sub-1", { status: "completed" }),
+      undefined,
+      null, // conversation already released
+    );
+
+    // Should not throw.
+    manager.dispose("sub-1");
+    expect(manager.getState("sub-1")).toBeUndefined();
+  });
+
+  test("usage stats are preserved after conversation release", async () => {
+    const manager = new SubagentManager();
+    const subagentId = "sub-1";
+    const state = makeState(subagentId);
+    injectFakeSubagent(manager, subagentId, state);
+
+    const managed = asInternals(manager).subagents.get(subagentId)!;
+    managed.conversation!.usageStats = {
+      inputTokens: 500,
+      outputTokens: 200,
+      estimatedCost: 0.05,
+    };
+    managed.conversation!.persistUserMessage = () => "msg-1";
+    managed.conversation!.runAgentLoop = async () => {};
+
+    await asInternals(manager).runSubagent(subagentId, "Do something");
+
+    expect(managed.conversation).toBeNull();
+    expect(state.usage).toEqual({
+      inputTokens: 500,
+      outputTokens: 200,
+      estimatedCost: 0.05,
+    });
+
+    asInternals(manager).stopSweep();
+  });
+
+  test("defers release when messages were enqueued during run", async () => {
+    const manager = new SubagentManager();
+    const subagentId = "sub-1";
+    const state = makeState(subagentId);
+    injectFakeSubagent(manager, subagentId, state);
+
+    const managed = asInternals(manager).subagents.get(subagentId)!;
+    managed.conversation!.persistUserMessage = () => "msg-1";
+    managed.conversation!.runAgentLoop = async () => {};
+    // Simulate that a message was enqueued during the run.
+    managed.hadEnqueuedMessages = true;
+
+    await asInternals(manager).runSubagent(subagentId, "Do something");
+
+    // Conversation should NOT be released — drain may still be active.
+    expect(managed.conversation).not.toBeNull();
+    // But retainedUntil should be set for eventual TTL cleanup.
+    expect(managed.retainedUntil).toBeGreaterThan(Date.now());
+    expect(state.status).toBe("completed");
+
+    asInternals(manager).stopSweep();
+  });
+});