@vellumai/assistant 0.4.56 → 0.4.57

package/src/__tests__/provider-error-scenarios.test.ts

@@ -49,6 +49,11 @@ mock.module("../util/retry.js", () => {
     return status === 429 || status >= 500;
   }
 
+  const RETRYABLE_NETWORK_MESSAGE_PATTERNS = [
+    /socket.*closed unexpectedly/i,
+    /socket hang up/i,
+  ];
+
   function isRetryableNetworkError(error: unknown): boolean {
     if (!(error instanceof Error)) return false;
     const retryableCodes = new Set([
@@ -63,6 +68,18 @@ mock.module("../util/retry.js", () => {
       const causeCode = (error.cause as NodeJS.ErrnoException).code;
       if (causeCode && retryableCodes.has(causeCode)) return true;
     }
+    if (
+      RETRYABLE_NETWORK_MESSAGE_PATTERNS.some((p) => p.test(error.message))
+    ) {
+      return true;
+    }
+    const cause = error.cause;
+    if (
+      cause instanceof Error &&
+      RETRYABLE_NETWORK_MESSAGE_PATTERNS.some((p) => p.test(cause.message))
+    ) {
+      return true;
+    }
     return false;
   }
 
@@ -396,6 +413,34 @@ describe("RetryProvider — network error retries", () => {
     expect(result.content[0]).toMatchObject({ type: "text", text: "ok" });
   });
 
+  test("retries on Bun 'socket connection was closed unexpectedly' (ProviderError wrapping)", async () => {
+    const inner = makeFlaky(
+      1,
+      new ProviderError(
+        "Anthropic request failed: The socket connection was closed unexpectedly. For more information, pass `verbose: true` in the second argument to fetch()",
+        "anthropic",
+      ),
+    );
+    const provider = new RetryProvider(inner);
+
+    const result = await provider.sendMessage(MESSAGES);
+    expect(inner.calls).toBe(2);
+    expect(result.stopReason).toBe("end_turn");
+  });
+
+  test("retries on 'socket connection was closed unexpectedly' in error cause", async () => {
+    const cause = new Error(
+      "The socket connection was closed unexpectedly. For more information, pass `verbose: true` in the second argument to fetch()",
+    );
+    const outer = new Error("fetch failed", { cause });
+    const inner = makeFlaky(1, outer);
+    const provider = new RetryProvider(inner);
+
+    const result = await provider.sendMessage(MESSAGES);
+    expect(inner.calls).toBe(2);
+    expect(result.content[0]).toMatchObject({ type: "text", text: "ok" });
+  });
+
   test("does not retry on non-retryable errors", async () => {
     const inner = makeFailing(new Error("unexpected error"));
     const provider = new RetryProvider(inner);
@@ -419,6 +464,115 @@ describe("RetryProvider — network error retries", () => {
   });
 });
 
+// ---------------------------------------------------------------------------
+// RetryProvider — streaming corruption retries
+// ---------------------------------------------------------------------------
+
+describe("RetryProvider — streaming corruption retries", () => {
+  test("retries on 'Unexpected event order' (message_start before message_stop)", async () => {
+    const inner = makeFlaky(
+      1,
+      new ProviderError(
+        'Anthropic request failed: Unexpected event order, got message_start before receiving "message_stop"',
+        "anthropic",
+      ),
+    );
+    const provider = new RetryProvider(inner);
+
+    const result = await provider.sendMessage(MESSAGES);
+    expect(result.stopReason).toBe("end_turn");
+    expect(inner.calls).toBe(2);
+  });
+
+  test("retries on 'Unexpected event order' (event before message_start)", async () => {
+    const inner = makeFlaky(
+      1,
+      new ProviderError(
+        'Anthropic request failed: Unexpected event order, got content_block_start before "message_start"',
+        "anthropic",
+      ),
+    );
+    const provider = new RetryProvider(inner);
+
+    const result = await provider.sendMessage(MESSAGES);
+    expect(inner.calls).toBe(2);
+    expect(result.model).toBe("test-model");
+  });
+
+  test("retries on 'stream ended without producing'", async () => {
+    const inner = makeFlaky(
+      1,
+      new ProviderError(
+        "Anthropic request failed: stream ended without producing a Message with role=assistant",
+        "anthropic",
+      ),
+    );
+    const provider = new RetryProvider(inner);
+
+    const result = await provider.sendMessage(MESSAGES);
+    expect(inner.calls).toBe(2);
+    expect(result.content).toHaveLength(1);
+  });
+
+  test("retries on 'request ended without sending any chunks'", async () => {
+    const inner = makeFlaky(
+      1,
+      new ProviderError(
+        "Anthropic request failed: request ended without sending any chunks",
+        "anthropic",
+      ),
+    );
+    const provider = new RetryProvider(inner);
+
+    await provider.sendMessage(MESSAGES);
+    expect(inner.calls).toBe(2);
+  });
+
+  test("throws after exhausting retries on persistent stream corruption", async () => {
+    const inner = makeFailing(
+      new ProviderError(
+        'Anthropic request failed: Unexpected event order, got message_start before receiving "message_stop"',
+        "anthropic",
+      ),
+    );
+    const provider = new RetryProvider(inner);
+
+    await expect(provider.sendMessage(MESSAGES)).rejects.toThrow(
+      "Unexpected event order",
+    );
+    expect(inner.calls).toBe(DEFAULT_MAX_RETRIES + 1);
+  });
+
+  test("does not retry non-stream ProviderError without status code", async () => {
+    const inner = makeFailing(
+      new ProviderError("model not found", "anthropic"),
+    );
+    const provider = new RetryProvider(inner);
+
+    await expect(provider.sendMessage(MESSAGES)).rejects.toThrow(
+      "model not found",
+    );
+    expect(inner.calls).toBe(1);
+  });
+
+  test("does not treat stream pattern as retryable when ProviderError has a status code", async () => {
+    // A 400 error that happens to contain "Unexpected event order" should NOT be retried
+    const inner = makeFailing(
+      new ProviderError(
+        "Unexpected event order in request payload",
+        "anthropic",
+        400,
+      ),
+    );
+    const provider = new RetryProvider(inner);
+
+    await expect(provider.sendMessage(MESSAGES)).rejects.toThrow(
+      "Unexpected event order",
+    );
+    expect(inner.calls).toBe(1);
+  });
+});
+
 // ---------------------------------------------------------------------------
 // RetryProvider — streaming + options passthrough
 // ---------------------------------------------------------------------------

package/src/__tests__/provider-fail-open-selection.test.ts

@@ -52,9 +52,9 @@ function makeProvidersConfig(provider: string, model: string): ProvidersConfig {
       "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" },
     },
   };
 }

package/src/__tests__/provider-managed-proxy-integration.test.ts

@@ -69,9 +69,9 @@ function makeProvidersConfig(provider: string, model: string): ProvidersConfig {
       "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" },
     },
   };
 }
