cursor-route 0.1.9 → 0.1.11

package/src/jobs.ts

@@ -17,6 +17,7 @@ import {
   sessionName,
   defaultDsModelFromEnv,
   DS_MODEL_IDS,
+  openCodeModel,
   type Lane,
   type WorkerKind,
   type DsModelAlias,
@@ -37,8 +38,8 @@ export interface Job {
   status: JobStatus;
   worker: WorkerKind;
   lane?: Lane;
-  /** Mid-lane DeepSeek model alias (flash|pro). Set for claude-ds and deepseek. */
-  model?: DsModelAlias;
+  /** Worker model: flash|pro for claude-ds/deepseek; provider/model for opencode. */
+  model?: string;
   prompt: string;
   cwd: string;
   alwaysApprove: boolean;
@@ -111,7 +112,7 @@ export interface JobEvidence {
     jobId: string;
     worker: WorkerKind;
     lane: Lane | null;
-    model: DsModelAlias | null;
+    model: string | null;
     startedAt: string;
   };
   execute: {
@@ -282,7 +283,7 @@ export interface StartOptions {
   lane?: Lane;
   /** Mid-lane DeepSeek: flash (default) | pro (claude-ds + deepseek). Ignored by grok/openrouter. */
   model?: DsModelAlias;
-  /** Concrete DeepSeek id (preserves pro[1m]). Derived from --model / env when unset. */
+  /** Concrete DeepSeek id (preserves pro[1m]) or OpenCode provider/model. Derived from --model / env when unset. */
   modelId?: string;
   cwd?: string;
   alwaysApprove?: boolean;
@@ -331,15 +332,18 @@ export function startJob(opts: StartOptions): {
   const paths = jobPaths(id);
   writeSecure(paths.prompt, opts.prompt);
 
-  let model: DsModelAlias | undefined;
+  let model: string | undefined;
   let modelId: string | undefined;
+  let dsAlias: DsModelAlias | undefined;
   if (worker === "claude-ds" || worker === "deepseek") {
     if (opts.model) {
+      dsAlias = opts.model;
       model = opts.model;
       modelId = opts.modelId ?? DS_MODEL_IDS[opts.model];
     } else {
       try {
         const choice = defaultDsModelFromEnv();
+        dsAlias = choice.alias;
         model = choice.alias;
         modelId = opts.modelId ?? choice.id;
       } catch (e) {
@@ -351,6 +355,19 @@ export function startJob(opts: StartOptions): {
         return { ok: false, error: (e as Error).message };
       }
     }
+  } else if (worker === "opencode") {
+    try {
+      const ocModel = openCodeModel(opts.modelId);
+      model = ocModel;
+      modelId = ocModel;
+    } catch (e) {
+      try {
+        unlinkSync(paths.prompt);
+      } catch {
+        /* ignore */
+      }
+      return { ok: false, error: (e as Error).message };
+    }
   }
 
   let plan;
@@ -359,7 +376,7 @@ export function startJob(opts: StartOptions): {
       promptFile: paths.prompt,
       cwd,
       alwaysApprove,
-      model,
+      model: dsAlias,
       modelId,
       dryRun: Boolean(opts.dryRun),
     });

package/src/zen-free.test.ts

@@ -0,0 +1,137 @@
+import { describe, expect, test } from "bun:test";
+import { mkdirSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import {
+  asOpenCodeZenId,
+  isZenFreeModel,
+  openCodeModel,
+  OPENCODE_DEFAULT_MODEL,
+  pickZenFreeModel,
+  rankZenFreeModels,
+  zenFreeBoost,
+  type ZenModel,
+} from "./zen-free.ts";
+
+const CATALOG: ZenModel[] = [
+  { id: "big-pickle", name: "Big Pickle" },
+  { id: "hy3-free", name: "HY3 Free" },
+  { id: "claude-opus-4-6", name: "Claude Opus 4.6" },
+  { id: "muse-spark-1.2-contributor-free", name: "Muse Spark Contributor" },
+  { id: "laguna-s-2.1-free", name: "Laguna" },
+  { id: "x-preview-f-free", name: "Ox Alpha Free" },
+  { id: "whisper-free", name: "Whisper" },
+];
+
+describe("zen free catalog", () => {
+  test("tags -free / big-pickle as free; skips paid and audio", () => {
+    expect(isZenFreeModel({ id: "x-preview-f-free" })).toBe(true);
+    expect(isZenFreeModel({ id: "big-pickle" })).toBe(true);
+    expect(isZenFreeModel({ id: "openrouter/qwen/qwen3-coder:free" })).toBe(true);
+    expect(isZenFreeModel({ id: "claude-opus-4-6" })).toBe(false);
+    expect(isZenFreeModel({ id: "whisper-free" })).toBe(false);
+    expect(
+      isZenFreeModel({
+        id: "some-zero-price",
+        pricing: { prompt: 0, completion: 0 },
+      }),
+    ).toBe(true);
+  });
+
+  test("Ox Alpha outranks coding free, which outranks big-pickle and contributor", () => {
+    expect(zenFreeBoost("opencode/x-preview-f-free")).toBe(40);
+    expect(zenFreeBoost("opencode/laguna-s-2.1-free")).toBe(20);
+    expect(zenFreeBoost("opencode/hy3-free")).toBe(20);
+    expect(zenFreeBoost("opencode/big-pickle")).toBe(5);
+    expect(zenFreeBoost("opencode/muse-spark-1.2-contributor-free")).toBe(1);
+  });
+
+  test("rank: Ox Alpha first while listed; paid/whisper dropped", () => {
+    const ranked = rankZenFreeModels(CATALOG);
+    expect(ranked[0]?.id).toBe("opencode/x-preview-f-free");
+    expect(ranked.map((r) => r.id)).not.toContain("opencode/claude-opus-4-6");
+    expect(ranked.map((r) => r.id)).not.toContain("opencode/whisper-free");
+    expect(ranked.at(-1)?.id).toBe("opencode/muse-spark-1.2-contributor-free");
+  });
+
+  test("rank without Ox: coding free beats big-pickle", () => {
+    const ranked = rankZenFreeModels([
+      { id: "big-pickle" },
+      { id: "laguna-s-2.1-free" },
+      { id: "muse-spark-1.2-contributor-free" },
+    ]);
+    expect(ranked[0]?.id).toBe("opencode/laguna-s-2.1-free");
+    expect(ranked[1]?.id).toBe("opencode/big-pickle");
+  });
+
+  test("asOpenCodeZenId prefixes bare Zen ids", () => {
+    expect(asOpenCodeZenId("x-preview-f-free")).toBe("opencode/x-preview-f-free");
+    expect(asOpenCodeZenId("opencode/big-pickle")).toBe("opencode/big-pickle");
+  });
+
+  test("pickZenFreeModel uses the ranked catalog winner", () => {
+    expect(pickZenFreeModel({ catalog: CATALOG })).toBe("opencode/x-preview-f-free");
+  });
+
+  test("offline / empty catalog falls back to Ox Alpha", () => {
+    expect(pickZenFreeModel({ catalog: [] })).toBe(OPENCODE_DEFAULT_MODEL);
+    expect(OPENCODE_DEFAULT_MODEL).toBe("opencode/x-preview-f-free");
+  });
+});
+
+describe("openCodeModel live pick", () => {
+  const isolate = (fn: () => void) => {
+    const dir = join(tmpdir(), `cr-zen-${process.pid}-${Math.random().toString(16).slice(2)}`);
+    mkdirSync(dir, { recursive: true });
+    const prev = {
+      model: process.env.CURSOR_ROUTE_OPENCODE_MODEL,
+      offline: process.env.CURSOR_ROUTE_ZEN_OFFLINE,
+      json: process.env.CURSOR_ROUTE_ZEN_CATALOG_JSON,
+      cache: process.env.CURSOR_ROUTE_ZEN_CACHE_PATH,
+      refresh: process.env.CURSOR_ROUTE_ZEN_REFRESH,
+    };
+    delete process.env.CURSOR_ROUTE_OPENCODE_MODEL;
+    process.env.CURSOR_ROUTE_ZEN_CACHE_PATH = join(dir, "cache.json");
+    process.env.CURSOR_ROUTE_ZEN_REFRESH = "1";
+    try {
+      fn();
+    } finally {
+      for (const [k, v] of Object.entries(prev)) {
+        const envKey = {
+          model: "CURSOR_ROUTE_OPENCODE_MODEL",
+          offline: "CURSOR_ROUTE_ZEN_OFFLINE",
+          json: "CURSOR_ROUTE_ZEN_CATALOG_JSON",
+          cache: "CURSOR_ROUTE_ZEN_CACHE_PATH",
+          refresh: "CURSOR_ROUTE_ZEN_REFRESH",
+        }[k]!;
+        if (v === undefined) delete process.env[envKey];
+        else process.env[envKey] = v;
+      }
+      rmSync(dir, { recursive: true, force: true });
+    }
+  };
+
+  test("free/empty + offline → Ox Alpha fallback", () => {
+    isolate(() => {
+      process.env.CURSOR_ROUTE_ZEN_OFFLINE = "1";
+      expect(openCodeModel()).toBe("opencode/x-preview-f-free");
+      expect(openCodeModel("free")).toBe("opencode/x-preview-f-free");
+    });
+  });
+
+  test("free + injected catalog → Ox Alpha", () => {
+    isolate(() => {
+      process.env.CURSOR_ROUTE_ZEN_CATALOG_JSON = JSON.stringify({ data: CATALOG });
+      expect(openCodeModel("free")).toBe("opencode/x-preview-f-free");
+    });
+  });
+
+  test("CURSOR_ROUTE_OPENCODE_MODEL pin wins over catalog", () => {
+    isolate(() => {
+      process.env.CURSOR_ROUTE_OPENCODE_MODEL = "opencode/hy3-free";
+      process.env.CURSOR_ROUTE_ZEN_CATALOG_JSON = JSON.stringify({ data: CATALOG });
+      expect(openCodeModel()).toBe("opencode/hy3-free");
+      expect(openCodeModel("free")).toBe("opencode/hy3-free");
+    });
+  });
+});

package/src/zen-free.ts

@@ -0,0 +1,258 @@
+import { spawnSync } from "node:child_process";
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+/**
+ * Live OpenCode Zen free-model pick — same idea as agent-toolkit
+ * `select-openrouter-free-model.ps1`: probe the catalog, keep $0 text/coding
+ * models, rank, cache ~15 min. Hardcoded ids are fallback only.
+ *
+ * Catalog: GET https://opencode.ai/zen/v1/models (no key). Zen ids are
+ * `big-pickle` / `x-preview-f-free`; the CLI wants `opencode/<id>`.
+ */
+
+export const ZEN_MODELS_URL_DEFAULT = "https://opencode.ai/zen/v1/models";
+
+/** Offline / fetch-fail fallback — Ox Alpha (zero-retention, currently top-tier free). */
+export const OPENCODE_DEFAULT_MODEL = "opencode/x-preview-f-free";
+
+export interface ZenModel {
+  id?: string;
+  name?: string;
+  context_length?: number;
+  pricing?: { prompt?: number | string; completion?: number | string };
+}
+
+export interface ZenFreePick {
+  id: string;
+  name: string;
+  context_length: number;
+  boost: number;
+  picked_at: string;
+  candidates: number;
+  source: "ranked-free" | "fallback";
+}
+
+const EXCLUDE_RE =
+  /lyria|whisper|tts|embed|embedding|image|vision-only|audio|diffusion|flux|stable-diffusion|moderation/i;
+const CODING_RE =
+  /coder|instruct|chat|laguna|nemotron|glm|qwen|kimi|deepseek|mimo|hy3|gpt-oss|north|gemma/i;
+const OX_ALPHA_RE = /x-preview|ox-alpha|oxalpha/i;
+const CONTRIBUTOR_RE = /contributor-free/i;
+
+function zenModelsUrl(): string {
+  return (process.env.CURSOR_ROUTE_ZEN_MODELS_URL || ZEN_MODELS_URL_DEFAULT).trim();
+}
+
+function cacheMinutes(): number {
+  const n = Number(process.env.CURSOR_ROUTE_ZEN_CACHE_MINUTES);
+  return Number.isFinite(n) && n > 0 ? n : 15;
+}
+
+function cachePath(): string {
+  return process.env.CURSOR_ROUTE_ZEN_CACHE_PATH?.trim() ||
+    join(tmpdir(), "cursor-route-zen-best-free.json");
+}
+
+export function assertOpenCodeModel(id: string): string {
+  if (!/^[a-z0-9][a-z0-9._-]*(?:\/[a-z0-9][a-z0-9._\-:]+)+$/i.test(id)) {
+    throw new Error(
+      `Invalid OpenCode model ${id}; expected provider/model (e.g. opencode/x-preview-f-free) or free`,
+    );
+  }
+  return id;
+}
+
+/** Prefix a Zen catalog id (`x-preview-f-free`) for `opencode run --model`. */
+export function asOpenCodeZenId(raw: string): string {
+  const id = raw.trim();
+  if (!id) throw new Error("empty Zen model id");
+  return id.includes("/") ? assertOpenCodeModel(id) : assertOpenCodeModel(`opencode/${id}`);
+}
+
+function num(v: unknown): number {
+  if (typeof v === "number" && Number.isFinite(v)) return v;
+  if (typeof v === "string" && v.trim()) {
+    const n = Number(v);
+    if (Number.isFinite(n)) return n;
+  }
+  return NaN;
+}
+
+export function isZenFreeModel(m: ZenModel): boolean {
+  const id = (m.id || "").trim();
+  if (!id) return false;
+  if (EXCLUDE_RE.test(id) || EXCLUDE_RE.test(m.name || "")) return false;
+  const prompt = num(m.pricing?.prompt);
+  const completion = num(m.pricing?.completion);
+  const pricedFree = prompt === 0 && completion === 0;
+  const tagged =
+    id.endsWith("-free") ||
+    id.endsWith(":free") ||
+    /(^|\/)big-pickle$/i.test(id);
+  return tagged || pricedFree;
+}
+
+/** Higher boost wins. Ox Alpha first while it is in the free catalog. */
+export function zenFreeBoost(id: string): number {
+  const s = id.toLowerCase();
+  if (OX_ALPHA_RE.test(s)) return 40;
+  if (CONTRIBUTOR_RE.test(s)) return 1;
+  if (CODING_RE.test(s)) return 20;
+  if (s.endsWith("-free") || s.endsWith(":free")) return 10;
+  if (/(^|\/)big-pickle$/.test(s)) return 5;
+  return 0;
+}
+
+export function rankZenFreeModels(models: ZenModel[]): Array<{
+  id: string;
+  name: string;
+  context_length: number;
+  boost: number;
+}> {
+  const out: Array<{ id: string; name: string; context_length: number; boost: number }> = [];
+  for (const m of models) {
+    if (!isZenFreeModel(m)) continue;
+    const raw = (m.id || "").trim();
+    let id: string;
+    try {
+      id = asOpenCodeZenId(raw);
+    } catch {
+      continue;
+    }
+    const ctx = Number.isFinite(Number(m.context_length)) ? Number(m.context_length) : 0;
+    out.push({
+      id,
+      name: (m.name || raw).trim(),
+      context_length: ctx,
+      boost: zenFreeBoost(id),
+    });
+  }
+  out.sort((a, b) => {
+    if (b.boost !== a.boost) return b.boost - a.boost;
+    if (b.context_length !== a.context_length) return b.context_length - a.context_length;
+    return a.id.localeCompare(b.id);
+  });
+  return out;
+}
+
+function readCache(): ZenFreePick | null {
+  const p = cachePath();
+  if (!existsSync(p)) return null;
+  try {
+    const j = JSON.parse(readFileSync(p, "utf8")) as ZenFreePick;
+    if (!j?.id) return null;
+    const ageMs = Date.now() - Date.parse(j.picked_at);
+    if (!Number.isFinite(ageMs) || ageMs < 0) return null;
+    if (ageMs > cacheMinutes() * 60_000) return null;
+    assertOpenCodeModel(j.id);
+    return j;
+  } catch {
+    return null;
+  }
+}
+
+function writeCache(pick: ZenFreePick): void {
+  try {
+    writeFileSync(cachePath(), JSON.stringify(pick), { mode: 0o600 });
+  } catch {
+    /* cache is optional */
+  }
+}
+
+function httpGetSync(url: string, timeoutMs = 4000): string | null {
+  const sec = Math.max(1, Math.ceil(timeoutMs / 1000));
+  const curl = spawnSync(
+    "curl",
+    ["-fsS", "--max-time", String(sec), "-H", "Accept: application/json", url],
+    { encoding: "utf8", timeout: timeoutMs + 500, env: { ...process.env } },
+  );
+  if (curl.status === 0 && curl.stdout?.trim()) return curl.stdout;
+  return null;
+}
+
+function parseCatalog(raw: string): ZenModel[] {
+  const j = JSON.parse(raw) as { data?: ZenModel[] } | ZenModel[];
+  if (Array.isArray(j)) return j;
+  if (Array.isArray(j.data)) return j.data;
+  return [];
+}
+
+export function loadZenCatalog(): ZenModel[] {
+  const inline = process.env.CURSOR_ROUTE_ZEN_CATALOG_JSON?.trim();
+  if (inline) return parseCatalog(inline);
+  if (process.env.CURSOR_ROUTE_ZEN_OFFLINE === "1") return [];
+  const body = httpGetSync(zenModelsUrl());
+  if (!body) return [];
+  try {
+    return parseCatalog(body);
+  } catch {
+    return [];
+  }
+}
+
+/** Last live pick if the cache is still fresh — health-safe (no network). */
+export function cachedZenFreePick(): string | null {
+  try {
+    return readCache()?.id ?? null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Best live Zen free model, or OPENCODE_DEFAULT_MODEL if the catalog is empty/offline.
+ * `CURSOR_ROUTE_ZEN_REFRESH=1` skips cache. Tests: `CURSOR_ROUTE_ZEN_OFFLINE=1` or
+ * `CURSOR_ROUTE_ZEN_CATALOG_JSON`.
+ */
+export function pickZenFreeModel(opts?: { catalog?: ZenModel[]; refresh?: boolean }): string {
+  const refresh =
+    opts?.refresh ||
+    process.env.CURSOR_ROUTE_ZEN_REFRESH === "1";
+  if (!refresh && opts?.catalog === undefined) {
+    const cached = readCache();
+    if (cached) return cached.id;
+  }
+  const models = opts?.catalog ?? loadZenCatalog();
+  const ranked = rankZenFreeModels(models);
+  const winner = ranked[0];
+  if (!winner) {
+    const fallback: ZenFreePick = {
+      id: OPENCODE_DEFAULT_MODEL,
+      name: "Ox Alpha Free (fallback)",
+      context_length: 0,
+      boost: 0,
+      picked_at: new Date().toISOString(),
+      candidates: 0,
+      source: "fallback",
+    };
+    if (opts?.catalog === undefined) writeCache(fallback);
+    return fallback.id;
+  }
+  const pick: ZenFreePick = {
+    id: winner.id,
+    name: winner.name,
+    context_length: winner.context_length,
+    boost: winner.boost,
+    picked_at: new Date().toISOString(),
+    candidates: ranked.length,
+    source: "ranked-free",
+  };
+  if (opts?.catalog === undefined) writeCache(pick);
+  return pick.id;
+}
+
+/**
+ * Resolve OpenCode `--model` / env to a concrete `provider/model` id.
+ * Empty or `free` → CURSOR_ROUTE_OPENCODE_MODEL pin, else live Zen free pick.
+ */
+export function openCodeModel(raw?: string | null): string {
+  const v = (raw ?? "").trim();
+  if (!v || v.toLowerCase() === "free") {
+    const env = (process.env.CURSOR_ROUTE_OPENCODE_MODEL ?? "").trim();
+    if (env && env.toLowerCase() !== "free") return assertOpenCodeModel(env);
+    return pickZenFreeModel();
+  }
+  return assertOpenCodeModel(v);
+}