@vellumai/assistant 0.8.3 → 0.8.5

package/src/__tests__/process-message-display-content.test.ts

@@ -196,7 +196,6 @@ function makeTestConversation() {
         metadata,
         displayContent,
       ),
-    setSlackRuntimeContextNotice: () => {},
     runAgentLoop,
     updateClient: () => {},
     getCurrentSender: () => undefined,
@@ -361,6 +360,7 @@ describe("processMessage displayContent", () => {
     expect(persistedBlocks).toEqual([
       {
         type: "file",
+        _attachmentId: "att-1",
         source: {
           type: "base64",
           media_type: "application/pdf",
@@ -370,21 +370,26 @@ describe("processMessage displayContent", () => {
       },
     ]);
     expect(addMessageCalls[0]!.content).not.toContain("<external_content");
-    expect(conversation.getMessages()[0]).toEqual({
-      role: "user",
-      content: [
-        { type: "text", text: modelContent },
-        {
-          type: "file",
-          source: {
-            type: "base64",
-            media_type: "application/pdf",
-            data: Buffer.from("pdf bytes").toString("base64"),
-            filename: "attachment.pdf",
-          },
-          extracted_text: undefined,
-        },
-      ],
+    const inMemoryMessage = conversation.getMessages()[0]!;
+    expect(inMemoryMessage.role).toBe("user");
+    expect(inMemoryMessage.content[0]).toEqual({
+      type: "text",
+      text: modelContent,
+    });
+    const inMemoryFileBlock = inMemoryMessage.content[1] as unknown as Record<
+      string,
+      unknown
+    >;
+    expect(inMemoryFileBlock._attachmentId).toBe("att-1");
+    expect(inMemoryFileBlock).toMatchObject({
+      type: "file",
+      source: {
+        type: "base64",
+        media_type: "application/pdf",
+        data: Buffer.from("pdf bytes").toString("base64"),
+        filename: "attachment.pdf",
+      },
+      extracted_text: undefined,
     });
   });
 

package/src/__tests__/prune-jobs-changes-parser.test.ts

@@ -0,0 +1,61 @@
+/**
+ * Unit coverage for the `parseDeletedCount` helper that reads the row
+ * count out of the sqlite3 CLI's stdout after a prune DELETE.
+ *
+ * The shape of the stdout we expect:
+ *
+ *   "<n>\n"
+ *
+ * — where `<n>` is the `SELECT changes()` value the CLI prints in
+ * default output mode after the DELETE statement runs. The helper has
+ * to tolerate empty/missing stdout, blank trailing lines, and any
+ * incidental log line emitted above the count.
+ */
+
+import { describe, expect, test } from "bun:test";
+
+import { _parseDeletedCount as parseDeletedCount } from "../memory/job-handlers/cleanup.js";
+
+describe("parseDeletedCount", () => {
+  test("bare integer on its own line", () => {
+    expect(parseDeletedCount("100\n")).toBe(100);
+  });
+
+  test("integer with trailing whitespace/blank lines", () => {
+    expect(parseDeletedCount("100\n\n")).toBe(100);
+    expect(parseDeletedCount("  42  \n")).toBe(42);
+  });
+
+  test("zero is a valid count", () => {
+    expect(parseDeletedCount("0\n")).toBe(0);
+  });
+
+  test("PRUNE_LOG_BATCH_LIMIT value", () => {
+    expect(parseDeletedCount("1000\n")).toBe(1000);
+  });
+
+  test("undefined stdout (subprocess never wrote anything)", () => {
+    expect(parseDeletedCount(undefined)).toBe(0);
+  });
+
+  test("empty stdout", () => {
+    expect(parseDeletedCount("")).toBe(0);
+  });
+
+  test("only whitespace", () => {
+    expect(parseDeletedCount("   \n\n  ")).toBe(0);
+  });
+
+  test("non-numeric lines are skipped, last numeric line wins", () => {
+    // Sample shape if the CLI ever logged an incidental warning above the count
+    expect(parseDeletedCount("warning: foo\n250\n")).toBe(250);
+  });
+
+  test("negative values are not accepted (sqlite changes() is unsigned)", () => {
+    expect(parseDeletedCount("-1\n")).toBe(0);
+  });
+
+  test("CRLF line endings", () => {
+    expect(parseDeletedCount("750\r\n")).toBe(750);
+  });
+});

package/src/__tests__/registry.test.ts

@@ -1,7 +1,6 @@
 import { afterAll, beforeEach, describe, expect, test } from "bun:test";
 
 import { RiskLevel } from "../permissions/types.js";
-import type { ToolDefinition } from "../providers/types.js";
 import {
   __clearRegistryForTesting,
   __resetRegistryForTesting,
@@ -30,13 +29,8 @@ function makeFakeTool(name: string): Tool {
     description: `Fake ${name}`,
     category: "test",
     defaultRiskLevel: RiskLevel.Low,
-    getDefinition(): ToolDefinition {
-      return {
-        name,
-        description: `Fake ${name}`,
-        input_schema: { type: "object", properties: {}, required: [] },
-      };
-    },
+    executionTarget: "sandbox",
+    input_schema: { type: "object", properties: {}, required: [] },
     async execute(
       _input: Record<string, unknown>,
       _context: ToolContext,

package/src/__tests__/require-fresh-approval.test.ts

@@ -103,7 +103,7 @@ mock.module("../permissions/checker.js", () => ({
 mock.module("../memory/tool-usage-store.js", () => ({
   recordToolInvocation: () => {},
   getRecentInvocations: () => [],
-  rotateToolInvocations: () => 0,
+  rotateToolInvocations: async () => 0,
 }));
 
 mock.module("../tools/registry.js", () => ({
@@ -116,7 +116,7 @@ mock.module("../tools/registry.js", () => ({
       category: isGmailTool ? "gmail" : "credential-execution",
       defaultRiskLevel: "high",
       executionTarget: isGmailTool ? ("host" as const) : undefined,
-      getDefinition: () => ({}),
+      input_schema: {},
       execute: async () => fakeToolResult,
     };
   },

package/src/__tests__/runtime-events-sse-bilingual.test.ts

@@ -0,0 +1,154 @@
+/**
+ * `GET /v1/events` (`handleSubscribeAssistantEvents`) — bilingual scope
+ * resolution. Two query params are accepted, with distinct semantics:
+ *
+ *   - `?conversationId=<internal-id>` — looks up the conversation row
+ *     directly by its assistant-minted id. 404 if not found. Does NOT
+ *     materialise a new row.
+ *   - `?conversationKey=<external-key>` — resolves via the
+ *     `conversation_keys` table; materialises on first use. Ignored when
+ *     `conversationId` is also supplied.
+ *
+ * Companion to `runtime-events-sse.test.ts`, which exercises the broader
+ * `?conversationKey=` happy/error path.
+ */
+
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+mock.module("../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+}));
+
+mock.module("../config/loader.js", () => ({
+  getConfig: () => ({
+    ui: {},
+    model: "test",
+    provider: "test",
+    memory: { enabled: false },
+    rateLimit: { maxRequestsPerMinute: 0 },
+    secretDetection: { enabled: false },
+  }),
+}));
+
+import { getOrCreateConversation } from "../memory/conversation-key-store.js";
+import { getDb } from "../memory/db-connection.js";
+import { initializeDb } from "../memory/db-init.js";
+import { buildAssistantEvent } from "../runtime/assistant-event.js";
+import { AssistantEventHub } from "../runtime/assistant-event-hub.js";
+import {
+  BadRequestError,
+  NotFoundError,
+} from "../runtime/routes/errors.js";
+import { handleSubscribeAssistantEvents } from "../runtime/routes/events-routes.js";
+
+initializeDb();
+
+describe("GET /v1/events — bilingual scope query params", () => {
+  beforeEach(() => {
+    const db = getDb();
+    db.run("DELETE FROM conversation_keys");
+    db.run("DELETE FROM conversations");
+  });
+
+  test("?conversationId=<existing-id> scopes the stream to that conversation", async () => {
+    // Materialise a conversation via the key path, then subscribe to it
+    // directly by its internal id.
+    const { conversationId } = getOrCreateConversation("sse-id-scope-source");
+
+    const ac = new AbortController();
+    const testHub = new AssistantEventHub();
+
+    const stream = handleSubscribeAssistantEvents(
+      {
+        queryParams: { conversationId },
+        abortSignal: ac.signal,
+      },
+      { hub: testHub },
+    );
+
+    const reader = stream.getReader();
+    // Consume the initial heartbeat.
+    const heartbeat = await reader.read();
+    expect(new TextDecoder().decode(heartbeat.value)).toBe(": heartbeat\n\n");
+
+    // Publish an event scoped to that conversation — should be delivered.
+    await testHub.publish(buildAssistantEvent({ type: "pong" }, conversationId));
+
+    const { value, done } = await reader.read();
+    ac.abort();
+
+    expect(done).toBe(false);
+    const frame = new TextDecoder().decode(value);
+    expect(frame).toContain("event: assistant_event");
+    expect(frame).toContain(`"conversationId":"${conversationId}"`);
+  });
+
+  test("?conversationId=<non-existent-id> throws NotFoundError", () => {
+    expect(() =>
+      handleSubscribeAssistantEvents({
+        queryParams: { conversationId: "does-not-exist" },
+        abortSignal: new AbortController().signal,
+      }),
+    ).toThrow(NotFoundError);
+  });
+
+  test("?conversationId is honored and ?conversationKey is ignored when both are present", async () => {
+    // Materialise two distinct conversations: one we'll subscribe to by id,
+    // one we'll publish to via the ignored key.
+    const { conversationId: idConv } = getOrCreateConversation("sse-id-wins");
+    const { conversationId: keyConv } = getOrCreateConversation(
+      "sse-key-ignored",
+    );
+    expect(idConv).not.toBe(keyConv);
+
+    const ac = new AbortController();
+    const testHub = new AssistantEventHub();
+
+    const stream = handleSubscribeAssistantEvents(
+      {
+        queryParams: {
+          conversationId: idConv,
+          conversationKey: "sse-key-ignored",
+        },
+        abortSignal: ac.signal,
+      },
+      { hub: testHub },
+    );
+    const reader = stream.getReader();
+    await reader.read(); // heartbeat
+
+    // Publish on the "key" conversation — should NOT be delivered (filter
+    // is locked to idConv because conversationId wins).
+    await testHub.publish(buildAssistantEvent({ type: "pong" }, keyConv));
+    // Publish on the "id" conversation — should be delivered.
+    await testHub.publish(buildAssistantEvent({ type: "pong" }, idConv));
+
+    const { value } = await reader.read();
+    ac.abort();
+    const frame = new TextDecoder().decode(value);
+
+    expect(frame).toContain(`"conversationId":"${idConv}"`);
+    expect(frame).not.toContain(`"conversationId":"${keyConv}"`);
+  });
+
+  test("empty conversationId is rejected with BadRequestError", () => {
+    expect(() =>
+      handleSubscribeAssistantEvents({
+        queryParams: { conversationId: "" },
+        abortSignal: new AbortController().signal,
+      }),
+    ).toThrow(BadRequestError);
+  });
+
+  test("empty conversationKey is still rejected (legacy parity)", () => {
+    expect(() =>
+      handleSubscribeAssistantEvents({
+        queryParams: { conversationKey: "" },
+        abortSignal: new AbortController().signal,
+      }),
+    ).toThrow(BadRequestError);
+  });
+});

package/src/__tests__/server-history-render.test.ts

@@ -84,6 +84,82 @@ describe("renderHistoryContent", () => {
     );
   });
 
+  test("emits attachment:N entries in contentOrder for interleaved file blocks", () => {
+    const output = renderHistoryContent([
+      { type: "text", text: "first paragraph" },
+      {
+        type: "file",
+        source: {
+          type: "base64",
+          media_type: "text/markdown",
+          filename: "dream-015.md",
+          data: Buffer.from("a").toString("base64"),
+        },
+        _attachmentId: "att-015",
+      },
+      {
+        type: "file",
+        source: {
+          type: "base64",
+          media_type: "text/markdown",
+          filename: "dream-016.md",
+          data: Buffer.from("b").toString("base64"),
+        },
+        _attachmentId: "att-016",
+      },
+      { type: "text", text: "trailing paragraph" },
+    ]);
+
+    expect(output.contentOrder).toEqual([
+      "text:0",
+      "attachment:0",
+      "attachment:1",
+      "text:1",
+    ]);
+    expect(output.attachments).toEqual([
+      {
+        attachmentId: "att-015",
+        filename: "dream-015.md",
+        mimeType: "text/markdown",
+        sizeBytes: 1,
+      },
+      {
+        attachmentId: "att-016",
+        filename: "dream-016.md",
+        mimeType: "text/markdown",
+        sizeBytes: 1,
+      },
+    ]);
+    // Trailing-segment summary is preserved for legacy channel-reply
+    // delivery (Slack/Telegram outbound text) and iOS rehydrate.
+    expect(output.textSegments[1]).toContain("[File attachment] dream-015.md");
+  });
+
+  test("omits attachmentId when file block has no _attachmentId", () => {
+    const output = renderHistoryContent([
+      {
+        type: "file",
+        source: {
+          type: "base64",
+          media_type: "application/pdf",
+          filename: "legacy.pdf",
+          data: Buffer.from("x").toString("base64"),
+        },
+      },
+    ]);
+
+    // attachment:0 marks the file's inline position; text:0 follows because
+    // the legacy summary append (for Slack/iOS) opens a trailing segment.
+    expect(output.contentOrder).toEqual(["attachment:0", "text:0"]);
+    expect(output.attachments).toEqual([
+      {
+        filename: "legacy.pdf",
+        mimeType: "application/pdf",
+        sizeBytes: 1,
+      },
+    ]);
+  });
+
   test("falls back to string conversion for non-array content", () => {
     expect(renderHistoryContent("raw string").text).toBe("raw string");
     expect(renderHistoryContent(null).text).toBe("");
@@ -320,14 +396,17 @@ describe("renderHistoryContent", () => {
     expect(output.toolCallsBeforeText).toBe(false);
   });
 
-  test("handles orphan tool_result without matching tool_use", () => {
+  test("drops orphan tool_result without matching tool_use", () => {
     const output = renderHistoryContent([
       { type: "tool_result", tool_use_id: "missing", content: "some result" },
     ]);
 
-    expect(output.toolCalls).toEqual([
-      { name: "unknown", input: {}, result: "some result", isError: false },
-    ]);
+    // Orphans are dropped — without the parent tool_use we can't tell the user
+    // what tool ran, so the result is meaningless. See shared.ts comment.
+    expect(output.toolCalls).toEqual([]);
+    expect(output.text).toBe("");
+    expect(output.textSegments).toEqual([]);
+    expect(output.contentOrder).toEqual([]);
   });
 
   test("produces textSegments for text-tool-text interleaving", () => {

package/src/__tests__/shell-tool-proxy-mode.test.ts

@@ -287,7 +287,7 @@ describe("shell tool proxy mode", () => {
   });
 
   test("schema includes network_mode and credential_ids", () => {
-    const def = shellTool.getDefinition();
+    const def = shellTool;
     const props = (def.input_schema as { properties: Record<string, unknown> })
       .properties;
     expect(props.network_mode).toBeDefined();

package/src/__tests__/skill-feature-flags.test.ts

@@ -130,9 +130,9 @@ describe("isAssistantFeatureFlagEnabled with skillFlagKey", () => {
 // ---------------------------------------------------------------------------
 
 describe("isAssistantFeatureFlagEnabled", () => {
-  test("returns true for unknown flags (open by default)", () => {
+  test("returns false for unknown flags (closed by default)", () => {
     const config = makeConfig();
-    expect(isAssistantFeatureFlagEnabled("unknown", config)).toBe(true);
+    expect(isAssistantFeatureFlagEnabled("unknown", config)).toBe(false);
   });
 
   test("file-based override overrides registry default", () => {

package/src/__tests__/skill-projection-feature-flag.test.ts

@@ -50,7 +50,7 @@ mock.module("../config/assistant-feature-flags.js", () => ({
   isAssistantFeatureFlagEnabled: (key: string, _config: unknown): boolean => {
     const explicit = _mockOverrides[key];
     if (typeof explicit === "boolean") return explicit;
-    return true; // undeclared flags default to enabled
+    return false; // undeclared flags default to disabled
   },
   clearFeatureFlagOverridesCache: () => {
     _mockOverrides = {};
@@ -121,15 +121,12 @@ mock.module("../tools/skills/skill-tool-factory.js", () => ({
       description: entry.description,
       category: entry.category,
       defaultRiskLevel: RiskLevel.Medium,
+      executionTarget: "sandbox" as const,
       origin: "skill" as const,
       ownerSkillId: skillId,
       ownerSkillVersionHash: versionHash,
       ownerSkillBundled: bundled ?? undefined,
-      getDefinition: () => ({
-        name: entry.name,
-        description: entry.description,
-        input_schema: entry.input_schema as object,
-      }),
+      input_schema: entry.input_schema as object,
       execute: async () => ({ content: "", isError: false }),
     }));
   },
@@ -422,7 +419,7 @@ describe("projectSkillTools feature flag enforcement", () => {
     ];
     const prevActive = new Map<string, string>();
 
-    // Declared skill is OFF, plain-skill is undeclared with no persisted override so remains ON.
+    // Declared skill is OFF; plain-skill has no featureFlag so remains ON.
     _setOverridesForTesting({ [DECLARED_FLAG_KEY]: false });
 
     const result = projectSkillTools(history, {

package/src/__tests__/skill-projection.benchmark.test.ts

@@ -23,7 +23,7 @@ mock.module("../util/logger.js", () => ({
 }));
 
 // Mock config loader and feature flags to avoid filesystem reads on CI.
-// getConfig returns a minimal config; all feature flags default to enabled.
+// The benchmark fixture treats every feature flag as enabled.
 mock.module("../config/loader.js", () => ({
   getConfig: () => ({}),
   loadConfig: () => ({}),
@@ -114,11 +114,7 @@ mock.module("../tools/skills/skill-tool-factory.js", () => ({
       ownerSkillId: skillId,
       ownerSkillVersionHash: versionHash,
       ownerSkillBundled: bundled,
-      getDefinition: () => ({
-        name: e.name,
-        description: e.description,
-        input_schema: e.input_schema,
-      }),
+      input_schema: e.input_schema,
       execute: async () => ({ content: "", isError: false }),
     })),
 }));

package/src/__tests__/skill-tool-factory.test.ts

@@ -145,7 +145,7 @@ describe("createSkillTool", () => {
       "v1:test",
     );
 
-    const def = tool.getDefinition();
+    const def = tool;
 
     expect(def.name).toBe("web_scrape");
     expect(def.description).toBe("Scrape a URL");