muonroi-cli 1.4.0 → 1.4.1

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

@@ -1,166 +0,0 @@
-import { describe, expect, it } from "vitest";
-import type { ModelInfo } from "../../types/index.js";
-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: Partial<ModelInfo>): ModelInfo {
-  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"] as const) {
-      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);
-    });
-  });
-});

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

@@ -1,232 +0,0 @@
-import { describe, expect, it } from "vitest";
-import type { ModelInfo } from "../../types/index.js";
-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: Partial<ModelInfo>): ModelInfo {
-  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 as { promptCacheKey?: string };
-      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 as { promptCacheKey?: string }).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 as { promptCacheKey?: string }).promptCacheKey;
-      const keyB = (b?.openai as { promptCacheKey?: string }).promptCacheKey;
-      const keyC = (c?.openai as { promptCacheKey?: string }).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 as { promptCacheKey?: string }).promptCacheKey).not.toBe(
-        (b?.openai as { promptCacheKey?: string }).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"] as const) {
-      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();
-    });
-  });
-});

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

@@ -1,66 +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";
-import type { ProviderId } from "../types.js";
-
-const ALL_PROVIDERS: ProviderId[] = ["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);
-  });
-});

package/src/providers/__tests__/capabilities.test.ts

@@ -1,44 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { getProviderCapabilities } from "../capabilities.js";
-
-describe("ProviderCapabilities", () => {
-  describe("supportsResponseTool — reliable providers", () => {
-    for (const id of ["openai", "anthropic", "google", "xai"] as const) {
-      it(`${id} reports true for all task types`, () => {
-        const caps = getProviderCapabilities(id);
-        expect(caps.supportsResponseTool("general")).toBe(true);
-        expect(caps.supportsResponseTool("analyze")).toBe(true);
-        expect(caps.supportsResponseTool("plan")).toBe(true);
-        expect(caps.supportsResponseTool("debug")).toBe(true);
-      });
-    }
-  });
-
-  describe("supportsResponseTool — DeepSeek family", () => {
-    for (const id of ["deepseek", "siliconflow"] as const) {
-      it(`${id} reports false for general (token leak), true for structured`, () => {
-        const caps = getProviderCapabilities(id);
-        expect(caps.supportsResponseTool("general")).toBe(false);
-        expect(caps.supportsResponseTool("analyze")).toBe(true);
-        expect(caps.supportsResponseTool("plan")).toBe(true);
-        expect(caps.supportsResponseTool("debug")).toBe(true);
-      });
-    }
-  });
-
-  describe("supportsResponseTool — Ollama (conservative)", () => {
-    it("reports false for general, true for structured", () => {
-      const caps = getProviderCapabilities("ollama");
-      expect(caps.supportsResponseTool("general")).toBe(false);
-      expect(caps.supportsResponseTool("analyze")).toBe(true);
-    });
-  });
-
-  describe("unknown provider id", () => {
-    it("falls back to reliable defaults", () => {
-      const caps = getProviderCapabilities("does-not-exist");
-      expect(caps.supportsResponseTool("general")).toBe(true);
-      expect(caps.supportsResponseTool("analyze")).toBe(true);
-    });
-  });
-});

package/src/providers/__tests__/provider-coverage.test.ts

@@ -1,48 +0,0 @@
-/**
- * Cross-registry coverage test.
- *
- * Single source of truth for "what providers exist" is `ALL_PROVIDER_IDS`
- * in src/providers/types.ts. Every other registry (strategies, adapter
- * factories, capabilities) MUST cover every id in `ALL_PROVIDER_IDS` —
- * otherwise we get silent desync where adding a provider to the union
- * type works at compile time but blows up at runtime for one code path.
- *
- * This test fails loudly when a new ProviderId is added to types.ts
- * without matching entries in all dispatch tables.
- */
-import { describe, expect, it } from "vitest";
-import { createAdapter } from "../adapter.js";
-import { getProviderCapabilities } from "../capabilities.js";
-import { getProviderStrategy } from "../strategies/registry.js";
-import { ALL_PROVIDER_IDS } from "../types.js";
-
-describe("provider registry coverage", () => {
-  it("every ProviderId has a strategy", () => {
-    for (const id of ALL_PROVIDER_IDS) {
-      expect(() => getProviderStrategy(id), `strategy missing for ${id}`).not.toThrow();
-      const s = getProviderStrategy(id);
-      expect(s.id, `strategy.id mismatch for ${id}`).toBe(id);
-    }
-  });
-
-  it("every ProviderId has an adapter factory", () => {
-    for (const id of ALL_PROVIDER_IDS) {
-      const adapter = createAdapter(id, { model: "test-model", apiKey: "test-key-long-enough-for-test" });
-      expect(adapter.id, `adapter.id mismatch for ${id}`).toBe(id);
-      expect(typeof adapter.stream, `adapter.stream missing for ${id}`).toBe("function");
-    }
-  });
-
-  it("every ProviderId has a capability entry", () => {
-    for (const id of ALL_PROVIDER_IDS) {
-      const caps = getProviderCapabilities(id);
-      expect(caps, `capabilities missing for ${id}`).toBeDefined();
-      // Sanity-check one method to make sure it is a real instance, not a default fallback.
-      expect(typeof caps.acceptsParam).toBe("function");
-    }
-  });
-
-  it("strategy registry rejects unknown ids loudly", () => {
-    expect(() => getProviderStrategy("nonexistent-provider")).toThrow(/No provider strategy registered/);
-  });
-});