@amir83nasr/10router 0.1.16 → 0.1.18

package/CHANGELOG.md

@@ -2,6 +2,17 @@
 
 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.
+- OpenCode Go transports are ordered `claude → openai → openai-responses → gemini`, so the fallback prefers Anthropic Messages, which is what Claude Code traffic uses.
+- OpenCode Go `supportedFormats` re-verified against the live endpoints (the published table is stale): `kimi-k3`, `kimi-k3.1-pro`, `minimax-m3` and `deepseek-v4.1-flash` also answer on `/messages`, most chat models also answer `/responses`, and `minimax-m2.7` is Messages-only. Models disabled in an account's console read as unavailable, so only `ModelProtocolUnsupported` narrows a model's formats.
+- Added the documented `step-5-preview` and `beam-free` models, plus `gemini-4-argon` on the Google wire: the executor builds the model-scoped `/{model}:generateContent` URL and authenticates with `x-goog-api-key`.
+
 ## [0.1.16] — 2026-10-26
 
 - Removed the fish-audio, glm-cn, groq, huggingface, minimax, minimax-cn, siliconflow, vercel-ai-gateway, xiaomi-tokenplan and xquik providers: registry entries, executors, usage, TTS and image handlers, logos and their tests are gone.

package/open-sse/config/opencodeGo.js

@@ -2,8 +2,9 @@
 // Limits and model access are enforced server-side; nothing here gates requests.
 export const OPENCODE_GO_DOCS_URL = "https://opencode.ai/v2/docs/console/go";
 
