@vellumai/assistant 0.4.17 → 0.4.18

package/src/__tests__/approval-conversation-turn.test.ts

@@ -1,28 +1,32 @@
-import { describe, expect,test } from 'bun:test';
+import { describe, expect, test } from "bun:test";
 
-import { runApprovalConversationTurn } from '../runtime/approval-conversation-turn.js';
+import { runApprovalConversationTurn } from "../runtime/approval-conversation-turn.js";
 import type {
   ApprovalConversationContext,
   ApprovalConversationGenerator,
   ApprovalConversationResult,
-} from '../runtime/http-types.js';
+} from "../runtime/http-types.js";
 
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------
 
-function makeContext(overrides: Partial<ApprovalConversationContext> = {}): ApprovalConversationContext {
+function makeContext(
+  overrides: Partial<ApprovalConversationContext> = {},
+): ApprovalConversationContext {
   return {
-    toolName: 'execute_shell',
-    allowedActions: ['approve_once', 'approve_always', 'reject'],
-    role: 'guardian',
-    pendingApprovals: [{ requestId: 'run-1', toolName: 'execute_shell' }],
-    userMessage: 'yes, go ahead',
+    toolName: "execute_shell",
+    allowedActions: ["approve_once", "approve_always", "reject"],
+    role: "guardian",
+    pendingApprovals: [{ requestId: "run-1", toolName: "execute_shell" }],
+    userMessage: "yes, go ahead",
     ...overrides,
   };
 }
 
-function makeGenerator(result: ApprovalConversationResult): ApprovalConversationGenerator {
+function makeGenerator(
+  result: ApprovalConversationResult,
+): ApprovalConversationGenerator {
   return async () => result;
 }
 
@@ -30,130 +34,145 @@ function makeGenerator(result: ApprovalConversationResult): ApprovalConversation
 // Tests
 // ---------------------------------------------------------------------------
 
-describe('runApprovalConversationTurn', () => {
-  test('successful keep_pending response (non-decision message)', async () => {
+describe("runApprovalConversationTurn", () => {
+  test("successful keep_pending response (non-decision message)", async () => {
     const result = await runApprovalConversationTurn(
-      makeContext({ userMessage: 'what does this tool do?' }),
+      makeContext({ userMessage: "what does this tool do?" }),
       makeGenerator({
-        disposition: 'keep_pending',
-        replyText: 'This tool runs shell commands. Would you like to approve it?',
+        disposition: "keep_pending",
+        replyText:
+          "This tool runs shell commands. Would you like to approve it?",
       }),
     );
-    expect(result.disposition).toBe('keep_pending');
-    expect(result.replyText).toBe('This tool runs shell commands. Would you like to approve it?');
+    expect(result.disposition).toBe("keep_pending");
+    expect(result.replyText).toBe(
+      "This tool runs shell commands. Would you like to approve it?",
+    );
     expect(result.targetRequestId).toBeUndefined();
   });
 
-  test('successful approve_once response', async () => {
+  test("successful approve_once response", async () => {
     const result = await runApprovalConversationTurn(
       makeContext(),
       makeGenerator({
-        disposition: 'approve_once',
-        replyText: 'Approved! Running the command now.',
-        targetRequestId: 'run-1',
+        disposition: "approve_once",
+        replyText: "Approved! Running the command now.",
+        targetRequestId: "run-1",
       }),
     );
-    expect(result.disposition).toBe('approve_once');
-    expect(result.replyText).toBe('Approved! Running the command now.');
-    expect(result.targetRequestId).toBe('run-1');
+    expect(result.disposition).toBe("approve_once");
+    expect(result.replyText).toBe("Approved! Running the command now.");
+    expect(result.targetRequestId).toBe("run-1");
   });
 
-  test('successful reject response', async () => {
+  test("successful reject response", async () => {
     const result = await runApprovalConversationTurn(
       makeContext(),
       makeGenerator({
-        disposition: 'reject',
-        replyText: 'Request denied.',
-        targetRequestId: 'run-1',
+        disposition: "reject",
+        replyText: "Request denied.",
+        targetRequestId: "run-1",
       }),
     );
-    expect(result.disposition).toBe('reject');
-    expect(result.replyText).toBe('Request denied.');
+    expect(result.disposition).toBe("reject");
+    expect(result.replyText).toBe("Request denied.");
   });
 
-  test('fail-closed on generator throwing an error', async () => {
+  test("fail-closed on generator throwing an error", async () => {
     const throwingGenerator: ApprovalConversationGenerator = async () => {
-      throw new Error('provider timeout');
+      throw new Error("provider timeout");
     };
-    const result = await runApprovalConversationTurn(makeContext(), throwingGenerator);
-    expect(result.disposition).toBe('keep_pending');
+    const result = await runApprovalConversationTurn(
+      makeContext(),
+      throwingGenerator,
+    );
+    expect(result.disposition).toBe("keep_pending");
     expect(result.replyText).toContain("couldn't process");
   });
 
-  test('fail-closed on generator returning malformed output', async () => {
+  test("fail-closed on generator returning malformed output", async () => {
     const malformedGenerator: ApprovalConversationGenerator = async () => {
       // Return an object missing the required replyText
-      return { disposition: 'approve_once', replyText: '' } as ApprovalConversationResult;
+      return {
+        disposition: "approve_once",
+        replyText: "",
+      } as ApprovalConversationResult;
     };
-    const result = await runApprovalConversationTurn(makeContext(), malformedGenerator);
-    expect(result.disposition).toBe('keep_pending');
+    const result = await runApprovalConversationTurn(
+      makeContext(),
+      malformedGenerator,
+    );
+    expect(result.disposition).toBe("keep_pending");
     expect(result.replyText).toContain("couldn't process");
   });
 
-  test('fail-closed on invalid disposition', async () => {
+  test("fail-closed on invalid disposition", async () => {
     const badDisposition: ApprovalConversationGenerator = async () => {
-      return { disposition: 'yolo' as 'approve_once', replyText: 'Sure!' };
+      return { disposition: "yolo" as "approve_once", replyText: "Sure!" };
     };
-    const result = await runApprovalConversationTurn(makeContext(), badDisposition);
-    expect(result.disposition).toBe('keep_pending');
+    const result = await runApprovalConversationTurn(
+      makeContext(),
+      badDisposition,
+    );
+    expect(result.disposition).toBe("keep_pending");
     expect(result.replyText).toContain("couldn't process");
   });
 
-  test('fail-closed when disposition is not in allowedActions', async () => {
+  test("fail-closed when disposition is not in allowedActions", async () => {
     // Context only allows approve_once and reject (no approve_always)
     const restrictedContext = makeContext({
-      allowedActions: ['approve_once', 'reject'],
+      allowedActions: ["approve_once", "reject"],
     });
 
     const result = await runApprovalConversationTurn(
       restrictedContext,
       makeGenerator({
-        disposition: 'approve_always',
-        replyText: 'Approved permanently!',
-        targetRequestId: 'run-1',
+        disposition: "approve_always",
+        replyText: "Approved permanently!",
+        targetRequestId: "run-1",
       }),
     );
-    expect(result.disposition).toBe('keep_pending');
+    expect(result.disposition).toBe("keep_pending");
     expect(result.replyText).toContain("couldn't process");
   });
 
-  test('keep_pending is always allowed regardless of allowedActions', async () => {
+  test("keep_pending is always allowed regardless of allowedActions", async () => {
     const restrictedContext = makeContext({
-      allowedActions: ['approve_once', 'reject'],
+      allowedActions: ["approve_once", "reject"],
     });
 
     const result = await runApprovalConversationTurn(
       restrictedContext,
       makeGenerator({
-        disposition: 'keep_pending',
-        replyText: 'Can you tell me more about this request?',
+        disposition: "keep_pending",
+        replyText: "Can you tell me more about this request?",
       }),
     );
-    expect(result.disposition).toBe('keep_pending');
-    expect(result.replyText).toBe('Can you tell me more about this request?');
+    expect(result.disposition).toBe("keep_pending");
+    expect(result.replyText).toBe("Can you tell me more about this request?");
   });
 
-  test('fail-closed when single pending approval and hallucinated targetRequestId', async () => {
+  test("fail-closed when single pending approval and hallucinated targetRequestId", async () => {
     // Only one pending approval, but model returns a non-matching targetRequestId
     const result = await runApprovalConversationTurn(
       makeContext({
-        pendingApprovals: [{ requestId: 'run-1', toolName: 'execute_shell' }],
+        pendingApprovals: [{ requestId: "run-1", toolName: "execute_shell" }],
       }),
       makeGenerator({
-        disposition: 'approve_once',
-        replyText: 'Approved!',
-        targetRequestId: 'run-nonexistent',
+        disposition: "approve_once",
+        replyText: "Approved!",
+        targetRequestId: "run-nonexistent",
       }),
     );
-    expect(result.disposition).toBe('keep_pending');
+    expect(result.disposition).toBe("keep_pending");
     expect(result.replyText).toContain("couldn't process");
   });
 
-  test('fail-closed when targetRequestId does not match any pending approval', async () => {
+  test("fail-closed when targetRequestId does not match any pending approval", async () => {
     const contextWithMultiple = makeContext({
       pendingApprovals: [
-        { requestId: 'run-1', toolName: 'execute_shell' },
-        { requestId: 'run-2', toolName: 'file_write' },
+        { requestId: "run-1", toolName: "execute_shell" },
+        { requestId: "run-2", toolName: "file_write" },
       ],
     });
 
@@ -161,20 +180,20 @@ describe('runApprovalConversationTurn', () => {
     const result = await runApprovalConversationTurn(
       contextWithMultiple,
       makeGenerator({
-        disposition: 'approve_once',
-        replyText: 'Approved!',
-        targetRequestId: 'run-nonexistent',
+        disposition: "approve_once",
+        replyText: "Approved!",
+        targetRequestId: "run-nonexistent",
       }),
     );
-    expect(result.disposition).toBe('keep_pending');
+    expect(result.disposition).toBe("keep_pending");
     expect(result.replyText).toContain("couldn't process");
   });
 
-  test('targetRequestId validation when multiple pending approvals', async () => {
+  test("targetRequestId validation when multiple pending approvals", async () => {
     const contextWithMultiple = makeContext({
       pendingApprovals: [
-        { requestId: 'run-1', toolName: 'execute_shell' },
-        { requestId: 'run-2', toolName: 'file_write' },
+        { requestId: "run-1", toolName: "execute_shell" },
+        { requestId: "run-2", toolName: "file_write" },
       ],
     });
 
@@ -182,34 +201,34 @@ describe('runApprovalConversationTurn', () => {
     const resultWithoutTarget = await runApprovalConversationTurn(
       contextWithMultiple,
       makeGenerator({
-        disposition: 'approve_once',
-        replyText: 'Approved!',
+        disposition: "approve_once",
+        replyText: "Approved!",
         // no targetRequestId
       }),
     );
-    expect(resultWithoutTarget.disposition).toBe('keep_pending');
+    expect(resultWithoutTarget.disposition).toBe("keep_pending");
     expect(resultWithoutTarget.replyText).toContain("couldn't process");
 
     // Decision-bearing disposition with targetRequestId should succeed
     const resultWithTarget = await runApprovalConversationTurn(
       contextWithMultiple,
       makeGenerator({
-        disposition: 'approve_once',
-        replyText: 'Approved!',
-        targetRequestId: 'run-1',
+        disposition: "approve_once",
+        replyText: "Approved!",
+        targetRequestId: "run-1",
       }),
     );
-    expect(resultWithTarget.disposition).toBe('approve_once');
-    expect(resultWithTarget.targetRequestId).toBe('run-1');
+    expect(resultWithTarget.disposition).toBe("approve_once");
+    expect(resultWithTarget.targetRequestId).toBe("run-1");
 
     // Non-decision disposition without targetRequestId should pass through fine
     const resultKeepPending = await runApprovalConversationTurn(
       contextWithMultiple,
       makeGenerator({
-        disposition: 'keep_pending',
-        replyText: 'Which request would you like to approve?',
+        disposition: "keep_pending",
+        replyText: "Which request would you like to approve?",
       }),
     );
-    expect(resultKeepPending.disposition).toBe('keep_pending');
+    expect(resultKeepPending.disposition).toBe("keep_pending");
   });
 });

package/src/__tests__/approval-hardcoded-copy-guard.test.ts

@@ -6,32 +6,60 @@
  * since that is where deterministic fallback copy legitimately lives.
  */
 
-import { describe, expect,test } from 'bun:test';
-import { readFileSync } from 'fs';
-import { join } from 'path';
+import { describe, expect, test } from "bun:test";
+
+import { readFileSync } from "fs";
+import { join } from "path";
 
 const SCANNED_FILES = [
-  'runtime/channel-approvals.ts',
-  'runtime/routes/channel-routes.ts',
-  'runtime/channel-guardian-service.ts',
+  "runtime/channel-approvals.ts",
+  "runtime/routes/channel-routes.ts",
+  "runtime/channel-guardian-service.ts",
 ];
 
 const BANNED_PATTERNS: { pattern: RegExp; description: string }[] = [
-  { pattern: /The assistant wants to use/i, description: 'old standard prompt' },
-  { pattern: /Do you want to allow this/i, description: 'old approval question' },
-  { pattern: /['"`]I'm still waiting/i, description: 'old reminder prefix (string literal)' },
-  { pattern: /['"`].*is requesting to run/i, description: 'old guardian prompt (string literal)' },
-  { pattern: /['"`]Sent to guardian/i, description: 'old forwarding notice (string literal)' },
-  { pattern: /['"`]Guardian verified successfully/i, description: 'old verify success (string literal)' },
-  { pattern: /['"`]Verification failed/i, description: 'old verify failure (string literal)' },
-  { pattern: /['"`]Your request has been sent/i, description: 'old request forwarded notice (string literal)' },
-  { pattern: /['"`]No guardian is configured/i, description: 'old no-binding notice (string literal)' },
+  {
+    pattern: /The assistant wants to use/i,
+    description: "old standard prompt",
+  },
+  {
+    pattern: /Do you want to allow this/i,
+    description: "old approval question",
+  },
+  {
+    pattern: /['"`]I'm still waiting/i,
+    description: "old reminder prefix (string literal)",
+  },
+  {
+    pattern: /['"`].*is requesting to run/i,
+    description: "old guardian prompt (string literal)",
+  },
+  {
+    pattern: /['"`]Sent to guardian/i,
+    description: "old forwarding notice (string literal)",
+  },
+  {
+    pattern: /['"`]Guardian verified successfully/i,
+    description: "old verify success (string literal)",
+  },
+  {
+    pattern: /['"`]Verification failed/i,
+    description: "old verify failure (string literal)",
+  },
+  {
+    pattern: /['"`]Your request has been sent/i,
+    description: "old request forwarded notice (string literal)",
+  },
+  {
+    pattern: /['"`]No guardian is configured/i,
+    description: "old no-binding notice (string literal)",
+  },
 ];
 
-describe('approval hardcoded copy guard', () => {
+describe("approval hardcoded copy guard", () => {
   for (const file of SCANNED_FILES) {
     test(`${file} does not contain banned approval copy literals`, () => {
-      const content = readFileSync(join(__dirname, '..', file), 'utf-8');
+      const content = readFileSync(join(__dirname, "..", file), "utf-8");
       for (const { pattern, description: _description } of BANNED_PATTERNS) {
         const match = content.match(pattern);
         expect(match).toBeNull();