@vellumai/assistant 0.12.2 → 0.12.3-staging.2

package/src/__tests__/tool-result-follow-up.test.ts

@@ -0,0 +1,99 @@
+import { describe, expect, test } from "bun:test";
+
+import { buildToolResultFollowUp } from "../agent/tool-result-follow-up.js";
+import type { ContentBlock, Message, TextContent } from "../providers/types.js";
+
+const opener: Message = {
+  role: "user",
+  content: [{ type: "text", text: "Check both" }],
+};
+
+/** Assistant turn calling two client tools and a native web search together. */
+const mixedTurn: Message = {
+  role: "assistant",
+  content: [
+    { type: "tool_use", id: "tu_a", name: "web_fetch", input: {} },
+    { type: "tool_use", id: "tu_b", name: "file_read", input: {} },
+    {
+      type: "server_tool_use",
+      id: "srvtoolu_deferred",
+      name: "web_search",
+      input: { query: "news" },
+    },
+  ],
+};
+
+/** The same turn without the search: nothing is deferred. */
+const clientOnlyTurn: Message = {
+  role: "assistant",
+  content: mixedTurn.content.filter((b) => b.type === "tool_use"),
+};
+
+const erroredResult: ContentBlock = {
+  type: "tool_result",
+  tool_use_id: "tu_a",
+  content: "Error: HTTP 404",
+  is_error: true,
+};
+
+const okResult: ContentBlock = {
+  type: "tool_result",
+  tool_use_id: "tu_b",
+  content: "file contents",
+  is_error: false,
+};
+
+const guidance: TextContent = {
+  type: "text",
+  text: "<system_notice>retry</system_notice>",
+};
+
+describe("buildToolResultFollowUp", () => {
+  test("returns the results untouched when there is no guidance", () => {
+    const results = [erroredResult, okResult];
+
+    expect(buildToolResultFollowUp([opener, mixedTurn], results, [])).toBe(
+      results,
+    );
+  });
+
+  test("appends guidance as separate blocks when no server tool is deferred", () => {
+    const followUp = buildToolResultFollowUp(
+      [opener, clientOnlyTurn],
+      [erroredResult, okResult],
+      [guidance],
+    );
+
+    expect(followUp).toEqual([erroredResult, okResult, guidance]);
+  });
+
+  test("folds guidance into the errored tool_result when a server tool is deferred", () => {
+    const followUp = buildToolResultFollowUp(
+      [opener, mixedTurn],
+      [erroredResult, okResult],
+      [guidance],
+    );
+
+    expect(followUp.map((b) => b.type)).toEqual(["tool_result", "tool_result"]);
+    expect(followUp[0]).toEqual({
+      ...erroredResult,
+      content: `Error: HTTP 404\n\n${guidance.text}`,
+    });
+    expect(followUp[1]).toBe(okResult);
+  });
+
+  test("falls back to the last tool_result when none errored", () => {
+    const followUp = buildToolResultFollowUp(
+      [opener, mixedTurn],
+      [okResult, { ...okResult, tool_use_id: "tu_a" }],
+      [guidance],
+    );
+
+    expect(followUp.map((b) => b.type)).toEqual(["tool_result", "tool_result"]);
+    expect(followUp[0]).toBe(okResult);
+    expect(followUp[1]).toMatchObject({
+      tool_use_id: "tu_a",
+      content: `file contents\n\n${guidance.text}`,
+    });
+  });
+});

package/src/__tests__/tool-result-metadata-plumbing.test.ts

@@ -26,7 +26,9 @@ mock.module("../persistence/llm-request-log-store.js", () => ({
 }));
 
 // ── Imports (after mocks) ─────────────────────────────────────────────────────
+import type { ToolActivityMetadata } from "../api/events/tool-result.js";
 import type { AssistantEvent } from "../api/index.js";
+import { toolImageFilename } from "../daemon/assistant-attachments.js";
 import type {
   EventHandlerDeps,
   EventHandlerState,
@@ -34,8 +36,9 @@ import type {
 import {
   createEventHandlerState,
   handleToolResult,
+  handleToolUse,
 } from "../daemon/conversation-agent-loop-handlers.js";
-import type { ToolActivityMetadata } from "../daemon/message-types/web-activity.js";
+import { mockUnownedModeSessions } from "./helpers/mock-conversation.js";
 
 type ToolResultEvent = Extract<AssistantEvent, { type: "tool_result" }>;
 
@@ -54,6 +57,7 @@ function createCollectorDeps(): {
       emitActivityState: () => {},
       markWorkspaceTopLevelDirty: () => {},
       currentTurnSurfaces: [],
+      modeSessions: mockUnownedModeSessions(),
     } as unknown as EventHandlerDeps["ctx"],
     onEvent: (msg: AssistantEvent) => events.push(msg),
     reqId: "req-meta",
@@ -139,3 +143,64 @@ describe("tool_result activityMetadata plumbing", () => {
     expect(toolResultEvent?.activityMetadata).toBeUndefined();
   });
 });
