@vellumai/assistant 0.8.5 → 0.8.6

package/src/__tests__/manual-token-reconciliation.test.ts

@@ -13,6 +13,8 @@ let connectionStore: Record<
 > = {};
 let deletedConnectionIds: string[] = [];
 let createdConnections: Array<{ provider: string; accountInfo?: string }> = [];
+let updatedConnections: Array<{ id: string; accountInfo?: string | null }> = [];
+let telegramBotUsername: string | undefined;
 const warnings: string[] = [];
 
 // ---------------------------------------------------------------------------
@@ -41,6 +43,10 @@ mock.module("../security/secure-keys.js", () => ({
   },
 }));
 
+mock.module("../telegram/bot-username.js", () => ({
+  getTelegramBotUsername: () => telegramBotUsername,
+}));
+
 mock.module("../oauth/oauth-store.js", () => ({
   getConnectionByProvider: (provider: string) =>
     connectionStore[provider] ?? undefined,
@@ -72,7 +78,16 @@ mock.module("../oauth/oauth-store.js", () => ({
     };
     return { id: `conn-${params.provider}` };
   },
-  updateConnection: () => {},
+  updateConnection: (id: string, updates: { accountInfo?: string | null }) => {
+    updatedConnections.push({ id, accountInfo: updates.accountInfo });
+    for (const conn of Object.values(connectionStore)) {
+      if (conn.id === id) {
+        conn.accountInfo = updates.accountInfo;
+        return true;
+      }
+    }
+    return false;
+  },
   upsertApp: async (_provider: string, _clientId: string) => ({
     id: "app-1",
   }),
@@ -119,6 +134,8 @@ describe("syncManualTokenConnection", () => {
     connectionStore = {};
     deletedConnectionIds = [];
     createdConnections = [];
+    updatedConnections = [];
+    telegramBotUsername = undefined;
     warnings.length = 0;
   });
 
@@ -291,6 +308,62 @@ describe("syncManualTokenConnection", () => {
       { provider: "telegram", accountInfo: undefined },
     ]);
   });
+
+  test("creates telegram connection with configured bot username when account is omitted", async () => {
+    telegramBotUsername = "example_bot";
+    setCredentialResult("telegram", "bot_token", {
+      value: "bot-token",
+      unreachable: false,
+    });
+    setCredentialResult("telegram", "webhook_secret", {
+      value: "webhook-secret",
+      unreachable: false,
+    });
+
+    await syncManualTokenConnection("telegram");
+
+    expect(createdConnections).toEqual([
+      { provider: "telegram", accountInfo: "@example_bot" },
+    ]);
+  });
+
+  test("updates existing telegram connection with configured bot username when account is omitted", async () => {
+    telegramBotUsername = "@example_bot";
+    seedConnection("telegram");
+    setCredentialResult("telegram", "bot_token", {
+      value: "bot-token",
+      unreachable: false,
+    });
+    setCredentialResult("telegram", "webhook_secret", {
+      value: "webhook-secret",
+      unreachable: false,
+    });
+
+    await syncManualTokenConnection("telegram");
+
+    expect(updatedConnections).toEqual([
+      { id: "conn-telegram", accountInfo: "@example_bot" },
+    ]);
+    expect(connectionStore["telegram"]?.accountInfo).toBe("@example_bot");
+  });
+
+  test("preserves existing telegram account label when deriving bot username lazily", async () => {
+    telegramBotUsername = "@example_bot";
+    seedConnection("telegram", { accountInfo: "@existing_bot" });
+    setCredentialResult("telegram", "bot_token", {
+      value: "bot-token",
+      unreachable: false,
+    });
+    setCredentialResult("telegram", "webhook_secret", {
+      value: "webhook-secret",
+      unreachable: false,
+    });
+
+    await syncManualTokenConnection("telegram");
+
+    expect(updatedConnections).toEqual([]);
+    expect(connectionStore["telegram"]?.accountInfo).toBe("@existing_bot");
+  });
 });
 
 describe("backfillManualTokenConnections", () => {
@@ -299,6 +372,8 @@ describe("backfillManualTokenConnections", () => {
     connectionStore = {};
     deletedConnectionIds = [];
     createdConnections = [];
+    updatedConnections = [];
+    telegramBotUsername = undefined;
     warnings.length = 0;
   });
 

package/src/__tests__/mcp-abort-signal.test.ts

@@ -8,7 +8,21 @@ mock.module("../security/secure-keys.js", () => ({
 }));
 
 mock.module("../config/env-registry.js", () => ({
+  getDebugStdoutLogs: () => false,
+  getIsContainerized: () => false,
   getIsPlatform: () => false,
+  isPlatformRemote: () => false,
+  getWorkspaceDirOverride: () => undefined,
+  getBackupDirOverride: () => undefined,
+  getBackupKeyPathOverride: () => undefined,
+  getCpuLimit: () => undefined,
+  getMinikubeStorageSize: () => undefined,
+  getProfilerRunId: () => undefined,
+  getProfilerMode: () => undefined,
+  getProfilerMaxBytes: () => undefined,
+  getProfilerMaxRuns: () => undefined,
+  getProfilerMinFreeMb: () => undefined,
+  checkUnrecognizedEnvVars: () => [],
 }));
 
 const { McpClient } = await import("../mcp/client.js");

package/src/__tests__/mcp-client-auth.test.ts

@@ -8,7 +8,21 @@ mock.module("../security/secure-keys.js", () => ({
 }));
 
 mock.module("../config/env-registry.js", () => ({
+  getDebugStdoutLogs: () => false,
+  getIsContainerized: () => false,
   getIsPlatform: () => false,
+  isPlatformRemote: () => false,
+  getWorkspaceDirOverride: () => undefined,
+  getBackupDirOverride: () => undefined,
+  getBackupKeyPathOverride: () => undefined,
+  getCpuLimit: () => undefined,
+  getMinikubeStorageSize: () => undefined,
+  getProfilerRunId: () => undefined,
+  getProfilerMode: () => undefined,
+  getProfilerMaxBytes: () => undefined,
+  getProfilerMaxRuns: () => undefined,
+  getProfilerMinFreeMb: () => undefined,
+  checkUnrecognizedEnvVars: () => [],
 }));
 
 const { McpClient } = await import("../mcp/client.js");

package/src/__tests__/messaging-send-tool.test.ts

@@ -79,6 +79,7 @@ const getBindingByChannelChatMock = mock(
 mock.module("../memory/conversation-crud.js", () => ({
   addMessage: addMessageMock,
   getConversation: getConversationMock,
+  reserveMessage: mock(async () => ({ id: "msg-reserve" })),
 }));
 
 mock.module("../memory/conversation-disk-view.js", () => ({

package/src/__tests__/migration-import-from-url.test.ts

@@ -118,13 +118,13 @@ mock.module("../config/env.js", () => ({
 // Imports (after mocks so module-level code picks up the stubs)
 // ---------------------------------------------------------------------------
 
-import { resetDb } from "../memory/db-connection.js";
 import { defaultV1Options } from "../runtime/migrations/__tests__/v1-test-helpers.js";
 import { buildVBundle } from "../runtime/migrations/vbundle-builder.js";
 import {
   _setUrlImportValidatorOptionsForTests,
   handleMigrationImport,
 } from "../runtime/routes/migration-routes.js";
+import { resetDbForTesting } from "./db-test-helpers.js";
 import { callHandler } from "./helpers/call-route-handler.js";
 // ---------------------------------------------------------------------------
 // Local http fixture server
@@ -448,7 +448,7 @@ describe("handleMigrationImport — no-swap path omits newer-migration warning",
 
     // Drop any cached Drizzle singleton so getDb() re-opens from the
     // seeded path above when the handler calls it post-import.
-    resetDb();
+    resetDbForTesting();
 
     // All-`vellum:*` credentials bundle: the streaming importer returns
     // ok=true with zero files_created/overwritten (no-swap success),
@@ -505,7 +505,7 @@ describe("handleMigrationImport — no-swap path omits newer-migration warning",
       await fixture.close();
       // Close the cached DB handle before the workspace dir gets rm'd
       // in afterEach so we don't leak WAL/SHM files across tests.
-      resetDb();
+      resetDbForTesting();
     }
   });
 });

package/src/__tests__/mock-gateway-ipc.ts

@@ -56,7 +56,9 @@ class FakePersistentIpcClient extends EventEmitter {
     if (simulateError) {
       throw new Error("Mock IPC socket error");
     }
-    return method in ipcResults ? ipcResults[method] : undefined;
+    if (method in ipcResults) return ipcResults[method];
+    if (method === "get_feature_flags") return GET_FEATURE_FLAGS_DEFAULT;
+    return undefined;
   }
 
   destroy(): void {
@@ -68,6 +70,18 @@ class FakePersistentIpcClient extends EventEmitter {
 // Register the mock (called once from test-preload.ts)
 // ---------------------------------------------------------------------------
 
+/**
+ * Sentinel returned by the mock for `get_feature_flags` when a test has not
+ * explicitly configured a result. Keeps the response non-empty so
+ * `initFeatureFlagOverrides()` does not enter its 7.75 s empty-result retry
+ * loop during tests that build the CLI program or otherwise trigger flag
+ * initialization. The sentinel key starts with a double underscore so it
+ * cannot collide with any real registry-declared flag.
+ */
+const GET_FEATURE_FLAGS_DEFAULT: Record<string, boolean> = {
+  __test_default__: false,
+};
+
 export function installGatewayIpcMock(): void {
   mock.module("@vellumai/gateway-client/ipc-client", () => ({
     ipcCall: async (
@@ -79,7 +93,9 @@ export function installGatewayIpcMock(): void {
         // Real ipcCall returns undefined on failure — mirror that behavior.
         return undefined;
       }
-      return method in ipcResults ? ipcResults[method] : undefined;
+      if (method in ipcResults) return ipcResults[method];
+      if (method === "get_feature_flags") return GET_FEATURE_FLAGS_DEFAULT;
+      return undefined;
     },
     PersistentIpcClient: FakePersistentIpcClient,
   }));

package/src/__tests__/model-intents.test.ts

@@ -20,7 +20,7 @@ describe("model intents", () => {
       "claude-haiku-4-5-20251001",
     );
     expect(resolveModelIntent("anthropic", "quality-optimized")).toBe(
-      "claude-opus-4-7",
+      "claude-opus-4-8",
     );
     expect(resolveModelIntent("anthropic", "vision-optimized")).toBe(
       "claude-opus-4-6",
@@ -44,9 +44,9 @@ describe("model intents", () => {
   });
 
   test("falls back to provider default for unknown providers", () => {
-    expect(getProviderDefaultModel("unknown-provider")).toBe("claude-opus-4-7");
+    expect(getProviderDefaultModel("unknown-provider")).toBe("claude-opus-4-8");
     expect(resolveModelIntent("unknown-provider", "quality-optimized")).toBe(
-      "claude-opus-4-7",
+      "claude-opus-4-8",
     );
   });
 });

package/src/__tests__/native-web-search.test.ts

@@ -51,8 +51,7 @@ mock.module("@anthropic-ai/sdk", () => ({
           _options?: Record<string, unknown>,
         ) => {
           lastStreamParams = JSON.parse(JSON.stringify(params));
-          const handlers: Record<string, ((...args: unknown[]) => void)[]> =
-            {};
+          const handlers: Record<string, ((...args: unknown[]) => void)[]> = {};
           return {
             on(event: string, cb: (...args: unknown[]) => void) {
               (handlers[event] ??= []).push(cb);
@@ -74,6 +73,7 @@ mock.module("@anthropic-ai/sdk", () => ({
 
 // Import after mocking
 import { AnthropicProvider } from "../providers/anthropic/client.js";
+import { isNativeWebSearchCapableProvider } from "../providers/registry.js";
 
 // ---------------------------------------------------------------------------
 // Helpers
@@ -99,6 +99,34 @@ const sampleTools: ToolDefinition[] = [
   },
 ];
 
+describe("Native Web Search — Selection Semantics", () => {
+  test("only native-capable inference providers/models request provider-native web search", () => {
+    expect(
+      isNativeWebSearchCapableProvider("anthropic", "claude-opus-4-7"),
+    ).toBe(true);
+    expect(isNativeWebSearchCapableProvider("openai", "gpt-5")).toBe(true);
+    expect(
+      isNativeWebSearchCapableProvider(
+        "openrouter",
+        "anthropic/claude-opus-4-7",
+      ),
+    ).toBe(true);
+
+    expect(
+      isNativeWebSearchCapableProvider(
+        "fireworks",
+        "accounts/fireworks/models/kimi-k2p6",
+      ),
+    ).toBe(false);
+    expect(isNativeWebSearchCapableProvider("gemini", "gemini-3.1-pro")).toBe(
+      false,
+    );
+    expect(isNativeWebSearchCapableProvider("openrouter", "openai/gpt-5")).toBe(
+      false,
+    );
+  });
+});
+
 // ---------------------------------------------------------------------------
 // Tests — Round-trip: fromAnthropicBlock
 // ---------------------------------------------------------------------------

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

@@ -38,6 +38,13 @@ mock.module("../notifications/deliveries-store.js", () => ({
   findDeliveryByDecisionAndChannel: () => undefined,
 }));
 
+// Mock conversation-crud so the broadcaster's source-context fallback lookup
+// can be driven from tests without DB access.
+let mockExistingConversations: Record<string, { id: string }> = {};
+mock.module("../memory/conversation-crud.js", () => ({
+  getConversation: (id: string) => mockExistingConversations[id] ?? null,
+}));
+
 // Configurable mock for conversation-pairing
 let nextPairingResult:
   | import("../notifications/conversation-pairing.js").PairingResult
@@ -141,6 +148,7 @@ class MockAdapter implements ChannelAdapter {
 describe("notification deep-link metadata", () => {
   beforeEach(() => {
     nextPairingResult = null;
+    mockExistingConversations = {};
   });
 
   describe("VellumAdapter", () => {
@@ -600,5 +608,59 @@ describe("notification deep-link metadata", () => {
       expect(deepLink1!.messageId).toBe("msg-delivery-1");
       expect(deepLink2!.messageId).toBe("msg-delivery-2");
     });
+
+    // ── Source-context fallback when pairing yields no conversation ──
+
+    test("falls back to signal.sourceContextId for deep link when pairing returns no conversation and sourceContextId resolves", async () => {
+      const vellumAdapter = new MockAdapter("vellum");
+      const broadcaster = new NotificationBroadcaster([vellumAdapter]);
+
+      // Passive vellum signal: pairing skips creation, returns null.
+      nextPairingResult = {
+        conversationId: null,
+        messageId: null,
+        strategy: "start_new_conversation" as const,
+        createdNewConversation: false,
+        conversationFallbackUsed: false,
+      };
+
+      const originConvId = "conv-origin-of-event";
+      mockExistingConversations[originConvId] = { id: originConvId };
+
+      const signal = makeSignal({ sourceContextId: originConvId });
+      const decision = makeDecision();
+
+      await broadcaster.broadcastDecision(signal, decision);
+
+      expect(vellumAdapter.sent).toHaveLength(1);
+      const deepLink = vellumAdapter.sent[0].deepLinkTarget;
+      expect(deepLink).toBeDefined();
+      expect(deepLink!.conversationId).toBe(originConvId);
+    });
+
+    test("omits conversationId from deep link when pairing returns no conversation and sourceContextId is a sentinel", async () => {
+      const vellumAdapter = new MockAdapter("vellum");
+      const broadcaster = new NotificationBroadcaster([vellumAdapter]);
+
+      nextPairingResult = {
+        conversationId: null,
+        messageId: null,
+        strategy: "start_new_conversation" as const,
+        createdNewConversation: false,
+        conversationFallbackUsed: false,
+      };
+
+      // Sentinel sourceContextId (job ID, access-req-*, etc.) — getConversation returns null.
+      const signal = makeSignal({ sourceContextId: "access-req-sentinel-xyz" });
+      const decision = makeDecision();
+
+      await broadcaster.broadcastDecision(signal, decision);
+
+      expect(vellumAdapter.sent).toHaveLength(1);
+      const deepLink = vellumAdapter.sent[0].deepLinkTarget;
+      // Decision did not carry a deepLinkTarget either — the resulting
+      // deep link should be undefined or have no conversationId.
+      expect(deepLink?.conversationId).toBeUndefined();
+    });
   });
 });

package/src/__tests__/oauth-commands-routes.test.ts

@@ -21,6 +21,7 @@ import { beforeEach, describe, expect, mock, test } from "bun:test";
 
 interface MockProviderRow {
   provider: string;
+  authorizeUrl: string;
   managedServiceConfigKey: string | null;
   baseUrl: string | null;
   injectionTemplates: string | null;
@@ -32,6 +33,7 @@ interface MockProviderRow {
 
 const baseProvider: MockProviderRow = {
   provider: "google",
+  authorizeUrl: "https://accounts.google.com/o/oauth2/v2/auth",
   managedServiceConfigKey: "google-oauth",
   baseUrl: "https://api.google.com",
   injectionTemplates: null,
@@ -69,6 +71,7 @@ let mockResolveResponse: {
   body: unknown;
 } = { status: 200, headers: {}, body: { ok: true } };
 let mockResolveRequests: unknown[] = [];
+let mockSyncManualTokenCalls: string[] = [];
 
 const mockDisconnectOAuthProvider = mock(() => Promise.resolve());
 const mockSaveRawConfig = mock(() => undefined);
@@ -117,6 +120,12 @@ mock.module("../oauth/connection-resolver.js", () => ({
   }),
 }));
 
+mock.module("../oauth/manual-token-connection.js", () => ({
+  syncManualTokenConnection: async (provider: string) => {
+    mockSyncManualTokenCalls.push(provider);
+  },
+}));
+
 mock.module("../platform/client.js", () => ({
   VellumPlatformClient: {
     create: async () => {
@@ -212,6 +221,7 @@ beforeEach(() => {
   });
   mockResolveResponse = { status: 200, headers: {}, body: { ok: true } };
   mockResolveRequests = [];
+  mockSyncManualTokenCalls = [];
   mockDisconnectOAuthProvider.mockClear();
   mockSaveRawConfig.mockClear();
 });
@@ -475,6 +485,33 @@ describe("GET oauth/status", () => {
     expect(result.connections[0]!.grantedScopes).toEqual([]);
   });
 
+  test("BYO mode reconciles manual-token providers before listing status", async () => {
+    mockProviders.telegram = {
+      ...baseProvider,
+      provider: "telegram",
+      authorizeUrl: "urn:manual-token",
+      managedServiceConfigKey: null,
+      baseUrl: "https://api.telegram.org",
+    };
+    mockAllConnections.telegram = [
+      {
+        id: "conn-telegram",
+        accountInfo: "@example_bot",
+        grantedScopes: "[]",
+        status: "active",
+        hasRefreshToken: 0,
+        expiresAt: null,
+      },
+    ];
+
+    const result = (await getRoute("GET", "oauth/status").handler(
+      makeArgs({ queryParams: { provider: "telegram" } }),
+    )) as { connections: Array<{ account: string | null }> };
+
+    expect(mockSyncManualTokenCalls).toEqual(["telegram"]);
+    expect(result.connections[0]!.account).toBe("@example_bot");
+  });
+
   test("managed mode surfaces platform connections", async () => {
     mockServiceModes["google-oauth"] = "managed";
     mockFetchImpl = async () => ({

package/src/__tests__/oauth-provider-visibility.test.ts

@@ -21,13 +21,13 @@ mock.module("../security/secure-keys.js", () => ({
   getSecureKeyAsync: () => Promise.resolve(undefined),
 }));
 
-import { _setOverridesForTesting } from "../config/assistant-feature-flags.js";
 import type { AssistantConfig } from "../config/schema.js";
-import { resetDb } from "../memory/db-connection.js";
 import { initializeDb } from "../memory/db-init.js";
 import { resetTestTables } from "../memory/raw-query.js";
 import { listProviders, seedProviders } from "../oauth/oauth-store.js";
 import { isProviderVisible } from "../oauth/provider-visibility.js";
+import { resetDbForTesting } from "./db-test-helpers.js";
+import { setOverridesForTesting } from "./feature-flag-test-helpers.js";
 
 initializeDb();
 
@@ -38,15 +38,15 @@ function makeConfig(): AssistantConfig {
 
 beforeEach(() => {
   resetTestTables("oauth_connections", "oauth_apps", "oauth_providers");
-  _setOverridesForTesting({});
+  setOverridesForTesting({});
 });
 
 afterEach(() => {
-  _setOverridesForTesting({});
+  setOverridesForTesting({});
 });
 
 afterAll(() => {
-  resetDb();
+  resetDbForTesting();
 });
 
 describe("isProviderVisible", () => {
@@ -70,7 +70,7 @@ describe("isProviderVisible", () => {
   });
 
   test("returns true when featureFlag is set and the flag is enabled", () => {
-    _setOverridesForTesting({ "test-gate": true });
+    setOverridesForTesting({ "test-gate": true });
 
     seedProviders([
       {
@@ -93,7 +93,7 @@ describe("isProviderVisible", () => {
   });
 
   test("returns false when featureFlag is set and the flag is disabled", () => {
-    _setOverridesForTesting({ "test-gate": false });
+    setOverridesForTesting({ "test-gate": false });
 
     seedProviders([
       {
@@ -115,7 +115,7 @@ describe("isProviderVisible", () => {
   });
 
   test("listProviders returns all providers but isProviderVisible filters gated ones when flag is disabled", () => {
-    _setOverridesForTesting({ "test-gate": false });
+    setOverridesForTesting({ "test-gate": false });
 
     seedProviders([
       {

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

@@ -42,7 +42,7 @@ mock.module("../oauth/credential-token-resolver.js", () => ({
 
 import { eq } from "drizzle-orm";
 
-import { getDb, resetDb } from "../memory/db-connection.js";
+import { getDb } from "../memory/db-connection.js";
 import { getSqliteFrom } from "../memory/db-connection.js";
 import { initializeDb } from "../memory/db-init.js";
 import { migrateOAuthProvidersTokenAuthMethodDefault } from "../memory/migrations/216-oauth-providers-token-auth-method.js";
@@ -70,6 +70,7 @@ import {
   upsertApp,
 } from "../oauth/oauth-store.js";
 import { seedOAuthProviders } from "../oauth/seed-providers.js";
+import { resetDbForTesting } from "./db-test-helpers.js";
 import { getMockFetchCalls, mockFetch, resetMockFetch } from "./mock-fetch.js";
 
 initializeDb();
@@ -103,7 +104,7 @@ beforeEach(() => {
 });
 
 afterAll(() => {
-  resetDb();
+  resetDbForTesting();
 });
 
 // ---------------------------------------------------------------------------

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

@@ -111,8 +111,9 @@ describe("onboarding template contracts", () => {
       expect(identity).toContain("**Emoji:**");
     });
 
-    test("contains parsed field format guidance", () => {
-      expect(identity).toContain("parsed by the app");
+    test("does not invite assistant-owned identity restructuring", () => {
+      expect(identity).not.toContain("This file is yours");
+      expect(identity).not.toContain("parsed by the app");
     });
   });
 

package/src/__tests__/openai-provider.test.ts

@@ -1557,32 +1557,32 @@ describe("OpenRouterProvider reasoning", () => {
     });
   });
 
-  test("sends reasoning.enabled=false when thinking is explicitly disabled", async () => {
+  test("omits reasoning when thinking is explicitly disabled", async () => {
     const provider = new OpenRouterProvider("or-key", "x-ai/grok-4");
     await provider.sendMessage([userMsg("hi")], undefined, undefined, {
       config: { thinking: { type: "disabled" } },
     });
 
     expect(lastCreateParams).toBeTruthy();
-    expect(lastCreateParams!.reasoning).toEqual({ enabled: false });
+    expect(lastCreateParams!.reasoning).toBeUndefined();
   });
 
-  test("sends reasoning.enabled=false when thinking config is absent", async () => {
+  test("omits reasoning when thinking config is absent", async () => {
     const provider = new OpenRouterProvider("or-key", "x-ai/grok-4");
     await provider.sendMessage([userMsg("hi")], undefined, undefined, {
       config: {},
     });
 
     expect(lastCreateParams).toBeTruthy();
-    expect(lastCreateParams!.reasoning).toEqual({ enabled: false });
+    expect(lastCreateParams!.reasoning).toBeUndefined();
   });
 
-  test("sends reasoning.enabled=false when no options are provided", async () => {
+  test("omits reasoning when no options are provided", async () => {
     const provider = new OpenRouterProvider("or-key", "x-ai/grok-4");
     await provider.sendMessage([userMsg("hi")]);
 
     expect(lastCreateParams).toBeTruthy();
-    expect(lastCreateParams!.reasoning).toEqual({ enabled: false });
+    expect(lastCreateParams!.reasoning).toBeUndefined();
   });
 
   test("sends OpenRouter app-attribution headers on OpenAI-compatible requests", async () => {
@@ -1623,15 +1623,14 @@ describe("OpenRouterProvider reasoning", () => {
     });
   });
 
-  test("RetryProvider + OpenRouterProvider disables thinking end-to-end", async () => {
+  test("RetryProvider + OpenRouterProvider omits reasoning when thinking disabled", async () => {
     const provider = new OpenRouterProvider("or-key", "x-ai/grok-4");
     const retry = new RetryProvider(provider);
 
-    // thinking disabled at loop-level can arrive as an explicit disabled config.
     await retry.sendMessage([userMsg("hi")], undefined, undefined, {
       config: { thinking: { type: "disabled" } },
     });
-    expect(lastCreateParams!.reasoning).toEqual({ enabled: false });
+    expect(lastCreateParams!.reasoning).toBeUndefined();
   });
 
   test("nests effort under reasoning and omits top-level reasoning_effort", async () => {