@vellumai/assistant 0.10.2 → 0.10.3-dev.202606252046.9075fd5

package/src/__tests__/conversation-routes-slash-commands.test.ts

@@ -126,6 +126,8 @@ mock.module("../runtime/confirmation-request-guardian-bridge.js", () => ({
 }));
 
 mock.module("../memory/conversation-crud.js", () => ({
+    setConversationProcessingStartedAt: () => {},
+    isConversationProcessing: () => false,
   addMessage: (
     conversationId: string,
     role: string,
@@ -190,6 +192,18 @@ mock.module("../runtime/trust-context-resolver.js", () => ({
   }),
 }));
 
+mock.module("../contacts/guardian-delivery-reader.js", () => ({
+  getGuardianDelivery: async () => [
+    {
+      channelType: "vellum",
+      contactId: "guardian-contact",
+      principalId: "test-user",
+      address: "test-user",
+      status: "active",
+    },
+  ],
+}));
+
 const ipcCallMock = mock(
   async (): Promise<Record<string, unknown> | undefined> => ({ ok: true }),
 );

package/src/__tests__/conversation-slash-queue.test.ts

@@ -100,6 +100,8 @@ mock.module("../security/secret-allowlist.js", () => ({
 }));
 
 mock.module("../memory/conversation-crud.js", () => ({
+    setConversationProcessingStartedAt: () => {},
+    isConversationProcessing: () => false,
   setConversationOriginChannelIfUnset: () => {},
   setConversationOriginInterfaceIfUnset: () => {},
   updateConversationContextWindow: () => {},

package/src/__tests__/conversation-slash-unknown.test.ts

@@ -101,6 +101,8 @@ const addMessageCalls: Array<{
 }> = [];
 
 mock.module("../memory/conversation-crud.js", () => ({
+    setConversationProcessingStartedAt: () => {},
+    isConversationProcessing: () => false,
   setConversationOriginChannelIfUnset: () => {},
   updateConversationContextWindow: () => {},
   deleteMessageById: () => {},

package/src/__tests__/conversation-speed-override.test.ts

@@ -119,6 +119,8 @@ mock.module("../security/secret-allowlist.js", () => ({
 }));
 
 mock.module("../memory/conversation-crud.js", () => ({
+    setConversationProcessingStartedAt: () => {},
+    isConversationProcessing: () => false,
   setConversationOriginChannelIfUnset: () => {},
   updateConversationContextWindow: () => {},
   deleteMessageById: () => {},

package/src/__tests__/conversation-surfaces-task-progress.test.ts

@@ -336,6 +336,35 @@ describe("task_progress surface compatibility", () => {
     });
   });
 
+  test("ui_show file_upload normalizes a comma-joined acceptedTypes string", async () => {
+    const sent: ServerMessage[] = [];
+    const ctx = makeContext(sent);
+
+    // The model may emit acceptedTypes as a comma-joined string; the renderer
+    // calls `.join`/`.some` on it, so the daemon hands the client a clean array.
+    const result = await surfaceProxyResolver(ctx, "ui_show", {
+      surface_type: "file_upload",
+      title: "Upload a receipt",
+      data: {
+        prompt: "Share the receipt",
+        acceptedTypes: "image/*, application/pdf",
+      },
+    });
+
+    expect(result.isError).toBe(false);
+
+    const showMessage = sent.find(
+      (msg): msg is UiSurfaceShow => msg.type === "ui_surface_show",
+    );
+    expect(showMessage).toBeDefined();
+    if (!showMessage || showMessage.surfaceType !== "file_upload") return;
+
+    expect(showMessage.data.acceptedTypes).toEqual([
+      "image/*",
+      "application/pdf",
+    ]);
+  });
+
   test("ui_show dynamic_page uses data.html when properly nested", async () => {
     const sent: ServerMessage[] = [];
     const ctx = makeContext(sent);

package/src/__tests__/conversation-title-service.test.ts

@@ -34,6 +34,8 @@ mock.module("../runtime/btw-sidechain.js", () => ({
 }));
 
 mock.module("../memory/conversation-crud.js", () => ({
+    setConversationProcessingStartedAt: () => {},
+    isConversationProcessing: () => false,
   getConversation: mockGetConversation,
   getMessages: mockGetMessages,
   updateConversationTitle: mockUpdateConversationTitle,

package/src/__tests__/conversation-tool-setup-attribution.test.ts

@@ -321,3 +321,50 @@ describe("createToolExecutor attribution threading", () => {
     expect(calls[0].context.attribution).toBeNull();
   });
 });
+
+describe("createToolExecutor isInteractive threading", () => {
+  test("uses the resolved turn-level interactivity over live client state", async () => {
+    // A scheduled/background turn (currentTurnIsNonInteractive=true) must read
+    // as non-interactive even when a client is attached (hasNoClient=false), so
+    // ask_question short-circuits instead of parking on the response backstop.
+    const { executor, calls } = makeCapturingExecutor();
+    const toolFn = makeToolFn(
+      executor,
+      makeCtx({ currentTurnIsNonInteractive: true, hasNoClient: false }),
+    );
+
+    await toolFn("file_read", { path: "/tmp/a" });
+
+    expect(calls[0].context.isInteractive).toBe(false);
+  });
+
+  test("reflects an interactive turn as interactive", async () => {
+    const { executor, calls } = makeCapturingExecutor();
+    const toolFn = makeToolFn(
+      executor,
+      makeCtx({ currentTurnIsNonInteractive: false }),
+    );
+
+    await toolFn("file_read", { path: "/tmp/a" });
+
+    expect(calls[0].context.isInteractive).toBe(true);
+  });
+
+  test("falls back to live client state when no turn value is set", async () => {
+    // No in-flight turn resolution (e.g. tool execution outside runAgentLoop):
+    // derive interactivity from whether a client is connected.
+    const noClient = makeCapturingExecutor();
+    await makeToolFn(
+      noClient.executor,
+      makeCtx({ currentTurnIsNonInteractive: undefined, hasNoClient: true }),
+    )("file_read", { path: "/tmp/a" });
+    expect(noClient.calls[0].context.isInteractive).toBe(false);
+
+    const withClient = makeCapturingExecutor();
+    await makeToolFn(
+      withClient.executor,
+      makeCtx({ currentTurnIsNonInteractive: undefined, hasNoClient: false }),
+    )("file_read", { path: "/tmp/a" });
+    expect(withClient.calls[0].context.isInteractive).toBe(true);
+  });
+});

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

@@ -23,6 +23,8 @@ mock.module("../config/loader.js", () => ({
 }));
 
 mock.module("../memory/conversation-crud.js", () => ({
+    setConversationProcessingStartedAt: () => {},
+    isConversationProcessing: () => false,
   updateConversationUsage: (
     conversationId: string,
     inputTokens: number,

package/src/__tests__/conversation-workspace-cache-state.test.ts

@@ -87,6 +87,8 @@ mock.module("../security/secret-allowlist.js", () => ({
 }));
 
 mock.module("../memory/conversation-crud.js", () => ({
+    setConversationProcessingStartedAt: () => {},
+    isConversationProcessing: () => false,
   setConversationOriginChannelIfUnset: () => {},
   setConversationHistoryStrippedAt: () => {},
   provenanceFromTrustContext: () => ({

package/src/__tests__/conversation-workspace-injection.test.ts

@@ -111,6 +111,8 @@ mock.module("../security/secret-allowlist.js", () => ({
 }));
 
 mock.module("../memory/conversation-crud.js", () => ({
+    setConversationProcessingStartedAt: () => {},
+    isConversationProcessing: () => false,
   setConversationOriginChannelIfUnset: () => {},
   setConversationHistoryStrippedAt: () => {},
   provenanceFromTrustContext: () => ({

package/src/__tests__/conversation-workspace-tool-tracking.test.ts

@@ -109,6 +109,8 @@ mock.module("../security/secret-allowlist.js", () => ({
 }));
 
 mock.module("../memory/conversation-crud.js", () => ({
+    setConversationProcessingStartedAt: () => {},
+    isConversationProcessing: () => false,
   setConversationOriginChannelIfUnset: () => {},
   setConversationHistoryStrippedAt: () => {},
   provenanceFromTrustContext: () => ({

package/src/__tests__/credential-security-invariants.test.ts

@@ -182,6 +182,7 @@ describe("Invariant 2: no generic plaintext secret read API", () => {
       "daemon/handlers/config-slack-channel.ts", // Slack channel config credential management
       "providers/platform-proxy/context.ts", // managed proxy API key lookup for provider initialization
       "platform/client.ts", // platform client credential store fallback for standalone CLI auth
+      "mcp/mcp-header-store.ts", // MCP static auth header persistence (credential store CRUD + legacy migration)
       "mcp/mcp-oauth-provider.ts", // MCP OAuth token/client/discovery persistence
       "runtime/routes/integrations/slack/token.ts", // shared Slack token resolver (bot/user token lookup for CLI use routes)
       "mcp/client.ts", // MCP client cached-token lookup
@@ -221,7 +222,6 @@ describe("Invariant 2: no generic plaintext secret read API", () => {
       "runtime/routes/sanity-routes.ts", // Sanity connect/discover routes (reads stored api_token from credential store)
       "runtime/routes/platform-routes.ts", // CLI platform connect/disconnect/status routes (CLI-migrated to IPC)
       "ipc/skill-routes/providers.ts", // host.providers.secureKeys.getProviderKey IPC route (out-of-process SkillHost companion)
-      "daemon/external-plugins-bootstrap.ts", // reads credentials at plugin init (manifest.requiresCredential) via the CES-mediated getSecureKeyAsync path
       "inbound/platform-callback-registration.ts", // managed credential lookup for platform base URL, assistant ID, and API key
       "tts/providers/elevenlabs-provider.ts", // ElevenLabs TTS API key lookup
       "tts/providers/deepgram-provider.ts", // Deepgram TTS API key lookup

package/src/__tests__/db-compaction-events-migration.test.ts

@@ -0,0 +1,129 @@
+import { Database } from "bun:sqlite";
+import { describe, expect, test } from "bun:test";
+
+import { drizzle } from "drizzle-orm/bun-sqlite";
+
+import { getSqliteFrom } from "../memory/db-connection.js";
+import { migrateCreateCompactionEvents } from "../memory/migrations/302-create-compaction-events.js";
+import * as schema from "../memory/schema.js";
+
+interface EventRow {
+  conversation_id: string;
+  compacted_at: number;
+  summary: string;
+  compacted_message_count: number;
+}
+
+function createTestDb() {
+  const sqlite = new Database(":memory:");
+  sqlite.exec("PRAGMA journal_mode=WAL");
+  sqlite.exec("PRAGMA foreign_keys = ON");
+  return drizzle(sqlite, { schema });
+}
+
+function bootstrapCheckpointsTable(raw: Database): void {
+  raw.exec(/*sql*/ `
+    CREATE TABLE IF NOT EXISTS memory_checkpoints (
+      key TEXT PRIMARY KEY,
+      value TEXT NOT NULL,
+      updated_at INTEGER NOT NULL
+    )
+  `);
+}
+
+function bootstrapConversations(raw: Database): void {
+  raw.exec(/*sql*/ `
+    CREATE TABLE conversations (
+      id TEXT PRIMARY KEY,
+      title TEXT,
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL,
+      context_summary TEXT,
+      context_compacted_message_count INTEGER NOT NULL DEFAULT 0,
+      context_compacted_at INTEGER
+    )
+  `);
+}
+
+function insertConversation(
+  raw: Database,
+  id: string,
+  summary: string | null,
+  count: number,
+  compactedAt: number | null,
+): void {
+  raw
+    .query(
+      /*sql*/ `
+        INSERT INTO conversations (
+          id, title, created_at, updated_at,
+          context_summary, context_compacted_message_count, context_compacted_at
+        ) VALUES (?, ?, ?, ?, ?, ?, ?)
+      `,
+    )
+    .run(id, id, 1000, 2000, summary, count, compactedAt);
+}
+
+function getEvents(raw: Database): EventRow[] {
+  return raw
+    .query(
+      /*sql*/ `
+        SELECT conversation_id, compacted_at, summary, compacted_message_count
+        FROM conversation_compaction_events
+        ORDER BY conversation_id
+      `,
+    )
+    .all() as EventRow[];
+}
+
+describe("migrateCreateCompactionEvents", () => {
+  test("creates the ledger and backfills one event per compacted conversation", () => {
+    const db = createTestDb();
+    const raw = getSqliteFrom(db);
+    bootstrapCheckpointsTable(raw);
+    bootstrapConversations(raw);
+
+    insertConversation(raw, "compacted", "Summary text", 5, 3000);
+    insertConversation(raw, "uncompacted", null, 0, null);
+    // count>0 but never actually compacted (no timestamp) — must be skipped.
+    insertConversation(raw, "count-without-at", "Orphan summary", 4, null);
+
+    migrateCreateCompactionEvents(db);
+
+    expect(getEvents(raw)).toEqual([
+      {
+        conversation_id: "compacted",
+        compacted_at: 3000,
+        summary: "Summary text",
+        compacted_message_count: 5,
+      },
+    ]);
+  });
+
+  test("is idempotent — re-running does not duplicate backfilled events", () => {
+    const db = createTestDb();
+    const raw = getSqliteFrom(db);
+    bootstrapCheckpointsTable(raw);
+    bootstrapConversations(raw);
+    insertConversation(raw, "compacted", "Summary text", 5, 3000);
+
+    migrateCreateCompactionEvents(db);
+    migrateCreateCompactionEvents(db);
+
+    expect(getEvents(raw)).toHaveLength(1);
+  });
+
+  test("the NOT EXISTS guard prevents duplicates even if the checkpoint is lost", () => {
+    const db = createTestDb();
+    const raw = getSqliteFrom(db);
+    bootstrapCheckpointsTable(raw);
+    bootstrapConversations(raw);
+    insertConversation(raw, "compacted", "Summary text", 5, 3000);
+
+    migrateCreateCompactionEvents(db);
+    raw.exec(`DELETE FROM memory_checkpoints`);
+    migrateCreateCompactionEvents(db);
+
+    expect(getEvents(raw)).toHaveLength(1);
+  });
+});