@vellumai/assistant 0.12.2 → 0.12.3-staging.2

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

@@ -244,42 +244,32 @@ describe("executeBrowserFillCredential", () => {
     expect(detachCalls).toBe(1);
   });
 
-  test("clears pre-populated field BEFORE inserting credential text", async () => {
-    // Regression: previously, fillCredential called focus + insertText
-    // directly, which APPENDED the credential to any existing value
-    // (autofill, prior typing, etc.) — corrupting the password and
-    // leaking partial state. The fix routes through the shared
-    // clearAndInsertText helper.
+  test("selects pre-populated content before inserting credential text", async () => {
     snapshotBackendNodeMaps.set("test-conversation", new Map([["e1", 555]]));
     await executeBrowserFillCredential(
       { service: "gmail", field: "password", element_id: "e1" },
       ctx,
     );
 
-    // The clear must happen BEFORE the insertText. Specifically, the
-    // Runtime.callFunctionOn that runs the clearing function declaration
-    // must precede Input.insertText.
+    // Selection must happen before Input.insertText so the credential replaces
+    // existing content without mutating framework-owned editor state directly.
     const methodSeq = sendCalls.map((c) => c.method);
     const clearIdx = methodSeq.indexOf("Runtime.callFunctionOn");
     const insertIdx = methodSeq.indexOf("Input.insertText");
     expect(clearIdx).toBeGreaterThanOrEqual(0);
     expect(insertIdx).toBeGreaterThan(clearIdx);
 
-    // The clearing function must reset both `value` and
-    // `textContent` so input/textarea AND contenteditable targets
-    // are handled.
+    // Form fields and contenteditable targets use their native selection APIs.
     const clearCall = sendCalls[clearIdx]!;
     const fnDecl = (clearCall.params as { functionDeclaration: string })
       .functionDeclaration;
-    expect(fnDecl).toContain('this.value = ""');
-    expect(fnDecl).toContain("this.textContent");
-    expect(fnDecl).toContain('new Event("input"');
+    expect(fnDecl).toContain("this.select()");
+    expect(fnDecl).toContain("range.selectNodeContents(this)");
+    expect(fnDecl).not.toContain('this.value = ""');
+    expect(fnDecl).not.toContain("this.textContent =");
 
-    // After the clear, the helper re-focuses the element (some sites
-    // blur on programmatic value reset) before inserting text — so we
-    // expect at least 2 DOM.focus calls in total.
     const focusCount = methodSeq.filter((m) => m === "DOM.focus").length;
-    expect(focusCount).toBeGreaterThanOrEqual(2);
+    expect(focusCount).toBe(1);
   });
 
   test("fills credential by CSS selector", async () => {
@@ -364,14 +354,13 @@ describe("executeBrowserFillCredential", () => {
     expect(result.isError).toBe(false);
     const methods = sendCalls.map((c) => c.method);
     expect(methods).toContain("Input.insertText");
-    // dispatchKeyPress for "Enter" dispatches keyDown + char + keyUp
-    // (Enter has text "\r" so it now produces a char event too).
+    // Enter dispatches rawKeyDown + char + keyUp.
     const keyEvents = sendCalls.filter(
       (c) => c.method === "Input.dispatchKeyEvent",
     );
     expect(keyEvents).toHaveLength(3);
     expect((keyEvents[0]!.params as { type: string; key: string }).type).toBe(
-      "keyDown",
+      "rawKeyDown",
     );
     expect((keyEvents[0]!.params as { type: string; key: string }).key).toBe(
       "Enter",

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

@@ -338,7 +338,7 @@ describe("POST /v1/btw", () => {
     expect(options!.config!.modelIntent).toBeUndefined();
   });
 
-  test("greeting requests pass callSite: 'emptyStateGreeting'", async () => {
+  test("greeting requests pass callSite: 'emptyStateGreeting' and send no tools", async () => {
     const provider = makeMockProvider();
     const session = makeMockSession(provider);
     mockGetOrCreateConversation.mockImplementationOnce(async () => session);
@@ -352,6 +352,9 @@ describe("POST /v1/btw", () => {
     expect(provider.sendMessage).toHaveBeenCalledTimes(1);
     const [, options] = provider.sendMessage.mock.calls[0];
     expect(options!.config!.callSite).toBe("emptyStateGreeting");
+    // The greeting targets no real conversation, so there is no cache prefix
+    // for tool definitions to share; they would only cost tokens.
+    expect(options!.tools).toEqual([]);
   });
 
   test("greeting requests include fresh turn context using the client timezone", async () => {

package/src/__tests__/build-persisted-content.test.ts

@@ -29,12 +29,12 @@ mock.module("../persistence/llm-request-log-store.js", () => ({
 // ── Imports (after mocks) ─────────────────────────────────────────────────────
 import { REDACTED_SENTINEL_OPEN } from "@vellumai/service-contracts/redacted-credential";
 
+import type { ToolActivityMetadata } from "../api/events/tool-result.js";
 import type { ResolvedRevealCandidate } from "../daemon/chat-credential-redaction.js";
 import {
   buildPersistedAssistantContent,
   stampThinkingTiming,
 } from "../daemon/conversation-agent-loop-handlers.js";
-import type { ToolActivityMetadata } from "../daemon/message-types/web-activity.js";
 import type { ContentBlock } from "../providers/types.js";
 import {
   OPENAI_PROJECT_KEY_REDACTION_MARKER,

package/src/__tests__/call-conversation-messages.test.ts

@@ -102,6 +102,7 @@ describe("call-conversation-messages", () => {
     const conversationId = "conv-call-msg-failed";
     ensureConversation(conversationId);
     const session = createCallSession({
+      direction: "inbound",
       conversationId,
       provider: "twilio",
       fromNumber: "+15550001111",
@@ -122,6 +123,7 @@ describe("call-conversation-messages", () => {
     const conversationId = "conv-call-msg-cancelled";
     ensureConversation(conversationId);
     const session = createCallSession({
+      direction: "inbound",
       conversationId,
       provider: "twilio",
       fromNumber: "+15550001111",
@@ -142,6 +144,7 @@ describe("call-conversation-messages", () => {
     const conversationId = "conv-call-msg-completed";
     ensureConversation(conversationId);
     const session = createCallSession({
+      direction: "inbound",
       conversationId,
       provider: "twilio",
       fromNumber: "+15550001111",
@@ -171,6 +174,7 @@ describe("call-conversation-messages", () => {
     const conversationId = "conv-call-msg-fallback";
     ensureConversation(conversationId);
     const session = createCallSession({
+      direction: "inbound",
       conversationId,
       provider: "twilio",
       fromNumber: "+12025550101",
@@ -208,6 +212,7 @@ describe("call-conversation-messages", () => {
     const conversationId = "conv-call-msg-schema";
     ensureConversation(conversationId);
     const session = createCallSession({
+      direction: "inbound",
       conversationId,
       provider: "twilio",
       fromNumber: "+12025550101",

package/src/__tests__/call-recovery.test.ts

@@ -54,9 +54,14 @@ function resetTables() {
   ensuredConvIds = new Set();
 }
 
-function createTestCallSession(opts: Parameters<typeof createCallSession>[0]) {
+function createTestCallSession(
+  opts: Omit<Parameters<typeof createCallSession>[0], "direction"> & {
+    direction?: Parameters<typeof createCallSession>[0]["direction"];
+  },
+) {
   ensureConversation(opts.conversationId);
-  return createCallSession(opts);
+  // Direction only shapes the funnel stamp; these suites test other things.
+  return createCallSession({ direction: "inbound", ...opts });
 }
 
 /** Backdate a session's createdAt so it appears older than the grace period. */

package/src/__tests__/call-routes-http.test.ts

@@ -327,6 +327,7 @@ describe("runtime call routes — HTTP layer", () => {
     ensureConversation("conv-get-1");
 
     const session = createCallSession({
+      direction: "outbound",
       conversationId: "conv-get-1",
       provider: "twilio",
       fromNumber: "+15550001111",
@@ -378,6 +379,7 @@ describe("runtime call routes — HTTP layer", () => {
     ensureConversation("conv-cancel-1");
 
     const session = createCallSession({
+      direction: "inbound",
       conversationId: "conv-cancel-1",
       provider: "twilio",
       fromNumber: "+15550001111",
@@ -407,6 +409,7 @@ describe("runtime call routes — HTTP layer", () => {
     ensureConversation("conv-cancel-2");
 
     const session = createCallSession({
+      direction: "inbound",
       conversationId: "conv-cancel-2",
       provider: "twilio",
       fromNumber: "+15550001111",
@@ -447,6 +450,7 @@ describe("runtime call routes — HTTP layer", () => {
     ensureConversation("conv-answer-badjson");
 
     const session = createCallSession({
+      direction: "inbound",
       conversationId: "conv-answer-badjson",
       provider: "twilio",
       fromNumber: "+15550001111",
@@ -469,6 +473,7 @@ describe("runtime call routes — HTTP layer", () => {
     ensureConversation("conv-answer-1");
 
     const session = createCallSession({
+      direction: "inbound",
       conversationId: "conv-answer-1",
       provider: "twilio",
       fromNumber: "+15550001111",
@@ -495,6 +500,7 @@ describe("runtime call routes — HTTP layer", () => {
     ensureConversation("conv-answer-2");
 
     const session = createCallSession({
+      direction: "inbound",
       conversationId: "conv-answer-2",
       provider: "twilio",
       fromNumber: "+15550001111",
@@ -517,6 +523,7 @@ describe("runtime call routes — HTTP layer", () => {
     ensureConversation("conv-answer-3");
 
     const session = createCallSession({
+      direction: "inbound",
       conversationId: "conv-answer-3",
       provider: "twilio",
       fromNumber: "+15550001111",
@@ -548,6 +555,7 @@ describe("runtime call routes — HTTP layer", () => {
     ensureConversation("conv-instr-badjson");
 
     const session = createCallSession({
+      direction: "inbound",
       conversationId: "conv-instr-badjson",
       provider: "twilio",
       fromNumber: "+15550001111",
@@ -570,6 +578,7 @@ describe("runtime call routes — HTTP layer", () => {
     ensureConversation("conv-instr-empty");
 
     const session = createCallSession({
+      direction: "inbound",
       conversationId: "conv-instr-empty",
       provider: "twilio",
       fromNumber: "+15550001111",
@@ -596,6 +605,7 @@ describe("runtime call routes — HTTP layer", () => {
     ensureConversation("conv-instr-missing");
 
     const session = createCallSession({
+      direction: "inbound",
       conversationId: "conv-instr-missing",
       provider: "twilio",
       fromNumber: "+15550001111",
@@ -640,6 +650,7 @@ describe("runtime call routes — HTTP layer", () => {
     ensureConversation("conv-instr-ended");
 
     const session = createCallSession({
+      direction: "inbound",
       conversationId: "conv-instr-ended",
       provider: "twilio",
       fromNumber: "+15550001111",
@@ -668,6 +679,7 @@ describe("runtime call routes — HTTP layer", () => {
     ensureConversation("conv-instr-no-orch");
 
     const session = createCallSession({
+      direction: "inbound",
       conversationId: "conv-instr-no-orch",
       provider: "twilio",
       fromNumber: "+15550001111",

package/src/__tests__/call-store.test.ts

@@ -53,9 +53,14 @@ function resetTables() {
 }
 
 /** Wrapper that ensures the FK conversation row exists before creating a session. */
-function createTestCallSession(opts: Parameters<typeof createCallSession>[0]) {
+function createTestCallSession(
+  opts: Omit<Parameters<typeof createCallSession>[0], "direction"> & {
+    direction?: Parameters<typeof createCallSession>[0]["direction"];
+  },
+) {
   ensureConversation(opts.conversationId);
-  return createCallSession(opts);
+  // Direction only shapes the funnel stamp; these suites test other things.
+  return createCallSession({ direction: "inbound", ...opts });
 }
 
 describe("call-store", () => {

package/src/__tests__/channel-approval.test.ts

@@ -1,6 +1,5 @@
 import { describe, expect, test } from "bun:test";
 
-import type { ApprovalAction } from "../runtime/channel-approval-types.js";
 import { parseCallbackData } from "../runtime/routes/channel-route-shared.js";
 
 // ═══════════════════════════════════════════════════════════════════════════
@@ -19,19 +18,15 @@ describe("parseCallbackData", () => {
     expect(result!.source).toBe("button");
   });
 
-  test.each<[string, string]>([
-    ["apr:req-123:approve_10m", "approve_once"],
-    ["apr:req-123:approve_conversation", "approve_once"],
-    ["apr:req-123:approve_always", "approve_once"],
-  ])(
-    'maps legacy action "%s" to %s (backward compat)',
-    (data, expectedAction) => {
-      const result = parseCallbackData(data);
-      expect(result).not.toBeNull();
-      expect(result!.action).toBe(expectedAction as ApprovalAction);
-      expect(result!.requestId).toBe("req-123");
-    },
-  );
+  // The parser never maps one action id onto another: an id outside the
+  // approval vocabulary is no action, whatever it resembles.
+  test.each([
+    "apr:req-123:approve_10m",
+    "apr:req-123:approve_conversation",
+    "apr:req-123:approve_always",
+  ])('returns null for the unrecognized action id in "%s"', (data) => {
+    expect(parseCallbackData(data)).toBeNull();
+  });
 
   test("every channel's button press attributes as the button modality", () => {
     for (const channel of ["slack", "telegram", "whatsapp", "discord"]) {

package/src/__tests__/channel-reply-delivery.test.ts

@@ -588,6 +588,62 @@ describe("channel-reply-delivery", () => {
     expect(deliveryCalls[0].payload.text).toBe("Fallback text");
   });
 
+  it("delivers a screenshot-only reply attachment", async () => {
+    const screenshot: RuntimeAttachmentMetadata = {
+      id: "final-screenshot",
+      filename: "computer-use-click.png",
+      mimeType: "image/png",
+      sizeBytes: 10,
+      kind: "image",
+    };
+
+    await deliverRenderedReplyViaCallback({
+      callbackUrl: "http://gateway/deliver/telegram",
+      chatId: "chat-screenshot",
+      textSegments: [],
+      fallbackText: "",
+      attachments: [screenshot],
+      interSegmentDelayMs: 0,
+    });
+
+    expect(deliveryCalls).toHaveLength(1);
+    expect(deliveryCalls[0].payload).toMatchObject({
+      chatId: "chat-screenshot",
+      attachments: [screenshot],
+    });
+  });
+
+  it("delivers the final screenshot with an unrelated PDF", async () => {
+    const attachments: RuntimeAttachmentMetadata[] = [
+      {
+        id: "final-screenshot",
+        filename: "computer-use-click.png",
+        mimeType: "image/png",
+        sizeBytes: 10,
+        kind: "image",
+      },
+      {
+        id: "explicit-report",
+        filename: "report.pdf",
+        mimeType: "application/pdf",
+        sizeBytes: 20,
+        kind: "document",
+      },
+    ];
+
+    await deliverRenderedReplyViaCallback({
+      callbackUrl: "http://gateway/deliver/slack",
+      chatId: "chat-screenshot-pdf",
+      textSegments: ["Done."],
+      fallbackText: "Done.",
+      attachments,
+      interSegmentDelayMs: 0,
+    });
+
+    expect(deliveryCalls).toHaveLength(1);
+    expect(deliveryCalls[0].payload.attachments).toEqual(attachments);
+  });
+
   it("uses rendered textSegments (tool boundaries) when delivering from conversation history", async () => {
     conversationMessages.push(
       { id: "msg-user", role: "user", content: "hi" },

package/src/__tests__/channel-retry-sweep.test.ts

@@ -98,6 +98,7 @@ import {
   clearConversations,
   setConversation,
 } from "../daemon/conversation-registry.js";
+import type { TrustContext } from "../daemon/trust-context-types.js";
 import { getDb } from "../persistence/db-connection.js";
 import { initializeDb } from "../persistence/db-init.js";
 import * as deliveryCrud from "../persistence/delivery-crud.js";
@@ -318,7 +319,11 @@ describe("channel-retry-sweep", () => {
           }
         | undefined;
 
+      let capturedAuthor: TrustContext | undefined;
+      let capturedTrust: TrustContext | undefined;
       await sweepFailedEvents(async (conversationId, _content, options) => {
+        capturedAuthor = options?.author;
+        capturedTrust = options?.trustContext;
         capturedOptions = options as {
           trustContext?: {
             trustClass?: string;
@@ -345,6 +350,10 @@ describe("channel-retry-sweep", () => {
         "principal-1",
       );
       expect(capturedOptions?.isInteractive).toBe(c.expectedInteractive);
+      // The replay persists the sender's own message, so it names them as
+      // the row's author, exactly as live ingress does.
+      expect(capturedAuthor?.trustClass).toBe(c.trustClass);
+      expect(capturedAuthor).toEqual(capturedTrust);
 
       const db = getDb();
       const row = db

package/src/__tests__/chat-credential-redaction.test.ts

@@ -204,6 +204,22 @@ describe("collectRevealRefsFromCommand", () => {
     );
   });
 
+  test("parses a legacy service/field path", () => {
+    expect(
+      collectRevealRefsFromCommand(
+        "assistant credentials reveal resend/api_key",
+      ),
+    ).toEqual([{ service: "resend", field: "api_key" }]);
+  });
+
+  test("legacy path survives malformed extra arguments", () => {
+    expect(
+      collectRevealRefsFromCommand(
+        "assistant credentials reveal resend/api_key --json extra",
+      ),
+    ).toEqual([{ service: "resend", field: "api_key" }]);
+  });
+
   test("unparseable invocation yields no ref (fails safe)", () => {
     expect(
       collectRevealRefsFromCommand("assistant credentials reveal --service x"),
@@ -437,6 +453,13 @@ describe("redactSecretsForChat", () => {
     expect(out).not.toContain(SYNTHETIC_OPENAI_PROJECT_KEY);
   });
 
+  test("Resend key in persisted assistant text is redacted without a candidate", () => {
+    const key = `re_${"a".repeat(8)}_${"b".repeat(24)}`;
+    const out = redactSecretsForChat(`the key is ${key} and it failed`, []);
+    expect(out).not.toContain(key);
+    expect(out).toContain("\u3014redacted:Resend API Key\u3015");
+  });
+
   test("no candidate match produces the plain sentinel — never a guess", () => {
     const out = redactSecretsForChat(`key: ${SYNTHETIC_OPENAI_PROJECT_KEY}`, [
       { service: "openai", field: "api_key", value: "different-value" },

package/src/__tests__/chat-reveal-guard-priming.test.ts

@@ -99,6 +99,7 @@ import {
   _resetRevealSuccessRegistryForTest,
   recordRevealSuccess,
 } from "../runtime/reveal-success-registry.js";
+import { mockUnownedModeSessions } from "./helpers/mock-conversation.js";
 import {
   SYNTHETIC_OPAQUE_CREDENTIAL,
   SYNTHETIC_OPENAI_PROJECT_KEY,
@@ -122,6 +123,7 @@ function createMockDeps(collected: AssistantEvent[]): EventHandlerDeps {
       emitActivityState: () => {},
       markWorkspaceTopLevelDirty: () => {},
       currentTurnSurfaces: [],
+      modeSessions: mockUnownedModeSessions(),
     } as unknown as EventHandlerDeps["ctx"],
     onEvent: (msg: AssistantEvent) => {
       collected.push(msg);

package/src/__tests__/checker.test.ts

@@ -140,9 +140,17 @@ registerSkillTools("app-builder", [mockBundledSkillTool]);
 
 // Register CU tools so check() can look them up in the tool registry
 // instead of falling through to Medium (unknown tool).
-import { allComputerUseTools } from "../tools/computer-use/definitions.js";
-for (const tool of allComputerUseTools) {
-  registerTool(tool);
+import { COMPUTER_USE_TOOL_NAMES } from "./test-support/computer-use-skill-harness.js";
+for (const name of COMPUTER_USE_TOOL_NAMES) {
+  registerTool({
+    name,
+    description: name,
+    category: "computer-use",
+    defaultRiskLevel: RiskLevel.Low,
+    executionTarget: "host",
+    input_schema: { type: "object", properties: {} },
+    execute: async () => ({ content: "ok", isError: false }),
+  });
 }
 
 function writeSkill(

package/src/__tests__/client-os-metadata-persistence.test.ts

@@ -36,7 +36,7 @@ mock.module("../persistence/conversation-crud.js", () => ({
       content,
       metadata: options?.metadata,
     });
-    return { id: `persisted-${addMessageCalls.length}` };
+    return { id: `persisted-${addMessageCalls.length}`, createdAt: 100 };
   },
   getConversation: () => null,
   provenanceFromTrustContext: () => ({}),
@@ -189,6 +189,40 @@ describe("client OS surface metadata persistence", () => {
       browser_family: "safari",
     });
   });
+
+  test("strips caller ownership and tracks only the inserted structural row", async () => {
+    const acceptTurn = mock(() => ({
+      id: "session-123",
+      mode: "browser" as const,
+    }));
+    const trackPersistedRow = mock(() => {});
+    const ctx = Object.assign(createWebTurnContext("web"), {
+      modeSessions: { acceptTurn, trackPersistedRow },
+    });
+    await persistQueuedMessageBody(ctx, {
+      content: "continue",
+      requestId: "req-structural",
+      activeSurfaceId: "surface-123",
+      metadata: {
+        modeSession: { id: "spoofed", mode: "computer_use" },
+      },
+    });
+
+    expect(lastUserMetadata().modeSession).toBeUndefined();
+    expect(acceptTurn).toHaveBeenCalledWith("req-structural", {
+      kind: "surface",
+      responseId: "surface-123",
+    });
+    expect(trackPersistedRow).toHaveBeenCalledWith(
+      "req-structural",
+      "persisted-1",
+      100,
+      {
+        publishMessagesChanged: true,
+        startsDisplayBoundary: false,
+      },
+    );
+  });
 });
 
 /**