cartethyia 2.7.0 → 2.7.1

package/src/providers/integrations/inferhub.ts

@@ -11,7 +11,7 @@ import type { FetchLike, ProviderQuotaResult } from "../quota/quota-contracts";
 import { probeApiKeyConnectivity } from "../quota/quota-support";
 import type { CanonicalEvent, CanonicalRequest, ContentPart } from "../../protocol/canonical-model";
 import { GatewayError } from "../../protocol/gateway-error";
-import { applyParamQuirks } from "../../transport/translation/quirks";
+import { applyParamQuirks } from "../../protocol/translation/quirks";
 import { buildClaudeMessagesRequest, filterClaudeCustomHeaders } from "./shared/claude-messages";
 import { resolveInboundSessionId } from "../operations/session-resolution";
 import { isRecord } from "../../protocol/codecs";

package/src/providers/integrations/kiro/kiro-request.ts

@@ -21,7 +21,7 @@
 import { createHash, randomUUID } from "node:crypto";
 import type { CanonicalMessage, CanonicalRequest, ContentPart, ToolDefinition } from "../../../protocol/canonical-model";
 import { resolveImageSource, splitDataUrl } from "../../../protocol/codecs";
-import type { ReasoningEffortLevel } from "../../../transport/translation/thinking";
+import type { ReasoningEffortLevel } from "../../../protocol/translation/thinking";
 
 /** Longest tool name the upstream accepts, counted in code points. */
 export const KIRO_TOOL_NAME_MAX_LENGTH = 64;

package/src/providers/integrations/mistral.ts

