muonroi-cli 1.8.1 → 1.8.4

package/dist/src/providers/__tests__/adapter-oauth-wiring.test.js

@@ -1,125 +0,0 @@
-/**
- * src/providers/__tests__/adapter-oauth-wiring.test.ts
- *
- * Integration-style tests: verify that createProviderFactoryAsync injects OAuth
- * headers when tokens are stored, and falls through to API-key path when they
- * are not.  No live network — token-store is mocked at module boundary.
- */
-import { beforeAll, describe, expect, it, vi } from "vitest";
-import { loadCatalog } from "../../models/registry.js";
-import { OpenAIOAuthProvider } from "../auth/openai-oauth.js";
-import { createProviderFactory, createProviderFactoryAsync } from "../runtime.js";
-// Hoist mock so it is applied before any import side-effects run.
-// When loadTokens returns null, createProviderFactoryAsync falls through to the
-// API-key path — this exercises the fallback branch without hitting the keychain.
-vi.mock("../auth/token-store.js", () => ({
-    loadTokens: vi.fn().mockResolvedValue(null),
-    saveTokens: vi.fn().mockResolvedValue(undefined),
-    deleteTokens: vi.fn().mockResolvedValue(undefined),
-}));
-// ---------------------------------------------------------------------------
-// Shared mock token
-// ---------------------------------------------------------------------------
-// Use clearly fake, non-secret-like values that won't trigger the pre-commit
-// secret scanner. Values are built at runtime so literal strings don't match
-// scanner patterns for bearer tokens or API keys.
-const FAKE_ACCESS = ["FAKE", "oauth", "access", "token"].join("_");
-const FAKE_REFRESH = ["FAKE", "oauth", "refresh", "token"].join("_");
-const FAKE_ID_TOKEN = ["FAKE", "oauth", "id", "token"].join("_");
-// Provider keys used in tests — built from parts to avoid literal-pattern matches.
-const FAKE_OPENAI_KEY = ["openai", "fixture", "key", "for", "unit", "tests"].join("-");
-const FAKE_ANTHROPIC_KEY = ["anthropic", "fixture", "key", "for", "unit", "tests"].join("-");
-const MOCK_TOKENS = {
-    accessToken: FAKE_ACCESS,
-    refreshToken: FAKE_REFRESH,
-    idToken: FAKE_ID_TOKEN,
-    accountId: "acct_testAccountId123",
-    expiresAt: Date.now() + 3_600_000, // 1 hour from now — no refresh needed
-    email: "test@example.com",
-};
-// ---------------------------------------------------------------------------
-beforeAll(async () => {
-    await loadCatalog();
-});
-// ---------------------------------------------------------------------------
-// createProviderFactory — headers option (sync path)
-// ---------------------------------------------------------------------------
-describe("createProviderFactory — headers option wires into OpenAI client", () => {
-    it("creates openai factory with custom headers (OAuth bearer)", () => {
-        const oauthHeaders = {
-            Authorization: `Bearer ${MOCK_TOKENS.accessToken}`,
-            "ChatGPT-Account-ID": MOCK_TOKENS.accountId,
-        };
-        const result = createProviderFactory("openai", { headers: oauthHeaders });
-        expect(result.id).toBe("openai");
-        // Factory should produce a model object without throwing
-        const model = result.factory("gpt-4o");
-        expect(model).toBeDefined();
-    });
-    it("creates openai factory with API key (no headers) — regression", () => {
-        const result = createProviderFactory("openai", {
-            apiKey: FAKE_OPENAI_KEY,
-        });
-        expect(result.id).toBe("openai");
-        const model = result.factory("gpt-4o");
-        expect(model).toBeDefined();
-    });
-    it("creates xai (Grok) factory with custom headers (subscription OAuth bearer)", () => {
-        // xAI OAuth tokens hit the same OpenAI-compatible api.x.ai/v1 host as a key,
-        // so the strategy just injects the Bearer header and builds without error.
-        const result = createProviderFactory("xai", {
-            headers: { Authorization: `Bearer ${MOCK_TOKENS.accessToken}` },
-        });
-        expect(result.id).toBe("xai");
-        const model = result.factory("grok-4.3");
-        expect(model).toBeDefined();
-    });
-    it("creates xai factory with API key (no headers) — regression", () => {
-        const result = createProviderFactory("xai", { apiKey: ["xai", "fixture", "key"].join("-") });
-        expect(result.id).toBe("xai");
-        const model = result.factory("grok-4.3");
-        expect(model).toBeDefined();
-    });
-});
-// ---------------------------------------------------------------------------
-// authHeaders shape — regression: Bearer + ChatGPT-Account-ID
-// ---------------------------------------------------------------------------
-describe("openAIOAuth.authHeaders — header shape", () => {
-    it("exposes Authorization: Bearer ... and ChatGPT-Account-ID", () => {
-        const oauthProvider = new OpenAIOAuthProvider();
-        const headers = oauthProvider.authHeaders(MOCK_TOKENS);
-        expect(headers.Authorization).toBe(`Bearer ${MOCK_TOKENS.accessToken}`);
-        expect(headers["ChatGPT-Account-ID"]).toBe(MOCK_TOKENS.accountId);
-    });
-    it("omits ChatGPT-Account-ID when accountId is absent", () => {
-        const oauthProvider = new OpenAIOAuthProvider();
-        const tokensNoAccount = { ...MOCK_TOKENS, accountId: undefined };
-        const headers = oauthProvider.authHeaders(tokensNoAccount);
-        expect(headers.Authorization).toBe(`Bearer ${MOCK_TOKENS.accessToken}`);
-        expect(headers["ChatGPT-Account-ID"]).toBeUndefined();
-    });
-});
-// ---------------------------------------------------------------------------
-// createProviderFactoryAsync — API-key fallback (no OAuth tokens)
-// ---------------------------------------------------------------------------
-describe("createProviderFactoryAsync — API-key fallback when no tokens", () => {
-    it("returns a valid factory when no OAuth tokens are stored", async () => {
-        // token-store mock is hoisted at top level (returns null → API-key path)
-        const result = await createProviderFactoryAsync("openai", {
-            apiKey: FAKE_OPENAI_KEY,
-        });
-        expect(result.id).toBe("openai");
-        const model = result.factory("gpt-4o");
-        expect(model).toBeDefined();
-    });
-    it("non-OpenAI providers are unaffected — async path same as sync", async () => {
-        // Anthropic should not touch token-store at all
-        const result = await createProviderFactoryAsync("anthropic", {
-            apiKey: FAKE_ANTHROPIC_KEY,
-        });
-        expect(result.id).toBe("anthropic");
-        const model = result.factory("claude-sonnet-4-6");
-        expect(model).toBeDefined();
-    });
-});
-//# sourceMappingURL=adapter-oauth-wiring.test.js.map

