@vellumai/assistant 0.8.12 → 0.9.0-staging.2

package/src/__tests__/context-window-manager-compact-retry.test.ts

@@ -47,6 +47,7 @@ interface CompactionRunResult {
   summaryText: string;
   reason?: string;
   summaryFailed?: boolean;
+  tailFloorReached?: boolean;
 }
 
 let runCalls: Array<{
@@ -306,6 +307,69 @@ describe("ContextWindowManager.maybeCompact retry budget", () => {
     expect(result.exhausted).toBe(true);
     expect(result.estimatedInputTokens).toBe(165_000);
   });
+
+  test("tailFloorReached after one pass → no futile retry, exhausted", async () => {
+    // Pass 1 compacted but stayed above threshold AND the forward-cut hit the
+    // tail floor — a second full-context pass would land on the same floor and
+    // free nothing. The manager must NOT run attempt 2 even though maxAttempts=3.
+    // Pre-compaction 180k → attempt-1 recompute 165k (above 140k threshold).
+    estimateReturns.push(180_000, 165_000);
+    runResults = [
+      compactResult({ estimatedInputTokens: 165_000, tailFloorReached: true }),
+      // Never consumed — proves no retry fired:
+      compactResult({ estimatedInputTokens: 50_000 }),
+    ];
+
+    const manager = buildManager(3);
+    const result = await manager.maybeCompact(makeMessages(10));
+
+    expect(runCalls.length).toBe(1);
+    expect(result.exhausted).toBe(true);
+    expect(result.estimatedInputTokens).toBe(165_000);
+  });
+
+  test("tailFloorReached but already under threshold → ship, not exhausted", async () => {
+    // The floor flag only forces exhaustion when still over the gate. A pass
+    // that cleared the threshold ships as a clean success regardless.
+    estimateReturns.push(180_000, 50_000);
+    runResults = [
+      compactResult({ estimatedInputTokens: 50_000, tailFloorReached: true }),
+    ];
+
+    const manager = buildManager(3);
+    const result = await manager.maybeCompact(makeMessages(10));
+
+    expect(runCalls.length).toBe(1);
+    expect(result.compacted).toBe(true);
+    expect(result.exhausted).toBeUndefined();
+    expect(result.estimatedInputTokens).toBe(50_000);
+  });
+
+  test("tailFloorReached on a retry pass → stops the retry loop", async () => {
+    // Pass 1 shrank but stayed above threshold WITHOUT hitting the floor, so a
+    // retry runs. Pass 2 shrinks further, still above threshold, and this time
+    // hits the floor — the loop must stop before attempt 3.
+    // 180k → attempt-1 165k → attempt-2 150k (both above 140k).
+    estimateReturns.push(180_000, 165_000, 150_000);
+    runResults = [
+      compactResult({ estimatedInputTokens: 165_000, compactedMessages: 3 }),
+      compactResult({
+        estimatedInputTokens: 150_000,
+        compactedMessages: 2,
+        tailFloorReached: true,
+      }),
+      // Never consumed:
+      compactResult({ estimatedInputTokens: 50_000 }),
+    ];
+
+    const manager = buildManager(3);
+    const result = await manager.maybeCompact(makeMessages(10));
+
+    expect(runCalls.length).toBe(2);
+    expect(result.exhausted).toBe(true);
+    expect(result.estimatedInputTokens).toBe(150_000);
+    expect(result.compactedMessages).toBe(5);
+  });
 });
 
 describe("ContextWindowManager.emergencyCompact", () => {

package/src/__tests__/conversation-abort-tool-results.test.ts

@@ -13,11 +13,6 @@ mock.module("../util/logger.js", () => ({
     new Proxy({} as Record<string, unknown>, { get: () => () => {} }),
 }));
 
-mock.module("../memory/guardian-action-store.js", () => ({
-  getGuardianActionRequest: () => null,
-  resolveGuardianActionRequest: () => {},
-}));
-
 mock.module("../providers/registry.js", () => ({
   getProvider: () => ({ name: "mock-provider" }),
   initializeProviders: async () => {},

package/src/__tests__/conversation-confirmation-signals.test.ts

@@ -41,11 +41,6 @@ mock.module("../util/logger.js", () => ({
   getLogger: () => makeLoggerStub(),
 }));
 
-mock.module("../memory/guardian-action-store.js", () => ({
-  getGuardianActionRequest: () => null,
-  resolveGuardianActionRequest: () => {},
-}));
-
 mock.module("../providers/registry.js", () => ({
   getProvider: () => ({ name: "mock-provider" }),
   initializeProviders: async () => {},

package/src/__tests__/conversation-history-web-search.test.ts

@@ -796,6 +796,13 @@ describe("web_search_tool_result structural guard", () => {
     // conservative direction (fewer nudges). Same reasoning as agent/loop.ts.
     "plugins/defaults/exploration-drift/hooks/post-tool-use.ts",
 
+    // Detects turn boundaries by checking whether a user message carries any
+    // tool_result block (internal continuation) vs. none (genuine user prompt).
+    // A web_search_tool_result-only message is also internal, but treating one
+    // as a boundary only bounds the round count early — the conservative
+    // direction (fewer nudges). Same reasoning as exploration-drift above.
+    "plugins/defaults/task-progress-nudge/hooks/post-tool-use.ts",
+
     // Reconciles synthesized cancellation tool_results for locally-executed
     // tools only. Same reasoning as agent/loop.ts above.
     "daemon/conversation-agent-loop.ts",

package/src/__tests__/conversation-process-callsite.test.ts

@@ -36,11 +36,6 @@ mock.module("../util/logger.js", () => ({
     new Proxy({} as Record<string, unknown>, { get: () => () => {} }),
 }));
 
-mock.module("../memory/guardian-action-store.js", () => ({
-  getGuardianActionRequest: () => null,
-  resolveGuardianActionRequest: () => {},
-}));
-
 const mockProviderStub = { name: "mock-provider" };
 mock.module("../providers/registry.js", () => ({
   getProvider: () => mockProviderStub,

package/src/__tests__/conversation-provider-retry-repair.test.ts

@@ -10,11 +10,6 @@ mock.module("../util/logger.js", () => ({
     new Proxy({} as Record<string, unknown>, { get: () => () => {} }),
 }));
 
-mock.module("../memory/guardian-action-store.js", () => ({
-  getGuardianActionRequest: () => null,
-  resolveGuardianActionRequest: () => {},
-}));
-
 mock.module("../providers/registry.js", () => ({
   getProvider: () => ({ name: "mock-provider" }),
   initializeProviders: async () => {},

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

@@ -37,11 +37,6 @@ mock.module("../util/logger.js", () => ({
   getLogger: () => makeLoggerStub(),
 }));
 
-mock.module("../memory/guardian-action-store.js", () => ({
-  getGuardianActionRequest: () => null,
-  resolveGuardianActionRequest: () => {},
-}));
-
 mock.module("../providers/registry.js", () => ({
   getProvider: () => ({ name: "mock-provider" }),
   initializeProviders: async () => {},

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

@@ -18,11 +18,6 @@ mock.module("../util/logger.js", () => ({
     new Proxy({} as Record<string, unknown>, { get: () => () => {} }),
 }));
 
-mock.module("../memory/guardian-action-store.js", () => ({
-  getGuardianActionRequest: () => null,
-  resolveGuardianActionRequest: () => {},
-}));
-
 mock.module("../providers/registry.js", () => ({
   getProvider: () => ({ name: "mock-provider" }),
   initializeProviders: async () => {},

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

@@ -14,11 +14,6 @@ mock.module("../util/logger.js", () => ({
     new Proxy({} as Record<string, unknown>, { get: () => () => {} }),
 }));
 
-mock.module("../memory/guardian-action-store.js", () => ({
-  getGuardianActionRequest: () => null,
-  resolveGuardianActionRequest: () => {},
-}));
-
 mock.module("../providers/registry.js", () => ({
   getProvider: () => ({ name: "mock-provider" }),
   initializeProviders: async () => {},

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

@@ -37,11 +37,6 @@ mock.module("../util/logger.js", () => ({
   getLogger: () => makeLoggerStub(),
 }));
 
-mock.module("../memory/guardian-action-store.js", () => ({
-  getGuardianActionRequest: () => null,
-  resolveGuardianActionRequest: () => {},
-}));
-
 mock.module("../providers/registry.js", () => ({
   getProvider: () => ({ name: "mock-provider" }),
   initializeProviders: async () => {},

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

@@ -416,6 +416,103 @@ describe("ui_surface_update persistence", () => {
   });
 });
 
+describe("ui_dismiss persisted-state convergence", () => {
+  let writes: Array<{ id: string; content: unknown }> = [];
+
+  beforeEach(() => {
+    writes = [];
+    updateMessageContentSpy = (id: string, content: string) => {
+      writes.push({ id, content: JSON.parse(content) });
+    };
+    getMessagesImpl = () => [];
+    cancelPendingSurfaceDataPersists();
+  });
+
+  afterEach(() => {
+    cancelPendingSurfaceDataPersists();
+  });
+
+  test("passive dismiss drops the surface from the turn snapshot and strips the persisted block", async () => {
+    const sent: ServerMessage[] = [];
+    const ctx = makeContext(sent);
+    const surfaceId = "surface-dismiss-1";
+    // A progress card the model marked `completed` while leaving step 4 spinning.
+    const data: CardSurfaceData = {
+      title: "Refreshing dashboard",
+      body: "",
+      template: "task_progress",
+      templateData: {
+        status: "completed",
+        steps: [{ label: "Surface today's numbers", status: "in_progress" }],
+      },
+    };
+    ctx.surfaceState.set(surfaceId, { surfaceType: "card", data });
+    ctx.currentTurnSurfaces.push({ surfaceId, surfaceType: "card", data });
+    seedRows([
+      {
+        id: "msg-dismiss",
+        content: [
+          { type: "text", text: "done" },
+          { type: "ui_surface", surfaceId, surfaceType: "card", data },
+        ],
+      },
+    ]);
+
+    const result = await surfaceProxyResolver(ctx, "ui_dismiss", {
+      surface_id: surfaceId,
+    });
+    expect(result.isError).toBe(false);
+    expect(result.content).toBe("Surface dismissed");
+
+    // Removed from the pending turn snapshot so turn completion never re-appends it.
+    expect(
+      ctx.currentTurnSurfaces.find((s) => s.surfaceId === surfaceId),
+    ).toBeUndefined();
+
+    // The already-persisted block is stripped; the sibling text block survives.
+    expect(writes).toHaveLength(1);
+    const blocks = writes[0].content as Array<Record<string, unknown>>;
+    expect(blocks.find((b) => b.type === "ui_surface")).toBeUndefined();
+    expect(blocks.find((b) => b.type === "text")).toBeDefined();
+
+    // A passive dismiss event (not a completion) was emitted to the client.
+    expect(sent.some((m) => m.type === "ui_surface_dismiss")).toBe(true);
+    expect(sent.some((m) => m.type === "ui_surface_complete")).toBe(false);
+  });
+
+  test("dismiss cancels a pending debounced persist so a stale update cannot re-add the block", async () => {
+    const sent: ServerMessage[] = [];
+    const ctx = makeContext(sent);
+    const surfaceId = "surface-dismiss-2";
+    const data: CardSurfaceData = {
+      title: "x",
+      body: "",
+      template: "task_progress",
+      templateData: { status: "in_progress" },
+    };
+    ctx.surfaceState.set(surfaceId, { surfaceType: "card", data });
+    seedRows([
+      {
+        id: "msg-dismiss-2",
+        content: [{ type: "ui_surface", surfaceId, surfaceType: "card", data }],
+      },
+    ]);
+
+    // A final ui_update is still inside the debounce window when dismiss fires.
+    scheduleSurfaceDataPersist("conv-persist-1", surfaceId, {
+      ...data,
+      templateData: { status: "completed" },
+    } as SurfaceData);
+
+    await surfaceProxyResolver(ctx, "ui_dismiss", { surface_id: surfaceId });
+    const writeCountAfterDismiss = writes.length;
+
+    // The cancelled debounce must not fire a write that resurrects the block.
+    await new Promise((r) => setTimeout(r, 600));
+    expect(writes).toHaveLength(writeCountAfterDismiss);
+  });
+});
+
 describe("standalone surface DB persistence", () => {
   let writes: Array<{ id: string; content: unknown }> = [];
 

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

@@ -208,6 +208,73 @@ describe("task_progress surface compatibility", () => {
     );
   });
 
+  test("ui_show fills well-formed templateData for a stepless task_progress card", async () => {
+    const sent: ServerMessage[] = [];
+    const ctx = makeContext(sent);
+
+    const result = await surfaceProxyResolver(ctx, "ui_show", {
+      surface_type: "card",
+      title: "Researching",
+      template: "task_progress",
+      data: {},
+    });
+
+    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 !== "card") return;
+
+    const card = showMessage.data as CardSurfaceData;
+    expect(card.template).toBe("task_progress");
+    const templateData = card.templateData as Record<string, unknown>;
+    expect(templateData.status).toBe("in_progress");
+    expect(templateData.title).toBe("Researching");
+    expect(templateData.steps).toEqual([]);
+  });
+
+  test("ui_show coerces invalid status and malformed steps on a task_progress card", async () => {
+    const sent: ServerMessage[] = [];
+    const ctx = makeContext(sent);
+
+    const result = await surfaceProxyResolver(ctx, "ui_show", {
+      surface_type: "card",
+      title: "Building",
+      template: "task_progress",
+      templateData: {
+        status: "working",
+        steps: [
+          { label: "Valid step" },
+          { title: "Aliased label", status: "completed" },
+          { status: "in_progress" },
+          "not an object",
+        ],
+      },
+    });
+
+    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 !== "card") return;
+
+    const templateData = (showMessage.data as CardSurfaceData)
+      .templateData as Record<string, unknown>;
+    expect(templateData.status).toBe("in_progress");
+    const steps = templateData.steps as Array<Record<string, unknown>>;
+    expect(steps).toHaveLength(2);
+    expect(steps[0]).toEqual({ label: "Valid step", status: "pending" });
+    expect(steps[1]).toEqual({
+      title: "Aliased label",
+      label: "Aliased label",
+      status: "completed",
+    });
+  });
+
   test("ui_show normalizes top-level dynamic_page fields into data", async () => {
     const sent: ServerMessage[] = [];
     const ctx = makeContext(sent);

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

@@ -256,6 +256,8 @@ describe("recordUsage", () => {
         conversationId: "conv-usage-1",
         inputTokens: 3_420_218,
         outputTokens: 11_768,
+        cacheCreationInputTokens: 373_619,
+        cacheReadInputTokens: 3_046_461,
         totalInputTokens: 3_420_218,
         totalOutputTokens: 11_768,
         estimatedCost: expectedPricing.estimatedCostUsd ?? 0,

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

@@ -21,11 +21,6 @@ mock.module("../util/logger.js", () => ({
     new Proxy({} as Record<string, unknown>, { get: () => () => {} }),
 }));
 
-mock.module("../memory/guardian-action-store.js", () => ({
-  getGuardianActionRequest: () => null,
-  resolveGuardianActionRequest: () => {},
-}));
-
 mock.module("../providers/registry.js", () => ({
   getProvider: () => ({ name: "mock-provider" }),
   initializeProviders: async () => {},

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

@@ -19,11 +19,6 @@ mock.module("../util/logger.js", () => ({
     new Proxy({} as Record<string, unknown>, { get: () => () => {} }),
 }));
 
-mock.module("../memory/guardian-action-store.js", () => ({
-  getGuardianActionRequest: () => null,
-  resolveGuardianActionRequest: () => {},
-}));
-
 mock.module("../providers/registry.js", () => ({
   getProvider: () => ({ name: "mock-provider" }),
   initializeProviders: async () => {},

package/src/__tests__/credential-broker-browser-fill.test.ts

@@ -461,7 +461,7 @@ describe("CredentialBroker.browserFill", () => {
       expect(result.reason).toContain("not allowed");
     });
 
-    test("denies with empty allowedTools and suggests credential_store", async () => {
+    test("denies with empty allowedTools and suggests assistant credentials set", async () => {
       upsertCredentialMetadata("custom", "key", {
         allowedTools: [],
       });
@@ -478,7 +478,7 @@ describe("CredentialBroker.browserFill", () => {
 
       expect(result.success).toBe(false);
       expect(result.reason).toContain("No tools are currently allowed");
-      expect(result.reason).toContain("credential_store");
+      expect(result.reason).toContain("assistant credentials set");
     });
   });
 

package/src/__tests__/credential-broker-server-use.test.ts

@@ -305,7 +305,7 @@ describe("CredentialBroker.serverUse", () => {
 
       expect(result.success).toBe(false);
       expect(result.reason).toContain("No tools are currently allowed");
-      expect(result.reason).toContain("credential_store");
+      expect(result.reason).toContain("assistant credentials set");
     });
 
     test("denies when credential has domain restrictions even if tool matches", async () => {
@@ -594,7 +594,7 @@ describe("CredentialBroker.serverUseById", () => {
     expect(result.success).toBe(false);
     if (result.success) throw new Error("expected denial");
     expect(result.reason).toContain("No tools are currently allowed");
-    expect(result.reason).toContain("credential_store");
+    expect(result.reason).toContain("assistant credentials set");
   });
 
   test("denies when metadata exists but no stored secret value", async () => {

package/src/__tests__/credential-broker.test.ts

@@ -85,7 +85,7 @@ describe("CredentialBroker", () => {
       if (!result.authorized) {
         expect(result.reason).toContain("not allowed");
         expect(result.reason).toContain("No tools are currently allowed");
-        expect(result.reason).toContain("credential_store");
+        expect(result.reason).toContain("assistant credentials set");
       }
     });