@vellumai/assistant 0.4.56 → 0.5.0

package/src/__tests__/ratelimit.test.ts

@@ -38,7 +38,6 @@ describe("RateLimitProvider", () => {
     test("allows requests under the limit", async () => {
       const config: RateLimitConfig = {
         maxRequestsPerMinute: 5,
-        maxTokensPerSession: 0,
       };
       const provider = new RateLimitProvider(makeProvider(), config);
 
@@ -50,7 +49,6 @@ describe("RateLimitProvider", () => {
     test("throws RateLimitError when exceeding request limit", async () => {
       const config: RateLimitConfig = {
         maxRequestsPerMinute: 2,
-        maxTokensPerSession: 0,
       };
       const provider = new RateLimitProvider(makeProvider(), config);
 
@@ -63,7 +61,6 @@ describe("RateLimitProvider", () => {
     test("unlimited when maxRequestsPerMinute is 0", async () => {
       const config: RateLimitConfig = {
         maxRequestsPerMinute: 0,
-        maxTokensPerSession: 0,
       };
       const provider = new RateLimitProvider(makeProvider(), config);
 
@@ -73,56 +70,10 @@ describe("RateLimitProvider", () => {
     });
   });
 
-  describe("session token limiting", () => {
-    test("allows requests under the token budget", async () => {
-      const config: RateLimitConfig = {
-        maxRequestsPerMinute: 0,
-        maxTokensPerSession: 1000,
-      };
-      const provider = new RateLimitProvider(makeProvider(), config);
-
-      // Each call uses 150 tokens (100 input + 50 output)
-      for (let i = 0; i < 6; i++) {
-        await provider.sendMessage(messages);
-      }
-      // 6 * 150 = 900, still under 1000
-    });
-
-    test("throws RateLimitError when token budget exhausted", async () => {
-      const config: RateLimitConfig = {
-        maxRequestsPerMinute: 0,
-        maxTokensPerSession: 300,
-      };
-      const provider = new RateLimitProvider(makeProvider(), config);
-
-      // 150 tokens per call
-      await provider.sendMessage(messages); // 150
-      await provider.sendMessage(messages); // 300
-
-      expect(provider.sendMessage(messages)).rejects.toThrow(RateLimitError);
-    });
-
-    test("unlimited when maxTokensPerSession is 0", async () => {
-      const config: RateLimitConfig = {
-        maxRequestsPerMinute: 0,
-        maxTokensPerSession: 0,
-      };
-      const provider = new RateLimitProvider(
-        makeProvider({ usage: { inputTokens: 10000, outputTokens: 10000 } }),
-        config,
-      );
-
-      for (let i = 0; i < 10; i++) {
-        await provider.sendMessage(messages);
-      }
-    });
-  });
-
   describe("passthrough behavior", () => {
     test("delegates to inner provider", async () => {
       const config: RateLimitConfig = {
         maxRequestsPerMinute: 0,
-        maxTokensPerSession: 0,
       };
       const inner = makeProvider({ model: "custom-model" });
       const provider = new RateLimitProvider(inner, config);
@@ -134,7 +85,6 @@ describe("RateLimitProvider", () => {
     test("preserves provider name", () => {
       const config: RateLimitConfig = {
         maxRequestsPerMinute: 0,
-        maxTokensPerSession: 0,
       };
       const provider = new RateLimitProvider(makeProvider(), config);
       expect(provider.name).toBe("mock");
@@ -143,7 +93,6 @@ describe("RateLimitProvider", () => {
     test("passes through all arguments to inner provider", async () => {
       const config: RateLimitConfig = {
         maxRequestsPerMinute: 0,
-        maxTokensPerSession: 0,
       };
       let receivedArgs: unknown[] = [];
       const inner: Provider = {
@@ -173,27 +122,10 @@ describe("RateLimitProvider", () => {
     });
   });
 
-  describe("combined limits", () => {
-    test("enforces both limits simultaneously", async () => {
-      const config: RateLimitConfig = {
-        maxRequestsPerMinute: 10,
-        maxTokensPerSession: 300,
-      };
-      const provider = new RateLimitProvider(makeProvider(), config);
-
-      // Token limit should hit first (2 * 150 = 300)
-      await provider.sendMessage(messages);
-      await provider.sendMessage(messages);
-
-      expect(provider.sendMessage(messages)).rejects.toThrow(RateLimitError);
-    });
-  });
-
   describe("shared request timestamps", () => {
     test("multiple providers sharing timestamps enforce a global rate limit", async () => {
       const config: RateLimitConfig = {
         maxRequestsPerMinute: 2,
-        maxTokensPerSession: 0,
       };
       const shared: number[] = [];
       const provider1 = new RateLimitProvider(makeProvider(), config, shared);
@@ -215,7 +147,6 @@ describe("RateLimitProvider", () => {
     test("out-of-order timestamps are pruned correctly (clock skew)", async () => {
       const config: RateLimitConfig = {
         maxRequestsPerMinute: 3,
-        maxTokensPerSession: 0,
       };
       const shared: number[] = [];
       const provider = new RateLimitProvider(makeProvider(), config, shared);
@@ -236,7 +167,6 @@ describe("RateLimitProvider", () => {
     test("waitSec uses actual oldest timestamp under clock skew", async () => {
       const config: RateLimitConfig = {
         maxRequestsPerMinute: 2,
-        maxTokensPerSession: 0,
       };
       const shared: number[] = [];
       const provider = new RateLimitProvider(makeProvider(), config, shared);
@@ -266,7 +196,6 @@ describe("RateLimitProvider", () => {
       const highLimit = 200_000;
       const config: RateLimitConfig = {
         maxRequestsPerMinute: highLimit,
-        maxTokensPerSession: 0,
       };
       const shared: number[] = [];
       const provider = new RateLimitProvider(makeProvider(), config, shared);
@@ -286,7 +215,6 @@ describe("RateLimitProvider", () => {
     test("shared array reference survives pruning", async () => {
       const config: RateLimitConfig = {
         maxRequestsPerMinute: 100,
-        maxTokensPerSession: 0,
       };
       const shared: number[] = [];
       const provider1 = new RateLimitProvider(makeProvider(), config, shared);
@@ -311,7 +239,6 @@ describe("RateLimitProvider", () => {
     test("concurrent calls are rate-limited because timestamp is recorded before await", async () => {
       const config: RateLimitConfig = {
         maxRequestsPerMinute: 1,
-        maxTokensPerSession: 0,
       };
       // Slow provider that yields to the event loop
       const inner: Provider = {
@@ -343,7 +270,6 @@ describe("RateLimitProvider", () => {
     test("failed inner calls still count toward request rate", async () => {
       const config: RateLimitConfig = {
         maxRequestsPerMinute: 1,
-        maxTokensPerSession: 0,
       };
       const inner: Provider = {
         name: "failing",

package/src/__tests__/recording-handler.test.ts

@@ -24,7 +24,6 @@ mock.module("../config/loader.js", () => ({
     daemon: { standaloneRecording: true },
     provider: "mock-provider",
     permissions: { mode: "workspace" },
-    sandbox: { enabled: false },
     timeouts: { toolExecutionTimeoutSec: 30, permissionTimeoutSec: 5 },
     skills: { load: { extraDirs: [] } },
     secretDetection: { enabled: false, allowOneTimeSend: false },

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

@@ -52,7 +52,7 @@ const mockConfig = {
       network: "none" as const,
     },
   },
-  rateLimit: { maxRequestsPerMinute: 0, maxTokensPerSession: 0 },
+  rateLimit: { maxRequestsPerMinute: 0 },
   secretDetection: {
     enabled: false,
     action: "warn" as const,

package/src/__tests__/runtime-attachment-metadata.test.ts

@@ -43,7 +43,7 @@ mock.module("../config/loader.js", () => ({
     model: "test",
     provider: "test",
     memory: { enabled: false },
-    rateLimit: { maxRequestsPerMinute: 0, maxTokensPerSession: 0 },
+    rateLimit: { maxRequestsPerMinute: 0 },
   }),
 }));
 

package/src/__tests__/runtime-events-sse-parity.test.ts

@@ -50,7 +50,7 @@ mock.module("../config/loader.js", () => ({
     model: "test",
     provider: "test",
     memory: { enabled: false },
-    rateLimit: { maxRequestsPerMinute: 0, maxTokensPerSession: 0 },
+    rateLimit: { maxRequestsPerMinute: 0 },
     secretDetection: { enabled: false },
   }),
 }));

package/src/__tests__/runtime-events-sse.test.ts

@@ -42,7 +42,7 @@ mock.module("../config/loader.js", () => ({
     model: "test",
     provider: "test",
     memory: { enabled: false },
-    rateLimit: { maxRequestsPerMinute: 0, maxTokensPerSession: 0 },
+    rateLimit: { maxRequestsPerMinute: 0 },
     secretDetection: { enabled: false },
   }),
 }));

package/src/__tests__/scheduler-recurrence.test.ts

@@ -1,7 +1,15 @@
 import { mkdtempSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { afterAll, beforeEach, describe, expect, mock, test } from "bun:test";
+import {
+  afterAll,
+  beforeAll,
+  beforeEach,
+  describe,
+  expect,
+  mock,
+  test,
+} from "bun:test";
 
 const testDir = mkdtempSync(join(tmpdir(), "scheduler-recurrence-test-"));
 
@@ -86,7 +94,30 @@ function buildEndedRrule(): string {
 
 // ── RRULE schedule fires through the scheduler ──────────────────────
 
+// Replace setTimeout with a zero-delay version so the 500ms scheduler
+// wait calls fire instantly instead of waiting real time.
+let origSetTimeout: typeof globalThis.setTimeout;
+
 describe("scheduler RRULE execution", () => {
+  beforeAll(() => {
+    origSetTimeout = globalThis.setTimeout;
+    globalThis.setTimeout = ((
+      fn: TimerHandler,
+      _ms?: number,
+      ...args: unknown[]
+    ) => {
+      // Use a small real delay so fire-and-forget async ticks have time to
+      // settle, while still cutting the 500ms waits down dramatically.
+      // 200ms gives headroom for the run_task path which does a dynamic
+      // import of task-runner.js on first invocation.
+      return origSetTimeout(fn, 200, ...args);
+    }) as typeof setTimeout;
+  });
+
+  afterAll(() => {
+    globalThis.setTimeout = origSetTimeout;
+  });
+
   beforeEach(() => {
     const db = getDb();
     db.run("DELETE FROM cron_runs");
@@ -157,8 +188,11 @@ describe("scheduler RRULE execution", () => {
     forceScheduleDue(schedule.id);
 
     const directCalls: { conversationId: string; message: string }[] = [];
+    let onMessage: (() => void) | undefined;
+    const messageReceived = new Promise<void>((r) => (onMessage = r));
     const processMessage = async (conversationId: string, message: string) => {
       directCalls.push({ conversationId, message });
+      onMessage?.();
     };
 
     const scheduler = startScheduler(
@@ -166,7 +200,17 @@ describe("scheduler RRULE execution", () => {
       () => {},
       () => {},
     );
-    await new Promise((resolve) => setTimeout(resolve, 500));
+    // The run_task path involves a dynamic import which can take >50ms in CI,
+    // exceeding the patched setTimeout delay. Await the actual callback instead
+    // of relying on a fixed timeout.
+    await Promise.race([
+      messageReceived,
+      new Promise((r) => origSetTimeout(r, 2000)),
+    ]);
+    // Yield to the macrotask queue so all pending microtasks settle —
+    // the scheduler tick still needs to create the schedule run after
+    // processMessage returns.
+    await new Promise((r) => origSetTimeout(r, 0));
     scheduler.stop();
 
     // runTask renders the template, so processMessage gets the template text

package/src/__tests__/schema-transforms.test.ts

@@ -2,8 +2,8 @@ import { describe, expect, test } from "bun:test";
 
 import type { ToolDefinition } from "../providers/types.js";
 import {
-  injectReasonField,
-  REASON_SKIP_SET,
+  ACTIVITY_SKIP_SET,
+  injectActivityField,
   schemaDefinesProperty,
 } from "../tools/schema-transforms.js";
 
@@ -14,26 +14,26 @@ function makeDef(
   return { name, description: `Tool ${name}`, input_schema: schema };
 }
 
-describe("REASON_SKIP_SET", () => {
-  test("contains expected tool names", () => {
-    expect(REASON_SKIP_SET.has("skill_execute")).toBe(true);
-    expect(REASON_SKIP_SET.has("bash")).toBe(true);
-    expect(REASON_SKIP_SET.has("host_bash")).toBe(true);
-    expect(REASON_SKIP_SET.has("request_system_permission")).toBe(true);
-    expect(REASON_SKIP_SET.size).toBe(4);
+describe("ACTIVITY_SKIP_SET", () => {
+  test("is empty (all tools now define their own activity property)", () => {
+    expect(ACTIVITY_SKIP_SET.size).toBe(0);
   });
 });
 
-describe("injectReasonField", () => {
-  test("injects reason on a tool without it", () => {
+describe("injectActivityField", () => {
+  test("injects activity on a tool without it", () => {
     const defs = [makeDef("my_tool")];
-    const result = injectReasonField(defs);
+    const result = injectActivityField(defs);
     const schema = result[0].input_schema as Record<string, unknown>;
     const props = schema.properties as Record<string, unknown>;
-    expect(props.reason).toEqual({ type: "string" });
+    expect(props.activity).toEqual({
+      type: "string",
+      description:
+        "Brief, natural description of what you're doing, shown as a live status update (e.g. 'Checking your project settings')",
+    });
   });
 
-  test("adds reason to required array", () => {
+  test("adds activity to required array", () => {
     const defs = [
       makeDef("my_tool", {
         type: "object",
@@ -41,9 +41,9 @@ describe("injectReasonField", () => {
         required: ["foo"],
       }),
     ];
-    const result = injectReasonField(defs);
+    const result = injectActivityField(defs);
     const schema = result[0].input_schema as Record<string, unknown>;
-    expect(schema.required).toEqual(["foo", "reason"]);
+    expect(schema.required).toEqual(["foo", "activity"]);
   });
 
   test("creates required array if missing", () => {
@@ -53,38 +53,38 @@ describe("injectReasonField", () => {
         properties: { foo: { type: "string" } },
       }),
     ];
-    const result = injectReasonField(defs);
+    const result = injectActivityField(defs);
     const schema = result[0].input_schema as Record<string, unknown>;
-    expect(schema.required).toEqual(["reason"]);
+    expect(schema.required).toEqual(["activity"]);
   });
 
   test("skips tools in skip set (returns unchanged)", () => {
     const defs = [makeDef("bash"), makeDef("host_bash")];
-    const result = injectReasonField(defs);
+    const result = injectActivityField(defs, new Set(["bash", "host_bash"]));
     // Should be the exact same object references
     expect(Object.is(result[0], defs[0])).toBe(true);
     expect(Object.is(result[1], defs[1])).toBe(true);
-    // No reason injected
+    // No activity injected
     const schema0 = result[0].input_schema as Record<string, unknown>;
     const props0 = schema0.properties as Record<string, unknown>;
-    expect("reason" in props0).toBe(false);
+    expect("activity" in props0).toBe(false);
   });
 
-  test("skips tools that already have reason in properties", () => {
+  test("skips tools that already have activity in properties", () => {
     const defs = [
       makeDef("my_tool", {
         type: "object",
-        properties: { reason: { type: "number" } },
+        properties: { activity: { type: "number" } },
         required: [],
       }),
     ];
-    const result = injectReasonField(defs);
+    const result = injectActivityField(defs);
     // Should be the exact same object reference (no clone needed)
     expect(Object.is(result[0], defs[0])).toBe(true);
     const schema = result[0].input_schema as Record<string, unknown>;
     const props = schema.properties as Record<string, unknown>;
-    // Original reason type preserved
-    expect(props.reason).toEqual({ type: "number" });
+    // Original activity type preserved
+    expect(props.activity).toEqual({ type: "number" });
   });
 
   test("does NOT mutate original definition objects", () => {
@@ -97,10 +97,10 @@ describe("injectReasonField", () => {
     };
     const defs = [makeDef("my_tool", originalSchema)];
 
-    const result = injectReasonField(defs);
+    const result = injectActivityField(defs);
 
     // Original properties object is untouched
-    expect("reason" in originalProps).toBe(false);
+    expect("activity" in originalProps).toBe(false);
     // Original required array is untouched
     expect(originalRequired).toEqual(["foo"]);
     // Original schema properties ref is the same object
@@ -115,40 +115,40 @@ describe("injectReasonField", () => {
 
   test("passes through non-object schemas unchanged", () => {
     const defs = [makeDef("my_tool", { type: "string" })];
-    const result = injectReasonField(defs);
+    const result = injectActivityField(defs);
     expect(Object.is(result[0], defs[0])).toBe(true);
   });
 
   test("passes through schemas without properties unchanged", () => {
     const defs = [makeDef("my_tool", { type: "object" })];
-    const result = injectReasonField(defs);
+    const result = injectActivityField(defs);
     expect(Object.is(result[0], defs[0])).toBe(true);
   });
 
-  test("skips tools with reason defined inside allOf member (composite schema)", () => {
+  test("skips tools with activity defined inside allOf member (composite schema)", () => {
     const defs = [
       makeDef("my_tool", {
         type: "object",
         properties: { foo: { type: "string" } },
         allOf: [
           {
-            properties: { reason: { type: "string" } },
+            properties: { activity: { type: "string" } },
           },
         ],
         required: [],
       }),
     ];
-    const result = injectReasonField(defs);
+    const result = injectActivityField(defs);
     // Should be the exact same object reference (no injection)
     expect(Object.is(result[0], defs[0])).toBe(true);
     const schema = result[0].input_schema as Record<string, unknown>;
     const props = schema.properties as Record<string, unknown>;
-    // Top-level properties should NOT have reason injected
-    expect("reason" in props).toBe(false);
+    // Top-level properties should NOT have activity injected
+    expect("activity" in props).toBe(false);
   });
 
   test("handles empty definitions array", () => {
-    const result = injectReasonField([]);
+    const result = injectActivityField([]);
     expect(result).toEqual([]);
   });
 });
@@ -157,44 +157,44 @@ describe("schemaDefinesProperty", () => {
   test("returns true for direct properties match", () => {
     const schema = {
       type: "object",
-      properties: { reason: { type: "string" } },
+      properties: { activity: { type: "string" } },
     };
-    expect(schemaDefinesProperty(schema, "reason")).toBe(true);
+    expect(schemaDefinesProperty(schema, "activity")).toBe(true);
   });
 
   test("returns true for property in allOf member", () => {
     const schema = {
-      allOf: [{ properties: { reason: { type: "string" } } }],
+      allOf: [{ properties: { activity: { type: "string" } } }],
     };
-    expect(schemaDefinesProperty(schema, "reason")).toBe(true);
+    expect(schemaDefinesProperty(schema, "activity")).toBe(true);
   });
 
   test("returns true for property in oneOf member", () => {
     const schema = {
       oneOf: [
         { properties: { foo: { type: "string" } } },
-        { properties: { reason: { type: "string" } } },
+        { properties: { activity: { type: "string" } } },
       ],
     };
-    expect(schemaDefinesProperty(schema, "reason")).toBe(true);
+    expect(schemaDefinesProperty(schema, "activity")).toBe(true);
   });
 
   test("returns true for property in anyOf member", () => {
     const schema = {
-      anyOf: [{ properties: { reason: { type: "string" } } }],
+      anyOf: [{ properties: { activity: { type: "string" } } }],
     };
-    expect(schemaDefinesProperty(schema, "reason")).toBe(true);
+    expect(schemaDefinesProperty(schema, "activity")).toBe(true);
   });
 
   test("returns true for nested allOf within oneOf", () => {
     const schema = {
       oneOf: [
         {
-          allOf: [{ properties: { reason: { type: "string" } } }],
+          allOf: [{ properties: { activity: { type: "string" } } }],
         },
       ],
     };
-    expect(schemaDefinesProperty(schema, "reason")).toBe(true);
+    expect(schemaDefinesProperty(schema, "activity")).toBe(true);
   });
 
   test("returns false when property not defined", () => {
@@ -202,25 +202,85 @@ describe("schemaDefinesProperty", () => {
       type: "object",
       properties: { foo: { type: "string" } },
     };
-    expect(schemaDefinesProperty(schema, "reason")).toBe(false);
+    expect(schemaDefinesProperty(schema, "activity")).toBe(false);
   });
 
-  test("returns false for $ref (fail-closed)", () => {
+  test("returns false for $ref with default behavior (fail-closed)", () => {
     const schema = { $ref: "#/definitions/Foo" };
-    expect(schemaDefinesProperty(schema, "reason")).toBe(false);
+    expect(schemaDefinesProperty(schema, "activity")).toBe(false);
+  });
+
+  test("returns true for $ref with assume-defined behavior (fail-open)", () => {
+    const schema = { $ref: "#/definitions/Foo" };
+    expect(
+      schemaDefinesProperty(schema, "activity", {
+        refBehavior: "assume-defined",
+      }),
+    ).toBe(true);
+  });
+
+  test("returns true for $ref nested in allOf with assume-defined refBehavior", () => {
+    const schema = {
+      allOf: [{ $ref: "#/definitions/Foo" }],
+    };
+    expect(
+      schemaDefinesProperty(schema, "activity", {
+        refBehavior: "assume-defined",
+      }),
+    ).toBe(true);
+  });
+
+  test("returns false for $ref nested in allOf with assume-undefined refBehavior", () => {
+    const schema = {
+      allOf: [{ $ref: "#/definitions/Foo" }],
+    };
+    expect(
+      schemaDefinesProperty(schema, "activity", {
+        refBehavior: "assume-undefined",
+      }),
+    ).toBe(false);
+  });
+
+  test("returns true for $ref nested in oneOf with assume-defined refBehavior", () => {
+    const schema = {
+      oneOf: [{ $ref: "#/definitions/Foo" }],
+    };
+    expect(
+      schemaDefinesProperty(schema, "activity", {
+        refBehavior: "assume-defined",
+      }),
+    ).toBe(true);
+  });
+
+  test("returns true for $ref nested in anyOf with assume-defined refBehavior", () => {
+    const schema = {
+      anyOf: [{ $ref: "#/definitions/Foo" }],
+    };
+    expect(
+      schemaDefinesProperty(schema, "activity", {
+        refBehavior: "assume-defined",
+      }),
+    ).toBe(true);
+  });
+
+  test("returns false for $ref nested in allOf with default refBehavior (fail-closed)", () => {
+    const schema = {
+      allOf: [{ $ref: "#/definitions/Foo" }],
+    };
+    expect(schemaDefinesProperty(schema, "activity")).toBe(false);
   });
 
   test("returns false for null schema", () => {
-    expect(schemaDefinesProperty(null, "reason")).toBe(false);
+    expect(schemaDefinesProperty(null, "activity")).toBe(false);
   });
 
   test("returns false for undefined schema", () => {
-    expect(schemaDefinesProperty(undefined, "reason")).toBe(false);
+    expect(schemaDefinesProperty(undefined, "activity")).toBe(false);
   });
 
   test("returns false for non-object schema", () => {
-    expect(schemaDefinesProperty("not-an-object", "reason")).toBe(false);
-    expect(schemaDefinesProperty(42, "reason")).toBe(false);
-    expect(schemaDefinesProperty(true, "reason")).toBe(false);
+    expect(schemaDefinesProperty("not-an-object", "activity")).toBe(false);
+    expect(schemaDefinesProperty(42, "activity")).toBe(false);
+    expect(schemaDefinesProperty(true, "activity")).toBe(false);
   });
 });

package/src/__tests__/secret-onetime-send.test.ts

@@ -14,9 +14,29 @@ const mockConfig = {
   timeouts: { permissionTimeoutSec: 300 },
 };
 
+function setMockNestedValue(
+  obj: Record<string, unknown>,
+  path: string,
+  value: unknown,
+): void {
+  const keys = path.split(".");
+  let current = obj;
+  for (let i = 0; i < keys.length - 1; i++) {
+    const key = keys[i];
+    if (current[key] == null || typeof current[key] !== "object") {
+      current[key] = {};
+    }
+    current = current[key] as Record<string, unknown>;
+  }
+  current[keys[keys.length - 1]] = value;
+}
+
 mock.module("../config/loader.js", () => ({
   getConfig: () => mockConfig,
   loadConfig: () => mockConfig,
+  loadRawConfig: () => ({}),
+  saveRawConfig: () => {},
+  setNestedValue: setMockNestedValue,
   invalidateConfigCache: () => {},
 }));
 

package/src/__tests__/secret-routes-managed-proxy.test.ts

@@ -24,9 +24,12 @@ const mockConfig = {
     "image-generation": {
       mode: "your-own" as const,
       provider: "gemini",
-      model: "gemini-2.5-flash-image",
+      model: "gemini-3.1-flash-image-preview",
+    },
+    "web-search": {
+      mode: "your-own" as const,
+      provider: "inference-provider-native",
     },
-    "web-search": { mode: "your-own" as const, provider: "anthropic-native" },
   },
 };
 

package/src/__tests__/secret-scanner-executor.test.ts

@@ -20,8 +20,7 @@ const mockConfig = {
     shellMaxTimeoutSec: 600,
     permissionTimeoutSec: 300,
   },
-  sandbox: { enabled: false },
-  rateLimit: { maxRequestsPerMinute: 0, maxTokensPerSession: 0 },
+  rateLimit: { maxRequestsPerMinute: 0 },
   secretDetection: {
     enabled: true,
     action: "warn" as "redact" | "warn" | "block",