package/dist/src/providers/__tests__/capabilities-cosmetic.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/src/providers/__tests__/capabilities-cosmetic.test.js

@@ -1,109 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { getProviderCapabilities } from "../capabilities.js";
-/**
- * G5 cosmetic-capability coverage — verifies the three methods added in
- * Phase 12.2 group 5 (`consoleSignupURL`, `cacheMetricLayout`,
- * `systemPromptStyle`) return the expected per-provider values. These
- * capabilities replace the inlined `consoleUrlFor("anthropic")`,
- * `providerId !== "anthropic"`, and `model.startsWith("deepseek")` literals
- * across the codebase — see plan 12.2-G5 for the call-site map.
- */
-describe("ProviderCapabilities — G5 cosmetic methods", () => {
-    describe("consoleSignupURL", () => {
-        it("anthropic → https://console.anthropic.com/settings/keys", () => {
-            expect(getProviderCapabilities("anthropic").consoleSignupURL()).toBe("https://console.anthropic.com/settings/keys");
-        });
-        it("openai → https://platform.openai.com/api-keys", () => {
-            expect(getProviderCapabilities("openai").consoleSignupURL()).toBe("https://platform.openai.com/api-keys");
-        });
-        it("google → https://aistudio.google.com/app/apikey", () => {
-            expect(getProviderCapabilities("google").consoleSignupURL()).toBe("https://aistudio.google.com/app/apikey");
-        });
-        it("deepseek → https://platform.deepseek.com/api_keys", () => {
-            expect(getProviderCapabilities("deepseek").consoleSignupURL()).toBe("https://platform.deepseek.com/api_keys");
-        });
-        it("siliconflow → https://cloud.siliconflow.com/account/ak", () => {
-            expect(getProviderCapabilities("siliconflow").consoleSignupURL()).toBe("https://cloud.siliconflow.com/account/ak");
-        });
-        it("xai → https://console.x.ai/", () => {
-            expect(getProviderCapabilities("xai").consoleSignupURL()).toBe("https://console.x.ai/");
-        });
-        it("ollama → keyless placeholder", () => {
-            expect(getProviderCapabilities("ollama").consoleSignupURL()).toBe("(no key needed for Ollama)");
-        });
-        it("unknown provider id falls back to default anthropic console", () => {
-            expect(getProviderCapabilities("does-not-exist").consoleSignupURL()).toBe("https://console.anthropic.com/settings/keys");
-        });
-    });
-    describe("cacheMetricLayout", () => {
-        it("anthropic → cachedInputTokens with creation supported", () => {
-            const layout = getProviderCapabilities("anthropic").cacheMetricLayout();
-            expect(layout.readField).toBe("cachedInputTokens");
-            expect(layout.creationSupported).toBe(true);
-        });
-        it("openai → cachedInputTokens without creation", () => {
-            const layout = getProviderCapabilities("openai").cacheMetricLayout();
-            expect(layout.readField).toBe("cachedInputTokens");
-            expect(layout.creationSupported).toBe(false);
-        });
-        it("google → default cachedInputTokens layout", () => {
-            const layout = getProviderCapabilities("google").cacheMetricLayout();
-            expect(layout.readField).toBe("cachedInputTokens");
-            expect(layout.creationSupported).toBe(false);
-        });
-        it("xai → default cachedInputTokens layout", () => {
-            const layout = getProviderCapabilities("xai").cacheMetricLayout();
-            expect(layout.readField).toBe("cachedInputTokens");
-            expect(layout.creationSupported).toBe(false);
-        });
-        it("deepseek → promptCacheHitTokens layout, no creation", () => {
-            const layout = getProviderCapabilities("deepseek").cacheMetricLayout();
-            expect(layout.readField).toBe("promptCacheHitTokens");
-            expect(layout.creationSupported).toBe(false);
-        });
-        it("siliconflow → inherits deepseek layout (promptCacheHitTokens)", () => {
-            const layout = getProviderCapabilities("siliconflow").cacheMetricLayout();
-            expect(layout.readField).toBe("promptCacheHitTokens");
-            expect(layout.creationSupported).toBe(false);
-        });
-        it("ollama → default layout", () => {
-            const layout = getProviderCapabilities("ollama").cacheMetricLayout();
-            expect(layout.readField).toBe("cachedInputTokens");
-            expect(layout.creationSupported).toBe(false);
-        });
-    });
-    describe("systemPromptStyle", () => {
-        it("anthropic → anthropic style", () => {
-            expect(getProviderCapabilities("anthropic").systemPromptStyle()).toBe("anthropic");
-        });
-        it("openai → openai style", () => {
-            expect(getProviderCapabilities("openai").systemPromptStyle()).toBe("openai");
-        });
-        it("google → generic", () => {
-            expect(getProviderCapabilities("google").systemPromptStyle()).toBe("generic");
-        });
-        it("xai → generic", () => {
-            expect(getProviderCapabilities("xai").systemPromptStyle()).toBe("generic");
-        });
-        it("deepseek → generic", () => {
-            expect(getProviderCapabilities("deepseek").systemPromptStyle()).toBe("generic");
-        });
-        it("siliconflow → generic (inherits deepseek default)", () => {
-            expect(getProviderCapabilities("siliconflow").systemPromptStyle()).toBe("generic");
-        });
-        it("ollama → generic", () => {
-            expect(getProviderCapabilities("ollama").systemPromptStyle()).toBe("generic");
-        });
-    });
-    describe("ALL_PROVIDER_IDS single source of truth", () => {
-        it("contains exactly 7 providers in canonical order", async () => {
-            const { ALL_PROVIDER_IDS } = await import("../types.js");
-            expect(ALL_PROVIDER_IDS).toEqual(["anthropic", "openai", "google", "deepseek", "siliconflow", "xai", "ollama"]);
-        });
-        it("iterProviders returns the same canonical list", async () => {
-            const { ALL_PROVIDER_IDS, iterProviders } = await import("../types.js");
-            expect(iterProviders()).toBe(ALL_PROVIDER_IDS);
-        });
-    });
-});
-//# sourceMappingURL=capabilities-cosmetic.test.js.map

