@vellumai/assistant 0.7.1 → 0.7.3

package/src/__tests__/conversation-surfaces-data-persist.test.ts

@@ -0,0 +1,404 @@
+import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
+
+// Mock the persistence layer the surface helpers reach into so we can
+// observe writes without touching SQLite. We swap this out per test by
+// re-assigning the spies recorded on the closure below.
+let getMessagesImpl: (conversationId: string) => Array<{
+  id: string;
+  conversationId: string;
+  role: string;
+  content: string;
+  createdAt: number;
+  metadata: string | null;
+}> = () => [];
+let updateMessageContentSpy: (id: string, content: string) => void = () => {};
+
+const realCrud = await import("../memory/conversation-crud.js");
+
+mock.module("../memory/conversation-crud.js", () => ({
+  ...realCrud,
+  getMessages: (conversationId: string) => getMessagesImpl(conversationId),
+  updateMessageContent: (id: string, content: string) =>
+    updateMessageContentSpy(id, content),
+}));
+
+// Imports must come AFTER mock.module so the surface module picks up
+// the mocked persistence functions.
+const {
+  cancelPendingSurfaceDataPersists,
+  flushPendingSurfaceDataPersists,
+  createSurfaceMutex,
+  flushSurfaceDataPersist,
+  markSurfaceCompleted,
+  scheduleSurfaceDataPersist,
+  surfaceProxyResolver,
+} = await import("../daemon/conversation-surfaces.js");
+
+import type { SurfaceConversationContext } from "../daemon/conversation-surfaces.js";
+import type {
+  CardSurfaceData,
+  ServerMessage,
+  SurfaceData,
+  SurfaceType,
+} from "../daemon/message-protocol.js";
+
+function makeContext(sent: ServerMessage[] = []): SurfaceConversationContext {
+  return {
+    conversationId: "conv-persist-1",
+    traceEmitter: { emit: () => {} },
+    sendToClient: (msg) => sent.push(msg),
+    pendingSurfaceActions: new Map<string, { surfaceType: SurfaceType }>(),
+    lastSurfaceAction: new Map<
+      string,
+      { actionId: string; data?: Record<string, unknown> }
+    >(),
+    surfaceState: new Map<
+      string,
+      { surfaceType: SurfaceType; data: SurfaceData; title?: string }
+    >(),
+    surfaceUndoStacks: new Map<string, string[]>(),
+    accumulatedSurfaceState: new Map<string, Record<string, unknown>>(),
+    surfaceActionRequestIds: new Set<string>(),
+    currentTurnSurfaces: [],
+    isProcessing: () => false,
+    enqueueMessage: () => ({ queued: false, requestId: "req-1" }),
+    getQueueDepth: () => 0,
+    processMessage: async () => "ok",
+    withSurface: createSurfaceMutex(),
+  };
+}
+
+function seedRows(rows: Array<{ id: string; content: unknown }>): void {
+  getMessagesImpl = () =>
+    rows.map((r) => ({
+      id: r.id,
+      conversationId: "conv-persist-1",
+      role: "assistant",
+      content:
+        typeof r.content === "string" ? r.content : JSON.stringify(r.content),
+      createdAt: 0,
+      metadata: null,
+    }));
+}
+
+describe("ui_surface_update persistence", () => {
+  let writes: Array<{ id: string; content: unknown }> = [];
+
+  beforeEach(() => {
+    writes = [];
+    updateMessageContentSpy = (id: string, content: string) => {
+      writes.push({ id, content: JSON.parse(content) });
+    };
+    getMessagesImpl = () => [];
+    // Make sure module-level pending timers from a previous test don't
+    // leak into this one.
+    cancelPendingSurfaceDataPersists();
+  });
+
+  afterEach(() => {
+    cancelPendingSurfaceDataPersists();
+  });
+
+  test("ui_update schedules a debounced DB write that lands within ~600ms", async () => {
+    const sent: ServerMessage[] = [];
+    const ctx = makeContext(sent);
+
+    // Seed an existing in-memory surface and a persisted message that
+    // contains the matching ui_surface block.
+    const surfaceId = "surface-debounced-1";
+    const initial: CardSurfaceData = {
+      title: "Health check",
+      body: "",
+      template: "task_progress",
+      templateData: { status: "in_progress", steps: [] },
+    };
+    ctx.surfaceState.set(surfaceId, { surfaceType: "card", data: initial });
+    seedRows([
+      {
+        id: "msg-1",
+        content: [
+          { type: "text", text: "running" },
+          {
+            type: "ui_surface",
+            surfaceId,
+            surfaceType: "card",
+            data: initial,
+          },
+        ],
+      },
+    ]);
+
+    const result = await surfaceProxyResolver(ctx, "ui_update", {
+      surface_id: surfaceId,
+      data: { templateData: { status: "completed" } },
+    });
+    expect(result.isError).toBe(false);
+
+    // Write must not have happened synchronously.
+    expect(writes).toHaveLength(0);
+
+    // After the debounce window the write lands.
+    await new Promise((r) => setTimeout(r, 600));
+    expect(writes).toHaveLength(1);
+    expect(writes[0].id).toBe("msg-1");
+    const persistedBlocks = writes[0].content as Array<Record<string, unknown>>;
+    const persistedSurface = persistedBlocks.find(
+      (b) => b.type === "ui_surface",
+    );
+    expect(persistedSurface).toBeDefined();
+    const persistedData = persistedSurface!.data as CardSurfaceData;
+    expect((persistedData.templateData as Record<string, unknown>).status).toBe(
+      "completed",
+    );
+  });
+
+  test("multiple rapid updates collapse to a single DB write", async () => {
+    const sent: ServerMessage[] = [];
+    const ctx = makeContext(sent);
+
+    const surfaceId = "surface-debounced-2";
+    const initial: CardSurfaceData = {
+      title: "Health check",
+      body: "",
+      template: "task_progress",
+      templateData: { status: "in_progress", steps: [] },
+    };
+    ctx.surfaceState.set(surfaceId, { surfaceType: "card", data: initial });
+    seedRows([
+      {
+        id: "msg-2",
+        content: [
+          {
+            type: "ui_surface",
+            surfaceId,
+            surfaceType: "card",
+            data: initial,
+          },
+        ],
+      },
+    ]);
+
+    for (const status of ["a", "b", "c", "d"]) {
+      // Patches arrive faster than the debounce window.
+      await surfaceProxyResolver(ctx, "ui_update", {
+        surface_id: surfaceId,
+        data: { templateData: { status } },
+      });
+      await new Promise((r) => setTimeout(r, 50));
+    }
+
+    // Wait past the debounce window after the LAST update.
+    await new Promise((r) => setTimeout(r, 600));
+
+    expect(writes).toHaveLength(1);
+    const persistedSurface = (
+      writes[0].content as Array<Record<string, unknown>>
+    ).find((b) => b.type === "ui_surface");
+    const persistedData = persistedSurface!.data as CardSurfaceData;
+    expect((persistedData.templateData as Record<string, unknown>).status).toBe(
+      "d",
+    );
+  });
+
+  test("markSurfaceCompleted force-flushes any pending debounced write", async () => {
+    const surfaceId = "surface-flush-1";
+    const initial: CardSurfaceData = {
+      title: "x",
+      body: "",
+      template: "task_progress",
+      templateData: { status: "in_progress" },
+    };
+    seedRows([
+      {
+        id: "msg-flush",
+        content: [
+          {
+            type: "ui_surface",
+            surfaceId,
+            surfaceType: "card",
+            data: initial,
+          },
+        ],
+      },
+    ]);
+
+    // Schedule a debounced persist directly.
+    scheduleSurfaceDataPersist("conv-persist-1", surfaceId, {
+      ...initial,
+      templateData: { status: "completed" },
+    } as SurfaceData);
+
+    expect(writes).toHaveLength(0);
+
+    // Calling markSurfaceCompleted should immediately flush the pending
+    // data persist AND apply its own completion patch — two writes
+    // against the same row, with the completion landing last.
+    markSurfaceCompleted({ conversationId: "conv-persist-1" }, surfaceId, "ok");
+
+    expect(writes.length).toBeGreaterThanOrEqual(2);
+    const finalBlocks = writes[writes.length - 1].content as Array<
+      Record<string, unknown>
+    >;
+    const finalSurface = finalBlocks.find((b) => b.type === "ui_surface")!;
+    expect(finalSurface.completed).toBe(true);
+    expect(finalSurface.completionSummary).toBe("ok");
+  });
+
+  test("flushSurfaceDataPersist fires the latest data immediately", () => {
+    const surfaceId = "surface-flush-2";
+    seedRows([
+      {
+        id: "msg-flush-2",
+        content: [
+          {
+            type: "ui_surface",
+            surfaceId,
+            surfaceType: "card",
+            data: { title: "x", body: "" },
+          },
+        ],
+      },
+    ]);
+    scheduleSurfaceDataPersist("conv-persist-1", surfaceId, {
+      title: "x",
+      body: "later",
+    } as SurfaceData);
+
+    expect(writes).toHaveLength(0);
+    flushSurfaceDataPersist(surfaceId);
+    expect(writes).toHaveLength(1);
+    const block = (writes[0].content as Array<Record<string, unknown>>).find(
+      (b) => b.type === "ui_surface",
+    );
+    expect((block!.data as Record<string, unknown>).body).toBe("later");
+  });
+
+  test("update arriving before the message is persisted is safely skipped", async () => {
+    const surfaceId = "surface-orphan-1";
+    // No rows seeded — simulates mid-stream before message_complete persists.
+    seedRows([]);
+
+    scheduleSurfaceDataPersist("conv-persist-1", surfaceId, {
+      title: "x",
+      body: "",
+    } as SurfaceData);
+
+    await new Promise((r) => setTimeout(r, 600));
+
+    // No write — and no crash.
+    expect(writes).toHaveLength(0);
+  });
+
+  test("cancelPendingSurfaceDataPersists clears scoped timers without firing", async () => {
+    const surfaceId = "surface-cancel-1";
+    seedRows([
+      {
+        id: "msg-cancel",
+        content: [
+          {
+            type: "ui_surface",
+            surfaceId,
+            surfaceType: "card",
+            data: { title: "x", body: "" },
+          },
+        ],
+      },
+    ]);
+
+    scheduleSurfaceDataPersist("conv-persist-1", surfaceId, {
+      title: "x",
+      body: "queued",
+    } as SurfaceData);
+
+    cancelPendingSurfaceDataPersists("conv-persist-1");
+    await new Promise((r) => setTimeout(r, 600));
+
+    expect(writes).toHaveLength(0);
+  });
+
+  test("flushPendingSurfaceDataPersists writes pending updates synchronously and clears timers", async () => {
+    const surfaceId = "surface-flush-pending-1";
+    seedRows([
+      {
+        id: "msg-flush-pending",
+        content: [
+          {
+            type: "ui_surface",
+            surfaceId,
+            surfaceType: "card",
+            data: { title: "x", body: "" },
+          },
+        ],
+      },
+    ]);
+
+    scheduleSurfaceDataPersist("conv-persist-1", surfaceId, {
+      title: "x",
+      body: "shutdown-flush",
+    } as SurfaceData);
+
+    // Write should not have fired yet (debounce hasn't elapsed).
+    expect(writes).toHaveLength(0);
+
+    flushPendingSurfaceDataPersists("conv-persist-1");
+
+    // Synchronous flush — write lands immediately with the latest data.
+    expect(writes).toHaveLength(1);
+    expect(writes[0].id).toBe("msg-flush-pending");
+    const block = (writes[0].content as Array<Record<string, unknown>>).find(
+      (b) => b.type === "ui_surface",
+    )!;
+    expect((block.data as Record<string, unknown>).body).toBe("shutdown-flush");
+
+    // Timer is cleared — waiting past the debounce window doesn't fire again.
+    await new Promise((r) => setTimeout(r, 600));
+    expect(writes).toHaveLength(1);
+  });
+
+  test("flushPendingSurfaceDataPersists scoped to one conversation leaves other conversations' timers alone", async () => {
+    const surfaceA = "surface-flush-scoped-a";
+    const surfaceB = "surface-flush-scoped-b";
+    seedRows([
+      {
+        id: "msg-scoped-a",
+        content: [
+          {
+            type: "ui_surface",
+            surfaceId: surfaceA,
+            surfaceType: "card",
+            data: { title: "x", body: "" },
+          },
+        ],
+      },
+      {
+        id: "msg-scoped-b",
+        content: [
+          {
+            type: "ui_surface",
+            surfaceId: surfaceB,
+            surfaceType: "card",
+            data: { title: "x", body: "" },
+          },
+        ],
+      },
+    ]);
+
+    scheduleSurfaceDataPersist("conv-persist-1", surfaceA, {
+      title: "x",
+      body: "a",
+    } as SurfaceData);
+    scheduleSurfaceDataPersist("conv-other", surfaceB, {
+      title: "x",
+      body: "b",
+    } as SurfaceData);
+
+    flushPendingSurfaceDataPersists("conv-persist-1");
+
+    // Only conv-persist-1's surface flushed; conv-other's still pending.
+    expect(writes).toHaveLength(1);
+    expect(writes[0].id).toBe("msg-scoped-a");
+
+    // Cleanup the other conversation's timer.
+    cancelPendingSurfaceDataPersists("conv-other");
+  });
+});

