@amir83nasr/10router 0.1.17 → 0.1.18

package/CHANGELOG.md

@@ -2,6 +2,10 @@
 
 All notable changes to 10Router will be documented in this file.
 
+## [0.1.18] — 2026-10-30
+
+- Synced OpenCode free-tier and OpenCode Go improvements from 9router: TLS-impersonating client (wreq-js) for the free tier, opencode free-tier capability entries (glm-5.3-flash-free on openai format, mimo reasoning, deepseek-v4.1-flash-free 330k context cap), and `isOpencodeFreeTierModel`/`isDeepSeekModel` helpers.
+
 ## [0.1.17] — 2026-10-26
 
 - Fix: OpenCode Go routed each model to the provider's default endpoint instead of one it actually serves. An OpenAI-format client asking for a claude-only model (`claude-haiku-5-5`, `minimax-m2.7`) was sent to `/chat/completions` and rejected upstream with `ModelProtocolUnsupported`; `chatCore` and the tests now share `resolveModelTransport` (`open-sse/services/provider.js`), which prefers the sourceFormat-matched endpoint (no translation) and otherwise a model-declared one.

package/open-sse/executors/opencode.js

@@ -6,6 +6,7 @@ import { getThinkingLevels } from "../providers/thinkingLevels.js";
 import { injectReasoningContent } from "../utils/reasoningContentInjector.js";
 import { resolveSessionId } from "../utils/sessionManager.js";
 import { isMuseSparkModel } from "../providers/models/helpers.js";