@@ -206,7 +206,7 @@ describe("managed proxy integration — credential precedence", () => {
       expect(baseURL).toContain("/v1/runtime-proxy/anthropic");
     });
 
-    test("managed gemini uses vertex proxy path", async () => {
+    test("managed gemini uses gemini proxy path", async () => {
       enableManagedProxy();
       mockProviderKeys = {};
       await initializeProviders(makeProvidersConfig("anthropic", "test-model"));
@@ -216,8 +216,7 @@ describe("managed proxy integration — credential precedence", () => {
         | { baseUrl?: string }
         | undefined;
       expect(httpOptions).toBeDefined();
-      expect(httpOptions!.baseUrl).toContain("/v1/runtime-proxy/vertex");
-      expect(httpOptions!.baseUrl).not.toContain("/v1/runtime-proxy/gemini");
+      expect(httpOptions!.baseUrl).toContain("/v1/runtime-proxy/gemini");
     });
   });
 
@@ -309,8 +308,8 @@ describe("managed proxy integration — ollama exclusion", () => {
 });
 
 describe("managed proxy integration — constants integrity", () => {
-  test("anthropic, gemini, and vertex have metadata with managed=true and a proxyPath", () => {
-    for (const provider of ["anthropic", "gemini", "vertex"]) {
+  test("anthropic and gemini have metadata with managed=true and a proxyPath", () => {
+    for (const provider of ["anthropic", "gemini"]) {
       const meta = MANAGED_PROVIDER_META[provider];
       expect(meta).toBeDefined();
       expect(meta.managed).toBe(true);
@@ -325,9 +324,9 @@ describe("managed proxy integration — constants integrity", () => {
     );
   });
 
-  test("gemini routes through vertex proxy path", () => {
+  test("gemini routes through gemini proxy path", () => {
     expect(MANAGED_PROVIDER_META.gemini.proxyPath).toBe(
-      "/v1/runtime-proxy/vertex",
+      "/v1/runtime-proxy/gemini",
     );
   });
 

package/src/__tests__/provider-registry-ollama.test.ts

@@ -25,9 +25,12 @@ describe("provider registry (ollama)", () => {
         "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: "inference-provider-native",
         },
-        "web-search": { mode: "your-own", provider: "anthropic-native" },
       },
     });
 

package/src/__tests__/qdrant-manager.test.ts

@@ -36,9 +36,9 @@ import { QdrantManager } from "../memory/qdrant-manager.js";
 
 /** Short timeouts so tests complete fast but with enough headroom for CI. */
 const FAST_TIMEOUTS = {
-  readyzPollIntervalMs: 10,
-  readyzTimeoutMs: 1_000,
-  shutdownGraceMs: 200,
+  readyzPollIntervalMs: 5,
+  readyzTimeoutMs: 100,
+  shutdownGraceMs: 50,
 } as const;
 
 function placeFakeBinary(script: string): string {
@@ -248,7 +248,7 @@ describe("QdrantManager", () => {
       const startPromise = mgr.start();
 
       // Wait for spawn to happen
-      await Bun.sleep(300);
+      await Bun.sleep(50);
 
       // PID file should be written
       expect(existsSync(pidPath)).toBe(true);
@@ -277,7 +277,7 @@ describe("QdrantManager", () => {
       });
 
       const startPromise = mgr.start();
-      await Bun.sleep(300);
+      await Bun.sleep(50);
 
       expect(existsSync(pidPath)).toBe(true);
 
@@ -285,8 +285,8 @@ describe("QdrantManager", () => {
       await mgr.stop();
       const stopElapsed = Date.now() - stopStart;
 
-      // Grace period is 200ms with FAST_TIMEOUTS — should wait at least that long
-      expect(stopElapsed).toBeGreaterThanOrEqual(100);
+      // Grace period is 50ms with FAST_TIMEOUTS — should wait at least that long
+      expect(stopElapsed).toBeGreaterThanOrEqual(30);
       expect(existsSync(pidPath)).toBe(false);
 
       await expect(startPromise).rejects.toThrow("did not become ready");

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