package/dist/src/providers/__tests__/capabilities-flags.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/src/providers/__tests__/capabilities-flags.test.js

@@ -1,145 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { getProviderCapabilities } from "../capabilities.js";
-/**
- * G1 flag-method coverage — verifies the three capability methods added in
- * Phase 12.2 group 1 (`supportsClientTools`, `usesResponsesAPI`,
- * `acceptsParam`) return the same value the orchestrator's inline
- * `modelInfo?.flag === false` checks used to compute. Subclasses
- * (DeepSeek / Ollama) should inherit the defaults — they only override
- * `supportsResponseTool`, not the new G1 methods.
- */
-function baseModel(overrides) {
-    return {
-        id: "test-model",
-        name: "Test Model",
-        contextWindow: 128_000,
-        inputPrice: 0,
-        outputPrice: 0,
-        reasoning: false,
-        description: "fixture",
-        provider: "openai",
-        ...overrides,
-    };
-}
-describe("ProviderCapabilities — G1 flag methods", () => {
-    describe("supportsClientTools", () => {
-        it("returns true by default (anthropic, claude-sonnet, no flags)", () => {
-            const caps = getProviderCapabilities("anthropic");
-            const model = baseModel({ provider: "anthropic", id: "claude-sonnet-4" });
-            expect(caps.supportsClientTools(model)).toBe(true);
-        });
-        it("returns false when ModelInfo.supportsClientTools === false", () => {
-            const caps = getProviderCapabilities("openai");
-            const model = baseModel({ supportsClientTools: false });
-            expect(caps.supportsClientTools(model)).toBe(false);
-        });
-        it("returns true when ModelInfo.supportsClientTools === true (explicit)", () => {
-            const caps = getProviderCapabilities("openai");
-            const model = baseModel({ supportsClientTools: true });
-            expect(caps.supportsClientTools(model)).toBe(true);
-        });
-        it("returns true when ModelInfo is undefined", () => {
-            const caps = getProviderCapabilities("openai");
-            expect(caps.supportsClientTools(undefined)).toBe(true);
-        });
-        it("DeepSeek subclass inherits default (does not override G1 methods)", () => {
-            const caps = getProviderCapabilities("deepseek");
-            const model = baseModel({ provider: "deepseek", supportsClientTools: false });
-            expect(caps.supportsClientTools(model)).toBe(false);
-            const model2 = baseModel({ provider: "deepseek" });
-            expect(caps.supportsClientTools(model2)).toBe(true);
-        });
-        it("SiliconFlow subclass inherits default", () => {
-            const caps = getProviderCapabilities("siliconflow");
-            const model = baseModel({ provider: "siliconflow" });
-            expect(caps.supportsClientTools(model)).toBe(true);
-        });
-    });
-    describe("usesResponsesAPI", () => {
-        it("returns false by default", () => {
-            const caps = getProviderCapabilities("openai");
-            const model = baseModel({ id: "gpt-4o" });
-            expect(caps.usesResponsesAPI(model)).toBe(false);
-        });
-        it("returns true when ModelInfo.responsesOnly === true (gpt-5 fixture)", () => {
-            const caps = getProviderCapabilities("openai");
-            const model = baseModel({ id: "gpt-5", responsesOnly: true });
-            expect(caps.usesResponsesAPI(model)).toBe(true);
-        });
-        it("returns false when ModelInfo.responsesOnly === false", () => {
-            const caps = getProviderCapabilities("openai");
-            const model = baseModel({ responsesOnly: false });
-            expect(caps.usesResponsesAPI(model)).toBe(false);
-        });
-        it("returns false when ModelInfo is undefined", () => {
-            const caps = getProviderCapabilities("anthropic");
-            expect(caps.usesResponsesAPI(undefined)).toBe(false);
-        });
-        it("G3 promotion: reasoning-only openai model returns true (migrated from runtime.ts)", () => {
-            // G3: OpenAIProviderCapabilities.usesResponsesAPI now returns true when
-            // `responsesOnly === true` OR `reasoning === true`. Prior to G3 the
-            // `reasoning === true` branch lived inline in runtime.ts:185.
-            const caps = getProviderCapabilities("openai");
-            const model = baseModel({ id: "gpt-5", reasoning: true /* no responsesOnly */ });
-            expect(caps.usesResponsesAPI(model)).toBe(true);
-        });
-    });
-    describe("acceptsParam('maxOutputTokens')", () => {
-        it("returns true by default", () => {
-            const caps = getProviderCapabilities("openai");
-            const model = baseModel({});
-            expect(caps.acceptsParam("maxOutputTokens", model)).toBe(true);
-        });
-        it("returns false when supportsMaxOutputTokens === false (gpt-5 fixture)", () => {
-            const caps = getProviderCapabilities("openai");
-            const model = baseModel({ id: "gpt-5", supportsMaxOutputTokens: false });
-            expect(caps.acceptsParam("maxOutputTokens", model)).toBe(false);
-        });
-        it("returns true when ModelInfo is undefined", () => {
-            const caps = getProviderCapabilities("anthropic");
-            expect(caps.acceptsParam("maxOutputTokens", undefined)).toBe(true);
-        });
-    });
-    describe("acceptsParam('temperature' / 'topP')", () => {
-        it("returns true for non-reasoning models", () => {
-            const caps = getProviderCapabilities("openai");
-            const model = baseModel({ reasoning: false });
-            expect(caps.acceptsParam("temperature", model)).toBe(true);
-            expect(caps.acceptsParam("topP", model)).toBe(true);
-        });
-        it("returns false for reasoning models (gpt-5 reasoning=true)", () => {
-            const caps = getProviderCapabilities("openai");
-            const model = baseModel({ id: "gpt-5", reasoning: true });
-            expect(caps.acceptsParam("temperature", model)).toBe(false);
-            expect(caps.acceptsParam("topP", model)).toBe(false);
-        });
-        it("returns true when ModelInfo is undefined", () => {
-            const caps = getProviderCapabilities("anthropic");
-            expect(caps.acceptsParam("temperature", undefined)).toBe(true);
-            expect(caps.acceptsParam("topP", undefined)).toBe(true);
-        });
-    });
-    describe("all providers — defaults applied uniformly", () => {
-        for (const id of ["anthropic", "openai", "google", "xai", "deepseek", "siliconflow", "ollama"]) {
-            it(`${id}: bare model → supportsClientTools=true, usesResponsesAPI=false, acceptsParam(*)=true`, () => {
-                const caps = getProviderCapabilities(id);
-                const model = baseModel({ provider: id });
-                expect(caps.supportsClientTools(model)).toBe(true);
-                expect(caps.usesResponsesAPI(model)).toBe(false);
-                expect(caps.acceptsParam("maxOutputTokens", model)).toBe(true);
-                expect(caps.acceptsParam("temperature", model)).toBe(true);
-                expect(caps.acceptsParam("topP", model)).toBe(true);
-            });
-        }
-    });
-    describe("unknown provider id falls back to reliable defaults", () => {
-        it("returns reliable answers for all G1 methods", () => {
-            const caps = getProviderCapabilities("does-not-exist");
-            const model = baseModel({});
-            expect(caps.supportsClientTools(model)).toBe(true);
-            expect(caps.usesResponsesAPI(model)).toBe(false);
-            expect(caps.acceptsParam("maxOutputTokens", model)).toBe(true);
-        });
-    });
-});
-//# sourceMappingURL=capabilities-flags.test.js.map