-// Wire formats Go serves, matching the registry transport `format` values. A Go key
-// must be accepted by every endpoint here, so the connection probe checks all of them.
+// Wire formats the connection probe covers, matching registry transport `format`
+// values. The Google wire (`/google/v1beta/models/{model}`) is served for a single
+// model and is not probed, because its URL depends on that model's availability.
 export const OPENCODE_GO_ENDPOINTS = [
   {
     format: "openai",

package/open-sse/executors/opencode-go.js

@@ -50,6 +50,13 @@ export class OpenCodeGoExecutor extends DefaultExecutor {
   buildUrl(model, stream, urlIndex = 0, credentials = null) {
     // Muse Spark lives on /responses even when a stale runtimeTransport leaks in.
     if (isResponsesModel(model)) return RESPONSES_BASE_URL;
+    // Google wire carries the model id in the path, unlike the OpenAI/Anthropic
+    // endpoints whose transport URL is the full target.
+    const transport = credentials?.runtimeTransport;
+    if (transport?.format === "gemini") {
+      const action = stream ? "streamGenerateContent?alt=sse" : "generateContent";
+      return `${transport.baseUrl}/${baseModelId(model)}:${action}`;
+    }
     return super.buildUrl(model, stream, urlIndex, credentials);
   }
 

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/handlers/chatCore.js

@@ -1,4 +1,4 @@
-import { detectFormat, getTargetFormat, resolveTransport } from "../services/provider.js";
+import { detectFormat, getTargetFormat, resolveModelTransport } from "../services/provider.js";
 import { translateRequest } from "../translator/index.js";
 import {
   applyThinking,
@@ -138,20 +138,13 @@ export async function handleChatCore({
   const alias = PROVIDER_ID_TO_ALIAS[provider] || provider;
   const modelTargetFormat = getModelTargetFormat(alias, model);
   // Multi-endpoint providers: pick transport matching sourceFormat → zero translation.
-  // Per-model guard: only use the transport when the model declares support for that
-  // sourceFormat — opencode-go models differ in endpoint support (kimi/glm only do
-  // /chat/completions), so without this guard a claude-format request would wrongly
-  // route kimi to /messages.
+  // Guarded per model: opencode-go models differ in endpoint support, so a
+  // claude-format request must not go to /messages for kimi/glm and an OpenAI one
+  // must not go to /chat/completions for claude-haiku-5-5 (upstream answers
+  // ModelProtocolUnsupported). When the client format has no endpoint, the model's
+  // preferred declared endpoint is used and translation handles the wire change.
   const modelSupportedFormats = getModelSupportedFormats(alias, model);
-  const runtimeTransport = resolveTransport(provider, sourceFormat);
-  // Per-model guard: when a model declares supportedFormats, only use the
-  // sourceFormat-matched transport if that format is declared (opencode-go models
-  // differ — kimi/glm only do /chat/completions). Undeclared models keep the
-  // upstream default (use the transport), preserving behavior for glm/deepseek/...
-  const useTransport =
-    !modelSupportedFormats || modelSupportedFormats.includes(sourceFormat)
-      ? runtimeTransport
-      : null;
+  const useTransport = resolveModelTransport(provider, sourceFormat, modelSupportedFormats);
   // A source-format-matched endpoint keeps the request lossless. Prefer it
   // over a model-level targetFormat, which is only the fallback for clients
   // whose wire format has no supported transport (for example MiniMax-M3:

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/providers/registry/opencode-go.js

@@ -25,8 +25,15 @@ export default {
   },
   // Multi-endpoint: pick the transport matching the client sourceFormat to skip
   // translation. Guarded per-model by `supportedFormats` (see chatCore) because
-  // opencode-go models differ in endpoint support.
+  // opencode-go models differ in endpoint support. Order is the fallback
+  // preference when the client format has no endpoint on the model: Anthropic
+  // first (Claude Code is the main client), then Chat Completions, then Responses.
   transports: [
+    {
+      format: "claude",
+      baseUrl: "https://opencode.ai/inference/go/anthropic/v1/messages",
+      auth: { combined: true, header: "x-api-key", scheme: "raw", anthropicVersion: true },
+    },
     {
       format: "openai",
       baseUrl: "https://opencode.ai/inference/go/openai/v1/chat/completions",
@@ -35,58 +42,122 @@ export default {
       // (400 unknown field "thinking"), so normalize reasoning to reasoning_effort.
       thinkingFormat: "openai",
     },
-    {
-      format: "claude",
-      baseUrl: "https://opencode.ai/inference/go/anthropic/v1/messages",
-      auth: { combined: true, header: "x-api-key", scheme: "raw", anthropicVersion: true },
-    },
     {
       format: "openai-responses",
       baseUrl: "https://opencode.ai/inference/go/openai/v1/responses",
       auth: { combined: true, header: "Authorization", scheme: "bearer" },
       thinkingFormat: "openai",
     },
+    {
+      // Google protocol: the model id is a path segment, so the executor appends
+      // `/{model}:generateContent` instead of using baseUrl as the full endpoint.
+      format: "gemini",
+      baseUrl: "https://opencode.ai/inference/go/google/v1beta/models",
+      auth: { combined: true, header: "x-goog-api-key", scheme: "raw" },
+    },
   ],
-  // supportedFormats follow the endpoint table in https://opencode.ai/v2/docs/console/go
+  // supportedFormats are the endpoints each model actually answers on. The docs table
+  // is incomplete (it omits models a Go key can reach and lists protocols the gateway
+  // rejects); these values were verified against the live Go endpoints. claude comes
+  // first on purpose: most 10Router traffic is Claude Code, which then needs no
+  // translation. Probes ran on one account, so "model unavailable" can mean the model
+  // is disabled in that account's console — do not narrow a model's formats for it;
+  // only ModelProtocolUnsupported proves an endpoint is unsupported.
   models: [
-    { id: "deepseek-v4.1-flash", name: "DeepSeek V4.1 Flash", supportedFormats: ["openai"] },
-    { id: "glm-5.3-flash", name: "GLM 5.3 Flash (Vision)", supportedFormats: ["openai"] },
-    { id: "glm-5.3", name: "GLM 5.3", supportedFormats: ["openai"] },
-    { id: "glm-5.2", name: "GLM 5.2", supportedFormats: ["openai"] },
-    { id: "glm-5.1", name: "GLM 5.1", supportedFormats: ["openai"] },
-    { id: "kimi-k2.7-code", name: "Kimi K2.7 Code", supportedFormats: ["openai"] },
-    { id: "kimi-k2.6", name: "Kimi K2.6", supportedFormats: ["openai"] },
-    { id: "kimi-k3", name: "Kimi K3", supportedFormats: ["openai"] },
-    { id: "kimi-k3.1-pro", name: "Kimi K3.1 Pro", supportedFormats: ["openai"] },
+    {
+      id: "deepseek-v4.1-flash",
+      name: "DeepSeek V4.1 Flash",
+      supportedFormats: ["claude", "openai", "openai-responses"],
+    },
+    {
+      id: "glm-5.3-flash",
+      name: "GLM 5.3 Flash (Vision)",
+      supportedFormats: ["openai", "openai-responses"],
+    },
+    { id: "glm-5.3", name: "GLM 5.3", supportedFormats: ["openai", "openai-responses"] },
+    { id: "glm-5.2", name: "GLM 5.2", supportedFormats: ["openai", "openai-responses"] },
+    { id: "glm-5.1", name: "GLM 5.1", supportedFormats: ["openai", "openai-responses"] },
+    {
+      id: "kimi-k2.7-code",
+      name: "Kimi K2.7 Code",
+      supportedFormats: ["openai", "openai-responses"],
+    },
+    { id: "kimi-k2.6", name: "Kimi K2.6", supportedFormats: ["openai", "openai-responses"] },
+    {
+      id: "kimi-k3",
+      name: "Kimi K3",
+      supportedFormats: ["claude", "openai", "openai-responses"],
+    },
+    {
+      id: "kimi-k3.1-pro",
+      name: "Kimi K3.1 Pro",
+      supportedFormats: ["claude", "openai", "openai-responses"],
+    },
     {
       id: "deepseek-v4-pro",
       name: "DeepSeek V4 Pro",
-      supportedFormats: ["openai", "claude", "openai-responses"],
+      supportedFormats: ["claude", "openai", "openai-responses"],
     },
     {
       id: "deepseek-v4-flash",
       name: "DeepSeek V4 Flash",
-      supportedFormats: ["openai", "claude", "openai-responses"],
+      supportedFormats: ["claude", "openai", "openai-responses"],
     },
     {
       id: "deepseek-v4-flash-vision-exp",
       name: "DeepSeek V4 Flash Vision (Exp)",
-      supportedFormats: ["openai", "claude", "openai-responses"],
+      supportedFormats: ["claude", "openai", "openai-responses"],
+    },
+    { id: "longcat-2.0", name: "LongCat 2.0", supportedFormats: ["openai", "openai-responses"] },
+    {
+      id: "mimo-v2.6-flash",
+      name: "MiMo V2.6 Flash",
+      supportedFormats: ["openai", "openai-responses"],
     },
-    { id: "longcat-2.0", name: "LongCat 2.0", supportedFormats: ["openai"] },
-    { id: "mimo-v2.6-flash", name: "MiMo V2.6 Flash", supportedFormats: ["openai"] },
-    { id: "mimo-v2.6-pro", name: "MiMo V2.6 Pro", supportedFormats: ["openai"] },
-    { id: "mimo-v2.5", name: "MiMo V2.5", supportedFormats: ["openai"] },
+    {
+      id: "mimo-v2.6-pro",
+      name: "MiMo V2.6 Pro",
+      supportedFormats: ["openai", "openai-responses"],
+    },
+    { id: "mimo-v2.5", name: "MiMo V2.5", supportedFormats: ["openai", "openai-responses"] },
+    // "Unsupported model" on every wire: either retired or disabled in the account's
+    // console, which the probe cannot tell apart. Keep the documented Chat Completions
+    // route instead of narrowing what other accounts can use.
     { id: "mimo-v2.5-pro", name: "MiMo V2.5 Pro", supportedFormats: ["openai"] },
-    { id: "minimax-m3", name: "MiniMax M3", supportedFormats: ["openai", "claude"] },
-    { id: "minimax-m3.1-flash", name: "MiniMax M3.1 Flash", supportedFormats: ["openai"] },
-    { id: "minimax-m2.7", name: "MiniMax M2.7", supportedFormats: ["openai", "claude"] },
+    {
+      id: "minimax-m3",
+      name: "MiniMax M3",
+      supportedFormats: ["claude", "openai", "openai-responses"],
+    },
+    {
+      id: "minimax-m3.1-flash",
+      name: "MiniMax M3.1 Flash",
+      supportedFormats: ["claude", "openai"],
+    },
+    { id: "minimax-m2.7", name: "MiniMax M2.7", supportedFormats: ["claude"] },
     { id: "claude-haiku-5-5", name: "Claude Haiku 5.5", supportedFormats: ["claude"] },
-    { id: "qwen3.8-max", name: "Qwen 3.8 Max", supportedFormats: ["openai", "claude"] },
-    { id: "qwen3.8-flash", name: "Qwen 3.8 Flash", supportedFormats: ["openai", "claude"] },
-    { id: "qwen3.7-plus", name: "Qwen 3.7 Plus", supportedFormats: ["openai", "claude"] },
-    { id: "hy4-preview", name: "Hy4 Preview", supportedFormats: ["openai"] },
-    { id: "hy3", name: "Hy3", supportedFormats: ["openai"] },
+    {
+      id: "qwen3.8-max",
+      name: "Qwen 3.8 Max",
+      supportedFormats: ["claude", "openai", "openai-responses"],
+    },
+    {
+      id: "qwen3.8-flash",
+      name: "Qwen 3.8 Flash",
+      supportedFormats: ["claude", "openai", "openai-responses"],
+    },
+    {
+      id: "qwen3.7-plus",
+      name: "Qwen 3.7 Plus",
+      supportedFormats: ["claude", "openai", "openai-responses"],
+    },
+    { id: "hy4-preview", name: "Hy4 Preview", supportedFormats: ["openai", "openai-responses"] },
+    { id: "hy3", name: "Hy3", supportedFormats: ["openai", "openai-responses"] },
+    {
+      id: "step-5-preview",
+      name: "Step 5 Preview",
+      supportedFormats: ["openai", "openai-responses"],
+    },
     {
       id: "space-bunny-free",
       name: "Space Bunny Free",
@@ -99,6 +170,20 @@ export default {
       supportedFormats: ["openai"],
       tier: "free",
     },
+    {
+      id: "beam-free",
+      name: "Beam Free",
+      supportedFormats: ["openai", "openai-responses"],
+      tier: "free",
+    },
+    // Google wire only (documented). Every client format pivots through OpenAI to
+    // gemini, and the executor builds `/{model}:generateContent` from the transport.
+    {
+      id: "gemini-4-argon",
+      name: "Gemini 4 Argon",
+      targetFormat: "gemini",
+      supportedFormats: ["gemini"],
+    },
     // Served by /inference/go/openai/v1/responses only — the responses-only entry forces chatCore
     // past the sourceFormat-matched transports into translation (see chatCore guard).
     {

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/services/provider.js

@@ -158,6 +158,33 @@ export function resolveTransport(provider, sourceFormat) {
   return transports.find((t) => t.format === sourceFormat) || null;
 }
 
+// Fallback transport for a multi-endpoint provider when the client's wire format
+// has no endpoint on this model (per-model `supportedFormats`). Without it the
+// request would go to the provider's default URL and upstream would answer
+// ModelProtocolUnsupported (opencode-go: claude-haiku-5-5 has no /chat/completions).
+// The registry's transport order is the preference order, so providers can put the
+// endpoint real clients use most first.
+export function resolveFallbackTransport(provider, supportedFormats) {
+  if (!Array.isArray(supportedFormats) || !supportedFormats.length) return null;
+  const config = PROVIDERS[provider];
+  const transports = config?.transports;
+  if (!Array.isArray(transports) || !transports.length) return null;
+  return transports.find((t) => supportedFormats.includes(t.format || "openai")) || null;
+}
+
+// Transport for one model: the sourceFormat-matched endpoint when the model
+// declares that format (zero translation), otherwise the model's preferred
+// declared endpoint. Undeclared models keep the old behavior — the matched
+// transport or the provider default.
+export function resolveModelTransport(provider, sourceFormat, supportedFormats) {
+  const matchesSource = !supportedFormats || supportedFormats.includes(sourceFormat);
+  if (matchesSource) {
+    const matched = resolveTransport(provider, sourceFormat);
+    if (matched) return matched;
+  }
+  return resolveFallbackTransport(provider, supportedFormats);
+}
+
 // Check if last message is from user
 export function isLastMessageFromUser(body) {
   const messages = body.messages || body.contents;

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.16",
+  "version": "0.1.18",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/Amir83Nasr/10Router.git"