@aliou/pi-synthetic 0.17.3 → 0.18.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aliou/pi-synthetic",
-  "version": "0.17.3",
+  "version": "0.18.0",
   "license": "MIT",
   "type": "module",
   "private": false,
@@ -29,7 +29,8 @@
   },
   "files": [
     "src",
-    "README.md"
+    "README.md",
+    "!src/**/*.test.ts"
   ],
   "peerDependencies": {
     "@earendil-works/pi-coding-agent": "0.74.0",
@@ -40,8 +41,8 @@
     "@aliou/pi-utils-ui": "^0.4.0"
   },
   "devDependencies": {
-    "@aliou/biome-plugins": "^0.7.0",
-    "@biomejs/biome": "^2.4.2",
+    "@aliou/biome-plugins": "^0.8.1",
+    "@biomejs/biome": "^2.4.15",
     "@changesets/cli": "^2.27.11",
     "@earendil-works/pi-coding-agent": "0.74.0",
     "typebox": "^1.1.37",

package/src/extensions/provider/models.ts

@@ -91,38 +91,6 @@ export const SYNTHETIC_MODELS: SyntheticModelConfig[] = [
     contextWindow: 196608,
     maxTokens: 65536,
   },
-  // models.dev: synthetic/hf:meta-llama/Llama-3.3-70B-Instruct → ctx=128000, out=32768
-  {
-    id: "hf:meta-llama/Llama-3.3-70B-Instruct",
-    name: "meta-llama/Llama-3.3-70B-Instruct",
-    provider: "together",
-    reasoning: false,
-    input: ["text"],
-    cost: {
-      input: 0.88,
-      output: 0.88,
-      cacheRead: 0.88,
-      cacheWrite: 0,
-    },
-    contextWindow: 131072,
-    maxTokens: 32768,
-  },
-  // models.dev: synthetic/hf:deepseek-ai/DeepSeek-R1-0528 → ctx=128000, out=128000
-  {
-    id: "hf:deepseek-ai/DeepSeek-R1-0528",
-    name: "deepseek-ai/DeepSeek-R1-0528",
-    provider: "together",
-    reasoning: true,
-    input: ["text"],
-    cost: {
-      input: 3,
-      output: 8,
-      cacheRead: 3,
-      cacheWrite: 0,
-    },
-    contextWindow: 131072,
-    maxTokens: 128000,
-  },
   // models.dev: synthetic/hf:deepseek-ai/DeepSeek-V3.2 → ctx=162816, out=8000
   {
     id: "hf:deepseek-ai/DeepSeek-V3.2",
@@ -191,122 +159,139 @@ export const SYNTHETIC_MODELS: SyntheticModelConfig[] = [
     contextWindow: 262144,
     maxTokens: 65536,
   },
-  // API: hf:moonshotai/Kimi-K2.5 → ctx=262144, out=65536
+  // API: hf:Qwen/Qwen3.5-397B-A17B → ctx=262144, out=65536
   {
-    id: "hf:moonshotai/Kimi-K2.5",
-    name: "moonshotai/Kimi-K2.5",
+    id: "hf:Qwen/Qwen3.5-397B-A17B",
+    name: "Qwen/Qwen3.5-397B-A17B",
     provider: "together",
     reasoning: true,
     input: ["text", "image"],
     cost: {
-      input: 0.5,
-      output: 2.8,
-      cacheRead: 0.5,
+      input: 0.6,
+      output: 3.6,
+      cacheRead: 0.6,
       cacheWrite: 0,
     },
     contextWindow: 262144,
     maxTokens: 65536,
   },
-  // API: hf:nvidia/Kimi-K2.5-NVFP4 → ctx=262144; models.dev: out=65536 (NVFP4 quantized)
+  // API: hf:MiniMaxAI/MiniMax-M2.5 → ctx=191488, out=65536
   {
-    id: "hf:nvidia/Kimi-K2.5-NVFP4",
-    name: "nvidia/Kimi-K2.5-NVFP4",
-    provider: "together",
+    id: "hf:MiniMaxAI/MiniMax-M2.5",
+    name: "MiniMaxAI/MiniMax-M2.5",
+    provider: "synthetic",
     reasoning: true,
-    input: ["text", "image"],
+    thinkingLevelMap: { off: null, minimal: null, low: null, xhigh: null },
+    input: ["text"],
     cost: {
-      input: 0.5,
-      output: 2.8,
-      cacheRead: 0.5,
+      input: 0.4,
+      output: 2,
+      cacheRead: 0.4,
       cacheWrite: 0,
     },
-    contextWindow: 262144,
+    contextWindow: 191488,
     maxTokens: 65536,
+    compat: {
+      supportsReasoningEffort: true,
+      maxTokensField: "max_completion_tokens",
+    },
   },
-  // models.dev: synthetic/hf:deepseek-ai/DeepSeek-V3 → ctx=128000, out=128000
+  // API: hf:nvidia/NVIDIA-Nemotron-3-Super-120B-A12B-NVFP4 → ctx=262144, out=65536
   {
-    id: "hf:deepseek-ai/DeepSeek-V3",
-    name: "deepseek-ai/DeepSeek-V3",
-    provider: "together",
+    id: "hf:nvidia/NVIDIA-Nemotron-3-Super-120B-A12B-NVFP4",
+    name: "nvidia/NVIDIA-Nemotron-3-Super-120B-A12B-NVFP4",
+    provider: "synthetic",
     reasoning: true,
+    thinkingLevelMap: { minimal: null, low: null, xhigh: null },
+    compat: {
+      supportsReasoningEffort: true,
+    },
     input: ["text"],
     cost: {
-      input: 1.25,
-      output: 1.25,
-      cacheRead: 1.25,
+      input: 0.3,
+      output: 1,
+      cacheRead: 0.3,
       cacheWrite: 0,
     },
-    contextWindow: 131072,
-    maxTokens: 128000,
+    contextWindow: 262144,
+    maxTokens: 65536,
   },
-  // models.dev: synthetic/hf:Qwen/Qwen3-235B-A22B-Thinking-2507 → ctx=256000, out=32000
+  // API: syn:large:text → alias for hf:zai-org/GLM-5.1 → ctx=196608, out=65536
   {
-    id: "hf:Qwen/Qwen3-235B-A22B-Thinking-2507",
-    name: "Qwen/Qwen3-235B-A22B-Thinking-2507",
-    provider: "together",
+    id: "syn:large:text",
+    name: "syn:large:text",
+    provider: "synthetic",
     reasoning: true,
+    thinkingLevelMap: { minimal: null, xhigh: null },
+    compat: {
+      supportsReasoningEffort: true,
+      supportsDeveloperRole: false,
+    },
     input: ["text"],
     cost: {
-      input: 0.65,
+      input: 1,
       output: 3,
-      cacheRead: 0.65,
+      cacheRead: 1,
       cacheWrite: 0,
     },
-    contextWindow: 262144,
-    maxTokens: 32000,
+    contextWindow: 196608,
+    maxTokens: 65536,
   },
-  // API: hf:Qwen/Qwen3.5-397B-A17B → ctx=262144, out=65536
+  // API: syn:small:text → alias for hf:zai-org/GLM-4.7-Flash → ctx=196608, out=65536
   {
-    id: "hf:Qwen/Qwen3.5-397B-A17B",
-    name: "Qwen/Qwen3.5-397B-A17B",
-    provider: "together",
+    id: "syn:small:text",
+    name: "syn:small:text",
+    provider: "synthetic",
     reasoning: true,
-    input: ["text", "image"],
+    thinkingLevelMap: { minimal: null, xhigh: null },
+    compat: {
+      supportsReasoningEffort: true,
+    },
+    input: ["text"],
     cost: {
-      input: 0.6,
-      output: 3.6,
-      cacheRead: 0.6,
+      input: 0.1,
+      output: 0.5,
+      cacheRead: 0.1,
       cacheWrite: 0,
     },
-    contextWindow: 262144,
+    contextWindow: 196608,
     maxTokens: 65536,
   },
-  // API: hf:MiniMaxAI/MiniMax-M2.5 → ctx=191488, out=65536
+  // API: syn:large:vision → alias for hf:moonshotai/Kimi-K2.6 → ctx=262144, out=65536
   {
-    id: "hf:MiniMaxAI/MiniMax-M2.5",
-    name: "MiniMaxAI/MiniMax-M2.5",
+    id: "syn:large:vision",
+    name: "syn:large:vision",
     provider: "synthetic",
     reasoning: true,
-    thinkingLevelMap: { off: null, minimal: null, low: null, xhigh: null },
-    input: ["text"],
+    thinkingLevelMap: { minimal: null, low: null, xhigh: null },
+    compat: {
+      supportsReasoningEffort: true,
+    },
+    input: ["text", "image"],
     cost: {
-      input: 0.4,
-      output: 2,
-      cacheRead: 0.4,
+      input: 0.95,
+      output: 4,
+      cacheRead: 0.95,
       cacheWrite: 0,
     },
-    contextWindow: 191488,
+    contextWindow: 262144,
     maxTokens: 65536,
-    compat: {
-      supportsReasoningEffort: true,
-      maxTokensField: "max_completion_tokens",
-    },
   },
-  // API: hf:nvidia/NVIDIA-Nemotron-3-Super-120B-A12B-NVFP4 → ctx=262144, out=65536
+  // API: syn:small:vision → alias for hf:moonshotai/Kimi-K2.6 → ctx=262144, out=65536
   {
-    id: "hf:nvidia/NVIDIA-Nemotron-3-Super-120B-A12B-NVFP4",
-    name: "nvidia/NVIDIA-Nemotron-3-Super-120B-A12B-NVFP4",
+    id: "syn:small:vision",
+    name: "syn:small:vision",
     provider: "synthetic",
     reasoning: true,
     thinkingLevelMap: { minimal: null, low: null, xhigh: null },
     compat: {
       supportsReasoningEffort: true,
     },
-    input: ["text"],
+    input: ["text", "image"],
     cost: {
-      input: 0.3,
-      output: 1,
-      cacheRead: 0.3,
+      input: 0.95,
+      output: 4,
+      cacheRead: 0.95,
       cacheWrite: 0,
     },
     contextWindow: 262144,

package/src/extensions/provider/index.test.ts

@@ -1,46 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { buildSyntheticProviderModels } from "./index";
-import { SYNTHETIC_MODELS } from "./models";
-
-describe("buildSyntheticProviderModels", () => {
-  it("excludes proxied models when includeProxiedModels is false", () => {
-    const models = buildSyntheticProviderModels(false);
-    for (const model of models) {
-      const source = SYNTHETIC_MODELS.find((m) => m.id === model.id);
-      expect(source).toBeDefined();
-      expect(source?.provider).toBe("synthetic");
-    }
-  });
-
-  it("includes all models when includeProxiedModels is true", () => {
-    const models = buildSyntheticProviderModels(true);
-    expect(models).toHaveLength(SYNTHETIC_MODELS.length);
-  });
-
-  it("does not expose the internal provider field", () => {
-    const models = buildSyntheticProviderModels(true);
-    for (const model of models) {
-      expect(model).not.toHaveProperty("provider");
-    }
-  });
-
-  it("sets default compat fields on every model", () => {
-    const models = buildSyntheticProviderModels(true);
-    for (const model of models) {
-      expect(model.compat).toMatchObject({
-        supportsDeveloperRole: false,
-      });
-      expect(model.compat).toHaveProperty("maxTokensField");
-    }
-  });
-
-  it("preserves model-specific compat overrides", () => {
-    const models = buildSyntheticProviderModels(true);
-    const miniMax = models.find((m) => m.id === "hf:MiniMaxAI/MiniMax-M2.5");
-    expect(miniMax).toBeDefined();
-    expect(miniMax?.compat).toMatchObject({
-      supportsDeveloperRole: false,
-      maxTokensField: "max_completion_tokens",
-    });
-  });
-});

package/src/extensions/provider/models.test.ts

@@ -1,217 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { SYNTHETIC_MODELS } from "./models";
-
-interface ApiModel {
-  id: string;
-  name: string;
-  provider: string | null;
-  input_modalities: string[];
-  output_modalities: string[];
-  context_length: number;
-  max_output_length: number;
-  pricing: {
-    prompt: string;
-    completion: string;
-    input_cache_reads: string;
-    input_cache_writes: string;
-  };
-  supported_features?: string[];
-}
-
-interface ApiResponse {
-  data: ApiModel[];
-}
-
-interface Discrepancy {
-  model: string;
-  field: string;
-  hardcoded: unknown;
-  api: unknown;
-}
-
-async function fetchApiModels(): Promise<ApiModel[]> {
-  // Making ourselves known
-  const response = await fetch("https://api.synthetic.new/openai/v1/models", {
-    headers: {
-      Referer: "https://github.com/aliou/pi-synthetic",
-    },
-  });
-
-  if (!response.ok) {
-    throw new Error(
-      `API request failed: ${response.status} ${response.statusText}`,
-    );
-  }
-
-  const data: ApiResponse = await response.json();
-  return data.data;
-}
-
-function parsePrice(priceStr: string): number {
-  // Convert "$0.0000006" to 0.6 (dollars per million tokens)
-  const match = priceStr.match(/\$?(\d+\.?\d*)/);
-  if (!match) return 0;
-  const pricePerToken = Number.parseFloat(match[1]);
-  // API prices are per token, hardcoded prices are per million tokens
-  return pricePerToken * 1_000_000;
-}
-
-function compareModels(
-  apiModels: ApiModel[],
-  hardcodedModels: typeof SYNTHETIC_MODELS,
-): Discrepancy[] {
-  const discrepancies: Discrepancy[] = [];
-
-  for (const hardcoded of hardcodedModels) {
-    const apiModel = apiModels.find((m) => m.id === hardcoded.id);
-
-    if (!apiModel) {
-      discrepancies.push({
-        model: hardcoded.id,
-        field: "exists",
-        hardcoded: true,
-        api: false,
-      });
-      continue;
-    }
-
-    // Check input modalities (text vs image support)
-    const apiInputs = apiModel.input_modalities.sort();
-    const hardcodedInputs = [...hardcoded.input].sort();
-    if (JSON.stringify(apiInputs) !== JSON.stringify(hardcodedInputs)) {
-      discrepancies.push({
-        model: hardcoded.id,
-        field: "input",
-        hardcoded: hardcodedInputs,
-        api: apiInputs,
-      });
-    }
-
-    // Check context window
-    if (apiModel.context_length !== hardcoded.contextWindow) {
-      discrepancies.push({
-        model: hardcoded.id,
-        field: "contextWindow",
-        hardcoded: hardcoded.contextWindow,
-        api: apiModel.context_length,
-      });
-    }
-
-    // Check max output tokens (skip if API doesn't provide it)
-    if (
-      apiModel.max_output_length !== undefined &&
-      apiModel.max_output_length !== hardcoded.maxTokens
-    ) {
-      discrepancies.push({
-        model: hardcoded.id,
-        field: "maxTokens",
-        hardcoded: hardcoded.maxTokens,
-        api: apiModel.max_output_length,
-      });
-    }
-
-    // Check input cost (convert API price to per-million rate)
-    const apiInputCost = parsePrice(apiModel.pricing.prompt);
-    const epsilon = 0.001; // Small tolerance for floating point
-    if (Math.abs(apiInputCost - hardcoded.cost.input) > epsilon) {
-      discrepancies.push({
-        model: hardcoded.id,
-        field: "cost.input",
-        hardcoded: hardcoded.cost.input,
-        api: apiInputCost,
-      });
-    }
-
-    // Check output cost
-    const apiOutputCost = parsePrice(apiModel.pricing.completion);
-    if (Math.abs(apiOutputCost - hardcoded.cost.output) > epsilon) {
-      discrepancies.push({
-        model: hardcoded.id,
-        field: "cost.output",
-        hardcoded: hardcoded.cost.output,
-        api: apiOutputCost,
-      });
-    }
-
-    // Check cache read cost
-    const apiCacheReadCost = parsePrice(apiModel.pricing.input_cache_reads);
-    if (Math.abs(apiCacheReadCost - hardcoded.cost.cacheRead) > epsilon) {
-      discrepancies.push({
-        model: hardcoded.id,
-        field: "cost.cacheRead",
-        hardcoded: hardcoded.cost.cacheRead,
-        api: apiCacheReadCost,
-      });
-    }
-
-    // Check reasoning capability from supported_features (skip if API doesn't provide it)
-    if (apiModel.supported_features !== undefined) {
-      const apiSupportsReasoning =
-        apiModel.supported_features.includes("reasoning");
-      if (apiSupportsReasoning !== hardcoded.reasoning) {
-        discrepancies.push({
-          model: hardcoded.id,
-          field: "reasoning",
-          hardcoded: hardcoded.reasoning,
-          api: apiSupportsReasoning,
-        });
-      }
-    }
-
-    // Check provider
-    if (
-      apiModel.provider !== null &&
-      apiModel.provider !== hardcoded.provider
-    ) {
-      discrepancies.push({
-        model: hardcoded.id,
-        field: "provider",
-        hardcoded: hardcoded.provider,
-        api: apiModel.provider,
-      });
-    }
-  }
-
-  // Check for API models not in hardcoded list
-  for (const apiModel of apiModels) {
-    const hardcoded = hardcodedModels.find((m) => m.id === apiModel.id);
-    if (!hardcoded) {
-      discrepancies.push({
-        model: apiModel.id,
-        field: "exists",
-        hardcoded: false,
-        api: true,
-      });
-    }
-  }
-
-  return discrepancies;
-}
-
-describe("Synthetic models", () => {
-  it("should match API model definitions", { timeout: 30000 }, async () => {
-    const apiModels = await fetchApiModels();
-    const discrepancies = compareModels(apiModels, SYNTHETIC_MODELS);
-
-    if (discrepancies.length > 0) {
-      console.error("\nModel discrepancies found:");
-      console.error("==========================");
-      for (const d of discrepancies) {
-        if (d.field === "exists") {
-          if (d.hardcoded) {
-            console.error(`  ${d.model}: Missing from API`);
-          } else {
-            console.error(`  ${d.model}: Missing from hardcoded models (NEW)`);
-          }
-        } else {
-          console.error(`  ${d.model}.${d.field}:`);
-          console.error(`    hardcoded: ${JSON.stringify(d.hardcoded)}`);
-          console.error(`    api:       ${JSON.stringify(d.api)}`);
-        }
-      }
-      console.error("==========================\n");
-    }
-
-    expect(discrepancies).toHaveLength(0);
-  });
-});