package/dist/src/providers/__tests__/capabilities-provider-options.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/src/providers/__tests__/capabilities-provider-options.test.js

@@ -1,201 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { getProviderCapabilities } from "../capabilities.js";
-/**
- * G3 — provider-specific `buildProviderOptions` coverage.
- *
- * Locks in the contract that every provider quirk previously inlined in
- * `runtime.ts` (anthropic.thinking, openai/xai reasoningEffort) and in
- * `orchestrator.ts` (openai.promptCacheKey) now flows through the
- * capability layer. The F1 cost-leak invariant — promptCacheKey stable
- * across rounds in the same session — is asserted directly here.
- */
-function baseModel(overrides) {
-    return {
-        id: "test-model",
-        name: "Test Model",
-        contextWindow: 128_000,
-        inputPrice: 0,
-        outputPrice: 0,
-        reasoning: false,
-        description: "fixture",
-        provider: "openai",
-        ...overrides,
-    };
-}
-describe("ProviderCapabilities — G3 buildProviderOptions", () => {
-    describe("Anthropic", () => {
-        it("returns enabled thinking with 8000 budget when thinkingType=enabled", () => {
-            const caps = getProviderCapabilities("anthropic");
-            const model = baseModel({ provider: "anthropic", thinkingType: "enabled" });
-            const opts = caps.buildProviderOptions({ model });
-            expect(opts).toEqual({ anthropic: { thinking: { type: "enabled", budgetTokens: 8_000 } } });
-        });
-        it("returns enabled thinking with 10000 budget when thinkingType=adaptive", () => {
-            const caps = getProviderCapabilities("anthropic");
-            const model = baseModel({ provider: "anthropic", thinkingType: "adaptive" });
-            const opts = caps.buildProviderOptions({ model });
-            expect(opts).toEqual({ anthropic: { thinking: { type: "enabled", budgetTokens: 10_000 } } });
-        });
-        it("returns undefined when thinkingType is absent", () => {
-            const caps = getProviderCapabilities("anthropic");
-            const model = baseModel({ provider: "anthropic" });
-            expect(caps.buildProviderOptions({ model })).toBeUndefined();
-        });
-        it("returns undefined when model is undefined", () => {
-            const caps = getProviderCapabilities("anthropic");
-            expect(caps.buildProviderOptions({ model: undefined })).toBeUndefined();
-        });
-        it("ignores sessionId (anthropic does not use promptCacheKey)", () => {
-            const caps = getProviderCapabilities("anthropic");
-            const model = baseModel({ provider: "anthropic", thinkingType: "enabled" });
-            const opts = caps.buildProviderOptions({ model, sessionId: "ignored-by-anthropic" });
-            expect(opts).toEqual({ anthropic: { thinking: { type: "enabled", budgetTokens: 8_000 } } });
-        });
-    });
-    describe("OpenAI", () => {
-        it("returns reasoningEffort when supportsReasoningEffort=true (uses ctx.reasoningEffort)", () => {
-            const caps = getProviderCapabilities("openai");
-            const model = baseModel({ provider: "openai", supportsReasoningEffort: true });
-            const opts = caps.buildProviderOptions({ model, reasoningEffort: "high" });
-            expect(opts).toEqual({ openai: { reasoningEffort: "high" } });
-        });
-        it("falls back to model defaultReasoningEffort when ctx.reasoningEffort is undefined", () => {
-            const caps = getProviderCapabilities("openai");
-            const model = baseModel({
-                provider: "openai",
-                supportsReasoningEffort: true,
-                defaultReasoningEffort: "low",
-            });
-            const opts = caps.buildProviderOptions({ model });
-            expect(opts).toEqual({ openai: { reasoningEffort: "low" } });
-        });
-        it("defaults to 'medium' reasoningEffort when neither ctx nor model specifies one", () => {
-            const caps = getProviderCapabilities("openai");
-            const model = baseModel({ provider: "openai", supportsReasoningEffort: true });
-            const opts = caps.buildProviderOptions({ model });
-            expect(opts).toEqual({ openai: { reasoningEffort: "medium" } });
-        });
-        it("returns promptCacheKey when sessionId is provided", () => {
-            const caps = getProviderCapabilities("openai");
-            const model = baseModel({ provider: "openai" });
-            const opts = caps.buildProviderOptions({ model, sessionId: "session-abc-123" });
-            expect(opts).toBeDefined();
-            const openai = opts?.openai;
-            expect(openai.promptCacheKey).toBeDefined();
-            expect(typeof openai.promptCacheKey).toBe("string");
-            expect(openai.promptCacheKey?.length).toBe(32); // sha256 hex sliced to 32
-        });
-        it("merges reasoningEffort + promptCacheKey when both supplied", () => {
-            const caps = getProviderCapabilities("openai");
-            const model = baseModel({ provider: "openai", supportsReasoningEffort: true });
-            const opts = caps.buildProviderOptions({ model, sessionId: "abc", reasoningEffort: "xhigh" });
-            expect(opts?.openai).toMatchObject({ reasoningEffort: "xhigh" });
-            expect((opts?.openai).promptCacheKey).toBeDefined();
-        });
-        it("returns undefined when nothing applies (no sessionId, no reasoning support)", () => {
-            const caps = getProviderCapabilities("openai");
-            const model = baseModel({ provider: "openai" });
-            expect(caps.buildProviderOptions({ model })).toBeUndefined();
-        });
-        it("F1 invariant — same sessionId yields same promptCacheKey across calls", () => {
-            const caps = getProviderCapabilities("openai");
-            const model = baseModel({ provider: "openai" });
-            const a = caps.buildProviderOptions({ model, sessionId: "session-stable-id" });
-            const b = caps.buildProviderOptions({ model, sessionId: "session-stable-id" });
-            const c = caps.buildProviderOptions({ model, sessionId: "session-stable-id" });
-            const keyA = (a?.openai).promptCacheKey;
-            const keyB = (b?.openai).promptCacheKey;
-            const keyC = (c?.openai).promptCacheKey;
-            expect(keyA).toBeDefined();
-            expect(keyA).toBe(keyB);
-            expect(keyB).toBe(keyC);
-        });
-        it("F1 invariant — different sessionIds yield different promptCacheKeys", () => {
-            const caps = getProviderCapabilities("openai");
-            const model = baseModel({ provider: "openai" });
-            const a = caps.buildProviderOptions({ model, sessionId: "session-1" });
-            const b = caps.buildProviderOptions({ model, sessionId: "session-2" });
-            expect((a?.openai).promptCacheKey).not.toBe((b?.openai).promptCacheKey);
-        });
-        it("usesResponsesAPI returns true for reasoning models (G3-promoted from G1)", () => {
-            const caps = getProviderCapabilities("openai");
-            const reasoningModel = baseModel({ id: "gpt-5", reasoning: true });
-            expect(caps.usesResponsesAPI(reasoningModel)).toBe(true);
-            const responsesOnlyModel = baseModel({ id: "o1-preview", responsesOnly: true });
-            expect(caps.usesResponsesAPI(responsesOnlyModel)).toBe(true);
-            const plainModel = baseModel({ id: "gpt-4o" });
-            expect(caps.usesResponsesAPI(plainModel)).toBe(false);
-        });
-    });
-    describe("xAI", () => {
-        it("returns reasoningEffort when supportsReasoningEffort=true", () => {
-            const caps = getProviderCapabilities("xai");
-            const model = baseModel({ provider: "xai", supportsReasoningEffort: true });
-            const opts = caps.buildProviderOptions({ model, reasoningEffort: "low" });
-            expect(opts).toEqual({ xai: { reasoningEffort: "low" } });
-        });
-        it("falls back to model defaultReasoningEffort", () => {
-            const caps = getProviderCapabilities("xai");
-            const model = baseModel({
-                provider: "xai",
-                supportsReasoningEffort: true,
-                defaultReasoningEffort: "high",
-            });
-            const opts = caps.buildProviderOptions({ model });
-            expect(opts).toEqual({ xai: { reasoningEffort: "high" } });
-        });
-        it("returns undefined when supportsReasoningEffort is absent", () => {
-            const caps = getProviderCapabilities("xai");
-            const model = baseModel({ provider: "xai" });
-            expect(caps.buildProviderOptions({ model })).toBeUndefined();
-        });
-        it("ignores sessionId (xai has no promptCacheKey)", () => {
-            const caps = getProviderCapabilities("xai");
-            const model = baseModel({ provider: "xai", supportsReasoningEffort: true });
-            const opts = caps.buildProviderOptions({ model, sessionId: "session-xyz" });
-            expect(opts).toEqual({ xai: { reasoningEffort: "medium" } });
-        });
-    });
-    describe("Providers without buildProviderOptions overrides — return undefined", () => {
-        for (const id of ["google", "ollama"]) {
-            it(`${id}: returns undefined for any context`, () => {
-                const caps = getProviderCapabilities(id);
-                const model = baseModel({ provider: id, supportsReasoningEffort: true, thinkingType: "enabled" });
-                expect(caps.buildProviderOptions({ model })).toBeUndefined();
-                expect(caps.buildProviderOptions({ model, sessionId: "s", reasoningEffort: "high" })).toBeUndefined();
-                expect(caps.buildProviderOptions({ model: undefined })).toBeUndefined();
-            });
-        }
-    });
-    // DeepSeek/SiliconFlow no longer override buildProviderOptions.
-    // The previous RC#1 workaround (disable thinking entirely) was removed
-    // after reasoning-roundtrip.test.ts proved that @ai-sdk/openai-compatible
-    // 2.0.42 correctly serializes assistant reasoning parts as
-    // `reasoning_content` on the wire — satisfying the DeepSeek thinking_mode
-    // guide requirement natively.
-    describe("DeepSeek / SiliconFlow — reasoning round-trips natively (no override)", () => {
-        it("deepseek: returns undefined regardless of thinkingType", () => {
-            const caps = getProviderCapabilities("deepseek");
-            expect(caps.buildProviderOptions({ model: baseModel({ provider: "deepseek", thinkingType: "enabled" }) })).toBeUndefined();
-            expect(caps.buildProviderOptions({ model: baseModel({ provider: "deepseek", thinkingType: "adaptive" }) })).toBeUndefined();
-            expect(caps.buildProviderOptions({ model: baseModel({ provider: "deepseek" }) })).toBeUndefined();
-            expect(caps.buildProviderOptions({ model: undefined })).toBeUndefined();
-        });
-        it("siliconflow: returns undefined regardless of thinkingType", () => {
-            const caps = getProviderCapabilities("siliconflow");
-            expect(caps.buildProviderOptions({
-                model: baseModel({ provider: "siliconflow", thinkingType: "enabled" }),
-            })).toBeUndefined();
-            expect(caps.buildProviderOptions({ model: baseModel({ provider: "siliconflow" }) })).toBeUndefined();
-        });
-    });
-    describe("Unknown provider id falls back to default (undefined)", () => {
-        it("returns undefined for any context", () => {
-            const caps = getProviderCapabilities("does-not-exist");
-            const model = baseModel({});
-            expect(caps.buildProviderOptions({ model })).toBeUndefined();
-            expect(caps.buildProviderOptions({ model, sessionId: "x" })).toBeUndefined();
-        });
-    });
-});
-//# sourceMappingURL=capabilities-provider-options.test.js.map

