@vellumai/assistant 0.10.4 → 0.10.5-dev.202607022329.d89bf2f

package/src/__tests__/skill-tool-factory.test.ts

@@ -33,6 +33,12 @@ function makeEntry(overrides: Partial<SkillToolEntry> = {}): SkillToolEntry {
   };
 }
 
+// These factory tests exercise the host executor-routing path (the default
+// makeEntry uses execution_target: "host"). Host execution is a first-party
+// capability, so the runner only runs it for bundled skills — pass this as the
+// `bundled` argument so createSkillTool actually reaches the executor.
+const BUNDLED = true;
+
 function makeContext(overrides: Partial<ToolContext> = {}): ToolContext {
   return {
     workingDir: "/tmp",
@@ -131,6 +137,7 @@ describe("createSkillTool", () => {
       makeEntry({ executor: "echo.ts" }),
       tempDir,
       hash,
+      BUNDLED,
     );
     const ctx = makeContext({ workingDir: "/my/project" });
     const input = { query: "hello" };
@@ -149,6 +156,7 @@ describe("createSkillTool", () => {
       makeEntry({ executor: "nonexistent.ts" }),
       tempDir,
       hash,
+      BUNDLED,
     );
 
     // Provide valid input so we reach the executor (the default schema
@@ -209,6 +217,7 @@ describe("createSkillTool — unknown parameter validation", () => {
       makeEntry({ executor: "echo.ts" }),
       tempDir,
       hash,
+      BUNDLED,
     );
 
     const result = await tool.execute(
@@ -229,6 +238,7 @@ describe("createSkillTool — unknown parameter validation", () => {
       makeEntry({ executor: "echo.ts" }),
       tempDir,
       hash,
+      BUNDLED,
     );
 
     const result = await tool.execute(
@@ -248,6 +258,7 @@ describe("createSkillTool — unknown parameter validation", () => {
       makeEntry({ executor: "echo.ts" }),
       tempDir,
       hash,
+      BUNDLED,
     );
 
     const result = await tool.execute({ query: "hello" }, makeContext());
@@ -267,6 +278,7 @@ describe("createSkillTool — unknown parameter validation", () => {
       }),
       tempDir,
       hash,
+      BUNDLED,
     );
 
     const result = await tool.execute({}, makeContext());
@@ -283,6 +295,7 @@ describe("createSkillTool — unknown parameter validation", () => {
       }),
       tempDir,
       hash,
+      BUNDLED,
     );
 
     const result = await tool.execute({ anything: "goes" }, makeContext());
@@ -302,6 +315,7 @@ describe("createSkillTool — required/type/enum validation", () => {
       makeEntry({ executor: "echo.ts" }),
       tempDir,
       hash,
+      BUNDLED,
     );
 
     const result = await tool.execute({}, makeContext());
@@ -317,15 +331,68 @@ describe("createSkillTool — required/type/enum validation", () => {
       makeEntry({ executor: "echo.ts" }),
       tempDir,
       hash,
+      BUNDLED,
     );
 
-    const result = await tool.execute({ query: 123 }, makeContext());
+    const result = await tool.execute({ query: { nested: 1 } }, makeContext());
 
     expect(result.isError).toBe(true);
     expect(result.content).toContain('Invalid input for tool "test_tool"');
     expect(result.content).toContain("query must be a string");
   });
 
+  test("coerces finite numbers to strings before validation and passes the coerced value to the executor", async () => {
+    const hash = computeSkillVersionHash(tempDir);
+    const tool = createSkillTool(
+      makeEntry({
+        executor: "echo.ts",
+        input_schema: {
+          type: "object",
+          properties: { phone_number: { type: "string" } },
+          required: ["phone_number"],
+        },
+      }),
+      tempDir,
+      hash,
+      BUNDLED,
+    );
+
+    const result = await tool.execute(
+      { phone_number: 15550100 },
+      makeContext(),
+    );
+
+    expect(result.isError).toBe(false);
+    const parsed = JSON.parse(result.content);
+    expect(parsed.input).toEqual({ phone_number: "15550100" });
+  });
+
+  test("rejects integers outside the safe range instead of coercing a rounded value", async () => {
+    const hash = computeSkillVersionHash(tempDir);
+    const tool = createSkillTool(
+      makeEntry({
+        executor: "echo.ts",
+        input_schema: {
+          type: "object",
+          properties: { account_id: { type: "string" } },
+          required: ["account_id"],
+        },
+      }),
+      tempDir,
+      hash,
+      BUNDLED,
+    );
+
+    const result = await tool.execute(
+      { account_id: 12345678901234567890 },
+      makeContext(),
+    );
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain('Invalid input for tool "test_tool"');
+    expect(result.content).toContain("account_id must be a string");
+  });
+
   test("rejects enum violation with `must be one of` message", async () => {
     const hash = computeSkillVersionHash(tempDir);
     const tool = createSkillTool(
@@ -338,6 +405,7 @@ describe("createSkillTool — required/type/enum validation", () => {
       }),
       tempDir,
       hash,
+      BUNDLED,
     );
 
     const result = await tool.execute({ mode: "c" }, makeContext());
@@ -362,6 +430,7 @@ describe("createSkillTool — required/type/enum validation", () => {
       }),
       tempDir,
       hash,
+      BUNDLED,
     );
 
     const result = await tool.execute(
@@ -386,6 +455,7 @@ describe("createSkillTool — required/type/enum validation", () => {
       }),
       tempDir,
       hash,
+      BUNDLED,
     );
 
     const result = await tool.execute({ auto_open: "yes" }, makeContext());
@@ -409,6 +479,7 @@ describe("createSkillTool — required/type/enum validation", () => {
       }),
       tempDir,
       hash,
+      BUNDLED,
     );
 
     const result = await tool.execute({ mode: "a" }, makeContext());
@@ -431,6 +502,7 @@ describe("createSkillTool — version hash plumbing to runner", () => {
       makeEntry({ executor: "echo.ts" }),
       tempDir,
       hash,
+      BUNDLED,
     );
     const ctx = makeContext({ workingDir: "/my/project" });
     const input = { query: "test" };

package/src/__tests__/slack-app-setup-skill-regression.test.ts

@@ -8,29 +8,22 @@ const SKILL_PATH = resolve(REPO_ROOT, "skills", "slack-app-setup", "SKILL.md");
 const skillContent = readFileSync(SKILL_PATH, "utf-8");
 
 describe("slack-app-setup skill regression", () => {
-  test("keeps Slack token collection on the secure credential prompt path", () => {
-    expect(skillContent).toContain(
-      "assistant credentials prompt --service slack_channel",
-    );
-    expect(skillContent).toContain(
-      "same Slack settings handler used by Settings",
-    );
+  test("uses the channel_setup wizard surface for token entry", () => {
+    expect(skillContent).toContain('surface_type: "channel_setup"');
+    expect(skillContent).toContain("ui_show");
   });
 
-  test("forbids plaintext forms and chat-pasted secrets", () => {
-    expect(skillContent).toContain("Do NOT use `ui_show`");
+  test("forbids plaintext token collection in chat", () => {
+    expect(skillContent).toContain("Do NOT collect tokens in chat");
     expect(skillContent).toContain(
-      "Do NOT ask the user to paste tokens in chat",
+      "Do NOT ask the user to paste tokens into the conversation",
     );
   });
 
-  test("does not instruct the agent to reimplement Slack validation in shell", () => {
+  test("does not instruct the agent to reveal or manually store credentials", () => {
     expect(skillContent).not.toContain(
       "assistant credentials reveal --service slack_channel",
     );
-    expect(skillContent).not.toContain(
-      'curl -sf -X POST "https://slack.com/api/auth.test"',
-    );
     expect(skillContent).not.toContain("assistant config set slack.teamId");
     expect(skillContent).not.toContain("assistant config set slack.teamName");
     expect(skillContent).not.toContain("assistant config set slack.botUserId");
@@ -38,4 +31,34 @@ describe("slack-app-setup skill regression", () => {
       "assistant config set slack.botUsername",
     );
   });
+
+  test("verifies on the wizard-closed auto-notify instead of manual confirmation", () => {
+    // Step 2 must promise the auto-notify rather than asking the user to
+    // report back...
+    expect(skillContent).toContain(
+      "The wizard will auto-notify me when you close it",
+    );
+    expect(skillContent).not.toContain("let me know when you're done");
+    // ...and Step 3 must trigger on the notification, keyed to the exact
+    // marker the web client sends on drawer close (see
+    // `clients/web/src/domains/chat/channel-setup-close-notify.ts`).
+    expect(skillContent).toContain("wizard-closed notification");
+    expect(skillContent).toContain(
+      "[User action on channel_setup surface: closed the slack setup wizard]",
+    );
+    // Phone-sized clients open the setup on the Contacts page, which cannot
+    // auto-notify on completion — the client signals the relocation with a
+    // hand-off marker and the skill must react by asking the user to report
+    // back instead of waiting for a wizard-closed notification.
+    expect(skillContent).toContain(
+      "[User action on channel_setup surface: moved the slack setup to the Contacts page]",
+    );
+    expect(skillContent).toContain("Hand-off notification");
+  });
+
+  test("retains the Settings clearing path", () => {
+    expect(skillContent).toContain(
+      "same Slack settings handler used by Settings",
+    );
+  });
 });

package/src/__tests__/slack-inbound-verification.test.ts

@@ -84,6 +84,7 @@ function seedGatewayGuardian(
   });
 }
 
+import { createCanonicalGuardianRequest } from "../contacts/canonical-guardian-store.js";
 import { getDb } from "../persistence/db-connection.js";
 import { initializeDb } from "../persistence/db-init.js";
 import { findActiveSession } from "../runtime/channel-verification-service.js";
@@ -186,6 +187,41 @@ describe("Slack inbound trusted contact verification", () => {
     ).toContain("I don't recognize you yet");
   });
 
+  test("a terminally-denied Slack sender gets no challenge and no guardian re-prompt", async () => {
+    // Guardian previously denied this sender (terminal). Seed the denied
+    // canonical request under the assistant-scoped conversationId the ingress
+    // path derives for (self, slack, U0123UNKNOWN).
+    createCanonicalGuardianRequest({
+      id: `denied-${Date.now()}`,
+      kind: "access_request",
+      sourceType: "channel",
+      sourceChannel: "slack",
+      conversationId: "access-req-self-slack-U0123UNKNOWN",
+      requesterExternalUserId: "U0123UNKNOWN",
+      guardianPrincipalId: "guardian-principal",
+      toolName: "ingress_access_request",
+      status: "denied",
+    });
+
+    const resp = await handleChannelInbound(
+      buildSlackInboundRequest(),
+      undefined,
+      TEST_BEARER_TOKEN,
+    );
+    const json = (await resp.json()) as Record<string, unknown>;
+
+    // Still denied — but not via a fresh, unusable verification challenge.
+    expect(json.denied).toBe(true);
+    expect(json.reason).not.toBe("verification_challenge_sent");
+    expect(json.verificationSessionId).toBeUndefined();
+
+    // No verification session was minted for the denied sender.
+    expect(findActiveSession("slack")).toBeNull();
+
+    // And the guardian was not re-notified.
+    expect(emitSignalCalls.length).toBe(0);
+  });
+
   test("verification session is identity-bound to the Slack user", async () => {
     const req = buildSlackInboundRequest();
     await handleChannelInbound(req, undefined, TEST_BEARER_TOKEN);

package/src/__tests__/slack-notification-approval-card.test.ts

@@ -10,7 +10,7 @@ import type { ApprovalUIMetadata } from "../runtime/channel-approval-types.js";
  * quoted-preview body, action callback ids, source/permalink and requester-id
  * context blocks, the security-warning context block, and guardian
  * verification note that `buildApprovalNotificationBlocks` emits for an
- * access request.
+ * access request — plus the tool-approval card body/continuation split.
  */
 
 const APPROVAL: ApprovalUIMetadata = {
@@ -39,7 +39,9 @@ type Block = Record<string, unknown>;
 
 function card(blocks: unknown[]): Block {
   const c = (blocks as Block[]).find((b) => b.type === "card");
-  if (!c) throw new Error("no card block");
+  if (!c) {
+    throw new Error("no card block");
+  }
   return c;
 }
 
@@ -174,3 +176,88 @@ describe("Slack access-request card blocks", () => {
     ).toBe(true);
   });
 });
+
+const TOOL_APPROVAL: ApprovalUIMetadata = {
+  requestId: "req-456",
+  actions: [
+    { id: "approve_once", label: "Approve once" },
+    { id: "reject", label: "Reject" },
+  ],
+  plainTextFallback: 'Reply "ABC123 approve" or "ABC123 reject"',
+  permissionDetails: {
+    toolName: "bash",
+    riskLevel: "medium",
+    toolInput: { command: "ls /tmp" },
+    requesterIdentifier: "Alice",
+  },
+};
+
+function buildToolApprovalPayload(): ChannelDeliveryPayload {
+  return {
+    sourceEventName: "guardian.question",
+    copy: { title: "Guardian Question", body: "Approve tool: bash" },
+    urgency: "high",
+    approvalContext: TOOL_APPROVAL,
+  };
+}
+
+function sectionTexts(blocks: unknown[]): string[] {
+  return (blocks as Block[])
+    .filter((b) => b.type === "section")
+    .map((b) => text(b.text));
+}
+
+describe("Slack tool-approval card blocks", () => {
+  test("short message renders entirely in the card body with no companion section", () => {
+    const message = "Alice is requesting approval to run: ls /tmp";
+    const blocks = buildApprovalNotificationBlocks(
+      buildToolApprovalPayload(),
+      message,
+    );
+    expect(text(card(blocks).body)).toBe(message);
+    expect(sectionTexts(blocks)).toHaveLength(0);
+  });
+
+  test("card carries tool title and tool/requester subtitle", () => {
+    const c = card(
+      buildApprovalNotificationBlocks(buildToolApprovalPayload(), "msg"),
+    );
+    expect(text(c.title)).toBe("Tool Approval");
+    expect(text(c.subtitle)).toBe("bash — requested by Alice");
+  });
+
+  test("long message continues in a section without repeating the card body", () => {
+    const message = Array.from(
+      { length: 40 },
+      (_, i) => `word${String(i).padStart(2, "0")}`,
+    ).join(" "); // 279 chars of distinct words
+    const blocks = buildApprovalNotificationBlocks(
+      buildToolApprovalPayload(),
+      message,
+    );
+
+    const body = text(card(blocks).body);
+    expect(body.length).toBeLessThanOrEqual(200);
+    expect(body.endsWith(" ↓")).toBe(true);
+
+    const sections = sectionTexts(blocks);
+    expect(sections).toHaveLength(1);
+    const continuation = sections[0];
+
+    // Body + continuation reassemble the full message with nothing repeated
+    // and nothing lost — the guardian reads each word exactly once.
+    const bodyWords = body.replace(/ ↓$/, "").split(" ");
+    const continuationWords = continuation.replace(/^… /, "").split(" ");
+    expect([...bodyWords, ...continuationWords].join(" ")).toBe(message);
+  });
+
+  test("split lands on a word boundary", () => {
+    const message = `${"a".repeat(190)} ${"b".repeat(60)}`;
+    const blocks = buildApprovalNotificationBlocks(
+      buildToolApprovalPayload(),
+      message,
+    );
+    expect(text(card(blocks).body)).toBe(`${"a".repeat(190)} ↓`);
+    expect(sectionTexts(blocks)[0]).toBe(`… ${"b".repeat(60)}`);
+  });
+});

package/src/__tests__/slack-reaction-canonical-approval.test.ts

@@ -34,7 +34,10 @@ import {
 import type { Conversation } from "../daemon/conversation.js";
 import { getDb } from "../persistence/db-connection.js";
 import { initializeDb } from "../persistence/db-init.js";
-import { routeGuardianReply } from "../runtime/guardian-reply-router.js";
+import {
+  inferDecisionActionFromFreeText,
+  routeGuardianReply,
+} from "../runtime/guardian-reply-router.js";
 import * as pendingInteractions from "../runtime/pending-interactions.js";
 
 await initializeDb();
@@ -283,3 +286,50 @@ describe("routeGuardianReply / reactions", () => {
     expect(hcr).not.toHaveBeenCalled();
   });
 });
+
+// ---------------------------------------------------------------------------
+// Free-text decision inference (no request code)
+// ---------------------------------------------------------------------------
+
+describe("inferDecisionActionFromFreeText / introduction verbs", () => {
+  // Regression: a bare "block" on an access request must map to the block
+  // action (revoke), not the weaker generic reject (leave_unverified).
+  test('"block" maps to block for access requests, reject elsewhere', () => {
+    expect(inferDecisionActionFromFreeText("block", "access_request")).toBe(
+      "block",
+    );
+    expect(inferDecisionActionFromFreeText("Block!", "access_request")).toBe(
+      "block",
+    );
+    expect(inferDecisionActionFromFreeText("block")).toBe("reject");
+    expect(inferDecisionActionFromFreeText("block", "tool_approval")).toBe(
+      "reject",
+    );
+  });
+
+  test("trust and verify verbs are recognized for access requests", () => {
+    expect(inferDecisionActionFromFreeText("trust", "access_request")).toBe(
+      "trust",
+    );
+    expect(inferDecisionActionFromFreeText("verify", "access_request")).toBe(
+      "verify_code",
+    );
+    // Unknown outside access requests — falls through to null (no cue).
+    expect(inferDecisionActionFromFreeText("trust")).toBeNull();
+  });
+
+  test("generic vocabulary keeps its semantics per kind", () => {
+    expect(inferDecisionActionFromFreeText("no", "access_request")).toBe(
+      "leave_unverified",
+    );
+    expect(inferDecisionActionFromFreeText("reject", "access_request")).toBe(
+      "leave_unverified",
+    );
+    expect(inferDecisionActionFromFreeText("yes", "access_request")).toBe(
+      "approve_once",
+    );
+    expect(inferDecisionActionFromFreeText("no", "tool_approval")).toBe(
+      "reject",
+    );
+  });
+});