+
+describe("computer-use screenshot capture", () => {
+  test("tracks direct and wrapped invocations but excludes their images from ordinary promotion", () => {
+    const state = createEventHandlerState();
+    const { deps } = createCollectorDeps();
+
+    handleToolUse(state, deps, {
+      type: "tool_use",
+      id: "direct-call",
+      name: "computer_use_click",
+      input: { x: 10, y: 20 },
+    });
+    handleToolUse(state, deps, {
+      type: "tool_use",
+      id: "wrapped-call",
+      name: "skill_execute",
+      input: { tool: "computer_use_scroll" },
+    });
+    handleToolUse(state, deps, {
+      type: "tool_use",
+      id: "ordinary-call",
+      name: "browser_screenshot",
+      input: {},
+    });
+    handleToolResult(state, deps, {
+      type: "tool_result",
+      toolUseId: "wrapped-call",
+      content: "scrolled",
+      isError: false,
+      contentBlocks: [
+        {
+          type: "image",
+          source: {
+            type: "base64",
+            media_type: "image/png",
+            data: "c2NyZWVuc2hvdA==",
+          },
+        },
+      ],
+    });
+
+    expect(state.computerUseToolUseIds).toEqual([
+      "direct-call",
+      "wrapped-call",
+    ]);
+    expect(state.computerUseToolNames).toEqual(
+      new Map([
+        ["direct-call", "computer_use_click"],
+        ["wrapped-call", "computer_use_scroll"],
+      ]),
+    );
+    expect(
+      toolImageFilename(
+        "image/png",
+        state.computerUseToolNames.get("wrapped-call"),
+      ),
+    ).toBe("computer-use-scroll.png");
+    expect(state.computerUseScreenshotBlocks.has("wrapped-call")).toBe(true);
+    expect(state.accumulatedToolContentBlocks).toEqual([]);
+  });
+});

package/src/__tests__/tool-start-timestamp.test.ts

@@ -48,6 +48,7 @@ import {
   createEventHandlerState,
   handleToolUse,
 } from "../daemon/conversation-agent-loop-handlers.js";
+import { mockUnownedModeSessions } from "./helpers/mock-conversation.js";
 
 // ── Helpers ───────────────────────────────────────────────────────────────────
 
@@ -60,6 +61,7 @@ function makeDeps(onEvent: (event: AssistantEvent) => void): EventHandlerDeps {
       emitActivityState: () => {},
       markWorkspaceTopLevelDirty: () => {},
       currentTurnSurfaces: [],
+      modeSessions: mockUnownedModeSessions(),
     } as unknown as EventHandlerDeps["ctx"],
     onEvent,
     reqId: "test-req",

package/src/__tests__/twilio-routes.test.ts

@@ -387,6 +387,7 @@ function createTestSession(
 ) {
   ensureConversation(convId);
   const session = createCallSession({
+    direction: "inbound",
     conversationId: convId,
     provider: "twilio",
     fromNumber: "+14155550111",

package/src/__tests__/unicode.test.ts

@@ -4,6 +4,7 @@ import {
   safeStringSlice,
   stripOrphanedSurrogates,
   stripOrphanedSurrogatesDeep,
+  surrogateSafeWindow,
 } from "../util/unicode.js";
 
 // U+1F389 PARTY POPPER = "\uD83C\uDF89" (a surrogate pair).
@@ -302,3 +303,38 @@ describe("stripOrphanedSurrogatesDeep", () => {
     expect(() => JSON.parse(json)).not.toThrow();
   });
 });
+
+describe("surrogateSafeWindow", () => {
+  const codeAt = (text: string) => (i: number) => text.charCodeAt(i);
+
+  test("a start that lands on a low surrogate backs up to include the pair", () => {
+    const text = `a${EMOJI}b`;
+    expect(surrogateSafeWindow(text.length, codeAt(text), 2, 10)).toEqual({
+      start: 1,
+      end: 4,
+    });
+  });
+
+  test("an end that would cut a pair backs off one unit", () => {
+    const text = `ab${EMOJI}cd`;
+    expect(surrogateSafeWindow(text.length, codeAt(text), 0, 3)).toEqual({
+      start: 0,
+      end: 2,
+    });
+  });
+
+  test("a one-unit window on a pair takes the whole pair so paging advances", () => {
+    const text = `${EMOJI}x`;
+    expect(surrogateSafeWindow(text.length, codeAt(text), 0, 1)).toEqual({
+      start: 0,
+      end: 2,
+    });
+  });
+
+  test("clamps to the text bounds", () => {
+    expect(surrogateSafeWindow(3, codeAt("abc"), 10, 5)).toEqual({
+      start: 3,
+      end: 3,
+    });
+  });
+});

package/src/__tests__/web-search-backend-failure.test.ts

@@ -27,7 +27,7 @@
 
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
-import type { ToolActivityMetadata } from "../daemon/message-types/web-activity.js";
+import type { ToolActivityMetadata } from "../api/events/tool-result.js";
 
 // ---------------------------------------------------------------------------
 // Mock the daemon collaborators the handler module imports at load time so the

package/src/activation/progress-store.test.ts

@@ -25,6 +25,7 @@ import {
   beforeEach,
   describe,
   expect,
+  jest,
   mock,
   spyOn,
   test,
@@ -361,14 +362,18 @@ describe("activation progress store", () => {
       });
       publishedTags.length = 0;
 
-      for (let i = 0; i < 5; i++) {
-        await bumpActivationStepCount("conv-1");
-      }
+      jest.useFakeTimers();
+      try {
+        for (let i = 0; i < 5; i++) {
+          await bumpActivationStepCount("conv-1");
+        }
 
-      // The leading bump lands immediately; the rest coalesce behind the
-      // throttle window.
-      expect(readActivationProgress().tasks["draft-email"].stepCount).toBe(1);
-      expect(syncPublishCount()).toBe(1);
+        expect(readActivationProgress().tasks["draft-email"].stepCount).toBe(1);
+        expect(syncPublishCount()).toBe(1);
+        jest.advanceTimersByTime(THROTTLE_MS);
+      } finally {
+        jest.useRealTimers();
+      }
 
       await waitFor(
         () => readActivationProgress().tasks["draft-email"].stepCount === 5,