+import { opencodeTlsFetch, OpencodeTlsUnavailableError } from "../services/opencodeTlsClient.js";
 import {
   applyFingerprintTools,
   detectToolShape,
@@ -357,6 +358,25 @@ export class OpenCodeExecutor extends BaseExecutor {
     const result = await super.execute({
       ...args,
       credentials: this.prepareRequestCredentials(args),
+      directFetch: async (url, options) => {
+        try {
+          return await opencodeTlsFetch(
+            url,
+            {
+              method: options.method,
+              headers: options.headers,
+              body: options.body,
+            },
+            { signal: options.signal },
+          );
+        } catch (error) {
+          if (error instanceof OpencodeTlsUnavailableError) {
+            // Fail-open: wreq-js not installed; use native fetch.
+            return fetch(url, options);
+          }
+          throw error;
+        }
+      },
     });
     // Only a temporary quota window earns the breaker. Entitlement 429s
     // ("free models work in OpenCode") are permanent plan gates: cooling the

package/open-sse/providers/capabilities.js

@@ -253,6 +253,16 @@ export const MODEL_CAPABILITIES = {
     contextWindow: 1000000,
     maxOutput: 131072,
   },
+  "glm-5.3-flash-free": {
+    vision: true,
+    videoInput: true,
+    pdf: true,
+    reasoning: true,
+    thinkingFormat: "openai",
+    thinkingCanDisable: false,
+    contextWindow: 1000000,
+    maxOutput: 128000,
+  },
   "glm-4.6v": {
     vision: true,
     videoInput: true,
@@ -621,6 +631,26 @@ export const PROVIDER_CAPABILITIES = {
   // /api/v2/image/upload and leaves image_urls/chat_context.imageUrls null
   // (same as qodercli). reasoning:true on all of them — every model can
   // reason; the upstream is_reasoning flag only drives model_config selection.
+  // OpenCode Free (oc)
+  opencode: {
+    "mimo-v2.6-flash-free": {
+      vision: true,
+      audioInput: true,
+      videoInput: true,
+      reasoning: true,
+      thinkingFormat: "openai",
+      thinkingCanDisable: true,
+      contextWindow: 1048576,
+      maxOutput: 131072,
+    },
+    "deepseek-v4.1-flash-free": {
+      vision: true,
+      reasoning: true,
+      thinkingFormat: "deepseek",
+      contextWindow: 330000,
+      maxOutput: 128000,
+    },
+  },
   // thinkingFormat keeps the true-model family for documentation/UI, but
   // thinkingCanDisable:false everywhere: the executor only forwards
   // messages/tools/max_tokens, and thinking is fixed upstream via

package/open-sse/providers/models/helpers.js

@@ -25,3 +25,17 @@ export function isMuseSparkModel(modelId) {
   const base = clean.includes("/") ? clean.split("/").pop() : clean;
   return /^muse[-_]?spark(?:$|[-_:.\s])/i.test(base);
 }
+
+export function isDeepSeekModel(modelId) {
+  if (!modelId || typeof modelId !== "string") return false;
+  const clean = modelId.replace(/\([^()]+\)\s*$/, "").trim();
+  const base = clean.includes("/") ? clean.split("/").pop() : clean;
+  return /^deepseek-/i.test(base);
+}
+
+export function isOpencodeFreeTierModel(modelId) {
+  if (!modelId || typeof modelId !== "string") return false;
+  const clean = modelId.replace(/\([^()]+\)\s*$/, "").trim();
+  const base = clean.includes("/") ? clean.split("/").pop() : clean;
+  return /-free$/i.test(base);
+}

package/open-sse/services/lazyRuntime.js

@@ -0,0 +1,110 @@
+// Lazy loader for heavy optional runtime deps (playwright-core, wreq-js).
+//
+// They are devDependencies only, so end-user installs stay small. On first
+// use the package is downloaded into <DATA_DIR>/runtime and imported from there.
+
+import { spawn } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+import { getWritableDataDir } from "../utils/writableDataDir.js";
+
+const LAZY_DEP_VERSIONS = {
+  "playwright-core": "^1.62.1",
+  "wreq-js": "^3.2.0",
+};
+
+function getRuntimeDir() {
+  return path.join(getWritableDataDir(), "runtime");
+}
+
+let createRequirePromise;
+function getCreateRequire() {
+  createRequirePromise ??= import(/* webpackIgnore: true */ "node:module").then(
+    (mod) => mod.createRequire,
+  );
+  return createRequirePromise;
+}
+
+function isModuleMissing(error) {
+  const code = String(error?.code || "");
+  return code === "MODULE_NOT_FOUND" || code === "ERR_MODULE_NOT_FOUND";
+}
+
+function npmInstall(pkg, version) {
+  const cwd = getRuntimeDir();
+  fs.mkdirSync(cwd, { recursive: true });
+  const manifest = path.join(cwd, "package.json");
+  if (!fs.existsSync(manifest)) {
+    fs.writeFileSync(
+      manifest,
+      JSON.stringify({ name: "10router-runtime", private: true }, null, 2),
+    );
+  }
+  const npm = process.platform === "win32" ? "npm.cmd" : "npm";
+  const args = ["install", "--no-audit", "--no-fund", "--prefer-online", `${pkg}@${version}`];
+  return new Promise((resolve) => {
+    const child = spawn(npm, args, {
+      cwd,
+      stdio: ["ignore", "pipe", "pipe"],
+      shell: process.platform === "win32",
+    });
+    let stderr = "";
+    child.stderr?.on("data", (chunk) => {
+      stderr += String(chunk);
+    });
+    child.on("error", (error) => resolve({ ok: false, stderr: String(error.message || error) }));
+    child.on("close", (status) => resolve({ ok: status === 0, stderr }));
+  });
+}
+
+async function installIntoRuntime(pkg, version) {
+  const res = await npmInstall(pkg, version);
+  if (!res.ok) {
+    const reason =
+      (res.stderr.match(/npm ERR! ?(.+)/) || [])[1] ||
+      res.stderr.split("\n").filter(Boolean).pop() ||
+      "unknown npm error";
+    throw new Error(
+      `${pkg} is missing and the on-demand install failed (${String(reason).slice(0, 160)}) — ` +
+        `install it manually: cd "${getRuntimeDir()}" && npm install ${pkg}@${version}`,
+    );
+  }
+}
+
+const inflight = new Map();
+
+async function load(pkg) {
+  try {
+    return await import(/* webpackIgnore: true */ pkg);
+  } catch (error) {
+    if (!isModuleMissing(error)) throw error;
+  }
+  const createRequire = await getCreateRequire();
+  const runtimeRequire = createRequire(path.join(getRuntimeDir(), "package.json"));
+  try {
+    return await import(/* webpackIgnore: true */ pathToFileURL(runtimeRequire.resolve(pkg)).href);
+  } catch (error) {
+    if (!isModuleMissing(error)) throw error;
+  }
+  const version = LAZY_DEP_VERSIONS[pkg] || "latest";
+  await installIntoRuntime(pkg, version);
+  try {
+    return await import(/* webpackIgnore: true */ pathToFileURL(runtimeRequire.resolve(pkg)).href);
+  } catch (error) {
+    if (!isModuleMissing(error)) throw error;
+    fs.rmSync(path.join(getRuntimeDir(), "node_modules", pkg), { recursive: true, force: true });
+    await installIntoRuntime(pkg, version);
+    return import(/* webpackIgnore: true */ pathToFileURL(runtimeRequire.resolve(pkg)).href);
+  }
+}
+
+export function loadRuntimeDep(pkg) {
+  if (!inflight.has(pkg)) {
+    inflight.set(
+      pkg,
+      load(pkg).finally(() => inflight.delete(pkg)),
+    );
+  }
+  return inflight.get(pkg);
+}

package/open-sse/services/opencodeTlsClient.js

@@ -0,0 +1,91 @@
+// TLS-impersonating HTTP client for opencode.ai's free tier.
+
+import { loadRuntimeDep } from "./lazyRuntime.js";
+
+const OPENCODE_CIPHER_LIST = [
+  "TLS_AES_128_GCM_SHA256",
+  "TLS_AES_256_GCM_SHA384",
+  "TLS_CHACHA20_POLY1305_SHA256",
+  "ECDHE-ECDSA-AES128-GCM-SHA256",
+  "ECDHE-RSA-AES128-GCM-SHA256",
+  "ECDHE-ECDSA-AES256-GCM-SHA384",
+  "ECDHE-RSA-AES256-GCM-SHA384",
+  "ECDHE-ECDSA-CHACHA20-POLY1305",
+  "ECDHE-RSA-CHACHA20-POLY1305",
+  "ECDHE-ECDSA-AES128-SHA",
+  "ECDHE-RSA-AES128-SHA",
+  "ECDHE-ECDSA-AES256-SHA",
+  "ECDHE-RSA-AES256-SHA",
+  "AES128-GCM-SHA256",
+  "AES256-GCM-SHA384",
+  "AES128-SHA",
+  "AES256-SHA",
+].join(":");
+
+const DEFAULT_TIMEOUT_MS = 120000;
+
+let sessionPromise = null;
+
+export class OpencodeTlsUnavailableError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "OpencodeTlsUnavailableError";
+  }
+}
+
+async function loadSession() {
+  if (!sessionPromise) {
+    sessionPromise = (async () => {
+      const wreq = await loadRuntimeDep("wreq-js");
+      if (typeof wreq.createSession !== "function") {
+        throw new Error("wreq-js runtime is missing createSession");
+      }
+      return wreq.createSession({
+        emulation: { tlsOptions: { cipherList: OPENCODE_CIPHER_LIST } },
+      });
+    })().catch((error) => {
+      sessionPromise = null;
+      throw error;
+    });
+  }
+  return sessionPromise;
+}
+
+export function resetOpencodeTlsSession() {
+  const pending = sessionPromise;
+  sessionPromise = null;
+  pending?.then((session) => session.close?.()).catch(() => {});
+}
+
+export async function opencodeTlsFetch(
+  url,
+  init = {},
+  { signal, timeoutMs = DEFAULT_TIMEOUT_MS } = {},
+) {
+  let session;
+  try {
+    session = await loadSession();
+  } catch (error) {
+    throw new OpencodeTlsUnavailableError(
+      `wreq-js unavailable (${error instanceof Error ? error.message : "unknown"}) — install the optional wreq-js dependency to reach the OpenCode free tier`,
+    );
+  }
+
+  const options = {
+    method: init.method || "GET",
+    headers: init.headers,
+    redirect: "follow",
+    timeout: timeoutMs,
+  };
+  if (init.body !== undefined) options.body = init.body;
+  if (signal) options.signal = signal;
+
+  const res = await session.fetch(url, options);
+  const headers = {};
+  res.headers?.forEach?.((value, key) => {
+    headers[key] = value;
+  });
+  return new Response(res.body, { status: res.status, statusText: res.statusText, headers });
+}
+
+export const __test__ = { OPENCODE_CIPHER_LIST };

package/open-sse/utils/writableDataDir.js

@@ -0,0 +1,32 @@
+// Resolve a writable data directory: DATA_DIR first, then ~/.10router, then
+// legacy ~/.9router, then tmpdir. Some installs point DATA_DIR at root-owned
+// paths that the server process cannot write browser profiles or runtime
+// installs into.
+
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+let cached = null;
+
+export function getWritableDataDir() {
+  if (cached) return cached;
+  const candidates = [
+    process.env.DATA_DIR,
+    path.join(os.homedir(), ".10router"),
+    path.join(os.homedir(), ".9router"),
+    path.join(os.tmpdir(), "10router"),
+  ].filter(Boolean);
+  for (const base of candidates) {
+    try {
+      fs.mkdirSync(base, { recursive: true });
+      fs.accessSync(base, fs.constants.W_OK);
+      cached = base;
+      return base;
+    } catch {
+      // Not writable — try the next candidate.
+    }
+  }
+  cached = process.cwd();
+  return cached;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@amir83nasr/10router",
-  "version": "0.1.17",
+  "version": "0.1.18",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/Amir83Nasr/10Router.git"