@amir83nasr/10router 0.1.15 → 0.1.16

package/open-sse/utils/opencodeFingerprint.js

@@ -80,7 +80,18 @@ export function fingerprintToolKey(name) {
   return OPENCODE_FINGERPRINT_TOOLS.includes(trimmed) ? trimmed : "";
 }
 
-/** Read a tool name from either flat ({name}) or chat ({function:{name}}) shape. */
+/**
+ * Tool declaration shapes. The fingerprint must be written in the same shape as
+ * the body it travels in: Claude's Messages API reads `input_schema` and rejects
+ * chat-shaped `function` envelopes outright.
+ */
+export const TOOL_SHAPE = {
+  CHAT: "chat", // {type:"function", function:{name, description, parameters}}
+  FLAT: "flat", // {type:"function", name, description, parameters} (Responses)
+  CLAUDE: "claude", // {name, description, input_schema} (Anthropic Messages)
+};
+
+/** Read a tool name from flat ({name}), chat ({function:{name}}) or Claude shape. */
 function toolNameOf(tool) {
   if (!tool || typeof tool !== "object" || Array.isArray(tool)) return "";
   if (typeof tool.name === "string" && tool.name.trim()) return tool.name.trim();
@@ -96,17 +107,76 @@ function chatFunctionOf(tool) {
   return fn && typeof fn === "object" && !Array.isArray(fn) ? fn : null;
 }
 
+/** Serialized input schema for a tool in any supported shape. */
+function toolSchemaOf(tool) {
+  const def = chatFunctionOf(tool) || tool;
+  return def?.parameters ?? def?.input_schema ?? null;
+}
+
 /** True when `tool` already carries OpenCode's exact definition for `key`. */
 function isFingerprintDefinition(tool, key) {
   const def = tool && (chatFunctionOf(tool) || tool);
   const want = FINGERPRINT_TOOL_DEFINITIONS[key];
   return (
     !!def &&
-    def.description === want.description &&
-    JSON.stringify(def.parameters) === JSON.stringify(want.parameters)
+    normalizePlatformSentence(def.description) === want.description &&
+    JSON.stringify(toolSchemaOf(tool)) === JSON.stringify(want.parameters)
   );
 }
 
+/** Build one fingerprint tool declaration in the requested shape. */
+function buildFingerprintTool(name, shape) {
+  const { description, parameters } = FINGERPRINT_TOOL_DEFINITIONS[name];
+  if (shape === TOOL_SHAPE.CLAUDE) return { name, description, input_schema: parameters };
+  if (shape === TOOL_SHAPE.FLAT) {
+    return { type: "function", name, description, parameters, strict: false };
+  }
+  return { type: "function", function: { name, description, parameters } };
+}
+
+/** Normalize the legacy boolean argument (true = flat, false = chat). */
+function normalizeShape(shape) {
+  if (shape === TOOL_SHAPE.CLAUDE || shape === TOOL_SHAPE.FLAT || shape === TOOL_SHAPE.CHAT) {
+    return shape;
+  }
+  return shape ? TOOL_SHAPE.FLAT : TOOL_SHAPE.CHAT;
+}
+
+/** Claude bodies declare `system` and `input_schema`; Chat bodies never do. */
+export function detectToolShape(body) {
+  if (!body || typeof body !== "object") return TOOL_SHAPE.CHAT;
+  if (body.system !== undefined) return TOOL_SHAPE.CLAUDE;
+  if (Array.isArray(body.tools) && body.tools.some((tool) => !!tool?.input_schema)) {
+    return TOOL_SHAPE.CLAUDE;
+  }
+  return TOOL_SHAPE.CHAT;
+}
+
+// OpenCode ships the same tool with OS-specific wording: "Commands run on Linux
+// using bash." vs "Commands run on Windows using powershell.". The upstream gate
+// compares descriptions verbatim, so a Windows caller's tool must travel with the
+// canonical sentence — otherwise it looks like a foreign tool, gets renamed to
+// `shell_client` and the client rejects the call (#5011).
+const PLATFORM_SENTENCE_RE =
+  /Commands run on (?:Linux using bash|Windows using powershell(?:\.exe)?)\./;
+const CANONICAL_PLATFORM_SENTENCE = "Commands run on Linux using bash.";
+
+function normalizePlatformSentence(text) {
+  return typeof text === "string"
+    ? text.replace(PLATFORM_SENTENCE_RE, CANONICAL_PLATFORM_SENTENCE)
+    : text;
+}
+
+/** Same tool, with the platform sentence rewritten to the canonical wording. */
+function withCanonicalPlatformSentence(tool, key) {
+  const want = FINGERPRINT_TOOL_DEFINITIONS[key];
+  const fn = chatFunctionOf(tool);
+  const target = fn || tool;
+  if (target.description === want.description) return tool;
+  const description = normalizePlatformSentence(target.description);
+  return fn ? { ...tool, function: { ...fn, description } } : { ...tool, description };
+}
+
 function withToolName(tool, name) {
   const fn = chatFunctionOf(tool);
   return fn ? { ...tool, function: { ...fn, name } } : { ...tool, name };
@@ -145,7 +215,7 @@ export function concealFingerprintToolNames(tools) {
     seen.add(key);
 
     if (isFingerprintDefinition(tool, key)) {
-      out.push(tool);
+      out.push(withCanonicalPlatformSentence(tool, key));
       continue;
     }
 
@@ -163,17 +233,13 @@ export function concealFingerprintToolNames(tools) {
  *
  * @returns {string[]} names that were appended
  */
-export function appendMissingFingerprintTools(tools, flat) {
+export function appendMissingFingerprintTools(tools, shape) {
   const appended = [];
   if (!Array.isArray(tools)) return appended;
+  const resolved = normalizeShape(shape);
   for (const name of OPENCODE_FINGERPRINT_TOOLS) {
     if (tools.some((tool) => fingerprintToolKey(toolNameOf(tool)) === name)) continue;
-    const { description, parameters } = FINGERPRINT_TOOL_DEFINITIONS[name];
-    tools.push(
-      flat
-        ? { type: "function", name, description, parameters, strict: false }
-        : { type: "function", function: { name, description, parameters } },
-    );
+    tools.push(buildFingerprintTool(name, resolved));
     appended.push(name);
   }
   return appended;
@@ -214,7 +280,8 @@ export function aliasHistoryToolCalls(body, map) {
 
   if (Array.isArray(body.input)) {
     body.input = body.input.map((item) =>
-      item?.type === "function_call" && aliases.has(item.name)
+      (item?.type === "function_call" || item?.type === "custom_tool_call") &&
+      aliases.has(item.name)
         ? { ...item, name: aliases.get(item.name) }
         : item,
     );
@@ -222,9 +289,19 @@ export function aliasHistoryToolCalls(body, map) {
 
   if (Array.isArray(body.messages)) {
     body.messages = body.messages.map((msg) => {
-      if (!Array.isArray(msg?.tool_calls)) return msg;
+      // Claude shape: prior tool_use blocks live in the content array.
+      const content = Array.isArray(msg?.content)
+        ? msg.content.map((block) =>
+            block?.type === "tool_use" && aliases.has(block.name)
+              ? { ...block, name: aliases.get(block.name) }
+              : block,
+          )
+        : null;
+      const withContent = content && content !== msg.content ? { ...msg, content } : msg;
+
+      if (!Array.isArray(msg?.tool_calls)) return withContent;
       return {
-        ...msg,
+        ...withContent,
         tool_calls: msg.tool_calls.map((call) =>
           aliases.has(call?.function?.name)
             ? { ...call, function: { ...call.function, name: aliases.get(call.function.name) } }
@@ -240,21 +317,41 @@ export function aliasHistoryToolCalls(body, map) {
 // in the system prompt instead. Upstream does not gate on the prompt text.
 // Wording matters: "not available" made the model also refuse the caller's own
 // Read/Bash; "placeholders ... use the other tools" kept those working.
-function noteUnavailableTools(body, flat, names) {
+function noteUnavailableTools(body, shape, names) {
   const list = names.map((name) => `\`${name}\``).join(" or ");
   const note =
     names.length > 1
       ? `Do not call the ${list} tools; they are placeholders that do nothing. Use the other tools you have been given instead.`
       : `Do not call the ${list} tool; it is a placeholder that does nothing. Use the other tools you have been given instead.`;
-  if (flat) {
+  // Anthropic rejects role "system" inside `messages`; its prompt lives in the
+  // top-level `system` field. A Claude body must never receive the chat note,
+  // even when a caller passed the chat shape.
+  const resolved = detectToolShape(body) === TOOL_SHAPE.CLAUDE ? TOOL_SHAPE.CLAUDE : shape;
+  if (resolved === TOOL_SHAPE.FLAT) {
     body.instructions =
       typeof body.instructions === "string" && body.instructions.trim()
         ? `${body.instructions}\n\n${note}`
         : note;
     return;
   }
-  // OpenAI chat shape only; Claude-shaped bodies carry `system` instead.
-  if (!Array.isArray(body.messages) || body.system !== undefined) return;
+  if (resolved === TOOL_SHAPE.CLAUDE) {
+    // Anthropic carries the prompt in `system`, as a string or text blocks.
+    if (typeof body.system === "string") {
+      body.system = body.system.trim() ? `${body.system}\n\n${note}` : note;
+      return;
+    }
+    if (Array.isArray(body.system) && body.system.length > 0) {
+      const last = body.system[body.system.length - 1];
+      body.system =
+        last?.type === "text"
+          ? [...body.system.slice(0, -1), { ...last, text: `${last.text}\n\n${note}` }]
+          : [...body.system, { type: "text", text: note }];
+      return;
+    }
+    body.system = note;
+    return;
+  }
+  if (!Array.isArray(body.messages)) return;
   const first = body.messages[0];
   if (first?.role === "system" && typeof first.content === "string") {
     body.messages = [
@@ -271,22 +368,24 @@ function noteUnavailableTools(body, flat, names) {
  * fingerprint definitions, and tell the model the appended ones are off-limits.
  *
  * @param {object} body
- * @param {boolean} flat - true for Responses tools ({name}), false for chat tools
+ * @param {string|boolean} shape - TOOL_SHAPE value; `true`/`false` are accepted
+ *   for the Responses and chat shapes respectively
  * @returns {Map<string,string>} map: sent name -> original name
  */
-export function applyFingerprintTools(body, flat) {
+export function applyFingerprintTools(body, shape) {
   if (!body || typeof body !== "object") return new Map();
+  const resolved = normalizeShape(shape === undefined ? detectToolShape(body) : shape);
 
   const { tools, map } = concealFingerprintToolNames(body.tools);
   body.tools = Array.isArray(tools) ? tools : [];
-  const appended = appendMissingFingerprintTools(body.tools, flat);
+  const appended = appendMissingFingerprintTools(body.tools, resolved);
   retargetToolChoice(body, map);
   aliasHistoryToolCalls(body, map);
-  if (appended.length) noteUnavailableTools(body, flat, appended);
+  if (appended.length) noteUnavailableTools(body, resolved, appended);
 
   // Responses keeps its explicit auto default. Never default to "none": upstream
   // answers tool_choice "none" with 403 FreeTierError.
-  if (!body.tool_choice && flat) body.tool_choice = "auto";
+  if (!body.tool_choice && resolved === TOOL_SHAPE.FLAT) body.tool_choice = "auto";
 
   recordRenamedToolNames(body, map);
   return map;

package/open-sse/utils/opencodeFreeUsage.js

@@ -1,3 +1,9 @@
+import {
+  OPENCODE_ENTITLEMENT_MESSAGE,
+  isFreeTierEntitlementMessage,
+} from "../config/opencodeErrors.js";
+import { isQuotaError, readErrorEnvelope } from "./opencodeErrors.js";
+
 // Short in-memory backoff for the OpenCode free lane (`Authorization: Bearer public`).
 //
 // Root cause it addresses: the free lane is one global upstream quota pool behind
@@ -35,27 +41,37 @@ export function parseRetryAfterMs(value) {
 }
 
 // Returns { status, message, resetsAtMs } for FreeUsageLimit 429s, else null so
-// callers fall through to the default parser.
+// callers fall through to the default parser. Entitlement failures (free models
+// requested through an API key) are permanent: no breaker, actionable message.
 export function parseFreeUsageError(response, bodyText) {
   try {
     if (!response || response.status !== 429) return null;
-    let type = "";
-    let msg = "";
-    try {
-      const json = JSON.parse(bodyText || "{}");
-      const err = json?.error && typeof json.error === "object" ? json.error : null;
-      type = err?.type || json?.type || "";
-      msg = err?.message || json?.message || "";
-    } catch {
-      msg = bodyText || "";
+    const envelope = readErrorEnvelope(bodyText);
+    const str = envelope.message || "";
+    if (isFreeTierEntitlementMessage(str)) {
+      return {
+        status: 429,
+        kind: "entitlement",
+        message: OPENCODE_ENTITLEMENT_MESSAGE,
+        resetsAtMs: null,
+      };
     }
-    const str = typeof msg === "string" ? msg : JSON.stringify(msg);
-    if (type !== "FreeUsageLimitError" && !/rate limit/i.test(str)) return null;
+    if (envelope.type !== "FreeUsageLimitError" && !isQuotaError(str)) return null;
     const retryMs = parseRetryAfterMs(response.headers?.get?.("retry-after"));
     const resetsAtMs = retryMs ? Date.now() + retryMs : null;
     const hint = retryMs ? ` (retry after ${humanMs(retryMs)})` : "";
+    // Our own synthetic 429 (already carries the "(local backoff, …)" hint): don't relabel it "upstream".
+    if (/local backoff/i.test(str)) {
+      return {
+        status: 429,
+        kind: "quota",
+        message: `OpenCode free-tier quota exhausted: ${str}`,
+        resetsAtMs,
+      };
+    }
     return {
       status: 429,
+      kind: "quota",
       message: `OpenCode free-tier quota exhausted upstream${hint}: ${str || "Rate limit exceeded"}`,
       resetsAtMs,
     };
@@ -64,6 +80,19 @@ export function parseFreeUsageError(response, bodyText) {
   }
 }
 
+// Classify an upstream response as a permanent entitlement gate (vs a quota
+// window) without consuming it. Used by executors to decide whether the local
+// breaker may record a cooldown.
+export async function isEntitlementResponse(response) {
+  if (!response || response.status !== 429) return false;
+  try {
+    const bodyText = await response.clone().text();
+    return isFreeTierEntitlementMessage(readErrorEnvelope(bodyText).message);
+  } catch {
+    return false;
+  }
+}
+
 // Remaining cooldown for key, or 0. Lazily evicts expired entries.
 export function freeUsageRemainingMs(key) {
   const until = breaker.get(key);
@@ -113,3 +142,19 @@ export function syntheticFreeUsageResponse(remainingMs) {
     },
   );
 }
+
+// Fail-fast response for free-tier models requested on a keyed lane. No
+// retry-after: the gate is a plan entitlement, not a temporary window.
+export function syntheticEntitlementResponse() {
+  return new Response(
+    JSON.stringify({
+      type: "error",
+      error: { type: "FreeUsageLimitError", message: OPENCODE_ENTITLEMENT_MESSAGE },
+      metadata: {},
+    }),
+    {
+      status: 429,
+      headers: { "content-type": "application/json" },
+    },
+  );
+}

package/open-sse/utils/usageTracking.js

@@ -181,8 +181,9 @@ export function canonicalizeUsage(usage) {
   if (!usage || typeof usage !== "object" || Array.isArray(usage)) return null;
 
   const num = (v) => (Number.isFinite(Number(v)) ? Number(v) : 0);
-  const completion = num(usage.completion_tokens ?? usage.output_tokens);
   const reasoning = num(usage.reasoning_tokens);
+  // Some upstreams report completion_tokens: 0 while spending everything on reasoning.
+  const completion = Math.max(num(usage.completion_tokens ?? usage.output_tokens), reasoning);
   // Fall back to the nested prompt_tokens_details.cache_creation_tokens shape
   // (buildUsage()'s OpenAI-forwarding format) when the top-level field is
   // absent, so callers that pass a buildUsage() object through don't silently
@@ -309,12 +310,13 @@ export function extractUsage(chunk) {
 
   // OpenAI format (also covers DeepSeek which uses prompt_cache_hit_tokens)
   if (chunk.usage && typeof chunk.usage === "object" && chunk.usage.prompt_tokens !== undefined) {
+    const reasoningTokens = chunk.usage.completion_tokens_details?.reasoning_tokens;
     return normalizeUsage({
       prompt_tokens: chunk.usage.prompt_tokens,
-      completion_tokens: chunk.usage.completion_tokens || 0,
+      completion_tokens: Math.max(chunk.usage.completion_tokens || 0, reasoningTokens || 0),
       cached_tokens:
         chunk.usage.prompt_tokens_details?.cached_tokens || chunk.usage.prompt_cache_hit_tokens,
-      reasoning_tokens: chunk.usage.completion_tokens_details?.reasoning_tokens,
+      reasoning_tokens: reasoningTokens,
       prompt_tokens_details: chunk.usage.prompt_tokens_details,
       completion_tokens_details: chunk.usage.completion_tokens_details,
     });

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@amir83nasr/10router",
-  "version": "0.1.15",
+  "version": "0.1.16",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/Amir83Nasr/10Router.git"
   },
-  "packageManager": "pnpm@12.6.0",
+  "packageManager": "pnpm@12.15.0",
   "description": "10Router dashboard",
   "bin": {
     "10router": "bin/10router.mjs"

package/src/app/(dashboard)/dashboard/console-log/ConsoleLogClient.tsx

@@ -293,6 +293,15 @@ export default function ConsoleLogClient() {
     logRef.current.scrollTop = logRef.current.scrollHeight;
   }, [logs, autoScroll]);
 
+  // Scrolling away from the bottom disengages Follow, so reading an older
+  // line isn't interrupted by every new one; scrolling back re-engages it.
+  const handleScroll = () => {
+    const el = logRef.current;
+    if (!el) return;
+    const atBottom = el.scrollHeight - el.scrollTop - el.clientHeight < 40;
+    setAutoScroll(atBottom);
+  };
+
   const toggleLevel = (level: LogLevel) => {
     setLevels((prev) => {
       const next = new Set(prev);
@@ -407,6 +416,7 @@ export default function ConsoleLogClient() {
       <CardContent className="pt-0">
         <div
           ref={logRef}
+          onScroll={handleScroll}
           className="h-[calc(100vh-220px)] overflow-y-auto rounded-b-lg border border-border bg-card p-2 font-mono text-xs"
         >
           {logs.length === 0 ? (

package/src/app/(dashboard)/dashboard/providers/[id]/ModelRow.tsx

@@ -1,5 +1,6 @@
 import Icon from "@/shared/components/Icon";
 import { CapacityBadges } from "@/shared/components";
+import { Badge } from "@/components/ui/badge";
 import { Tooltip, TooltipContent, TooltipTrigger } from "@/components/ui/tooltip";
 
 export default function ModelRow({
@@ -53,6 +54,19 @@ export default function ModelRow({
             <CapacityBadges caps={caps} colorOverride="text-muted-foreground/70" size={12} />
           </span>
         </div>
+        {isFree && (
+          <Tooltip>
+            <TooltipTrigger asChild>
+              <Badge className="shrink-0 bg-green-500/10 font-bold text-green-600 dark:text-green-500">
+                FREE
+              </Badge>
+            </TooltipTrigger>
+            <TooltipContent>
+              Free model: works through the free OpenCode lane. An OpenCode Zen/Go API key cannot
+              unlock it.
+            </TooltipContent>
+          </Tooltip>
+        )}
         {onTest && (
           <div className="relative shrink-0 group/btn">
             <button

package/src/app/(dashboard)/dashboard/providers/[id]/OpenCodeGoConnectionCard.tsx

@@ -0,0 +1,113 @@
+"use client";
+import Icon from "@/shared/components/Icon";
+import { Card, CardContent } from "@/components/ui/card";
+import { Button } from "@/components/ui/button";
+import { OPENCODE_URLS } from "open-sse/config/opencodeErrors.js";
+import {
+  OPENCODE_GO_DOCS_URL,
+  OPENCODE_GO_ENDPOINTS,
+  OPENCODE_GO_PLANS,
+  OPENCODE_GO_SETUP_NOTES,
+} from "open-sse/config/opencodeGo.js";
+
+interface OpenCodeGoConnectionCardProps {
+  connectionCount: number;
+  activeCount: number;
+  onAddConnection: () => void;
+}
+
+const SETUP_STEPS = [
+  "Subscribe to a Go plan in the OpenCode Console.",
+  "Copy your OpenCode API key from the same account.",
+  "Add it as a connection below. The x-opencode-session header is set automatically.",
+];
+
+export default function OpenCodeGoConnectionCard({
+  connectionCount,
+  activeCount,
+  onAddConnection,
+}: OpenCodeGoConnectionCardProps) {
+  const statusText =
+    connectionCount === 0 ? "No connections yet" : `${activeCount} of ${connectionCount} active`;
+
+  return (
+    <Card>
+      <CardContent>
+        <div className="mb-4 flex flex-col gap-3 sm:flex-row sm:items-start sm:justify-between">
+          <div className="min-w-0">
+            <h2 className="text-lg font-semibold">OpenCode Go Connection</h2>
+            <p className="text-sm text-muted-foreground">{statusText}</p>
+          </div>
+          <Button size="sm" onClick={onAddConnection} className="w-full sm:w-auto">
+            <Icon name="add" />
+            Add Connection
+          </Button>
+        </div>
+
+        <div className="mb-4 grid grid-cols-1 gap-2 sm:grid-cols-2">
+          {OPENCODE_GO_PLANS.map((plan) => (
+            <div
+              key={plan.id}
+              className="flex items-center justify-between rounded-lg border border-border px-3 py-2"
+            >
+              <span className="text-sm font-medium">{plan.name}</span>
+              <span className="text-sm text-muted-foreground">{plan.price}</span>
+            </div>
+          ))}
+        </div>
+
+        <div className="mb-4">
+          <h3 className="mb-2 text-sm font-medium">Endpoints</h3>
+          <ul className="flex flex-col gap-2">
+            {OPENCODE_GO_ENDPOINTS.map((endpoint) => (
+              <li
+                key={endpoint.format}
+                className="flex flex-col gap-0.5 rounded-lg border border-border px-3 py-2"
+              >
+                <span className="text-sm font-medium">{endpoint.label}</span>
+                <code className="break-all text-xs text-muted-foreground">{endpoint.url}</code>
+                <span className="text-xs text-muted-foreground">{endpoint.note}</span>
+              </li>
+            ))}
+          </ul>
+        </div>
+
+        <ol className="mb-4 flex list-decimal flex-col gap-1.5 pl-5 text-sm text-muted-foreground">
+          {SETUP_STEPS.map((step) => (
+            <li key={step}>{step}</li>
+          ))}
+        </ol>
+
+        <ul className="mb-4 flex flex-col gap-2 rounded-lg border border-blue-500/30 bg-blue-500/10 px-3 py-2 text-xs leading-relaxed text-blue-600 dark:text-blue-400">
+          {OPENCODE_GO_SETUP_NOTES.map((note) => (
+            <li key={note} className="flex gap-2">
+              <Icon name="info" className="mt-0.5 text-[16px] shrink-0" />
+              <span className="min-w-0">{note}</span>
+            </li>
+          ))}
+        </ul>
+
+        <div className="flex flex-col gap-2 sm:flex-row sm:gap-4">
+          <a
+            href={OPENCODE_URLS.go}
+            target="_blank"
+            rel="noopener noreferrer"
+            className="inline-flex items-center gap-1 text-xs text-primary hover:underline"
+          >
+            Subscribe to Go
+            <Icon name="open_in_new" className="text-sm" />
+          </a>
+          <a
+            href={OPENCODE_GO_DOCS_URL}
+            target="_blank"
+            rel="noopener noreferrer"
+            className="inline-flex items-center gap-1 text-xs text-primary hover:underline"
+          >
+            OpenCode Go docs
+            <Icon name="open_in_new" className="text-sm" />
+          </a>
+        </div>
+      </CardContent>
+    </Card>
+  );
+}

package/src/app/(dashboard)/dashboard/providers/[id]/page.tsx

@@ -36,7 +36,7 @@ import {
   isAnthropicCompatibleProvider,
   AI_PROVIDERS,
 } from "@/shared/constants/providers";
-import { getModelsByProviderId, getModelKind } from "@/shared/constants/models";
+import { getModelsByProviderId, getModelKind, isFreeTierModel } from "@/shared/constants/models";
 import { useCopyToClipboard } from "@/shared/hooks/useCopyToClipboard";
 import { useModelCaps } from "@/shared/hooks/useModelCaps";
 import { translate } from "@/i18n/runtime";
@@ -51,6 +51,7 @@ import { ArrowLeftRight, Server, Unplug } from "lucide-react";
 import PassthroughModelsSection from "./PassthroughModelsSection";
 import CompatibleModelsSection from "./CompatibleModelsSection";
 import ConnectionRow from "./ConnectionRow";
+import OpenCodeGoConnectionCard from "./OpenCodeGoConnectionCard";
 import AddApiKeyModal from "./AddApiKeyModal";
 import EditCompatibleNodeModal from "./EditCompatibleNodeModal";
 import AddCustomModelModal from "./AddCustomModelModal";
@@ -1128,7 +1129,7 @@ export default function ProviderDetailPage() {
                   : undefined
               }
               isTesting={testingModelIds.has(model.id)}
-              isFree={model.isFree}
+              isFree={model.isFree || isFreeTierModel(providerStorageAlias, model.id)}
               onDisable={() => handleDisableModel(model.id)}
               caps={getCaps(`${providerId}/${model.id}`)}
             />
@@ -1436,6 +1437,14 @@ export default function ProviderDetailPage() {
           </Card>
         )}
 
+        {providerId === "opencode-go" && (
+          <OpenCodeGoConnectionCard
+            connectionCount={connections.length}
+            activeCount={connections.filter((conn) => conn.isActive !== false).length}
+            onAddConnection={triggerAddConnection}
+          />
+        )}
+
         {/* Connections */}
         {isFreeNoAuth ? (
           <NoAuthProxyCard providerId={providerId} />

package/src/app/(dashboard)/dashboard/providers/components/ModelsCard.tsx

@@ -3,10 +3,11 @@ import Icon from "@/shared/components/Icon";
 
 import { useState, useCallback, useEffect } from "react";
 import { Card, CardContent } from "@/components/ui/card";
+import { Badge } from "@/components/ui/badge";
 import { Button } from "@/components/ui/button";
 import { Dialog, DialogContent, DialogHeader, DialogTitle } from "@/components/ui/dialog";
 import { Tooltip, TooltipContent, TooltipTrigger } from "@/components/ui/tooltip";
-import { getModelsByProviderId, getModelKind } from "@/shared/constants/models";
+import { getModelsByProviderId, getModelKind, isFreeTierModel } from "@/shared/constants/models";
 import { getProviderAlias } from "@/shared/constants/providers";
 import { useCopyToClipboard } from "@/shared/hooks/useCopyToClipboard";
 
@@ -83,9 +84,17 @@ export function ModelRow({
           </span>
         </div>
         {isFree && (
-          <span className="text-[10px] font-bold text-green-500 bg-green-500/10 px-1.5 py-0.5 rounded">
-            FREE
-          </span>
+          <Tooltip>
+            <TooltipTrigger asChild>
+              <Badge className="bg-green-500/10 font-bold text-green-600 dark:text-green-500">
+                FREE
+              </Badge>
+            </TooltipTrigger>
+            <TooltipContent>
+              Free model: works through the free OpenCode lane. An OpenCode Zen/Go API key cannot
+              unlock it.
+            </TooltipContent>
+          </Tooltip>
         )}
         {isCustom && (
           <Tooltip>
@@ -299,7 +308,7 @@ export default function ModelsCard({ providerId, kindFilter, providerAliasOverri
                   testStatus={modelTestResults[model.id]}
                   onTest={() => handleTestModel(model.id)}
                   isTesting={testingModelId === model.id}
-                  isFree={model.isFree}
+                  isFree={model.isFree || isFreeTierModel(providerAlias, model.id)}
                 />
               );
             })}