@vellumai/assistant 0.4.56 → 0.5.0

package/src/__tests__/notification-deep-link.test.ts

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

package/src/__tests__/notification-guardian-path.test.ts

@@ -239,7 +239,6 @@ describe("ASK_GUARDIAN canonical notification path", () => {
 
     const signalParams = emitCalls[0] as Record<string, unknown>;
     expect(typeof signalParams.onConversationCreated).toBe("function");
-    expect(signalParams.skipVellumThread).toBeUndefined();
   });
 
   test("creates guardian action deliveries from notification pipeline delivery results", async () => {

package/src/__tests__/notification-schedule-dedup.test.ts

@@ -72,7 +72,7 @@ function makeSignal(
     signalId: `sig-${crypto.randomUUID()}`,
     createdAt: Date.now(),
     sourceChannel: "scheduler",
-    sourceSessionId: "schedule-123",
+    sourceContextId: "schedule-123",
     sourceEventName: "schedule.complete",
     contextPayload: { scheduleId: "schedule-123", name: "Drink water" },
     attentionHints: {
@@ -118,7 +118,7 @@ describe("recurring schedule notification dedup", () => {
       id: firstSignal.signalId,
       sourceEventName: "schedule.complete",
       sourceChannel: "scheduler",
-      sourceSessionId: "schedule-123",
+      sourceContextId: "schedule-123",
       attentionHints: firstSignal.attentionHints,
       payload: firstSignal.contextPayload,
       // No dedupeKey — this is the bug scenario
@@ -132,7 +132,7 @@ describe("recurring schedule notification dedup", () => {
       id: secondSignal.signalId,
       sourceEventName: "schedule.complete",
       sourceChannel: "scheduler",
-      sourceSessionId: "schedule-123",
+      sourceContextId: "schedule-123",
       attentionHints: secondSignal.attentionHints,
       payload: secondSignal.contextPayload,
     });
@@ -160,7 +160,7 @@ describe("recurring schedule notification dedup", () => {
       id: firstSignal.signalId,
       sourceEventName: "schedule.complete",
       sourceChannel: "scheduler",
-      sourceSessionId: "schedule-123",
+      sourceContextId: "schedule-123",
       attentionHints: firstSignal.attentionHints,
       payload: firstSignal.contextPayload,
       dedupeKey: `schedule:complete:schedule-123:${Date.now() - 60_000}`,
@@ -173,7 +173,7 @@ describe("recurring schedule notification dedup", () => {
       id: secondSignal.signalId,
       sourceEventName: "schedule.complete",
       sourceChannel: "scheduler",
-      sourceSessionId: "schedule-123",
+      sourceContextId: "schedule-123",
       attentionHints: secondSignal.attentionHints,
       payload: secondSignal.contextPayload,
       dedupeKey: `schedule:complete:schedule-123:${Date.now()}`,
@@ -204,7 +204,7 @@ describe("recurring schedule notification dedup", () => {
       id: firstSignal.signalId,
       sourceEventName: "schedule.notify",
       sourceChannel: "scheduler",
-      sourceSessionId: "schedule-123",
+      sourceContextId: "schedule-123",
       attentionHints: firstSignal.attentionHints,
       payload: firstSignal.contextPayload,
       dedupeKey: `schedule:notify:schedule-123:${Date.now() - 60_000}`,
@@ -219,7 +219,7 @@ describe("recurring schedule notification dedup", () => {
       id: secondSignal.signalId,
       sourceEventName: "schedule.notify",
       sourceChannel: "scheduler",
-      sourceSessionId: "schedule-123",
+      sourceContextId: "schedule-123",
       attentionHints: secondSignal.attentionHints,
       payload: secondSignal.contextPayload,
       dedupeKey: `schedule:notify:schedule-123:${Date.now()}`,

package/src/__tests__/oauth-store.test.ts

@@ -83,9 +83,7 @@ async function createTestApp(providerKey = "github", clientId = "client-1") {
 }
 
 beforeEach(() => {
-  resetDb();
-  initializeDb();
-  // Explicitly clear all OAuth tables to prevent cross-test state pollution.
+  // Clear OAuth tables between tests instead of full DB reset + migration.
   // Delete in FK-dependency order: connections → apps → providers.
   resetTestTables("oauth_connections", "oauth_apps", "oauth_providers");
   mockDeleteSecureKeyAsync.mockClear();

package/src/__tests__/oauth2-gateway-transport.test.ts

@@ -484,17 +484,22 @@ describe("OAuth2 gateway transport", () => {
       };
 
       let capturedAuthUrl = "";
+      let urlReady!: () => void;
+      const urlReadyPromise = new Promise<void>((r) => {
+        urlReady = r;
+      });
       const flowPromise = startOAuth2Flow(
         BASE_OAUTH_CONFIG,
         {
           openUrl: (url) => {
             capturedAuthUrl = url;
+            urlReady();
           },
         },
         { callbackTransport: "loopback" },
       );
 
-      await new Promise((r) => setTimeout(r, 50));
+      await urlReadyPromise;
 
       const authUrl = new URL(capturedAuthUrl);
       const redirectUri = authUrl.searchParams.get("redirect_uri")!;

package/src/__tests__/onboarding-template-contract.test.ts

@@ -9,14 +9,19 @@ const user = readFileSync(join(templatesDir, "USER.md"), "utf-8");
 
 describe("onboarding template contracts", () => {
   describe("BOOTSTRAP.md", () => {
-    test("contains identity question prompts", () => {
+    test("preserves comment line format instruction", () => {
+      expect(bootstrap).toMatch(/^_ Lines starting with _/);
+    });
+
+    test("contains identity discovery prompts", () => {
       const lower = bootstrap.toLowerCase();
-      expect(lower).toContain("who am i");
+      expect(lower).toContain("your name");
+      expect(lower).toContain("personality");
+      expect(lower).toContain("avatar");
     });
 
     test("infers personality organically instead of asking directly", () => {
       const lower = bootstrap.toLowerCase();
-      // Personality step must instruct organic discovery via conversation
       expect(lower).toContain("personality");
       expect(lower).toContain("emerge");
       expect(lower).toContain("vibe");
@@ -28,28 +33,17 @@ describe("onboarding template contracts", () => {
       expect(lower).toContain("change it later");
     });
 
-    test("contains naming intent markers so the first reply includes naming cues", () => {
-      const lower = bootstrap.toLowerCase();
-      // The template must prompt the assistant to ask about names.
-      expect(lower).toContain("name");
-      // The first step should be about the assistant's name
-      expect(lower).toContain("your name");
-      // The conversation sequence must include identity/naming
-      expect(lower).toContain("who am i");
-    });
-
-    test("asks user name AFTER assistant identity is established", () => {
-      // Step 1 is the assistant's name, step 4 is asking the user's name
-      const assistantNameIdx = bootstrap.indexOf("Your name:");
-      const userNameIdx = bootstrap.indexOf("who am I talking to?");
-      expect(assistantNameIdx).toBeGreaterThan(-1);
-      expect(userNameIdx).toBeGreaterThan(-1);
-      expect(assistantNameIdx).toBeLessThan(userNameIdx);
+    test("asks about user after assistant identity", () => {
+      const nameIdx = bootstrap.indexOf("Your name");
+      const theirNameIdx = bootstrap.indexOf("Their name");
+      expect(nameIdx).toBeGreaterThan(-1);
+      expect(theirNameIdx).toBeGreaterThan(-1);
+      expect(nameIdx).toBeLessThan(theirNameIdx);
     });
 
     test("gathers user context: work role, hobbies, daily tools", () => {
       const lower = bootstrap.toLowerCase();
-      expect(lower).toContain("work");
+      expect(lower).toContain("work role");
       expect(lower).toContain("hobbies");
       expect(lower).toContain("tools");
     });
@@ -57,51 +51,32 @@ describe("onboarding template contracts", () => {
     test("shows exactly 2 suggestions via ui_show card with relay_prompt actions", () => {
       expect(bootstrap).toContain("ui_show");
       expect(bootstrap).toContain("exactly 2");
-      // Must use card surface with relay_prompt action buttons
-      expect(bootstrap).toContain('surface_type: "card"');
       expect(bootstrap).toContain("relay_prompt");
     });
 
-    test("contains completion gate with all required conditions", () => {
+    test("contains wrapping-up criteria with required conditions", () => {
       const lower = bootstrap.toLowerCase();
-      expect(lower).toContain("completion gate");
-      expect(lower).toContain("do not delete this file");
-      // Assistant name is hard-required
-      expect(lower).toContain("you have a name");
-      expect(lower).toContain("hard-required");
+      expect(lower).toContain("wrapping up");
+      expect(lower).toContain("done with onboarding");
       expect(lower).toContain("vibe");
-      // User detail fields must be resolved (provided, inferred, or declined)
-      expect(lower).toContain("resolved");
-      expect(lower).toContain("work role");
-      expect(lower).toContain("2 suggestions from step 6");
+      expect(lower).toContain("two suggestions");
     });
 
     test("contains refusal policy", () => {
       const lower = bootstrap.toLowerCase();
-      // Assistant name is hard-required, user details are best-effort
       expect(lower).toContain("hard-required");
       expect(lower).toContain("best-effort");
-      // Refusal is a valid resolution
       expect(lower).toContain("declined");
-      expect(lower).toContain("do not push");
+      expect(lower).toContain("not interrogation");
     });
 
     test("defines resolved as provided, inferred, or declined", () => {
       const lower = bootstrap.toLowerCase();
-      // The template must define what "resolved" means
       expect(lower).toContain("resolved");
       expect(lower).toContain("inferred");
       expect(lower).toContain("declined");
     });
 
-    // em-dash and technical jargon instructions are now hardcoded in the system
-    // prompt builder (buildSystemPrompt) rather than in the BOOTSTRAP.md template.
-
-    test("preserves comment line format instruction", () => {
-      // The template must start with the comment format explanation
-      expect(bootstrap).toMatch(/^_ Lines starting with _/);
-    });
-
     test("instructs saving to IDENTITY.md, USER.md, and SOUL.md via file_edit", () => {
       expect(bootstrap).toContain("IDENTITY.md");
       expect(bootstrap).toContain("USER.md");
@@ -118,18 +93,13 @@ describe("onboarding template contracts", () => {
       expect(identity).toContain("**Emoji:**");
     });
 
-    test("contains the emoji overwrite instruction", () => {
-      const lower = identity.toLowerCase();
-      expect(lower).toContain("change their emoji");
-    });
-
-    test("contains the style tendency field", () => {
-      expect(identity).toContain("**Style tendency:**");
+    test("contains parsed field format guidance", () => {
+      expect(identity).toContain("parsed by the app");
     });
   });
 
   describe("USER.md", () => {
-    test("contains onboarding snapshot with all required fields", () => {
+    test("contains profile fields", () => {
       expect(user).toContain("Preferred name/reference:");
       expect(user).toContain("Goals:");
       expect(user).toContain("Locale:");
@@ -137,11 +107,5 @@ describe("onboarding template contracts", () => {
       expect(user).toContain("Hobbies/fun:");
       expect(user).toContain("Daily tools:");
     });
-
-    test("documents resolved-field status conventions", () => {
-      const lower = user.toLowerCase();
-      expect(lower).toContain("declined_by_user");
-      expect(lower).toContain("resolved");
-    });
   });
 });

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");