@vellumai/assistant 0.9.0 → 0.10.0-dev.202606192226.8ed8a6a

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

@@ -0,0 +1,285 @@
+/**
+ * Tests for guardian approval-by-reaction on the canonical pipeline.
+ *
+ * A Slack emoji reaction (✅ / ❌) on a delivered approval card is routed
+ * through `routeGuardianReply` exactly like a button press or text reply. The
+ * emoji maps to an action and the reacted card's message id (`reactedMessageTs`)
+ * resolves the target request via its canonical delivery record — so the
+ * decision is applied precisely even when several cards are pending in the same
+ * chat, with no clarification prompt.
+ */
+
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+mock.module("../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+  truncateForLog: (value: string) => value,
+}));
+
+const _conversationMocks = new Map<string, unknown>();
+mock.module("../daemon/conversation-registry.js", () => ({
+  findConversation: (id: string) => _conversationMocks.get(id),
+}));
+
+import type { Conversation } from "../daemon/conversation.js";
+import {
+  createCanonicalGuardianDelivery,
+  createCanonicalGuardianRequest,
+  getCanonicalGuardianRequest,
+  getPendingCanonicalRequestByDestinationMessage,
+  resolveCanonicalGuardianRequest,
+} from "../memory/canonical-guardian-store.js";
+import { getDb } from "../memory/db-connection.js";
+import { initializeDb } from "../memory/db-init.js";
+import { routeGuardianReply } from "../runtime/guardian-reply-router.js";
+import * as pendingInteractions from "../runtime/pending-interactions.js";
+
+initializeDb();
+
+// ---------------------------------------------------------------------------
+// Constants & helpers
+// ---------------------------------------------------------------------------
+
+const GUARDIAN_USER = "U_GUARDIAN";
+const PRINCIPAL = "principal-1";
+const CHAT_ID = "D_GUARDIAN_DM";
+const TOOL_NAME = "execute_shell";
+
+function resetTables(): void {
+  const db = getDb();
+  db.run("DELETE FROM canonical_guardian_deliveries");
+  db.run("DELETE FROM canonical_guardian_requests");
+  db.run("DELETE FROM scoped_approval_grants");
+  pendingInteractions.clear();
+  _conversationMocks.clear();
+}
+
+/**
+ * Seed a pending tool-approval (canonical request + delivery + pending
+ * interaction with a mock conversation) and return the mocked
+ * `handleConfirmationResponse` so callers can assert it was driven.
+ */
+function seedApproval(opts: {
+  requestId: string;
+  ts: string;
+  chatId?: string;
+  principal?: string;
+}): ReturnType<typeof mock> {
+  const chatId = opts.chatId ?? CHAT_ID;
+  const principal = opts.principal ?? PRINCIPAL;
+  const conversationId = `conv-${opts.requestId}`;
+
+  createCanonicalGuardianRequest({
+    id: opts.requestId,
+    kind: "tool_approval",
+    sourceType: "channel",
+    sourceChannel: "slack",
+    conversationId,
+    requesterExternalUserId: "requester-1",
+    requesterChatId: chatId,
+    guardianExternalUserId: GUARDIAN_USER,
+    guardianPrincipalId: principal,
+    toolName: TOOL_NAME,
+    status: "pending",
+    expiresAt: Date.now() + 300_000,
+  });
+
+  createCanonicalGuardianDelivery({
+    requestId: opts.requestId,
+    destinationChannel: "slack",
+    destinationChatId: chatId,
+    destinationMessageId: opts.ts,
+  });
+
+  const handleConfirmationResponse = mock(() => {});
+  _conversationMocks.set(conversationId, {
+    handleConfirmationResponse,
+    ensureActorScopedHistory: async () => {},
+  } as unknown as Conversation);
+  pendingInteractions.register(opts.requestId, {
+    conversationId,
+    kind: "confirmation",
+    confirmationDetails: {
+      toolName: TOOL_NAME,
+      input: { command: "echo hi" },
+      riskLevel: "high",
+      allowlistOptions: [{ label: "t", description: "t", pattern: "t" }],
+      scopeOptions: [{ label: "everywhere", scope: "everywhere" }],
+    },
+  });
+  return handleConfirmationResponse;
+}
+
+function reaction(opts: {
+  emoji: string;
+  reactedMessageTs?: string;
+  chatId?: string;
+  principal?: string;
+}): Parameters<typeof routeGuardianReply>[0] {
+  return {
+    messageText: "",
+    channel: "slack",
+    actor: {
+      actorPrincipalId: opts.principal ?? PRINCIPAL,
+      actorExternalUserId: GUARDIAN_USER,
+      channel: "slack",
+      guardianPrincipalId: opts.principal ?? PRINCIPAL,
+    },
+    conversationId: "guardian-conv",
+    callbackData: `reaction:${opts.emoji}`,
+    reactedMessageTs: opts.reactedMessageTs,
+    channelDeliveryContext: {
+      replyCallbackUrl: "https://gateway.test/deliver",
+      guardianChatId: opts.chatId ?? CHAT_ID,
+      assistantId: "self",
+    },
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Store lookup
+// ---------------------------------------------------------------------------
+
+describe("getPendingCanonicalRequestByDestinationMessage", () => {
+  beforeEach(resetTables);
+
+  test("resolves the request whose delivery matches channel + chat + message id", () => {
+    seedApproval({ requestId: "req-1", ts: "1700000000.000001" });
+    const found = getPendingCanonicalRequestByDestinationMessage(
+      "slack",
+      CHAT_ID,
+      "1700000000.000001",
+    );
+    expect(found?.id).toBe("req-1");
+  });
+
+  test("returns null when no delivery matches the message id", () => {
+    seedApproval({ requestId: "req-1", ts: "1700000000.000001" });
+    expect(
+      getPendingCanonicalRequestByDestinationMessage(
+        "slack",
+        CHAT_ID,
+        "9999.0",
+      ),
+    ).toBeNull();
+  });
+
+  test("returns null once the matched request is no longer pending", () => {
+    seedApproval({ requestId: "req-1", ts: "1700000000.000001" });
+    resolveCanonicalGuardianRequest("req-1", "pending", { status: "approved" });
+    expect(
+      getPendingCanonicalRequestByDestinationMessage(
+        "slack",
+        CHAT_ID,
+        "1700000000.000001",
+      ),
+    ).toBeNull();
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Reaction routing
+// ---------------------------------------------------------------------------
+
+describe("routeGuardianReply / reactions", () => {
+  beforeEach(resetTables);
+
+  test("✅ on a delivered card approves the matching request", async () => {
+    const hcr = seedApproval({ requestId: "req-1", ts: "111.1" });
+
+    const result = await routeGuardianReply(
+      reaction({ emoji: "white_check_mark", reactedMessageTs: "111.1" }),
+    );
+
+    expect(result.consumed).toBe(true);
+    expect(result.decisionApplied).toBe(true);
+    expect(result.type).toBe("canonical_decision_applied");
+    expect(getCanonicalGuardianRequest("req-1")?.status).toBe("approved");
+    expect(hcr).toHaveBeenCalledTimes(1);
+    expect(hcr.mock.calls[0]?.[0]).toBe("req-1");
+    expect(hcr.mock.calls[0]?.[1]).toBe("allow");
+  });
+
+  test("❌ on a delivered card rejects the matching request", async () => {
+    const hcr = seedApproval({ requestId: "req-1", ts: "111.1" });
+
+    const result = await routeGuardianReply(
+      reaction({ emoji: "-1", reactedMessageTs: "111.1" }),
+    );
+
+    expect(result.decisionApplied).toBe(true);
+    expect(getCanonicalGuardianRequest("req-1")?.status).toBe("denied");
+    expect(hcr.mock.calls[0]?.[1]).toBe("deny");
+  });
+
+  test("reacting on a specific card resolves only that card (disambiguates N>1)", async () => {
+    const hcrA = seedApproval({ requestId: "req-A", ts: "100.1" });
+    const hcrB = seedApproval({ requestId: "req-B", ts: "200.2" });
+
+    // React on card B's message — only B should resolve.
+    const result = await routeGuardianReply(
+      reaction({ emoji: "white_check_mark", reactedMessageTs: "200.2" }),
+    );
+
+    expect(result.requestId).toBe("req-B");
+    expect(getCanonicalGuardianRequest("req-B")?.status).toBe("approved");
+    expect(getCanonicalGuardianRequest("req-A")?.status).toBe("pending");
+    expect(hcrB).toHaveBeenCalledTimes(1);
+    expect(hcrA).not.toHaveBeenCalled();
+  });
+
+  test("a reaction on an unknown message is not consumed (left for transcript)", async () => {
+    seedApproval({ requestId: "req-1", ts: "111.1" });
+
+    const result = await routeGuardianReply(
+      reaction({ emoji: "white_check_mark", reactedMessageTs: "no-such-ts" }),
+    );
+
+    expect(result.consumed).toBe(false);
+    expect(result.type).toBe("not_consumed");
+    expect(getCanonicalGuardianRequest("req-1")?.status).toBe("pending");
+  });
+
+  test("an unknown emoji is not consumed", async () => {
+    seedApproval({ requestId: "req-1", ts: "111.1" });
+
+    const result = await routeGuardianReply(
+      reaction({ emoji: "tada", reactedMessageTs: "111.1" }),
+    );
+
+    expect(result.consumed).toBe(false);
+    expect(getCanonicalGuardianRequest("req-1")?.status).toBe("pending");
+  });
+
+  test("a reaction without a reacted message id is not consumed", async () => {
+    seedApproval({ requestId: "req-1", ts: "111.1" });
+
+    const result = await routeGuardianReply(
+      reaction({ emoji: "white_check_mark" }),
+    );
+
+    expect(result.consumed).toBe(false);
+  });
+
+  test("a reaction from a different principal is surfaced, not silently dropped", async () => {
+    const hcr = seedApproval({ requestId: "req-1", ts: "111.1" });
+
+    const result = await routeGuardianReply(
+      reaction({
+        emoji: "white_check_mark",
+        reactedMessageTs: "111.1",
+        principal: "someone-else",
+      }),
+    );
+
+    // Consumed with a user-facing reply, request untouched, side effect not run.
+    expect(result.consumed).toBe(true);
+    expect(result.decisionApplied).toBe(false);
+    expect(result.replyText).toMatch(/permission/i);
+    expect(getCanonicalGuardianRequest("req-1")?.status).toBe("pending");
+    expect(hcr).not.toHaveBeenCalled();
+  });
+});

package/src/__tests__/subagent-tools.test.ts

@@ -6,6 +6,28 @@ import { describe, expect, mock, test } from "bun:test";
 let mockGetMessages: (
   conversationId: string,
 ) => Array<{ role: string; content: string }> | null = () => null;
+const mockProfiles = {
+  balanced: {},
+  "cost-optimized": {},
+  disabled: { status: "disabled" },
+  "quality-optimized": {},
+};
+mock.module("../config/loader.js", () => ({
+  getConfigReadOnly: () => ({
+    llm: { profiles: mockProfiles },
+  }),
+  getConfig: () => ({
+    llm: {
+      default: {
+        provider: "anthropic",
+        provider_connection: "anthropic-managed",
+        model: "claude-opus-4-7",
+      },
+      profiles: mockProfiles,
+    },
+    rateLimit: { maxRequestsPerMinute: 0 },
+  }),
+}));
 mock.module("../memory/conversation-crud.js", () => ({
   setConversationOriginChannelIfUnset: () => {},
   updateConversationContextWindow: () => {},
@@ -140,6 +162,7 @@ describe("Subagent tool definitions", () => {
     const def = findTool("subagent_spawn");
     expect(def).toBeDefined();
     expect(def.input_schema.required).toEqual(["label", "objective"]);
+    expect(def.input_schema.properties.inference_profile).toBeDefined();
   });
 
   test("abort tool has correct definition", () => {
@@ -422,6 +445,249 @@ describe("Subagent spawn success and failure", () => {
     }
   });
 
+  test("spawn passes explicit inference_profile to manager over inherited override", async () => {
+    const manager = getSubagentManager();
+    const originalSpawn = manager.spawn.bind(manager);
+    let capturedConfig: Record<string, unknown> | undefined;
+
+    manager.spawn = async (config: Record<string, unknown>) => {
+      capturedConfig = config;
+      return "profile-subagent-id";
+    };
+
+    try {
+      const result = await executeSubagentSpawn(
+        {
+          label: "Profile test",
+          objective: "Do it with a chosen model profile",
+          inference_profile: "quality-optimized",
+        },
+        makeContext("sess-spawn-profile", {
+          sendToClient: () => {},
+          overrideProfile: "balanced",
+        }),
+      );
+
+      expect(result.isError).toBe(false);
+      expect(capturedConfig).toBeDefined();
+      expect(capturedConfig!.overrideProfile).toBe("quality-optimized");
+      expect(capturedConfig!.forceOverrideProfile).toBe(true);
+    } finally {
+      manager.spawn = originalSpawn;
+    }
+  });
+
+  test("spawn inherits the invoking call site's default profile when no override is present", async () => {
+    const manager = getSubagentManager();
+    const originalSpawn = manager.spawn.bind(manager);
+    let capturedConfig: Record<string, unknown> | undefined;
+
+    manager.spawn = async (config: Record<string, unknown>) => {
+      capturedConfig = config;
+      return "inherit-default-id";
+    };
+
+    try {
+      const result = await executeSubagentSpawn(
+        { label: "Inherit default", objective: "Do it" },
+        makeContext("sess-inherit-default", {
+          sendToClient: () => {},
+          invokingCallSite: "mainAgent",
+        }),
+      );
+
+      expect(result.isError).toBe(false);
+      // No explicit profile and no per-turn override → the child matches the
+      // invoking call site's resolved default profile (balanced for mainAgent
+      // in the test config).
+      expect(capturedConfig!.overrideProfile).toBe("balanced");
+      expect(capturedConfig!.forceOverrideProfile).toBeUndefined();
+    } finally {
+      manager.spawn = originalSpawn;
+    }
+  });
+
+  test("spawn inherits a non-main invoker's call-site default profile", async () => {
+    const manager = getSubagentManager();
+    const originalSpawn = manager.spawn.bind(manager);
+    let capturedConfig: Record<string, unknown> | undefined;
+
+    manager.spawn = async (config: Record<string, unknown>) => {
+      capturedConfig = config;
+      return "inherit-heartbeat-id";
+    };
+
+    try {
+      const result = await executeSubagentSpawn(
+        { label: "Heartbeat child", objective: "Do it" },
+        makeContext("sess-inherit-heartbeat", {
+          sendToClient: () => {},
+          invokingCallSite: "heartbeatAgent",
+        }),
+      );
+
+      expect(result.isError).toBe(false);
+      // A subagent spawned from a heartbeat turn matches heartbeatAgent's own
+      // cost-optimized default, not the mainAgent default.
+      expect(capturedConfig!.overrideProfile).toBe("cost-optimized");
+    } finally {
+      manager.spawn = originalSpawn;
+    }
+  });
+
+  test("spawn prefers a per-turn override profile over the invoker default", async () => {
+    const manager = getSubagentManager();
+    const originalSpawn = manager.spawn.bind(manager);
+    let capturedConfig: Record<string, unknown> | undefined;
+
+    manager.spawn = async (config: Record<string, unknown>) => {
+      capturedConfig = config;
+      return "inherit-override-id";
+    };
+
+    try {
+      const result = await executeSubagentSpawn(
+        { label: "Override child", objective: "Do it" },
+        makeContext("sess-inherit-override", {
+          sendToClient: () => {},
+          invokingCallSite: "mainAgent",
+          overrideProfile: "quality-optimized",
+        }),
+      );
+
+      expect(result.isError).toBe(false);
+      // The live per-turn override (per-conversation or tool-routed) wins over
+      // the call-site default, and is forwarded non-forced.
+      expect(capturedConfig!.overrideProfile).toBe("quality-optimized");
+      expect(capturedConfig!.forceOverrideProfile).toBeUndefined();
+    } finally {
+      manager.spawn = originalSpawn;
+    }
+  });
+
+  test("spawn skips the auto profile so the child keeps its own default", async () => {
+    const manager = getSubagentManager();
+    const originalSpawn = manager.spawn.bind(manager);
+    let capturedConfig: Record<string, unknown> | undefined;
+
+    manager.spawn = async (config: Record<string, unknown>) => {
+      capturedConfig = config;
+      return "inherit-auto-id";
+    };
+
+    try {
+      const result = await executeSubagentSpawn(
+        { label: "Auto child", objective: "Do it" },
+        makeContext("sess-inherit-auto", {
+          sendToClient: () => {},
+          invokingCallSite: "mainAgent",
+          // "auto" is metadata-only; forwarding it would collapse the child to
+          // llm.default, so the inherited path drops it and the child keeps its
+          // own subagentSpawn default.
+          overrideProfile: "auto",
+        }),
+      );
+
+      expect(result.isError).toBe(false);
+      expect(capturedConfig!.overrideProfile).toBeUndefined();
+    } finally {
+      manager.spawn = originalSpawn;
+    }
+  });
+
+  test("spawn still forces an explicit inference_profile over the invoker default", async () => {
+    const manager = getSubagentManager();
+    const originalSpawn = manager.spawn.bind(manager);
+    let capturedConfig: Record<string, unknown> | undefined;
+
+    manager.spawn = async (config: Record<string, unknown>) => {
+      capturedConfig = config;
+      return "inherit-explicit-id";
+    };
+
+    try {
+      const result = await executeSubagentSpawn(
+        {
+          label: "Explicit child",
+          objective: "Do it",
+          inference_profile: "cost-optimized",
+        },
+        makeContext("sess-inherit-explicit", {
+          sendToClient: () => {},
+          invokingCallSite: "mainAgent",
+        }),
+      );
+
+      expect(result.isError).toBe(false);
+      expect(capturedConfig!.overrideProfile).toBe("cost-optimized");
+      expect(capturedConfig!.forceOverrideProfile).toBe(true);
+    } finally {
+      manager.spawn = originalSpawn;
+    }
+  });
+
+  test("spawn returns error for unknown inference_profile", async () => {
+    const manager = getSubagentManager();
+    const originalSpawn = manager.spawn.bind(manager);
+    let spawnCalled = false;
+
+    manager.spawn = async () => {
+      spawnCalled = true;
+      return "profile-subagent-id";
+    };
+
+    try {
+      const result = await executeSubagentSpawn(
+        {
+          label: "Bad profile",
+          objective: "Do it",
+          inference_profile: "does-not-exist",
+        },
+        makeContext("sess-spawn-bad-profile", { sendToClient: () => {} }),
+      );
+
+      expect(result.isError).toBe(true);
+      expect(result.content).toContain(
+        'Inference profile "does-not-exist" is not defined',
+      );
+      expect(spawnCalled).toBe(false);
+    } finally {
+      manager.spawn = originalSpawn;
+    }
+  });
+
+  test("spawn returns error for disabled inference_profile", async () => {
+    const manager = getSubagentManager();
+    const originalSpawn = manager.spawn.bind(manager);
+    let spawnCalled = false;
+
+    manager.spawn = async () => {
+      spawnCalled = true;
+      return "profile-subagent-id";
+    };
+
+    try {
+      const result = await executeSubagentSpawn(
+        {
+          label: "Disabled profile",
+          objective: "Do it",
+          inference_profile: "disabled",
+        },
+        makeContext("sess-spawn-disabled-profile", {
+          sendToClient: () => {},
+        }),
+      );
+
+      expect(result.isError).toBe(true);
+      expect(result.content).toContain(
+        'Inference profile "disabled" is disabled',
+      );
+      expect(spawnCalled).toBe(false);
+    } finally {
+      manager.spawn = originalSpawn;
+    }
+  });
+
   test("spawn handles non-Error throws gracefully", async () => {
     const manager = getSubagentManager();
     const originalSpawn = manager.spawn.bind(manager);