package/src/__tests__/conversation-tool-setup-app-refresh.test.ts

@@ -95,7 +95,6 @@ function makeCtx(overrides: Partial<ToolSetupContext> = {}): ToolSetupContext {
     getQueueDepth: () => 0,
     processMessage: async () => "",
     withSurface: async <T>(_id: string, fn: () => T | Promise<T>) => fn(),
-    memoryPolicy: { scopeId: "default" },
     ...overrides,
   };
 }
@@ -383,7 +382,7 @@ describe("session-tool-setup app refresh side effects", () => {
       // Simulate calling app_refresh by name (as the agent loop does)
       for (const toolName of ["app_refresh"]) {
         refreshSpy.mockClear();
-    broadcastSpy.mockClear();
+        broadcastSpy.mockClear();
         broadcastSpy.mockClear();
         updatePublishedSpy.mockClear();
 
@@ -423,7 +422,7 @@ describe("session-tool-setup app refresh side effects", () => {
         "app_file_write",
       ]) {
         refreshSpy.mockClear();
-    broadcastSpy.mockClear();
+        broadcastSpy.mockClear();
         broadcastSpy.mockClear();
         updatePublishedSpy.mockClear();
 
@@ -435,6 +434,4 @@ describe("session-tool-setup app refresh side effects", () => {
       }
     });
   });
-
-
 });

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

