@vellumai/assistant 0.6.1 → 0.6.3

package/src/__tests__/post-turn-tool-result-truncation.test.ts

@@ -0,0 +1,296 @@
+import { existsSync, mkdtempSync, readFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+
+import {
+  buildTruncatedContent,
+  derefToolResultReReads,
+  getToolResultFilePath,
+  postTurnTruncateToolResults,
+  REREAD_STUB,
+  TARGET_CHARS,
+  THRESHOLD_CHARS,
+  TOOL_RESULT_DIR,
+  TRUNCATION_MARKER,
+} from "../context/post-turn-tool-result-truncation.js";
+import type { ContentBlock, Message } from "../providers/types.js";
+
+function makeToolResult(
+  content: string,
+  toolUseId = "tool_use_1",
+  is_error = false,
+): ContentBlock {
+  return {
+    type: "tool_result" as const,
+    tool_use_id: toolUseId,
+    content,
+    ...(is_error ? { is_error: true } : {}),
+  };
+}
+
+function makeMessages(blocks: ContentBlock[]): Message[] {
+  return [{ role: "user", content: blocks }];
+}
+
+describe("postTurnTruncateToolResults", () => {
+  let convDir: string;
+
+  beforeEach(() => {
+    convDir = mkdtempSync(join(tmpdir(), "tool-result-trunc-"));
+  });
+
+  afterEach(() => {
+    rmSync(convDir, { recursive: true, force: true });
+  });
+
+  test("result below threshold is returned unchanged, no file written", () => {
+    const shortContent = "a".repeat(THRESHOLD_CHARS);
+    const messages = makeMessages([makeToolResult(shortContent)]);
+
+    const { messages: result, truncatedCount } =
+      postTurnTruncateToolResults(messages, { conversationDir: convDir });
+
+    expect(truncatedCount).toBe(0);
+    expect(result).toBe(messages); // same reference — no copy
+    expect(existsSync(join(convDir, TOOL_RESULT_DIR))).toBe(false);
+  });
+
+  test("result above threshold is truncated, file written with original content", () => {
+    const longContent = "x".repeat(THRESHOLD_CHARS + 1);
+    const toolUseId = "tool_use_abc";
+    const messages = makeMessages([makeToolResult(longContent, toolUseId)]);
+
+    const { messages: result, truncatedCount } =
+      postTurnTruncateToolResults(messages, { conversationDir: convDir });
+
+    expect(truncatedCount).toBe(1);
+
+    const block = result[0].content[0] as { type: "tool_result"; content: string };
+    expect(block.content).toContain(TRUNCATION_MARKER);
+    expect(block.content.length).toBeLessThan(longContent.length);
+
+    // Verify file on disk contains original content.
+    const filePath = getToolResultFilePath(convDir, toolUseId);
+    expect(existsSync(filePath)).toBe(true);
+    expect(readFileSync(filePath, "utf-8")).toBe(longContent);
+  });
+
+  test("error result above threshold is unchanged", () => {
+    const longContent = "e".repeat(THRESHOLD_CHARS + 100);
+    const messages = makeMessages([
+      makeToolResult(longContent, "tool_err", true),
+    ]);
+
+    const { messages: result, truncatedCount } =
+      postTurnTruncateToolResults(messages, { conversationDir: convDir });
+
+    expect(truncatedCount).toBe(0);
+    expect(result).toBe(messages);
+  });
+
+  test("already-truncated result is unchanged (idempotency)", () => {
+    // Simulate a result that was already truncated in a prior pass.
+    const alreadyTruncated =
+      "prefix..." +
+      `\n\n...(500 tokens omitted ${TRUNCATION_MARKER} /some/path.txt)\n\n` +
+      "...suffix".padEnd(THRESHOLD_CHARS + 1, "z");
+    const messages = makeMessages([
+      makeToolResult(alreadyTruncated, "tool_idempotent"),
+    ]);
+
+    const { messages: result, truncatedCount } =
+      postTurnTruncateToolResults(messages, { conversationDir: convDir });
+
+    expect(truncatedCount).toBe(0);
+    expect(result).toBe(messages);
+  });
+
+  test("multiple results in one turn are each evaluated independently", () => {
+    const short = "s".repeat(100);
+    const long1 = "a".repeat(THRESHOLD_CHARS + 1);
+    const long2 = "b".repeat(THRESHOLD_CHARS + 2);
+    const messages = makeMessages([
+      makeToolResult(short, "tool_short"),
+      makeToolResult(long1, "tool_long1"),
+      makeToolResult(long2, "tool_long2"),
+    ]);
+
+    const { messages: result, truncatedCount } =
+      postTurnTruncateToolResults(messages, { conversationDir: convDir });
+
+    expect(truncatedCount).toBe(2);
+
+    // Short result unchanged.
+    const b0 = result[0].content[0] as { type: "tool_result"; content: string };
+    expect(b0.content).toBe(short);
+
+    // Both long results truncated.
+    const b1 = result[0].content[1] as { type: "tool_result"; content: string };
+    const b2 = result[0].content[2] as { type: "tool_result"; content: string };
+    expect(b1.content).toContain(TRUNCATION_MARKER);
+    expect(b2.content).toContain(TRUNCATION_MARKER);
+  });
+
+  test("prefix/suffix split preserves first and last halves of TARGET_CHARS", () => {
+    // Build content where each char is its position modulo 10 so we can verify slicing.
+    const longContent = Array.from({ length: THRESHOLD_CHARS + 500 }, (_, i) =>
+      String(i % 10),
+    ).join("");
+
+    const filePath = "/tmp/fake-path.txt";
+    const stub = buildTruncatedContent(longContent, filePath);
+
+    const half = Math.floor(TARGET_CHARS / 2);
+    const expectedPrefix = longContent.slice(0, half);
+    const expectedSuffix = longContent.slice(-half);
+
+    expect(stub.startsWith(expectedPrefix)).toBe(true);
+    expect(stub.endsWith(expectedSuffix)).toBe(true);
+    expect(stub).toContain(TRUNCATION_MARKER);
+    expect(stub).toContain(filePath);
+  });
+
+  test("file path is deterministic for the same toolUseId", () => {
+    const id = "tool_use_deterministic";
+    const path1 = getToolResultFilePath("/some/dir", id);
+    const path2 = getToolResultFilePath("/some/dir", id);
+    expect(path1).toBe(path2);
+
+    // Different IDs produce different paths.
+    const path3 = getToolResultFilePath("/some/dir", "tool_use_other");
+    expect(path3).not.toBe(path1);
+  });
+});
+
+describe("derefToolResultReReads", () => {
+  function makeToolUse(
+    id: string,
+    name: string,
+    input: Record<string, unknown>,
+  ): ContentBlock {
+    return { type: "tool_use" as const, id, name, input };
+  }
+
+  test("file_read of .tool-results/ path: tool_result content replaced with REREAD_STUB", () => {
+    const toolUseId = "tu_reread_1";
+    const messages: Message[] = [
+      {
+        role: "assistant",
+        content: [
+          makeToolUse(toolUseId, "file_read", {
+            path: `/home/user/.vellum/workspace/conversations/abc/${TOOL_RESULT_DIR}/abc123.txt`,
+          }),
+        ],
+      },
+      {
+        role: "user",
+        content: [makeToolResult("full file contents here", toolUseId)],
+      },
+    ];
+
+    const { messages: result, dereferencedCount } =
+      derefToolResultReReads(messages);
+
+    expect(dereferencedCount).toBe(1);
+    const block = result[1].content[0] as { type: "tool_result"; content: string };
+    expect(block.content).toBe(REREAD_STUB);
+  });
+
+  test("file_read of normal path: tool_result unchanged", () => {
+    const toolUseId = "tu_normal_read";
+    const originalContent = "some file contents";
+    const messages: Message[] = [
+      {
+        role: "assistant",
+        content: [
+          makeToolUse(toolUseId, "file_read", {
+            path: "src/foo.ts",
+          }),
+        ],
+      },
+      {
+        role: "user",
+        content: [makeToolResult(originalContent, toolUseId)],
+      },
+    ];
+
+    const { messages: result, dereferencedCount } =
+      derefToolResultReReads(messages);
+
+    expect(dereferencedCount).toBe(0);
+    expect(result).toBe(messages); // same reference — no copy
+    const block = result[1].content[0] as { type: "tool_result"; content: string };
+    expect(block.content).toBe(originalContent);
+  });
+
+  test("non-file_read tool: tool_result unchanged even if output mentions .tool-results/", () => {
+    const toolUseId = "tu_bash";
+    const outputMentioningDir = `Found file at /home/user/${TOOL_RESULT_DIR}/abc.txt`;
+    const messages: Message[] = [
+      {
+        role: "assistant",
+        content: [
+          makeToolUse(toolUseId, "bash", {
+            command: "ls",
+          }),
+        ],
+      },
+      {
+        role: "user",
+        content: [makeToolResult(outputMentioningDir, toolUseId)],
+      },
+    ];
+
+    const { messages: result, dereferencedCount } =
+      derefToolResultReReads(messages);
+
+    expect(dereferencedCount).toBe(0);
+    expect(result).toBe(messages);
+    const block = result[1].content[0] as { type: "tool_result"; content: string };
+    expect(block.content).toBe(outputMentioningDir);
+  });
+
+  test("multiple re-reads in one turn: each deduplicated independently", () => {
+    const tu1 = "tu_multi_1";
+    const tu2 = "tu_multi_2";
+    const tuNormal = "tu_multi_normal";
+    const messages: Message[] = [
+      {
+        role: "assistant",
+        content: [
+          makeToolUse(tu1, "file_read", {
+            path: `/workspace/conv/${TOOL_RESULT_DIR}/aaa.txt`,
+          }),
+          makeToolUse(tu2, "file_read", {
+            path: `/workspace/conv/${TOOL_RESULT_DIR}/bbb.txt`,
+          }),
+          makeToolUse(tuNormal, "file_read", {
+            path: "src/bar.ts",
+          }),
+        ],
+      },
+      {
+        role: "user",
+        content: [
+          makeToolResult("re-read content 1", tu1),
+          makeToolResult("re-read content 2", tu2),
+          makeToolResult("normal read content", tuNormal),
+        ],
+      },
+    ];
+
+    const { messages: result, dereferencedCount } =
+      derefToolResultReReads(messages);
+
+    expect(dereferencedCount).toBe(2);
+
+    const b0 = result[1].content[0] as { type: "tool_result"; content: string };
+    const b1 = result[1].content[1] as { type: "tool_result"; content: string };
+    const b2 = result[1].content[2] as { type: "tool_result"; content: string };
+
+    expect(b0.content).toBe(REREAD_STUB);
+    expect(b1.content).toBe(REREAD_STUB);
+    expect(b2.content).toBe("normal read content"); // unchanged
+  });
+});

package/src/__tests__/proxy-approval-callback.test.ts

@@ -1,5 +1,6 @@
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
+import { _setOverridesForTesting } from "../config/assistant-feature-flags.js";
 import type { ProxyApprovalRequest } from "../outbound-proxy/index.js";
 
 // ---------------------------------------------------------------------------
@@ -110,6 +111,23 @@ describe("createProxyApprovalCallback", () => {
     addRuleMock.mockClear();
     findHighestPriorityRuleMock.mockClear();
     findHighestPriorityRuleMock.mockReturnValue(null);
+    _setOverridesForTesting({});
+  });
+
+  test("suppresses network approval cards under v2 and auto-allows", async () => {
+    _setOverridesForTesting({ "permission-controls-v2": true });
+
+    const ctx = makeContext();
+    const prompterSendToClient = mock(() => {});
+    const prompter = new PermissionPrompter(prompterSendToClient);
+
+    const callback = createProxyApprovalCallback(prompter, ctx);
+    const result = await callback(makeAskMissingCredentialRequest());
+
+    expect(result).toBe(true);
+    expect(prompterSendToClient).not.toHaveBeenCalled();
+    expect(findHighestPriorityRuleMock).not.toHaveBeenCalled();
+    expect(addRuleMock).not.toHaveBeenCalled();
   });
 
   test("returns true when user allows an ask_missing_credential request", async () => {

package/src/__tests__/require-fresh-approval.test.ts

@@ -108,16 +108,20 @@ mock.module("../permissions/checker.js", () => ({
 
 mock.module("../memory/tool-usage-store.js", () => ({
   recordToolInvocation: () => {},
+  getRecentInvocations: () => [],
+  rotateToolInvocations: () => 0,
 }));
 
 mock.module("../tools/registry.js", () => ({
   getTool: (name: string) => {
     if (name === "unknown_tool") return undefined;
+    const isGmailTool = name.startsWith("gmail_");
     return {
       name,
       description: "test tool",
-      category: "credential-execution",
+      category: isGmailTool ? "gmail" : "credential-execution",
       defaultRiskLevel: "high",
+      executionTarget: isGmailTool ? ("host" as const) : undefined,
       getDefinition: () => ({}),
       execute: async () => fakeToolResult,
     };
@@ -257,6 +261,41 @@ describe("requireFreshApproval: non-interactive guardian denial", () => {
     expect(result.isError).toBe(false);
   });
 
+  test("medium-risk gmail archive is auto-approved in non-interactive guardian sessions", async () => {
+    riskOverride = RiskLevel.Medium;
+    checkResultOverride = {
+      decision: "prompt",
+      reason: "Needs approval",
+    };
+
+    const executor = new ToolExecutor(makePrompter());
+    const result = await executor.execute(
+      "gmail_archive",
+      { query: "in:inbox", confidence: 0.92 },
+      makeContext({ isInteractive: false, trustClass: "guardian" }),
+    );
+
+    expect(result.isError).toBe(false);
+  });
+
+  test("high-risk gmail send_draft is denied in non-interactive guardian sessions", async () => {
+    riskOverride = RiskLevel.High;
+    checkResultOverride = {
+      decision: "prompt",
+      reason: "Needs approval",
+    };
+
+    const executor = new ToolExecutor(makePrompter());
+    const result = await executor.execute(
+      "gmail_send_draft",
+      { draft_id: "draft-123", confidence: 0.99 },
+      makeContext({ isInteractive: false, trustClass: "guardian" }),
+    );
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain("requires user approval");
+  });
+
   test("low-risk tools are still auto-approved in non-interactive guardian sessions", async () => {
     riskOverride = RiskLevel.Low;
     checkResultOverride = {
@@ -416,7 +455,6 @@ describe("requireFreshApproval: persistent decisions disabled", () => {
         _allowlistOptions: unknown[],
         _scopeOptions: unknown[],
         _previewDiff: unknown,
-        _sandboxed: boolean | undefined,
         _conversationId: string,
         _executionTarget: string,
         persistentDecisionsAllowed: boolean,
@@ -467,7 +505,6 @@ describe("requireFreshApproval: persistent decisions disabled", () => {
         _allowlistOptions: unknown[],
         _scopeOptions: unknown[],
         _previewDiff: unknown,
-        _sandboxed: boolean | undefined,
         _conversationId: string,
         _executionTarget: string,
         persistentDecisionsAllowed: boolean,

package/src/__tests__/sandbox-diagnostics.test.ts

@@ -10,22 +10,6 @@ mock.module("node:child_process", () => ({
   execSync: execSyncMock,
 }));
 
-// Mock config loader — return a config with sandbox settings
-let mockSandboxConfig: {
-  enabled: boolean;
-} = {
-  enabled: true,
-};
-
-mock.module("../config/loader.js", () => ({
-  getConfig: () => ({
-    ui: {},
-
-    sandbox: mockSandboxConfig,
-  }),
-  loadRawConfig: () => ({}),
-}));
-
 mock.module("../util/logger.js", () => ({
   getLogger: () => ({
     error: () => {},
@@ -49,9 +33,6 @@ function setPlatform(platform: string): void {
 
 beforeEach(() => {
   execSyncMock.mockReset();
-  mockSandboxConfig = {
-    enabled: true,
-  };
   // Default: all commands succeed.
   execSyncMock.mockImplementation(() => undefined);
 });
@@ -62,26 +43,14 @@ afterEach(() => {
 });
 
 describe("runSandboxDiagnostics — config reporting", () => {
-  test("reports sandbox enabled state", () => {
-    const result = runSandboxDiagnostics();
-    expect(result.config.enabled).toBe(true);
-  });
-
-  test("reports sandbox disabled state", () => {
-    mockSandboxConfig.enabled = false;
+  test("reports sandbox disabled (sandbox removed)", () => {
     const result = runSandboxDiagnostics();
     expect(result.config.enabled).toBe(false);
   });
 });
 
 describe("runSandboxDiagnostics — active backend reason", () => {
-  test("explains native backend selection", () => {
-    const result = runSandboxDiagnostics();
-    expect(result.activeBackendReason).toContain("Native backend");
-  });
-
   test("explains when sandbox is disabled", () => {
-    mockSandboxConfig.enabled = false;
     const result = runSandboxDiagnostics();
     expect(result.activeBackendReason).toContain("disabled");
   });

package/src/__tests__/sanitize-config-for-transfer.test.ts

@@ -0,0 +1,132 @@
+import { describe, expect, test } from "bun:test";
+
+import { sanitizeConfigForTransfer } from "../config/sanitize-for-transfer.js";
+
+describe("sanitizeConfigForTransfer", () => {
+  test("strips all four field groups", () => {
+    const input = {
+      ingress: {
+        publicBaseUrl: "https://example.com",
+        enabled: true,
+        webhook: { path: "/hook" },
+      },
+      daemon: { port: 3000, logLevel: "debug" },
+      skills: {
+        load: {
+          extraDirs: ["/custom/skills"],
+          builtIn: true,
+        },
+      },
+      name: "my-assistant",
+    };
+
+    const result = JSON.parse(sanitizeConfigForTransfer(JSON.stringify(input)));
+
+    expect(result.ingress.publicBaseUrl).toBe("");
+    expect(result.ingress.enabled).toBeUndefined();
+    expect(result.daemon).toBeUndefined();
+    expect(result.skills.load.extraDirs).toEqual([]);
+  });
+
+  test("preserves non-target fields unchanged", () => {
+    const input = {
+      name: "test",
+      model: "claude-3",
+      ingress: {
+        publicBaseUrl: "https://example.com",
+        enabled: true,
+        webhook: { path: "/hook" },
+        rateLimit: { max: 100 },
+      },
+      daemon: { port: 3000 },
+      skills: {
+        load: {
+          extraDirs: ["/dir"],
+          builtIn: true,
+        },
+        catalog: ["skill-a"],
+      },
+      memory: { enabled: true },
+    };
+
+    const result = JSON.parse(sanitizeConfigForTransfer(JSON.stringify(input)));
+
+    expect(result.name).toBe("test");
+    expect(result.model).toBe("claude-3");
+    expect(result.memory).toEqual({ enabled: true });
+    expect(result.skills.catalog).toEqual(["skill-a"]);
+    expect(result.skills.load.builtIn).toBe(true);
+  });
+
+  test("preserves nested ingress fields other than publicBaseUrl and enabled", () => {
+    const input = {
+      ingress: {
+        publicBaseUrl: "https://old.url",
+        enabled: false,
+        webhook: { path: "/webhook", secret: "abc" },
+        rateLimit: { max: 50, window: 60 },
+      },
+    };
+
+    const result = JSON.parse(sanitizeConfigForTransfer(JSON.stringify(input)));
+
+    expect(result.ingress.webhook).toEqual({ path: "/webhook", secret: "abc" });
+    expect(result.ingress.rateLimit).toEqual({ max: 50, window: 60 });
+    expect(result.ingress.publicBaseUrl).toBe("");
+    expect(result.ingress.enabled).toBeUndefined();
+  });
+
+  test("handles config missing some target fields", () => {
+    const input = {
+      name: "test",
+      ingress: { webhook: { path: "/hook" } },
+    };
+
+    const result = JSON.parse(sanitizeConfigForTransfer(JSON.stringify(input)));
+
+    expect(result.name).toBe("test");
+    expect(result.ingress.publicBaseUrl).toBe("");
+    expect(result.ingress.webhook).toEqual({ path: "/hook" });
+  });
+
+  test("handles config missing all target fields", () => {
+    const input = {
+      name: "test",
+      model: "claude-3",
+    };
+
+    const result = JSON.parse(sanitizeConfigForTransfer(JSON.stringify(input)));
+
+    expect(result.name).toBe("test");
+    expect(result.model).toBe("claude-3");
+  });
+
+  test("handles empty object", () => {
+    const result = sanitizeConfigForTransfer("{}");
+    expect(JSON.parse(result)).toEqual({});
+  });
+
+  test("handles invalid JSON by returning original string", () => {
+    const malformed = "{ not valid json }}}";
+    const result = sanitizeConfigForTransfer(malformed);
+    expect(result).toBe(malformed);
+  });
+
+  test("handles JSON null by returning original string", () => {
+    const result = sanitizeConfigForTransfer("null");
+    expect(result).toBe("null");
+  });
+
+  test("handles JSON array by returning original string", () => {
+    const result = sanitizeConfigForTransfer("[1, 2, 3]");
+    expect(result).toBe("[1, 2, 3]");
+  });
+
+  test("output uses 2-space indentation with trailing newline", () => {
+    const input = { name: "test" };
+    const result = sanitizeConfigForTransfer(JSON.stringify(input));
+
+    expect(result).toBe(JSON.stringify(input, null, 2) + "\n");
+    expect(result.endsWith("\n")).toBe(true);
+  });
+});