@vellumai/assistant 0.4.56 → 0.5.0

package/src/__tests__/checker.test.ts

@@ -201,18 +201,18 @@ describe("Permission Checker", () => {
       });
     });
 
-    // file_write is always medium
+    // file_write is always low (sandboxed)
     describe("file_write", () => {
-      test("file_write is always medium risk", async () => {
+      test("file_write is always low risk", async () => {
         const risk = await classifyRisk("file_write", {
           path: "/tmp/file.txt",
         });
-        expect(risk).toBe(RiskLevel.Medium);
+        expect(risk).toBe(RiskLevel.Low);
       });
 
-      test("file_write with any path is medium risk", async () => {
+      test("file_write with any path is low risk", async () => {
         const risk = await classifyRisk("file_write", { path: "/etc/passwd" });
-        expect(risk).toBe(RiskLevel.Medium);
+        expect(risk).toBe(RiskLevel.Low);
       });
     });
 
@@ -673,23 +673,22 @@ describe("Permission Checker", () => {
       expect(result.decision).toBe("allow");
     });
 
-    test("file_write within workspace with no rule → prompt (medium risk bypasses workspace auto-allow)", async () => {
+    test("file_write → auto-allow (workspace-scoped)", async () => {
       const result = await check(
         "file_write",
         { path: "/tmp/file.txt" },
         "/tmp",
       );
-      expect(result.decision).toBe("prompt");
-      expect(result.reason).toContain("medium risk");
+      expect(result.decision).toBe("allow");
     });
 
-    test("file_write outside workspace with no rule → prompt", async () => {
+    test("file_write outside workspace → auto-allow (Low risk)", async () => {
       const result = await check(
         "file_write",
         { path: "/etc/some-file.txt" },
         "/tmp",
       );
-      expect(result.decision).toBe("prompt");
+      expect(result.decision).toBe("allow");
     });
 
     test("file_write with matching rule → allow", async () => {
@@ -1486,12 +1485,12 @@ describe("Permission Checker", () => {
       expect(result.matchedRule!.id).toBe("default:allow-file_edit-updates");
     });
 
-    test("file_write of non-workspace file is not auto-allowed", async () => {
+    test("file_write of non-workspace file is auto-allowed (Low risk)", async () => {
       const otherPath = join(checkerTestDir, "workspace", "OTHER.md");
       // Use a workingDir that doesn't contain the path so it's not workspace-scoped
       const result = await check("file_write", { path: otherPath }, "/home");
-      // Medium risk with no matching allow rule → prompt
-      expect(result.decision).toBe("prompt");
+      // Low risk → auto-allowed even outside workspace
+      expect(result.decision).toBe("allow");
     });
   });
 
@@ -2096,16 +2095,16 @@ describe("Permission Checker", () => {
       expect(risk).toBe(RiskLevel.High);
     });
 
-    test("file_write to non-skill path remains Medium risk", async () => {
+    test("file_write to non-skill path is Low risk", async () => {
       const normalPath = "/tmp/some-file.txt";
       const risk = await classifyRisk("file_write", { path: normalPath });
-      expect(risk).toBe(RiskLevel.Medium);
+      expect(risk).toBe(RiskLevel.Low);
     });
 
-    test("file_edit of non-skill path remains Medium risk", async () => {
+    test("file_edit of non-skill path is Low risk", async () => {
       const normalPath = "/tmp/some-file.txt";
       const risk = await classifyRisk("file_edit", { path: normalPath });
-      expect(risk).toBe(RiskLevel.Medium);
+      expect(risk).toBe(RiskLevel.Low);
     });
 
     test("host_file_write to non-skill path remains Medium risk (via registry)", async () => {
@@ -2557,12 +2556,12 @@ describe("Permission Checker", () => {
         expect(result.reason).toContain("requires approval");
       });
 
-      test("strict mode: file_write to non-skill path prompts as Strict mode (not High risk)", async () => {
+      test("strict mode: file_write to non-skill path prompts as Strict mode", async () => {
         testConfig.permissions.mode = "strict";
         const normalPath = "/tmp/some-file.txt";
         const result = await check("file_write", { path: normalPath }, "/tmp");
         expect(result.decision).toBe("prompt");
-        // Medium-risk file_write in strict mode with no rule → Strict mode reason
+        // Low-risk file_write in strict mode with no rule → Strict mode reason
         expect(result.reason).toContain("Strict mode");
       });
 
@@ -2865,7 +2864,7 @@ describe("Permission Checker", () => {
       const symlinkedFile = join(symDir, "config.json");
       const realFileResolved = join(realDirResolved, "config.json");
 
-      // file_write is Medium risk — needs a matching rule to allow.
+      // file_write is Low risk — but add a rule to verify symlink path matching.
       addRule("file_write", `file_write:${realFileResolved}`, "everywhere");
       const result = await check(
         "file_write",
@@ -3597,7 +3596,7 @@ describe("Permission Checker", () => {
         expect(result.matchedRule!.pattern).toBe("skill_load:*");
       });
 
-      test("medium-risk file_write with no rule prompts in strict mode", async () => {
+      test("low-risk file_write with no rule prompts in strict mode", async () => {
         testConfig.permissions.mode = "strict";
         const result = await check(
           "file_write",
@@ -3996,14 +3995,14 @@ describe("Permission Checker", () => {
     );
 
     test(
-      "file_write to non-extra dir remains Medium when extra dirs are configured",
+      "file_write to non-extra dir remains Low when extra dirs are configured",
       withExtraDirs(async () => {
         const risk = await classifyRisk(
           "file_write",
           { path: "/tmp/unrelated.txt" },
           "/tmp",
         );
-        expect(risk).toBe(RiskLevel.Medium);
+        expect(risk).toBe(RiskLevel.Low);
       }),
     );
 
@@ -4583,24 +4582,24 @@ describe("workspace mode — auto-allow workspace-scoped operations", () => {
     expect(result.reason).toContain("Workspace mode");
   });
 
-  test("file_write within workspace → prompt (Medium risk bypasses workspace auto-allow)", async () => {
+  test("file_write within workspace → allow (workspace-scoped)", async () => {
     const result = await check(
       "file_write",
       { file_path: "/home/user/my-project/src/index.ts" },
       workspaceDir,
     );
-    expect(result.decision).toBe("prompt");
-    expect(result.reason).toContain("medium risk");
+    expect(result.decision).toBe("allow");
+    expect(result.reason).toContain("Workspace mode");
   });
 
-  test("file_edit within workspace → prompt (Medium risk bypasses workspace auto-allow)", async () => {
+  test("file_edit within workspace → allow (workspace-scoped)", async () => {
     const result = await check(
       "file_edit",
       { file_path: "/home/user/my-project/src/index.ts" },
       workspaceDir,
     );
-    expect(result.decision).toBe("prompt");
-    expect(result.reason).toContain("medium risk");
+    expect(result.decision).toBe("allow");
+    expect(result.reason).toContain("Workspace mode");
   });
 
   // ── file operations outside workspace follow risk-based fallback ──
@@ -4615,14 +4614,14 @@ describe("workspace mode — auto-allow workspace-scoped operations", () => {
     expect(result.reason).toContain("Low risk");
   });
 
-  test("file_write outside workspace → prompt (Medium risk fallback)", async () => {
+  test("file_write outside workspace → allow (Low risk fallback)", async () => {
     const result = await check(
       "file_write",
       { file_path: "/tmp/outside.txt" },
       workspaceDir,
     );
-    expect(result.decision).toBe("prompt");
-    expect(result.reason).toContain("risk");
+    expect(result.decision).toBe("allow");
+    expect(result.reason).toContain("Low risk");
   });
 
   // ── bash (sandbox) — default rule matches, workspace mode not reached ──

package/src/__tests__/chrome-cdp.test.ts

@@ -145,21 +145,37 @@ describe("ensureChromeWithCdp", () => {
       throw new Error("Connection refused");
     };
 
-    const session = await ensureChromeWithCdp({
-      startUrl: "https://example.com/",
-    });
-    expect(session.launchedByUs).toBe(true);
-    expect(session.baseUrl).toBe("http://localhost:9222");
-    expect(spawnMock).toHaveBeenCalledTimes(1);
-
-    // Verify spawn was called with the right Chrome path and args
-    const spawnArgs = spawnMock.mock.calls[0] as unknown as [string, string[]];
-    expect(spawnArgs[0]).toContain("Google Chrome");
-    const flags = spawnArgs[1];
-    expect(flags).toContain("--remote-debugging-port=9222");
-    expect(flags).toContain("--force-renderer-accessibility");
-    expect(flags.some((f: string) => f.includes("Chrome-CDP"))).toBe(true);
-    expect(flags).toContain("https://example.com/");
+    // Replace setTimeout with a zero-delay version to skip retry waits
+    const origSetTimeout = globalThis.setTimeout;
+    globalThis.setTimeout = ((
+      fn: TimerHandler,
+      _ms?: number,
+      ...args: unknown[]
+    ) => {
+      return origSetTimeout(fn, 0, ...args);
+    }) as typeof setTimeout;
+    try {
+      const session = await ensureChromeWithCdp({
+        startUrl: "https://example.com/",
+      });
+      expect(session.launchedByUs).toBe(true);
+      expect(session.baseUrl).toBe("http://localhost:9222");
+      expect(spawnMock).toHaveBeenCalledTimes(1);
+
+      // Verify spawn was called with the right Chrome path and args
+      const spawnArgs = spawnMock.mock.calls[0] as unknown as [
+        string,
+        string[],
+      ];
+      expect(spawnArgs[0]).toContain("Google Chrome");
+      const flags = spawnArgs[1];
+      expect(flags).toContain("--remote-debugging-port=9222");
+      expect(flags).toContain("--force-renderer-accessibility");
+      expect(flags.some((f: string) => f.includes("Chrome-CDP"))).toBe(true);
+      expect(flags).toContain("https://example.com/");
+    } finally {
+      globalThis.setTimeout = origSetTimeout;
+    }
   });
 
   test("uses custom port when specified", async () => {
@@ -182,9 +198,22 @@ describe("ensureChromeWithCdp", () => {
       throw new Error("Connection refused");
     };
 
-    const promise = ensureChromeWithCdp();
-    await expect(promise).rejects.toThrow("CDP endpoint not responding");
-  }, 20_000);
+    // Replace setTimeout with a zero-delay version to skip retry waits
+    const origSetTimeout = globalThis.setTimeout;
+    globalThis.setTimeout = ((
+      fn: TimerHandler,
+      _ms?: number,
+      ...args: unknown[]
+    ) => {
+      return origSetTimeout(fn, 0, ...args);
+    }) as typeof setTimeout;
+    try {
+      const promise = ensureChromeWithCdp();
+      await expect(promise).rejects.toThrow("CDP endpoint not responding");
+    } finally {
+      globalThis.setTimeout = origSetTimeout;
+    }
+  });
 });
 
 // ---------------------------------------------------------------------------

package/src/__tests__/claude-code-skill-regression.test.ts

@@ -38,9 +38,9 @@ mock.module("../config/loader.js", () => ({
       "image-generation": {
         mode: "your-own",
         provider: "gemini",
-        model: "gemini-2.5-flash-image",
+        model: "gemini-3.1-flash-image-preview",
       },
-      "web-search": { mode: "your-own", provider: "anthropic-native" },
+      "web-search": { mode: "your-own", provider: "inference-provider-native" },
     },
   }),
   loadConfig: () => ({}),

package/src/__tests__/config-schema-cmd.test.ts

@@ -76,9 +76,9 @@ mock.module("../config/loader.js", () => ({
       "image-generation": {
         mode: "your-own",
         provider: "gemini",
-        model: "gemini-2.5-flash-image",
+        model: "gemini-3.1-flash-image-preview",
       },
-      "web-search": { mode: "your-own", provider: "anthropic-native" },
+      "web-search": { mode: "your-own", provider: "inference-provider-native" },
     },
   }),
   loadConfig: () => ({}),

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

@@ -93,10 +93,12 @@ describe("AssistantConfigSchema", () => {
     expect(result.services.inference.mode).toBe("your-own");
     expect(result.services["image-generation"].provider).toBe("gemini");
     expect(result.services["image-generation"].model).toBe(
-      "gemini-2.5-flash-image",
+      "gemini-3.1-flash-image-preview",
     );
     expect(result.services["image-generation"].mode).toBe("your-own");
-    expect(result.services["web-search"].provider).toBe("anthropic-native");
+    expect(result.services["web-search"].provider).toBe(
+      "inference-provider-native",
+    );
     expect(result.services["web-search"].mode).toBe("your-own");
     expect(result.maxTokens).toBe(16000);
     expect(result.thinking).toEqual({
@@ -125,11 +127,10 @@ describe("AssistantConfigSchema", () => {
       providerStreamTimeoutSec: 300,
     });
     expect(result.sandbox).toEqual({
-      enabled: true,
+      enabled: false,
     });
     expect(result.rateLimit).toEqual({
       maxRequestsPerMinute: 0,
-      maxTokensPerSession: 0,
     });
     expect(result.secretDetection).toEqual({
       enabled: true,
@@ -153,8 +154,7 @@ describe("AssistantConfigSchema", () => {
         shellMaxTimeoutSec: 300,
         permissionTimeoutSec: 60,
       },
-      sandbox: { enabled: true },
-      rateLimit: { maxRequestsPerMinute: 10, maxTokensPerSession: 100000 },
+      rateLimit: { maxRequestsPerMinute: 10 },
       secretDetection: {
         enabled: false,
         action: "block" as const,
@@ -351,13 +351,6 @@ describe("AssistantConfigSchema", () => {
     expect(result.success).toBe(false);
   });
 
-  test("rejects non-integer rateLimit values", () => {
-    const result = AssistantConfigSchema.safeParse({
-      rateLimit: { maxTokensPerSession: 3.5 },
-    });
-    expect(result.success).toBe(false);
-  });
-
   test("rejects negative auditLog.retentionDays", () => {
     const result = AssistantConfigSchema.safeParse({
       auditLog: { retentionDays: -7 },
@@ -376,11 +369,10 @@ describe("AssistantConfigSchema", () => {
 
   test("accepts zero for non-negative fields", () => {
     const result = AssistantConfigSchema.parse({
-      rateLimit: { maxRequestsPerMinute: 0, maxTokensPerSession: 0 },
+      rateLimit: { maxRequestsPerMinute: 0 },
       auditLog: { retentionDays: 0 },
     });
     expect(result.rateLimit.maxRequestsPerMinute).toBe(0);
-    expect(result.rateLimit.maxTokensPerSession).toBe(0);
     expect(result.auditLog.retentionDays).toBe(0);
   });
 
@@ -1105,7 +1097,7 @@ describe("loadConfig with schema validation", () => {
   test("falls back for invalid sandbox.enabled", () => {
     writeConfig({ sandbox: { enabled: "yes" } });
     const config = loadConfig();
-    expect(config.sandbox.enabled).toBe(true);
+    expect(config.sandbox.enabled).toBe(false);
   });
 
   test("loads sandbox with only enabled field", () => {
@@ -1132,11 +1124,10 @@ describe("loadConfig with schema validation", () => {
 
   test("falls back for invalid rateLimit values", () => {
     writeConfig({
-      rateLimit: { maxRequestsPerMinute: -1, maxTokensPerSession: 3.5 },
+      rateLimit: { maxRequestsPerMinute: -1 },
     });
     const config = loadConfig();
     expect(config.rateLimit.maxRequestsPerMinute).toBe(0);
-    expect(config.rateLimit.maxTokensPerSession).toBe(0);
   });
 
   test("falls back for invalid auditLog.retentionDays", () => {

package/src/__tests__/confirmation-request-guardian-bridge.test.ts

@@ -175,7 +175,7 @@ describe("bridgeConfirmationRequestToGuardian", () => {
     expect(emittedSignals).toHaveLength(1);
     expect(emittedSignals[0].sourceEventName).toBe("guardian.question");
     expect(emittedSignals[0].sourceChannel).toBe("telegram");
-    expect(emittedSignals[0].sourceSessionId).toBe("conv-1");
+    expect(emittedSignals[0].sourceContextId).toBe("conv-1");
 
     const payload = emittedSignals[0].contextPayload as Record<string, unknown>;
     expect(payload.requestId).toBe(canonicalRequest.id);

package/src/__tests__/conversation-abort-tool-results.test.ts

@@ -47,7 +47,7 @@ mock.module("../config/loader.js", () => ({
         nonInteractiveLatestTurnCompression: "truncate",
       },
     },
-    rateLimit: { maxRequestsPerMinute: 0, maxTokensPerSession: 0 },
+    rateLimit: { maxRequestsPerMinute: 0 },
     daemon: {
       startupSocketWaitMs: 5000,
       stopTimeoutMs: 5000,
@@ -64,9 +64,9 @@ mock.module("../config/loader.js", () => ({
       "image-generation": {
         mode: "your-own",
         provider: "gemini",
-        model: "gemini-2.5-flash-image",
+        model: "gemini-3.1-flash-image-preview",
       },
-      "web-search": { mode: "your-own", provider: "anthropic-native" },
+      "web-search": { mode: "your-own", provider: "inference-provider-native" },
     },
   }),
   loadRawConfig: () => ({}),
@@ -133,7 +133,7 @@ mock.module("../memory/retriever.js", () => ({
     injectedTokens: 0,
     latencyMs: 0,
   }),
-  stripMemoryRecallMessages: (msgs: Message[]) => msgs,
+  injectMemoryRecallAsUserBlock: (msgs: Message[]) => msgs,
 }));
 
 mock.module("../context/window-manager.js", () => ({

package/src/__tests__/conversation-agent-loop-overflow.test.ts

@@ -50,7 +50,7 @@ mock.module("../config/loader.js", () => ({
         nonInteractiveLatestTurnCompression: "truncate",
       },
     },
-    rateLimit: { maxRequestsPerMinute: 0, maxTokensPerSession: 0 },
+    rateLimit: { maxRequestsPerMinute: 0 },
     workspaceGit: { turnCommitMaxWaitMs: 10 },
     ui: {},
   }),
@@ -171,7 +171,7 @@ mock.module("../memory/retriever.js", () => ({
     injectedTokens: 0,
     latencyMs: 0,
   }),
-  stripMemoryRecallMessages: (msgs: Message[]) => msgs,
+  injectMemoryRecallAsUserBlock: (msgs: Message[]) => msgs,
 }));
 
 mock.module("../memory/app-store.js", () => ({

package/src/__tests__/conversation-agent-loop.test.ts

@@ -38,7 +38,7 @@ mock.module("../config/loader.js", () => ({
         nonInteractiveLatestTurnCompression: "truncate",
       },
     },
-    rateLimit: { maxRequestsPerMinute: 0, maxTokensPerSession: 0 },
+    rateLimit: { maxRequestsPerMinute: 0 },
     workspaceGit: { turnCommitMaxWaitMs: 10 },
     ui: {},
   }),
@@ -154,7 +154,7 @@ mock.module("../memory/retriever.js", () => ({
     injectedTokens: 0,
     latencyMs: 0,
   }),
-  stripMemoryRecallMessages: (msgs: Message[]) => msgs,
+  injectMemoryRecallAsUserBlock: (msgs: Message[]) => msgs,
 }));
 
 mock.module("../memory/app-store.js", () => ({
@@ -1834,11 +1834,18 @@ describe("session-agent-loop", () => {
       const ctx = makeCtx({ agentLoopRun });
       await runAgentLoopImpl(ctx, "hello", "msg-1", (msg) => events.push(msg));
 
-      // The providerErrorUserMessage should trigger a synthesized assistant_text_delta
+      // The error should be sent as a conversation_error (not as an
+      // assistant_text_delta, which would cause duplicate text rendering
+      // alongside the InlineChatErrorAlert card).
       const textDeltas = events.filter(
         (e) => e.type === "assistant_text_delta",
       );
-      expect(textDeltas.length).toBeGreaterThanOrEqual(1);
+      expect(textDeltas).toHaveLength(0);
+
+      const conversationErrors = events.filter(
+        (e) => e.type === "conversation_error",
+      );
+      expect(conversationErrors.length).toBeGreaterThanOrEqual(1);
     });
   });
 });

package/src/__tests__/conversation-attachments.test.ts

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

package/src/__tests__/conversation-confirmation-signals.test.ts

@@ -78,7 +78,7 @@ mock.module("../config/loader.js", () => ({
       summaryModel: "mock-model",
       maxSummaryTokens: 512,
     },
-    rateLimit: { maxRequestsPerMinute: 0, maxTokensPerSession: 0 },
+    rateLimit: { maxRequestsPerMinute: 0 },
     timeouts: { permissionTimeoutSec: 1 },
     skills: { entries: {}, allowBundled: true },
     permissions: { mode: "workspace" },
@@ -158,7 +158,7 @@ mock.module("../memory/retriever.js", () => ({
     injectedTokens: 0,
     latencyMs: 0,
   }),
-  stripMemoryRecallMessages: (msgs: Message[]) => msgs,
+  injectMemoryRecallAsUserBlock: (msgs: Message[]) => msgs,
 }));
 
 mock.module("../context/window-manager.js", () => ({

package/src/__tests__/conversation-error.test.ts

@@ -66,6 +66,8 @@ describe("classifyConversationError", () => {
       "ETIMEDOUT",
       "ENOTFOUND",
       "socket hang up",
+      "The socket connection was closed unexpectedly",
+      "Anthropic request failed: The socket connection was closed unexpectedly. For more information, pass `verbose: true` in the second argument to fetch()",
       "fetch failed",
       "Connection refused by server",
       "connection reset",
@@ -276,6 +278,37 @@ describe("classifyConversationError", () => {
     });
   });
 
+  describe("streaming corruption errors", () => {
+    const cases = [
+      "Unexpected event order, got message_start before receiving message_stop",
+      "Anthropic request failed: Unexpected event order, got message_start before receiving \"message_stop\"",
+      "stream ended without producing a Message",
+      "request ended without sending any chunks",
+      "stream has ended, this shouldn't happen",
+    ];
+
+    for (const msg of cases) {
+      it(`classifies "${msg}" as PROVIDER_API (retryable)`, () => {
+        const result = classifyConversationError(new Error(msg), baseCtx);
+        expect(result.code).toBe("PROVIDER_API");
+        expect(result.retryable).toBe(true);
+        expect(result.userMessage).toContain("interrupted");
+        expect(result.errorCategory).toBe("stream_corruption");
+      });
+    }
+
+    it("classifies ProviderError without statusCode with streaming message as PROVIDER_API", () => {
+      const err = new ProviderError(
+        "Unexpected event order, got message_start before receiving message_stop",
+        "anthropic",
+      );
+      const result = classifyConversationError(err, baseCtx);
+      expect(result.code).toBe("PROVIDER_API");
+      expect(result.retryable).toBe(true);
+      expect(result.errorCategory).toBe("stream_corruption");
+    });
+  });
+
   describe("abort/cancel errors (non-user-initiated)", () => {
     it('classifies "aborted" as CONVERSATION_ABORTED', () => {
       const result = classifyConversationError(

package/src/__tests__/conversation-init.benchmark.test.ts

@@ -136,7 +136,6 @@ mock.module("../util/logger.js", () => ({
 const mockConfig = {
   model: "mock-model",
   provider: "mock",
-  sandbox: { enabled: false, backend: "native" },
   contextWindow: {
     enabled: true,
     maxInputTokens: 180000,

package/src/__tests__/conversation-load-history-repair.test.ts

@@ -31,7 +31,7 @@ mock.module("../config/loader.js", () => ({
       summaryModel: "mock-model",
       maxSummaryTokens: 512,
     },
-    rateLimit: { maxRequestsPerMinute: 0, maxTokensPerSession: 0 },
+    rateLimit: { maxRequestsPerMinute: 0 },
   }),
   loadRawConfig: () => ({}),
   saveRawConfig: () => {},

package/src/__tests__/conversation-pairing.test.ts

@@ -114,7 +114,7 @@ function makeSignal(
     signalId: "sig-test",
     createdAt: Date.now(),
     sourceChannel: "scheduler",
-    sourceSessionId: "sess-1",
+    sourceContextId: "sess-1",
     sourceEventName: "test.event",
     contextPayload: {},
     attentionHints: {

package/src/__tests__/conversation-pre-run-repair.test.ts

@@ -45,7 +45,7 @@ mock.module("../config/loader.js", () => ({
         nonInteractiveLatestTurnCompression: "truncate",
       },
     },
-    rateLimit: { maxRequestsPerMinute: 0, maxTokensPerSession: 0 },
+    rateLimit: { maxRequestsPerMinute: 0 },
     daemon: {
       startupSocketWaitMs: 5000,
       stopTimeoutMs: 5000,
@@ -62,9 +62,9 @@ mock.module("../config/loader.js", () => ({
       "image-generation": {
         mode: "your-own",
         provider: "gemini",
-        model: "gemini-2.5-flash-image",
+        model: "gemini-3.1-flash-image-preview",
       },
-      "web-search": { mode: "your-own", provider: "anthropic-native" },
+      "web-search": { mode: "your-own", provider: "inference-provider-native" },
     },
   }),
   loadRawConfig: () => ({}),
@@ -123,7 +123,7 @@ mock.module("../memory/retriever.js", () => ({
     injectedTokens: 0,
     latencyMs: 0,
   }),
-  stripMemoryRecallMessages: (msgs: Message[]) => msgs,
+  injectMemoryRecallAsUserBlock: (msgs: Message[]) => msgs,
 }));
 
 // Mock AgentLoop to capture the messages it receives

package/src/__tests__/conversation-provider-retry-repair.test.ts

@@ -45,7 +45,7 @@ mock.module("../config/loader.js", () => ({
         nonInteractiveLatestTurnCompression: "truncate",
       },
     },
-    rateLimit: { maxRequestsPerMinute: 0, maxTokensPerSession: 0 },
+    rateLimit: { maxRequestsPerMinute: 0 },
     services: {
       inference: {
         mode: "your-own",
@@ -55,9 +55,9 @@ mock.module("../config/loader.js", () => ({
       "image-generation": {
         mode: "your-own",
         provider: "gemini",
-        model: "gemini-2.5-flash-image",
+        model: "gemini-3.1-flash-image-preview",
       },
-      "web-search": { mode: "your-own", provider: "anthropic-native" },
+      "web-search": { mode: "your-own", provider: "inference-provider-native" },
     },
   }),
   loadRawConfig: () => ({}),
@@ -185,7 +185,7 @@ mock.module("../memory/retriever.js", () => ({
     injectedTokens: 0,
     latencyMs: 0,
   }),
-  stripMemoryRecallMessages: (msgs: Message[]) => msgs,
+  injectMemoryRecallAsUserBlock: (msgs: Message[]) => msgs,
 }));
 
 let maybeCompactCalls: Array<{ force: boolean }> = [];