@@ -1,8 +1,14 @@
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
 import type { AgentEvent } from "../agent/loop.js";
+import { _setOverridesForTesting } from "../config/assistant-feature-flags.js";
 import type { Message, ProviderResponse } from "../providers/types.js";
 
+// This test exercises v1 conversation routing. The `memory-v2-enabled` flag
+// (registry default `true`) flips memory routing to v2 — disable it here so
+// the v1 paths under test stay active.
+_setOverridesForTesting({ "memory-v2-enabled": false });
+
 // ---------------------------------------------------------------------------
 // Track agent loop calls
 // ---------------------------------------------------------------------------

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

@@ -1,8 +1,14 @@
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
 import type { AgentEvent } from "../agent/loop.js";
+import { _setOverridesForTesting } from "../config/assistant-feature-flags.js";
 import type { Message, ProviderResponse } from "../providers/types.js";
 
+// This test exercises v1 conversation routing. The `memory-v2-enabled` flag
+// (registry default `true`) flips memory routing to v2 — disable it here so
+// the v1 paths under test stay active.
+_setOverridesForTesting({ "memory-v2-enabled": false });
+
 // ---------------------------------------------------------------------------
 // Configurable agent loop behavior
 // ---------------------------------------------------------------------------

package/src/__tests__/credential-execution-feature-gates.test.ts