@@ -4,14 +4,11 @@ import { defineModel } from "../provider-model-definition";
 const MISTRAL_PROVIDER_ID = "mistral" as const;
 
 /**
- * Mistral's own current generalist tiers.
+ * Mistral's catalog for the generic OpenAI-compatible API-key provider.
  *
- * The provider is registered as a generic OpenAI-compatible API-key provider,
- * which carries no catalog of its own: without this list, every model it serves
- * stays absent until a discovery run happens to fetch them. These are the two
- * `latest` aliases Mistral keeps pointed at its current generalist models —
- * `mistral-large-latest` (Large 4) and `mistral-medium-latest` (Medium 3.5),
- * per the Mistral model overview.
+ * The provider is registered as a generic API-key provider, which carries no
+ * catalog of its own: without this list, every model it serves stays absent
+ * until a discovery run happens to fetch them.
  *
  * Limits and pricing come from the base catalog via `providerId`: `defineModel`
  * resolves `mistral:<id>` and falls back to the majority row, so no number is
@@ -19,28 +16,110 @@ const MISTRAL_PROVIDER_ID = "mistral" as const;
  * because the base catalog is keyed by bare id and a bare id maps to many
  * providers' servings.
  *
+ * Which rows are here: the chat models live on a real Mistral account (the
+ * code/codestral family, the ministral small/medium/large sizes, voxtral
+ * small, and the small/medium generalist tiers). A live probe against the
+ * Mistral API verified each of these responds on `/v1/chat/completions`.
+ *
  * Deliberately not included:
  *
- * - The dated rows (`mistral-large-2411`, `mistral-medium-2508`). Each is on
- *   Mistral's retired list with a named successor.
- * - `mistral-small-latest`. Still live, but the operator asked for the two
- *   frontier tiers, and listing a model is a routing claim rather than a
- *   completeness claim.
- * - Both Magistral rows. Mistral deprecated Magistral Medium and Small in
- *   favour of Mistral Medium 3.5 and Mistral Small 4, so listing them
- *   advertises models the provider is actively retiring.
- * - The open-weights rows (`open-mistral-7b`, `open-mixtral-8x7b`), the
- *   embedding row (`mistral-embed`, not a chat model), and the devstral and
- *   codestral families — Mistral publishes those as separate product lines.
+ * - `mistral-large-latest` / dated large rows — tier-gated (Mistral answers
+ *   403 `tier_not_allowed` on many subscription tiers).
+ * - The embed/moderation/OCR/transcribe/TTS/realtime rows — they speak a
+ *   different endpoint, not chat.
+ * - The Labs rows (`labs-leanstral-*`) — need an organization admin flag.
+ * - The open-weights rows (`open-mistral-7b`, `open-mixtral-8x7b`) and the
+ *   devstral family — separate product lines.
  */
 export const MISTRAL_MODELS: readonly ModelDefinition[] = [
+  // Code / coding family
+  defineModel({
+    id: "codestral-2508",
+    providerId: MISTRAL_PROVIDER_ID,
+    wireFamily: "chat",
+    vision: true,
+    toolCall: true,
+  }),
+  defineModel({
+    id: "codestral-latest",
+    providerId: MISTRAL_PROVIDER_ID,
+    wireFamily: "chat",
+    vision: true,
+    toolCall: true,
+  }),
+  defineModel({
+    id: "mistral-code-latest",
+    providerId: MISTRAL_PROVIDER_ID,
+    wireFamily: "chat",
+    vision: true,
+    toolCall: true,
+  }),
+  defineModel({
+    id: "mistral-code-fim-latest",
+    providerId: MISTRAL_PROVIDER_ID,
+    wireFamily: "chat",
+    vision: true,
+    toolCall: true,
+  }),
+  // Ministral sizes
+  defineModel({
+    id: "ministral-14b-2512",
+    providerId: MISTRAL_PROVIDER_ID,
+    wireFamily: "chat",
+    vision: true,
+    toolCall: true,
+  }),
+  defineModel({
+    id: "ministral-14b-latest",
+    providerId: MISTRAL_PROVIDER_ID,
+    wireFamily: "chat",
+    vision: true,
+    toolCall: true,
+  }),
   defineModel({
-    id: "mistral-large-latest",
+    id: "ministral-8b-2512",
     providerId: MISTRAL_PROVIDER_ID,
     wireFamily: "chat",
     vision: true,
     toolCall: true,
   }),
+  defineModel({
+    id: "ministral-8b-latest",
+    providerId: MISTRAL_PROVIDER_ID,
+    wireFamily: "chat",
+    vision: true,
+    toolCall: true,
+  }),
+  defineModel({
+    id: "ministral-3b-2512",
+    providerId: MISTRAL_PROVIDER_ID,
+    wireFamily: "chat",
+    vision: true,
+    toolCall: true,
+  }),
+  defineModel({
+    id: "ministral-3b-latest",
+    providerId: MISTRAL_PROVIDER_ID,
+    wireFamily: "chat",
+    vision: true,
+    toolCall: true,
+  }),
+  // Voxtral small (chat-capable)
+  defineModel({
+    id: "voxtral-small-2507",
+    providerId: MISTRAL_PROVIDER_ID,
+    wireFamily: "chat",
+    vision: true,
+    toolCall: true,
+  }),
+  defineModel({
+    id: "voxtral-small-latest",
+    providerId: MISTRAL_PROVIDER_ID,
+    wireFamily: "chat",
+    vision: true,
+    toolCall: true,
+  }),
+  // Medium generalist tiers
   defineModel({
     id: "mistral-medium-latest",
     providerId: MISTRAL_PROVIDER_ID,
@@ -49,4 +128,99 @@ export const MISTRAL_MODELS: readonly ModelDefinition[] = [
     reasoning: true,
     toolCall: true,
   }),
+  defineModel({
+    id: "mistral-medium",
+    providerId: MISTRAL_PROVIDER_ID,
+    wireFamily: "chat",
+    vision: true,
+    reasoning: true,
+    toolCall: true,
+  }),
+  defineModel({
+    id: "mistral-medium-3-5",
+    providerId: MISTRAL_PROVIDER_ID,
+    wireFamily: "chat",
+    vision: true,
+    reasoning: true,
+    toolCall: true,
+  }),
+  defineModel({
+    id: "mistral-medium-3.5",
+    providerId: MISTRAL_PROVIDER_ID,
+    wireFamily: "chat",
+    vision: true,
+    reasoning: true,
+    toolCall: true,
+  }),
+  defineModel({
+    id: "mistral-medium-3",
+    providerId: MISTRAL_PROVIDER_ID,
+    wireFamily: "chat",
+    vision: true,
+    reasoning: true,
+    toolCall: true,
+  }),
+  defineModel({
+    id: "mistral-medium-2604",
+    providerId: MISTRAL_PROVIDER_ID,
+    wireFamily: "chat",
+    vision: true,
+    reasoning: true,
+    toolCall: true,
+  }),
+  // Vibe CLI family
+  defineModel({
+    id: "mistral-vibe-cli-latest",
+    providerId: MISTRAL_PROVIDER_ID,
+    wireFamily: "chat",
+    vision: true,
+    toolCall: true,
+  }),
+  defineModel({
+    id: "mistral-vibe-cli-with-tools",
+    providerId: MISTRAL_PROVIDER_ID,
+    wireFamily: "chat",
+    vision: true,
+    toolCall: true,
+  }),
+  defineModel({
+    id: "mistral-vibe-cli-fast",
+    providerId: MISTRAL_PROVIDER_ID,
+    wireFamily: "chat",
+    vision: true,
+    toolCall: true,
+  }),
+  // Magistral / small generalist tiers (chat-capable)
+  defineModel({
+    id: "magistral-medium-latest",
+    providerId: MISTRAL_PROVIDER_ID,
+    wireFamily: "chat",
+    vision: true,
+    reasoning: true,
+    toolCall: true,
+  }),
+  defineModel({
+    id: "mistral-small-2603",
+    providerId: MISTRAL_PROVIDER_ID,
+    wireFamily: "chat",
+    vision: true,
+    reasoning: true,
+    toolCall: true,
+  }),
+  defineModel({
+    id: "mistral-small-latest",
+    providerId: MISTRAL_PROVIDER_ID,
+    wireFamily: "chat",
+    vision: true,
+    reasoning: true,
+    toolCall: true,
+  }),
+  defineModel({
+    id: "magistral-small-latest",
+    providerId: MISTRAL_PROVIDER_ID,
+    wireFamily: "chat",
+    vision: true,
+    reasoning: true,
+    toolCall: true,
+  }),
 ];

package/src/providers/integrations/opencode/fingerprint.ts

@@ -1,6 +1,14 @@
 import { getOpenCodeVersion } from "../../operations/client-versions";
 import { createHash, randomBytes } from "node:crypto";
 
+/**
+ * The OpenCode fallback client identity, used only while version discovery has
+ * not resolved yet. The live feed (`opencode/latest/<version>/cli`) wins once
+ * it is available; upstream accepts a range of releases, so the fallback does
+ * not need chasing.
+ */
+export const OPENCODE_CLIENT_VERSION = "2.1.1";
+
 let lastTimestamp = 0;
 let sequenceCounter = 0;
 const SESSION_ID_ALPHABET = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
@@ -118,11 +126,19 @@ function createTraceHeaders(): Record<string, string> {
   };
 }
 
