chore: import upstream snapshot with attribution

tests/unit/modelsdevsync-transform-split.test.ts

@@ -0,0 +1,109 @@
+/**
+ * Split-guard — modelsDevSync ↔ modelsDevSync/transform
+ *
+ * Guards the extraction of the pure transform layer (provider-id mapping +
+ * raw→OmniRoute pricing/capability transforms) into the leaf
+ * src/lib/modelsDevSync/transform.ts. Characterizes the provider map and the
+ * two transform functions, and proves the host still re-exports them so its
+ * public API is unchanged. DB-free by design — the transform layer is pure.
+ */
+
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+
+import {
+  mapProviderId,
+  transformModelsDevToPricing,
+  transformModelsDevToCapabilities,
+  MODELS_DEV_PROVIDER_MAP,
+} from "../../src/lib/modelsDevSync/transform.ts";
+
+describe("modelsDevSync/transform split-guard", () => {
+  it("maps known models.dev provider ids to OmniRoute aliases", () => {
+    assert.deepEqual(mapProviderId("openai"), ["openai", "cx"]);
+    assert.deepEqual(mapProviderId("anthropic"), ["anthropic", "cc"]);
+    assert.deepEqual(mapProviderId("zai"), ["zai", "glm"]);
+    assert.deepEqual(mapProviderId("bedrock"), ["kiro", "kr"]);
+    assert.deepEqual(mapProviderId("opencode"), ["opencode", "opencode-zen"]);
+  });
+
+  it("falls back to the raw id for unmapped providers", () => {
+    assert.deepEqual(mapProviderId("some-unknown-provider"), ["some-unknown-provider"]);
+  });
+
+  it("exports a non-trivial provider map table", () => {
+    assert.ok(MODELS_DEV_PROVIDER_MAP.openai);
+    assert.ok(Object.keys(MODELS_DEV_PROVIDER_MAP).length > 30);
+  });
+
+  it("transforms cost → pricing and writes to every mapped provider", () => {
+    const raw = {
+      openai: {
+        id: "openai",
+        models: {
+          "gpt-x": {
+            id: "gpt-x",
+            name: "GPT-X",
+            cost: { input: 1, output: 2, cache_read: 0.5, cache_write: 3, reasoning: 4 },
+          },
+        },
+      },
+    };
+    const pricing = transformModelsDevToPricing(raw as never);
+    assert.deepEqual(pricing.openai["gpt-x"], {
+      input: 1,
+      output: 2,
+      cached: 0.5,
+      cache_creation: 3,
+      reasoning: 4,
+    });
+    // openai maps to ["openai", "cx"] — both must receive the entry.
+    assert.deepEqual(pricing.cx["gpt-x"], pricing.openai["gpt-x"]);
+  });
+
+  it("skips models with no cost or missing input pricing", () => {
+    const raw = {
+      openai: {
+        id: "openai",
+        models: {
+          "no-cost": { id: "no-cost", name: "x" },
+          "no-input": { id: "no-input", name: "y", cost: { output: 5 } },
+        },
+      },
+    };
+    const pricing = transformModelsDevToPricing(raw as never);
+    assert.equal(pricing.openai, undefined);
+  });
+
+  it("transforms capabilities incl. interleaved=true → reasoning_content", () => {
+    const raw = {
+      anthropic: {
+        id: "anthropic",
+        models: {
+          "claude-x": {
+            id: "claude-x",
+            name: "Claude X",
+            tool_call: true,
+            reasoning: true,
+            interleaved: true,
+            modalities: { input: ["text", "image"], output: ["text"] },
+          },
+        },
+      },
+    };
+    const caps = transformModelsDevToCapabilities(raw as never);
+    assert.equal(caps.anthropic["claude-x"].tool_call, true);
+    assert.equal(caps.anthropic["claude-x"].interleaved_field, "reasoning_content");
+    assert.equal(caps.anthropic["claude-x"].modalities_input, JSON.stringify(["text", "image"]));
+    // anthropic maps to ["anthropic", "cc"].
+    assert.deepEqual(caps.cc["claude-x"], caps.anthropic["claude-x"]);
+  });
+
+  it("host re-exports the pure transform functions (public API preserved)", async () => {
+    const host = await import("../../src/lib/modelsDevSync.ts");
+    assert.equal(typeof host.mapProviderId, "function");
+    assert.equal(typeof host.transformModelsDevToPricing, "function");
+    assert.equal(typeof host.transformModelsDevToCapabilities, "function");
+    assert.deepEqual(host.mapProviderId("anthropic"), mapProviderId("anthropic"));
+  });
+});