@@ -17,12 +17,10 @@ import {
 import type { AssistantConfig } from "../config/schema.js";
 import {
   CES_GRANT_AUDIT_FLAG_KEY,
-  CES_MANAGED_SIDECAR_FLAG_KEY,
   CES_SECURE_INSTALL_FLAG_KEY,
   CES_SHELL_LOCKDOWN_FLAG_KEY,
   CES_TOOLS_FLAG_KEY,
   isCesGrantAuditEnabled,
-  isCesManagedSidecarEnabled,
   isCesSecureInstallEnabled,
   isCesShellLockdownEnabled,
   isCesToolsEnabled,
@@ -51,7 +49,6 @@ const ALL_CES_FLAG_KEYS = [
   CES_SHELL_LOCKDOWN_FLAG_KEY,
   CES_SECURE_INSTALL_FLAG_KEY,
   CES_GRANT_AUDIT_FLAG_KEY,
-  CES_MANAGED_SIDECAR_FLAG_KEY,
 ] as const;
 
 /** All CES predicate functions paired with their flag keys and expected defaults. */
@@ -80,12 +77,6 @@ const ALL_CES_PREDICATES = [
     key: CES_GRANT_AUDIT_FLAG_KEY,
     defaultEnabled: false,
   },
-  {
-    name: "isCesManagedSidecarEnabled",
-    fn: isCesManagedSidecarEnabled,
-    key: CES_MANAGED_SIDECAR_FLAG_KEY,
-    defaultEnabled: true,
-  },
 ] as const;
 
 // ---------------------------------------------------------------------------
@@ -180,7 +171,7 @@ describe("CES flags do not affect unrelated flags", () => {
     expect(isAssistantFeatureFlagEnabled("browser", config)).toBe(true);
   });
 
-  test("enabling all CES flags does not change sounds flag (defaultEnabled: true)", () => {
+  test("enabling all CES flags does not change unrelated default-open flags", () => {
     const overrides: Record<string, boolean> = {};
     for (const key of ALL_CES_FLAG_KEYS) {
       overrides[key] = true;
@@ -188,7 +179,9 @@ describe("CES flags do not affect unrelated flags", () => {
     _setOverridesForTesting(overrides);
     const config = makeConfig();
 
-    // sounds defaults to true in the registry and should stay true
-    expect(isAssistantFeatureFlagEnabled("sounds", config)).toBe(true);
+    // Unknown flags default open unless explicitly overridden.
+    expect(
+      isAssistantFeatureFlagEnabled("unrelated-default-open", config),
+    ).toBe(true);
   });
 });

package/src/__tests__/credential-execution-managed-contract.test.ts

@@ -1,8 +1,8 @@
 /**
  * Managed CES contract and wiring tests.
  *
- * Validates the contract surface, behavioral invariants, and feature-flag
- * gating for the managed (three-container pod) CES sidecar integration:
+ * Validates the contract surface and behavioral invariants for the managed
+ * (three-container pod) CES sidecar integration:
  *
  * 1. Pod creation contract: well-known path constants match the
  *    stateful_template.yaml K8s spec (read-only mount + private PVC).
@@ -18,25 +18,11 @@
  *    (UpdateManagedCredential, MakeAuthenticatedRequest) validate expected
  *    payloads and reject malformed ones at the contract level.
  *
- * 5. Feature-flag rollback: when the `ces-managed-sidecar` flag is off,
- *    the process manager falls back to local discovery and never attempts
- *    the managed sidecar path.
- *
  * All tests use contract schemas and handle parsers to verify behavioral
  * contracts — no real CES process or socket dependencies are needed.
  */
 
-import { afterEach, beforeEach, describe, expect, test } from "bun:test";
-
-import { _setOverridesForTesting } from "../config/assistant-feature-flags.js";
-
-beforeEach(() => {
-  _setOverridesForTesting({});
-});
-
-afterEach(() => {
-  _setOverridesForTesting({});
-});
+import { describe, expect, test } from "bun:test";
 
 import {
   CES_PROTOCOL_VERSION,
@@ -53,26 +39,11 @@ import {
   UpdateManagedCredentialSchema,
 } from "@vellumai/service-contracts/credential-rpc";
 
-import type { AssistantConfig } from "../config/schema.js";
-import {
-  isCesManagedSidecarEnabled,
-  isCesToolsEnabled,
-} from "../credential-execution/feature-gates.js";
 import {
   CES_ASSISTANT_DATA_READONLY_MOUNT,
   CES_PRIVATE_DATA_DIR,
-  type CesProcessManagerConfig,
 } from "../credential-execution/process-manager.js";
 
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-/** Create a minimal AssistantConfig (flag overrides are now set via _setOverridesForTesting). */
-function makeConfig(): AssistantConfig {
-  return {} as AssistantConfig;
-}
-
 // ---------------------------------------------------------------------------
 // Well-known paths contract
 // ---------------------------------------------------------------------------
@@ -440,102 +411,3 @@ describe("managed OAuth materialization through CES sidecar", () => {
     }
   });
 });
-
-// ---------------------------------------------------------------------------
-// Feature-flag rollback safety
-// ---------------------------------------------------------------------------
-
-describe("feature-flag rollback safety", () => {
-  test("managed sidecar flag defaults to true (enabled by default)", () => {
-    const config = makeConfig();
-    expect(isCesManagedSidecarEnabled(config)).toBe(true);
-  });
-
-  test("managed sidecar flag can be explicitly enabled", () => {
-    _setOverridesForTesting({
-      "ces-managed-sidecar": true,
-    });
-    const config = makeConfig();
-    expect(isCesManagedSidecarEnabled(config)).toBe(true);
-  });
-
-  test("managed sidecar flag can be explicitly disabled", () => {
-    _setOverridesForTesting({
-      "ces-managed-sidecar": false,
-    });
-    const config = makeConfig();
-    expect(isCesManagedSidecarEnabled(config)).toBe(false);
-  });
-
-  test("enabling managed sidecar does not enable CES tools", () => {
-    _setOverridesForTesting({
-      "ces-managed-sidecar": true,
-    });
-    const config = makeConfig();
-    // CES tools flag should remain independently controlled
-    expect(isCesToolsEnabled(config)).toBe(false);
-  });
-
-  test("disabling managed sidecar does not affect other CES flags", () => {
-    _setOverridesForTesting({
-      "ces-managed-sidecar": false,
-      "ces-tools": true,
-    });
-    const config = makeConfig();
-    expect(isCesToolsEnabled(config)).toBe(true);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Process manager config wiring
-// ---------------------------------------------------------------------------
-
-describe("process manager config wiring", () => {
-  test("CesProcessManagerConfig accepts assistantConfig for flag gating", () => {
-    _setOverridesForTesting({
-      "ces-managed-sidecar": true,
-    });
-    const config: CesProcessManagerConfig = {
-      assistantConfig: makeConfig(),
-    };
-    expect(config.assistantConfig).toBeDefined();
-    expect(isCesManagedSidecarEnabled(config.assistantConfig!)).toBe(true);
-  });
-
-  test("CesProcessManagerConfig requires assistantConfig for feature-flag gate", () => {
-    const config: CesProcessManagerConfig = {
-      assistantConfig: makeConfig(),
-    };
-    expect(config.assistantConfig).toBeDefined();
-  });
-
-  test("when flag is off, managed discovery is skipped", () => {
-    _setOverridesForTesting({
-      "ces-managed-sidecar": false,
-    });
-    const config: CesProcessManagerConfig = {
-      assistantConfig: makeConfig(),
-    };
-    // The managed path should be gated
-    expect(isCesManagedSidecarEnabled(config.assistantConfig!)).toBe(false);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Non-CES internal consumers intact
-// ---------------------------------------------------------------------------
-
-describe("non-CES internal consumers intact when flag is off", () => {
-  test("existing non-agent flows are unaffected by managed sidecar flag", () => {
-    _setOverridesForTesting({
-      "ces-managed-sidecar": false,
-    });
-    const config = makeConfig();
-    expect(isCesManagedSidecarEnabled(config)).toBe(false);
-  });
-
-  test("process manager without config allows managed mode (backward compat)", () => {
-    const config: CesProcessManagerConfig = {};
-    expect(config.assistantConfig).toBeUndefined();
-  });
-});