-/** Build the observed OpenCode CLI identity headers for an upstream dispatch. */
+/**
+ * Build the observed OpenCode CLI identity headers for an upstream dispatch.
+ *
+ * The v2 lane splits root and child session ids exactly like the reference
+ * gateway: `x-opencode-session` / `x-session-affinity` / `x-session-id` carry
+ * the root session, while `x-opencode-session-id` carries the child (the
+ * client's own session id when it sent one, else the root).
+ */
 export function buildOpenCodeHeaders(
   version = getOpenCodeVersion(),
   affinity?: string,
   projectId?: string,
+  childSessionId?: string,
 ): Record<string, string> {
   let sessionId: string;
   if (isOpenCodeSessionId(affinity)) {
@@ -132,6 +148,7 @@ export function buildOpenCodeHeaders(
   } else {
     sessionId = generateOpenCodeSessionId();
   }
+  const childId = isOpenCodeSessionId(childSessionId) ? childSessionId : sessionId;
   return {
     // The gate accepts both "cli" and "desktop" (measured 2026-10-17), so this
     // is not a refusal either way. It is "cli" because that is what the client
@@ -140,7 +157,7 @@ export function buildOpenCodeHeaders(
     // client identity this adapter does not have, for no measured benefit.
     "x-opencode-client": "cli",
     "x-opencode-session": sessionId,
-    "x-opencode-session-id": sessionId,
+    "x-opencode-session-id": childId,
     "x-session-affinity": sessionId,
     "x-session-id": sessionId,
     // No `x-opencode-request`: the current client no longer sends it, and

package/src/providers/integrations/opencode/prompt.ts

@@ -0,0 +1,111 @@
+/**
+ * The minimal system prompt injected into free-tier OpenCode payloads.
+ *
+ * The full CLI prompt is unnecessary: live trimming showed the free-tier gate
+ * accepts any system content that carries the `<env>` block with a
+ * `Working directory:` line — even a ~30-character placeholder passes. The
+ * marker line below is kept so `carriesOpenCodePrompt` can detect an already-
+ * injected prompt and avoid duplication.
+ */
+
+/** The marker that identifies a body already carrying the injected prompt. */
+export const OPENCODE_PROMPT_MARKER = "You are an interactive coding agent that helps users";
+
+/**
+ * Assembles the minimal prompt: the marker line plus the `<env>` block the
+ * gate requires. No model identity, no skills, no style rules — the model is
+ * a gateway proxy and should not claim an upstream identity.
+ */
+export function opencodeSystemPrompt(): string {
+  const directory = process.cwd().trim() || "/workspace";
+  return `You are an interactive coding agent that helps users with software engineering tasks.\n<env>  Working directory: ${directory}</env>`;
+}
+
+/** Flattens a system/instruction value into its text fragments. */
+export function textFragments(value: unknown): string[] {
+  if (typeof value === "string") {
+    return value.trim() === "" ? [] : [value];
+  }
+  if (Array.isArray(value)) return value.flatMap((item) => textFragments(item));
+  if (typeof value === "object" && value !== null) {
+    const record = value as Record<string, unknown>;
+    if (typeof record["text"] === "string") return textFragments(record["text"]);
+    if (record["content"] !== undefined) return textFragments(record["content"]);
+  }
+  return [];
+}
+
+/** Whether any text inside `value` already contains the injected prompt marker. */
+export function carriesOpenCodePrompt(value: unknown): boolean {
+  return textFragments(value).some((part) => part.includes(OPENCODE_PROMPT_MARKER));
+}
+
+/**
+ * Appends the `<env>` block to the first existing system/developer message
+ * instead of prepending a new leading system message. The tool's own system
+ * content (Claude Code, DSH, …) keeps its place; the gate-required env block
+ * is tacked on at the end of it.
+ */
+export function injectChatPrompt(payload: Record<string, unknown>, prompt: string): boolean {
+  const messages = payload["messages"];
+  if (!Array.isArray(messages)) return false;
+  const firstSystem = messages.findIndex((raw) => {
+    if (typeof raw !== "object" || raw === null) return false;
+    const role = (raw as Record<string, unknown>)["role"];
+    return role === "system" || role === "developer";
+  });
+  if (firstSystem === -1) {
+    payload["messages"] = [{ role: "system", content: prompt }, ...messages];
+    return true;
+  }
+  const message = messages[firstSystem] as Record<string, unknown>;
+  if (carriesOpenCodePrompt(message["content"])) return false;
+  const existing = textFragments(message["content"]).join("\n");
+  message["content"] = existing === "" ? prompt : `${existing}\n\n${prompt}`;
+  return true;
+}
+
+/** Appends the prompt to the top-level Anthropic `system` value. */
+export function injectAnthropicPrompt(payload: Record<string, unknown>, prompt: string): boolean {
+  const system = payload["system"];
+  if (system !== undefined && carriesOpenCodePrompt(system)) return false;
+  if (system === undefined) {
+    payload["system"] = prompt;
+    return true;
+  }
+  if (typeof system === "string") {
+    payload["system"] = system.trim() === "" ? prompt : system + "\n\n" + prompt;
+  } else if (Array.isArray(system)) {
+    payload["system"] = [...system, { type: "text", text: prompt }];
+  } else {
+    payload["system"] = prompt;
+  }
+  return true;
+}
+
+/** Appends the prompt to the Responses `instructions` value. */
+export function injectResponsesPrompt(payload: Record<string, unknown>, prompt: string): boolean {
+  const instructions = payload["instructions"];
+  if (instructions !== undefined && carriesOpenCodePrompt(instructions)) return false;
+  if (typeof instructions === "string") {
+    payload["instructions"] = instructions.trim() === "" ? prompt : instructions + "\n\n" + prompt;
+  } else {
+    payload["instructions"] = prompt;
+  }
+  return true;
+}
+
+/**
+ * Injects the prompt into a free-tier payload for the given wire family.
+ * System One payloads are never touched. Reports whether changed.
+ */
+export function injectOpenCodePrompt(
+  payload: Record<string, unknown>,
+  wireFamily: "chat" | "responses" | "messages" | "systemone",
+): boolean {
+  if (wireFamily === "systemone") return false;
+  const prompt = opencodeSystemPrompt();
+  if (wireFamily === "chat") return injectChatPrompt(payload, prompt);
+  if (wireFamily === "messages") return injectAnthropicPrompt(payload, prompt);
+  return injectResponsesPrompt(payload, prompt);
+}

package/src/providers/integrations/opencode/provider.ts

@@ -9,6 +9,7 @@ import type { ApiKeyProviderSpec } from "../../configured-provider";
 import { resolveOpenCodeUnavailableFree } from "../../../config/providers";
 import { buildOpenCodeHeaders } from "./fingerprint";
 import { OPENCODE_TOOL_DEFINITIONS } from "./tool-definitions";
+import { injectOpenCodePrompt } from "./prompt";
 /**
  * OpenCode's three API-key tiers, all served from `opencode.ai`:
  *
@@ -19,8 +20,10 @@ import { OPENCODE_TOOL_DEFINITIONS } from "./tool-definitions";
  * - `opencode-go` (OpenCode Go): billed API-key route on the separate
  *   `/zen/go/v1` base — a bundled, higher-tier model set.
  *
- * Free and Zen dispatch on `/inference/v1`, NOT `/zen/v1`. The catalog is the
- * other way round: `/zen/v1/models` publishes the listing while
+ * Free and Zen dispatch on the `/inference` origin using the 2.1 family
+ * segment: `/inference/openai/v1/...` for chat/responses and
+ * `/inference/anthropic/v1/messages?beta=true` for Anthropic. The catalog is
+ * the other way round: `/zen/v1/models` publishes the listing while
  * `/inference/v1/models` answers 404. A replay that hit `/inference/v1` directly
  * returned 200 while the gateway kept failing, because every model row carried
  * an explicit `/zen/v1` endpoint — which outranks the per-provider wire-family
@@ -30,8 +33,28 @@ import { OPENCODE_TOOL_DEFINITIONS } from "./tool-definitions";
  * (`x-opencode-*` correlation IDs, `user-agent: opencode`). Go is
  * intentionally API-key-only.
  */
-/** Dispatch base for the Free and Zen tiers. */
-const ZEN_PATH_PREFIX = "/inference/v1";
+/**
+ * The v2 upstream path for a wire family on the `/inference` origin, matching
+ * the reference implementation's `v2EndpointPath`: the 2.1 client
+ * groups `/inference` routes by provider family, so chat/responses sit under
+ * `/openai/v1/...` and Anthropic under `/anthropic/v1/messages?beta=true`.
+ * Go keeps the flat `/zen/go/v1/...` shape.
+ */
+function zenEndpoint(wireFamily: string): string {
+  if (wireFamily === "messages") return "/inference/anthropic/v1/messages?beta=true";
+  const protocol = wireFamily === "responses" ? "responses" : "chat/completions";
+  return `/inference/openai/v1/${protocol}`;
+}
+
+/**
+ * The System One decision endpoint on the `/inference` origin. Verified live:
+ * System One does NOT take the v2 family segment — `/inference/openai/v1/systemone`
+ * answers 404 while the flat `/inference/v1/systemone` answers 200 with a valid
+ * `{state, questions}` body.
+ */
+function zenSystemoneEndpoint(): string {
+  return "/inference/v1/systemone";
+}
 const GO_PATH_PREFIX = "/zen/go/v1";
 
 /**
@@ -121,7 +144,10 @@ export function isFreeTierZenModel(modelId: string): boolean {
   // id rather than the prefixed one.
   const bare = modelId.slice(modelId.indexOf("/") + 1);
   if (unavailableFreeZenIds().includes(bare)) return false;
-  return bare.endsWith("-free") || KNOWN_FREE_ZEN_IDS.includes(bare);
+  // The reference gateway's name rule admits any id containing "free" (any
+  // case) in addition to the suffix convention; the explicit lists keep the
+  // measured exclusions and the one free id that carries no marker.
+  return bare.endsWith("-free") || KNOWN_FREE_ZEN_IDS.includes(bare) || bare.toLowerCase().includes("free");
 }
 
 /**
@@ -156,6 +182,7 @@ function opencodeDesktopHeaders(
       undefined,
       context.conversation_affinity,
       context.request_headers?.["x-opencode-project"],
+      context.request_headers?.["x-opencode-session-id"],
     ),
     // The gate reads the anonymous sentinel: a free dispatch with no
     // Authorization is refused regardless of headers, tools, or session shape.
@@ -327,6 +354,34 @@ function clampOpenCodeTools(payload: Record<string, unknown>, request: Canonical
   if (kept.length > OPENCODE_MAX_TOOLS) return;
   payload["tools"] = [...kept, ...rest.slice(0, OPENCODE_MAX_TOOLS - kept.length)];
 }
+/**
+ * The completion ceiling a 2.x client puts on every v2 chat body, matching the
+ * reference gateway's `v2CompletionLimit`. The upstream's free gate expects the
+ * same ceiling; an explicit `max_tokens`/`max_completion_tokens` from the
+ * caller always wins.
+ */
+const OPENCODE_V2_COMPLETION_LIMIT = 32_000;
+
+/** The key order a 2.x client's JSON.stringify emits for a chat body. */
+const V2_CHAT_KEY_ORDER = ["model", "messages", "tools", "stream", "stream_options", "max_completion_tokens"] as const;
+
+/**
+ * Reorders a chat payload's keys to the 2.x client's byte layout: the skeleton
+ * keys first in the client's order, then every remaining key sorted. Values are
+ * untouched; JSON.stringify preserves this insertion order, so the serialized
+ * body matches the reference gateway's `marshalV2ChatBody`.
+ */
+function reorderV2ChatKeys(payload: Record<string, unknown>): void {
+  const keys = [
+    ...V2_CHAT_KEY_ORDER.filter((key) => key in payload),
+    ...Object.keys(payload).filter((key) => !(V2_CHAT_KEY_ORDER as readonly string[]).includes(key)).sort(),
+  ];
+  const next: Record<string, unknown> = {};
+  for (const key of keys) next[key] = payload[key];
+  for (const key of Object.keys(payload)) delete payload[key];
+  Object.assign(payload, next);
+}
+
 function opencodeSpec(providerId: "opencode" | "opencode-zen" | "opencode-go"): ApiKeyProviderSpec {
   // Free-tier gate facts (verified live 2026-10-14 against opencode.ai/zen/v1):
   // a request for a free model with stream:false is ALWAYS refused with 403
@@ -352,19 +407,42 @@ function opencodeSpec(providerId: "opencode" | "opencode-zen" | "opencode-go"):
       if (candidate.wire_family === "responses") {
         payload.store = false;
       }
-      if (candidate.wire_family === "chat" && request.stream) {
-        payload.stream_options = {
-          ...(typeof payload.stream_options === "object" && payload.stream_options !== null
-            ? (payload.stream_options as Record<string, unknown>)
-            : {}),
-          include_usage: true,
-        };
-      }
-      // Free model: force the upstream stream flag regardless of what the
-      // caller asked for. The gate refuses stream:false on free models with
-      // 403 FreeTierError; here it only patches the wire body, never the
+      // Free model: match the reference gateway's free-tier shaping 1:1 —
+      // the official CLI system prompt, the v2 completion ceiling, the
+      // include_usage flag, and the forced upstream stream. The gate refuses
+      // tool-less, non-streaming, or non-agent-shaped free dispatches with 403
+      // FreeTierError; here it only patches the wire body, never the
       // client-visible stream contract.
-      if (isFreeTierZenModel(candidate.model_id)) payload.stream = true;
+      if (isFreeTierZenModel(candidate.model_id)) {
+        if (candidate.wire_family === "chat") {
+          // The wire encoder injects the v2 ceiling (32000) as the default
+          // max_completion_tokens when the caller set no limit. Treat that
+          // sentinel as "unset" so the model's own declared output ceiling can
+          // take its place; an explicit user limit is never touched.
+          const isV2Default =
+            payload["max_completion_tokens"] === OPENCODE_V2_COMPLETION_LIMIT &&
+            payload["max_tokens"] === undefined;
+          if (isV2Default || (payload["max_completion_tokens"] === undefined && payload["max_tokens"] === undefined)) {
+            const ceiling =
+              typeof candidate.output_limit === "number" && candidate.output_limit > 0
+                ? candidate.output_limit
+                : OPENCODE_V2_COMPLETION_LIMIT;
+            payload["max_completion_tokens"] = ceiling;
+          }
+          payload.stream_options = {
+            ...(typeof payload.stream_options === "object" && payload.stream_options !== null
+              ? (payload.stream_options as Record<string, unknown>)
+              : {}),
+            include_usage: true,
+          };
+        }
+        const family = candidate.wire_family;
+        if (family === "chat" || family === "responses" || family === "messages") {
+          injectOpenCodePrompt(payload, family);
+        }
+        payload.stream = true;
+        if (candidate.wire_family === "chat") reorderV2ChatKeys(payload);
+      }
     },
     // OpenCode Free is a genuinely public, unauthenticated endpoint: no
     // credential is ever forwarded, whatever the account configuration says.
@@ -424,7 +502,7 @@ export async function discoverOpenCodeFreeModels(options: {
         ...systemoneLimits(),
         freeTier: true,
         serviceKind: "systemone" as const,
-        endpointPath: `${ZEN_PATH_PREFIX}/systemone`,
+        endpointPath: zenSystemoneEndpoint(),
       };
     });
 }
@@ -436,12 +514,12 @@ export async function discoverOpenCodeFreeModels(options: {
 // OpenCode row understates this model's 1M context limit, so keep the corrected
 // limit explicit for both tiers that serve it.
 const sharedZenChat: readonly ModelDefinition[] = [
-  defineModel({ id: "big-pickle", providerId: "opencode", wireFamily: "chat", endpoint: `${ZEN_PATH_PREFIX}/chat/completions`, vision: true, reasoning: true }),
+  defineModel({ id: "big-pickle", providerId: "opencode", wireFamily: "chat", endpoint: zenEndpoint("chat"), vision: true, reasoning: true }),
   defineModel({
     id: "mimo-v2.6-flash-free",
     providerId: "opencode",
     wireFamily: "chat",
-    endpoint: `${ZEN_PATH_PREFIX}/chat/completions`,
+    endpoint: zenEndpoint("chat"),
     ctx: 1_000_000,
     out: 32_000,
     vision: true,
@@ -478,7 +556,7 @@ const systemoneZen = (id: string, free: boolean): ModelDefinition =>
     providerId: "opencode",
     serviceKind: "systemone",
     wireFamily: "chat",
-    endpoint: `${ZEN_PATH_PREFIX}/systemone`,
+    endpoint: zenSystemoneEndpoint(),
     ctx: SYSTEMONE_LIMITS.context,
     out: SYSTEMONE_LIMITS.output,
     toolCall: false,
@@ -507,8 +585,8 @@ export const OPENCODE_FREE_MODELS: readonly ModelDefinition[] = [
 
 export const OPENCODE_ZEN_MODELS: readonly ModelDefinition[] = [
   ...sharedZenChat,
-  defineModel({ id: "muse-spark-1.2", providerId: "opencode", wireFamily: "responses", endpoint: `${ZEN_PATH_PREFIX}/responses`, vision: true, reasoning: true, reasoningEfforts: MUSE_SPARK_REASONING_EFFORTS }),
-  defineModel({ id: "muse-spark-1.3", providerId: "opencode", wireFamily: "responses", endpoint: `${ZEN_PATH_PREFIX}/responses`, vision: true, reasoning: true, reasoningEfforts: MUSE_SPARK_REASONING_EFFORTS }),
+  defineModel({ id: "muse-spark-1.2", providerId: "opencode", wireFamily: "responses", endpoint: zenEndpoint("responses"), vision: true, reasoning: true, reasoningEfforts: MUSE_SPARK_REASONING_EFFORTS }),
+  defineModel({ id: "muse-spark-1.3", providerId: "opencode", wireFamily: "responses", endpoint: zenEndpoint("responses"), vision: true, reasoning: true, reasoningEfforts: MUSE_SPARK_REASONING_EFFORTS }),
   systemoneZen("jev-1.13", false),
 ];
 

package/src/providers/integrations/opencode/tool-definitions.ts

@@ -6,10 +6,10 @@
  * even one carrying the right name — is refused with `403 FreeTierError`.
  * That is why these are verbatim rather than minimal.
  *
- * Source: the client's own tool registry as embedded by the `opencode2api`
- * gateway (`internal/gateway/opencode_tools.json`), captured from a real
- * dispatch. `patch` is absent from that capture; its description and single
- * `patchText` parameter come from the 2.0.32 CLI binary's own registration.
+ * Source: the client's own tool registry as embedded by the reference
+ * gateway's tool asset, captured from a real dispatch. `patch` is absent from
+ * that capture; its description and single `patchText` parameter come from the
+ * 2.0.32 CLI binary's own registration.
  *
  * Thirteen entries, matching the CLI's internal tool-name set.
  */