package/dist/src/providers/__tests__/capabilities-sanitize.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/src/providers/__tests__/capabilities-sanitize.test.js

@@ -1,60 +0,0 @@
-/**
- * sanitizeHistory coverage — every provider now returns the input array by
- * reference. The previous DeepSeek/SiliconFlow strip was removed once
- * reasoning-roundtrip.test.ts proved AI SDK 2.0.42 serializes assistant
- * reasoning parts as `reasoning_content` natively. Stripping them BEFORE the
- * send would re-introduce the original HTTP 400 code 20015 by breaking the
- * round-trip the DeepSeek thinking_mode guide requires.
- */
-import { describe, expect, it } from "vitest";
-import { getProviderCapabilities } from "../capabilities.js";
-const ALL_PROVIDERS = ["anthropic", "openai", "google", "xai", "deepseek", "siliconflow", "ollama"];
-describe("ProviderCapabilities.sanitizeHistory — identity for every provider", () => {
-    for (const p of ALL_PROVIDERS) {
-        it(`${p} returns the input array by reference when reasoning parts present`, () => {
-            const caps = getProviderCapabilities(p);
-            const messages = [
-                { role: "user", content: "hi" },
-                {
-                    role: "assistant",
-                    content: [
-                        { type: "reasoning", text: "internal thought" },
-                        { type: "text", text: "Hello!" },
-                    ],
-                },
-            ];
-            const out = caps.sanitizeHistory(messages);
-            expect(out).toBe(messages);
-        });
-        it(`${p} returns the input array by reference when no reasoning parts present`, () => {
-            const caps = getProviderCapabilities(p);
-            const messages = [
-                { role: "user", content: "hi" },
-                { role: "assistant", content: [{ type: "text", text: "hello" }] },
-            ];
-            const out = caps.sanitizeHistory(messages);
-            expect(out).toBe(messages);
-        });
-    }
-    it("unknown provider id falls back to identity", () => {
-        const caps = getProviderCapabilities("unknown-future-provider");
-        const messages = [
-            {
-                role: "assistant",
-                content: [{ type: "reasoning", text: "x" }],
-            },
-        ];
-        expect(caps.sanitizeHistory(messages)).toBe(messages);
-    });
-    it("deepseek still drops respond_general tool (separate quirk from reasoning)", () => {
-        const caps = getProviderCapabilities("deepseek");
-        expect(caps.supportsResponseTool("general")).toBe(false);
-        expect(caps.supportsResponseTool("plan")).toBe(true);
-    });
-    it("siliconflow still drops respond_general tool (separate quirk from reasoning)", () => {
-        const caps = getProviderCapabilities("siliconflow");
-        expect(caps.supportsResponseTool("general")).toBe(false);
-        expect(caps.supportsResponseTool("plan")).toBe(true);
-    });
-});
-//# sourceMappingURL=capabilities-sanitize.test.js.map