@aliou/pi-synthetic 0.5.1 → 0.6.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aliou/pi-synthetic",
-  "version": "0.5.1",
+  "version": "0.6.0",
   "license": "MIT",
   "type": "module",
   "private": false,
@@ -38,7 +38,8 @@
     "@sinclair/typebox": "^0.34.48",
     "@types/node": "^25.0.10",
     "husky": "^9.1.7",
-    "typescript": "^5.9.3"
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.18"
   },
   "peerDependenciesMeta": {
     "@mariozechner/pi-coding-agent": {
@@ -52,6 +53,8 @@
     "typecheck": "tsc --noEmit",
     "lint": "biome check",
     "format": "biome check --write",
+    "test": "vitest run",
+    "test:watch": "vitest",
     "check:lockfile": "pnpm install --frozen-lockfile --ignore-scripts",
     "changeset": "changeset",
     "version": "changeset version",

package/src/providers/index.ts

@@ -6,6 +6,10 @@ export function registerSyntheticProvider(pi: ExtensionAPI): void {
     baseUrl: "https://api.synthetic.new/openai/v1",
     apiKey: "SYNTHETIC_API_KEY",
     api: "openai-completions",
+    headers: {
+      Referer: "https://pi.dev",
+      "X-Title": "npm:@aliou/pi-synthetic",
+    },
     models: SYNTHETIC_MODELS.map((model) => ({
       id: model.id,
       name: model.name,

package/src/providers/models.test.ts

@@ -0,0 +1,203 @@
+import { describe, expect, it } from "vitest";
+import { SYNTHETIC_MODELS } from "./models";
+
+interface ApiModel {
+  id: string;
+  name: string;
+  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 = (await response.json()) as ApiResponse;
+  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 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);
+  });
+});

package/src/providers/models.ts

@@ -25,7 +25,7 @@ export interface SyntheticModelConfig {
 }
 
 export const SYNTHETIC_MODELS: SyntheticModelConfig[] = [
-  // models.dev: synthetic/hf:zai-org/GLM-4.7 → ctx=200000, out=64000
+  // API: hf:zai-org/GLM-4.7 → ctx=202752, out=65536
   {
     id: "hf:zai-org/GLM-4.7",
     name: "zai-org/GLM-4.7",
@@ -38,22 +38,22 @@ export const SYNTHETIC_MODELS: SyntheticModelConfig[] = [
       cacheWrite: 0,
     },
     contextWindow: 202752,
-    maxTokens: 64000,
+    maxTokens: 65536,
   },
-  // models.dev: synthetic/hf:MiniMaxAI/MiniMax-M2.1 → ctx=204800, out=131072
+  // API: hf:MiniMaxAI/MiniMax-M2.1 → ctx=196608, out=65536
   {
     id: "hf:MiniMaxAI/MiniMax-M2.1",
     name: "MiniMaxAI/MiniMax-M2.1",
     reasoning: true,
     input: ["text"],
     cost: {
-      input: 0.55,
-      output: 2.19,
-      cacheRead: 0.55,
+      input: 0.3,
+      output: 1.2,
+      cacheRead: 0.3,
       cacheWrite: 0,
     },
     contextWindow: 196608,
-    maxTokens: 131072,
+    maxTokens: 65536,
   },
   // models.dev: synthetic/hf:meta-llama/Llama-3.3-70B-Instruct → ctx=128000, out=32768
   {
@@ -160,31 +160,31 @@ export const SYNTHETIC_MODELS: SyntheticModelConfig[] = [
     contextWindow: 131072,
     maxTokens: 32768,
   },
-  // models.dev: synthetic/hf:Qwen/Qwen3-Coder-480B-A35B-Instruct → ctx=256000, out=32000
+  // API: hf:Qwen/Qwen3-Coder-480B-A35B-Instruct → ctx=262144, out=65536
   {
     id: "hf:Qwen/Qwen3-Coder-480B-A35B-Instruct",
     name: "Qwen/Qwen3-Coder-480B-A35B-Instruct",
-    reasoning: false,
+    reasoning: true,
     input: ["text"],
     cost: {
-      input: 0.45,
-      output: 1.8,
-      cacheRead: 0.45,
+      input: 2,
+      output: 2,
+      cacheRead: 2,
       cacheWrite: 0,
     },
     contextWindow: 262144,
-    maxTokens: 32000,
+    maxTokens: 65536,
   },
-  // models.dev: synthetic/hf:moonshotai/Kimi-K2.5 → ctx=262144, out=65536
+  // API: hf:moonshotai/Kimi-K2.5 → ctx=262144, out=65536
   {
     id: "hf:moonshotai/Kimi-K2.5",
     name: "moonshotai/Kimi-K2.5",
     reasoning: true,
     input: ["text", "image"],
     cost: {
-      input: 1.2,
-      output: 1.2,
-      cacheRead: 1.2,
+      input: 0.6,
+      output: 3,
+      cacheRead: 0.6,
       cacheWrite: 0,
     },
     contextWindow: 262144,
@@ -255,7 +255,7 @@ export const SYNTHETIC_MODELS: SyntheticModelConfig[] = [
     id: "hf:MiniMaxAI/MiniMax-M2.5",
     name: "MiniMaxAI/MiniMax-M2.5",
     reasoning: true,
-    input: ["text", "image"],
+    input: ["text"],
     cost: {
       input: 0.6,
       output: 3,