@bitkyc08/opencodex 2.76.0 → 2.78.0-preview.20261005

package/src/clients/config-export/contracts.ts

@@ -1,7 +1,10 @@
 // Shared client export contracts.
+import { canonicalizeReasoningEfforts } from "../../reasoning-effort";
 import type { OcxConfig } from "../../types";
 import type { ConfigFormat } from "../../integrations/serialize";
 
+export const DROID_DEFAULT_EFFORT_HEADER = "x-opencodex-droid-default-effort";
+
 /**
  * One entry opencodex owns inside a client's config: the JSON path to it and
  * the value we put there.
@@ -38,6 +41,12 @@ export interface OpencodeCatalogModel {
   id?: string;
   contextWindow?: number;
   maxTokens?: number;
+  /**
+   * Authoritative input ceiling, distinct from `contextWindow` (GPT-5.6 advertises 922k
+   * usable input under a 1.05M window). Carried from the catalog row so a client that has a
+   * separate input limit never treats the whole window as prompt budget.
+   */
+  maxInputTokens?: number;
   displayName?: string;
   /**
    * Declared input modalities, carried verbatim from `/api/models`. Serialized as opencode's
@@ -54,6 +63,9 @@ export interface OpencodeCatalogModel {
    * model-level setting — see {@link opencodeEffortVariants} for why.
    */
   defaultReasoningEffort?: string;
+  supportsTools?: boolean;
+  supportsReasoning?: boolean;
+  supportsReasoningSummaries?: boolean;
 }
 
 /**
@@ -73,10 +85,94 @@ export interface ExportModel {
   displayName?: string;
   contextWindow?: number;
   maxTokens?: number;
+  /** Authoritative input ceiling; optional and never guessed from the context window. */
+  maxInputTokens?: number;
   inputModalities?: string[];
   /** Optional effort ladder exported only to clients that support it. */
   reasoningEfforts?: string[];
   defaultReasoningEffort?: string;
+  supportsTools?: boolean;
+  supportsReasoning?: boolean;
+  supportsReasoningSummaries?: boolean;
+}
+
+/**
+ * Effective, override-applied export metadata for one model row: what a client export should
+ * serialize, as distinct from the raw editor representation `/api/models` also carries.
+ *
+ * Custom rows are the reason this exists. Their row fields are the operator's stored
+ * OVERRIDES (an absent field means "not overridden", an empty ladder means "no rungs"), so a
+ * serializer reading only them drops every capability the model inherits from the provider,
+ * the registry, or the gathered catalog. The management row list resolves that projection
+ * from the same canonical sources routed rows use and attaches it additively — the raw
+ * override fields stay exactly what the editor wrote.
+ */
+export interface EffectiveModelExportMetadata {
+  contextWindow?: number;
+  /** Input ceiling; distinct from `contextWindow`, carried only when a source asserts one. */
+  maxInputTokens?: number;
+  /** Output ceiling (a catalog row's `maxOutputTokens`). */
+  maxTokens?: number;
+  inputModalities?: string[];
+  /** Effective ladder; `[]` is an explicit "no rungs" declaration and survives as `[]`. */
+  reasoningEfforts?: string[];
+  /**
+   * A default some canonical source declared — never one synthesized from the ladder's
+   * preference order, and only when it is a member of the effective ladder. An empty
+   * ladder suppresses it entirely: there is no rung to default to.
+   */
+  defaultReasoningEffort?: string;
+  supportsTools?: boolean;
+  supportsReasoning?: boolean;
+  supportsReasoningSummaries?: boolean;
+}
+
+/**
+ * The per-row evidence the capability booleans are derived from. Only positive, canonical
+ * signals — no independent provider fact tables, no name-based inference.
+ */
+export interface ExportCapabilityEvidence {
+  native?: boolean;
+  reasoningEfforts?: readonly string[];
+  supportsReasoningSummaries?: boolean;
+  /** Normalized upstream capability names a catalog row carried (e.g. `"tools"`). */
+  capabilities?: readonly string[];
+  /** Provider-level parallel tool call opt-in for this model. */
+  parallelToolCalls?: boolean;
+}
+
+/**
+ * Tool support a canonical source positively asserts, or undefined when nothing is known.
+ *
+ * Mirrors the routing reader (`src/routing/capability.ts`): a catalog row without `"tools"`
+ * is UNKNOWN, never a negative — the row may simply not enumerate capabilities. `native`
+ * rows and the parallel-call opt-in are positive evidence on their own.
+ */
+export function knownToolsSupport(evidence: ExportCapabilityEvidence): boolean | undefined {
+  if (evidence.native === true) return true;
+  if (evidence.capabilities?.includes("tools") === true) return true;
+  if (evidence.parallelToolCalls === true) return true;
+  return undefined;
+}
+
+/**
+ * Reasoning support a canonical source positively asserts, or undefined when nothing is
+ * known.
+ *
+ * Never `false` from a missing or empty effort ladder: an empty ladder says "no ADJUSTABLE
+ * effort", which is not the claim "cannot reason" — a model can reason at a fixed depth with
+ * no rung to select. Known evidence is a positive reasoning rung (the catalog's own statement
+ * that the model accepts reasoning parameters) or delivered reasoning summaries. `none` is
+ * the off sentinel, not a rung: a ladder of only `none` offers an off variant and asserts
+ * nothing about whether the model reasons, so it is not positive evidence on its own.
+ */
+export function knownReasoningSupport(evidence: ExportCapabilityEvidence): boolean | undefined {
+  if (evidence.supportsReasoningSummaries === true) return true;
+  if (evidence.reasoningEfforts !== undefined
+    && canonicalizeReasoningEfforts(evidence.reasoningEfforts).some(effort => effort !== "none")) {
+    return true;
+  }
+  return undefined;
 }
 
 export interface ExportContext {
@@ -88,8 +184,12 @@ export interface ExportContext {
    * admission from `apiKey` to the `x-opencodex-api-key` header.
    */
   config?: OcxConfig;
+  droidReasoningDefaults?: DroidReasoningDefaults;
 }
 
+/** Namespaced model selector to one of that model's declared reasoning efforts. */
+export type DroidReasoningDefaults = Record<string, string>;
+
 export type ExportClientId =
   | "opencode"
   | "pi"

package/src/clients/config-export/droid.ts

@@ -1,9 +1,11 @@
 import { win32, join } from "node:path";
 import { homedir } from "node:os";
 import { exportPresentationLabel } from "../model-presentation";
-import type { ExportContext, ManagedContribution, OpencodeLaunchEnv } from "./contracts";
+import type { DroidReasoningDefaults, ExportContext, ExportModel, ManagedContribution, OpencodeLaunchEnv } from "./contracts";
 import { normalizeExportModels } from "./model-metadata";
-import { formatSelectorConjunction } from "../../integrations/merge";
+import { formatSelectorConjunction, readPath } from "../../integrations/merge";
+
+import { DROID_DEFAULT_EFFORT_HEADER } from "./contracts";
 
 /** Factory personal settings: https://docs.factory.ai/model-independence/byok */
 export interface DroidModelEntry {
@@ -12,6 +14,7 @@ export interface DroidModelEntry {
   baseUrl: string;
   provider: "generic-chat-completion-api";
   noImageSupport: boolean;
+  extraHeaders?: Record<string, string>;
 }
 
 export interface DroidGeneratedConfig { customModels: DroidModelEntry[] }
@@ -43,11 +46,60 @@ function buildDroidRows(ctx: ExportContext): Array<{ row: DroidModelEntry; selec
       baseUrl: ctx.baseUrl,
       provider: "generic-chat-completion-api",
       noImageSupport: !model.inputModalities?.includes("image"),
+      ...(ctx.droidReasoningDefaults && Object.hasOwn(ctx.droidReasoningDefaults, model.namespaced)
+        ? { extraHeaders: { [DROID_DEFAULT_EFFORT_HEADER]: ctx.droidReasoningDefaults[model.namespaced]! } }
+        : {}),
     } });
   }
   return rows;
 }
 
+export function droidReasoningModels(models: readonly ExportModel[]): Array<{ model: string; label: string; efforts: string[] }> {
+  const effortsByModel = new Map(normalizeExportModels(models).map(model => [model.namespaced, model.reasoningEfforts ?? []]));
+  return buildDroidRows({ baseUrl: "", models }).map(({ row }) => ({
+    model: row.model,
+    label: row.displayName.replace(/^OpenCodex: /, ""),
+    efforts: effortsByModel.get(row.model) ?? [],
+  }));
+}
+
+export function droidDefaultsFromOwnedRows(
+  ctx: ExportContext,
+  document: unknown,
+  fragmentPaths: readonly (readonly string[])[],
+): DroidReasoningDefaults {
+  const exportableModels = new Map(droidReasoningModels(ctx.models).map(model => [model.model, model.efforts]));
+  const defaults: DroidReasoningDefaults = {};
+  for (const path of fragmentPaths) {
+    if (path.length !== 2 || path[0] !== "customModels") continue;
+    const value = readPath(document, path);
+    if (!value || typeof value !== "object" || Array.isArray(value)) continue;
+    const current = value as Record<string, unknown>;
+    if (typeof current.model !== "string" || !exportableModels.has(current.model)) continue;
+    const headers = current.extraHeaders;
+    if (!headers || typeof headers !== "object" || Array.isArray(headers)) continue;
+    const header = headers as Record<string, unknown>;
+    const effort = header[DROID_DEFAULT_EFFORT_HEADER];
+    if (typeof effort !== "string" || !exportableModels.get(current.model)?.includes(effort)) continue;
+    defaults[current.model] = effort;
+  }
+  return defaults;
+}
+
+export function validateDroidReasoningDefaults(
+  models: readonly ExportModel[],
+  defaults: unknown,
+): string | null {
+  if (!defaults || typeof defaults !== "object" || Array.isArray(defaults)) return "droidReasoningDefaults must be an object";
+  const addressable = new Map(droidReasoningModels(models).map(model => [model.model, model.efforts]));
+  for (const [model, effort] of Object.entries(defaults)) {
+    const efforts = addressable.get(model);
+    if (!efforts) return `model ${model} is not currently exportable to Droid`;
+    if (typeof effort !== "string" || !efforts.includes(effort)) return `effort for ${model} is not declared by that model`;
+  }
+  return null;
+}
+
 export function buildDroidClientConfig(ctx: ExportContext): DroidGeneratedConfig {
   const rows = buildDroidRows(ctx);
   if (ctx.models.length > 0 && rows.length === 0) {

package/src/clients/config-export/dsh.ts

@@ -130,3 +130,24 @@ export function buildDshContribution(ctx: ExportContext): ManagedContribution {
   const doc = buildDshClientConfig(ctx);
   return singleFragment("dsh", ["llm-pi-ai", "providers", OPENCODE_PROVIDER_ID], doc["llm-pi-ai"].providers[OPENCODE_PROVIDER_ID]);
 }
+
+/**
+ * Where DSH 0.1.7+ reads provider routes: the `llm-pi-ai` row of a profile
+ * patch, a top-level YAML list of loader rows. `$DSH_HOME/settings.yaml` is
+ * imported into the first profile that boots and renamed, so a write there
+ * reaches DSH once at most. The Desktop app runs the `desktop` profile and
+ * owns it alone, and DSH hot reloads that file when it changes.
+ */
+export const DSH_DESKTOP_PROFILE = "desktop";
+export const DSH_PROFILE_PROVIDER_PATH = ["[id=llm-pi-ai]", "config", "providers", OPENCODE_PROVIDER_ID] as const;
+
+/** A profile patch DSH itself would load: a list whose every row is a mapping. */
+export function dshProfilePatchEstablished(parsed: unknown): boolean {
+  return Array.isArray(parsed)
+    && parsed.every(row => typeof row === "object" && row !== null && !Array.isArray(row));
+}
+
+export function buildDshProfilePatchContribution(ctx: ExportContext): ManagedContribution {
+  const doc = buildDshClientConfig(ctx);
+  return singleFragment("dsh", DSH_PROFILE_PROVIDER_PATH, doc["llm-pi-ai"].providers[OPENCODE_PROVIDER_ID]);
+}

package/src/clients/config-export/kilo.ts

@@ -14,9 +14,11 @@ import {
   normalizeExportModels,
   opencodeModelCapabilities,
   outputBudgetFor,
+  inputBudgetFor,
   proxyAdmissionHeaders,
   singleFragment,
 } from "./model-metadata";
+import { legacyReasoningMetadata, type LegacyEffortVariant } from "./reasoning-metadata";
 
 export const KILO_CONFIG_CANDIDATES = [
   "kilo.jsonc",
@@ -28,9 +30,14 @@ export const KILO_CONFIG_CANDIDATES = [
 
 export interface KiloModelEntry {
   name: string;
-  limit?: { context: number; output: number };
+  limit?: { context: number; input?: number; output: number };
   attachment?: boolean;
   modalities?: { input: string[]; output: string[] };
+  tool_call?: boolean;
+  reasoning?: boolean;
+  interleaved?: { field: "reasoning_content" };
+  options?: { reasoningEffort: string };
+  variants?: Record<string, LegacyEffortVariant>;
 }
 
 export interface KiloProviderBlock {
@@ -77,11 +84,14 @@ function kiloProviderBlock(ctx: ExportContext): KiloProviderBlock {
   const config = ctx.config ?? OPENCODE_PROVIDER_BLOCK_DEFAULT_CONFIG;
   const models: Record<string, KiloModelEntry> = {};
   for (const model of normalizeExportModels(ctx.models)) {
-    const entry: KiloModelEntry = { name: exportModelLabel(model) };
+    const entry: KiloModelEntry = { name: exportModelLabel(model), ...legacyReasoningMetadata(model) };
     const context = authoritativeContextWindow(model.contextWindow);
     if (context !== undefined) {
       entry.limit = { context, output: outputBudgetFor(context, model) };
+      const input = inputBudgetFor(context, model);
+      if (input !== undefined) entry.limit.input = input;
     }
+    if (typeof model.supportsTools === "boolean") entry.tool_call = model.supportsTools;
     const capabilities = opencodeModelCapabilities(model.inputModalities);
     if (capabilities) {
       entry.attachment = capabilities.attachment;

package/src/clients/config-export/model-metadata.ts

@@ -29,6 +29,12 @@ export function outputBudgetFor(context: number, model: OpencodeCatalogModel): n
   return Math.min(limit, context);
 }
 
+/** Input limits are optional: unlike output, a missing limit needs no schema fallback. */
+export function inputBudgetFor(context: number, model: OpencodeCatalogModel): number | undefined {
+  const limit = authoritativeContextWindow(model.maxInputTokens);
+  return limit === undefined ? undefined : Math.min(limit, context);
+}
+
 /**
  * Modalities a given client's schema will actually accept.
  *
@@ -89,12 +95,12 @@ export function inputModalitiesForClient(
 const OPENCODE_INPUT_MODALITIES: ReadonlySet<string> = new Set(["text", "audio", "image", "video", "pdf"]);
 
 /**
- * opencode's per-model capability fields for one catalog row, or `undefined` when the row
+ * Legacy per-model modality fields for one catalog row, or `undefined` when the row
  * declares nothing.
  *
- * `undefined` rather than `{ input: ["text"] }`: opencode already computes an entry without
- * capabilities as text-only, and leaving the keys out keeps every model that declares
- * nothing byte-identical to what shipped before. A declared list is carried across as-is, so
+ * `undefined` rather than guessing `{ input: ["text"] }`: unknown capabilities leave the
+ * client's fallback assumptions in place. V2 translates these lists into native capability
+ * fields; legacy clients also receive the attachment flag. A declared list is carried across as-is, so
  * an audio-only row keeps `attachment: true` instead of being rewritten to text it cannot
  * read — the same call Pi's exporter makes, in the opposite direction.
  */

package/src/clients/config-export/reasoning-metadata.ts

@@ -0,0 +1,47 @@
+import { canonicalizeReasoningEfforts, isDeclaredReasoningEffort } from "../../reasoning-effort";
+import { knownReasoningSupport, type OpencodeCatalogModel } from "./contracts";
+
+/** Unknown and explicitly empty ladders have different client-side meanings. */
+export function exportReasoningEfforts(model: OpencodeCatalogModel): string[] | undefined {
+  return model.reasoningEfforts === undefined ? undefined : canonicalizeReasoningEfforts(model.reasoningEfforts);
+}
+
+/** Carry an authoritative default, never invent one or revive a cleared ladder. */
+export function exportDefaultReasoningEffort(model: OpencodeCatalogModel): string | undefined {
+  const effort = model.defaultReasoningEffort;
+  if (typeof effort !== "string" || !isDeclaredReasoningEffort(effort)) return undefined;
+  const efforts = exportReasoningEfforts(model);
+  return efforts === undefined || efforts.includes(effort) ? effort : undefined;
+}
+
+export type LegacyEffortVariant = { reasoningEffort: string } | { disabled: true };
+
+/** Shared V1-family controls. A disabled-only map suppresses client-invented effort ladders. */
+export function legacyReasoningMetadata(model: OpencodeCatalogModel): {
+  reasoning?: boolean;
+  options?: { reasoningEffort: string };
+  interleaved?: { field: "reasoning_content" };
+  variants?: Record<string, LegacyEffortVariant>;
+} {
+  const efforts = exportReasoningEfforts(model);
+  const reasoning = model.supportsReasoning ?? knownReasoningSupport({
+    ...model, reasoningEfforts: efforts,
+  });
+  const defaultEffort = exportDefaultReasoningEffort(model);
+  // Both legacy runtimes merge generated variants with config, then filter disabled IDs.
+  // An unrelated sentinel leaves their generated choices alive. Disable the actual IDs
+  // instead (live-tested on Kilo 7.8.3, checked against stock OpenCode V1's merge).
+  const suppressed: Record<string, LegacyEffortVariant> = Object.fromEntries(
+    ["none", "minimal", "low", "medium", "high", "xhigh", "max"].map(id => [id, { disabled: true }]),
+  );
+  const variants = efforts?.length
+    ? Object.fromEntries(efforts.map(effort => [effort, { reasoningEffort: effort }]))
+    : reasoning === true ? suppressed : undefined;
+  return {
+    ...(typeof reasoning === "boolean" ? { reasoning } : {}),
+    ...(defaultEffort !== undefined ? { options: { reasoningEffort: defaultEffort } } : {}),
+    ...(reasoning === true || model.supportsReasoningSummaries === true
+      ? { interleaved: { field: "reasoning_content" } } : {}),
+    ...(variants !== undefined ? { variants } : {}),
+  };
+}

package/src/clients/config-export.ts

@@ -30,7 +30,7 @@ import { probeHostname } from "../server/proxy-liveness";
 import type { OcxConfig } from "../types";
 
 export type { ConfigFormat } from "../integrations/serialize";
-export type { ManagedFragment, ManagedContribution, BuildContribution, OpencodeLaunchEnv, OpencodeCatalogModel, ExportModel, ExportContext, ExportClientId, ExportClientSpec, PiModelEntry } from "./config-export/contracts";
+export type { ManagedFragment, ManagedContribution, BuildContribution, OpencodeLaunchEnv, OpencodeCatalogModel, ExportModel, ExportContext, ExportClientId, ExportClientSpec, PiModelEntry, DroidReasoningDefaults } from "./config-export/contracts";
 export { OPENCODE_PROVIDER_ID, OPENCODE_CONFIG_SCHEMA, OPENCODE_API_KEY_ENV, OPENCODE_API_KEY_ENV_REF, KILO_API_KEY_ENV, KILO_API_KEY_ENV_REF, KILO_CONFIG_SCHEMA, HERMES_API_KEY_ENV, HERMES_API_KEY_ENV_REF, OPENCLAW_API_KEY_ENV, OPENCLAW_API_KEY_ENV_REF, LOOPBACK_API_KEY_PLACEHOLDER, GAJAE_API_KEY_ENV, SCHEMA_REQUIRED_OUTPUT_BUDGET, OPENCODE_PROVIDER_BLOCK_DEFAULT_CONFIG } from "./config-export/constants";
 export { normalizeExportModels } from "./config-export/model-metadata";
 export type { OmpModelEntry, OmpProviderBlock, OmpGeneratedConfig } from "./config-export/omp";
@@ -48,17 +48,19 @@ export {
   zcodeStoreSchemaEstablished,
 } from "./config-export/zcode-store";
 export type { DshReasoningEffort, DshWireReasoningEffort, DshModelEntry, DshProviderBlock, DshGeneratedConfig } from "./config-export/dsh";
+export { DSH_PROFILE_PROVIDER_PATH, dshProfilePatchEstablished, buildDshProfilePatchContribution } from "./config-export/dsh";
 export type { McodeProviderBlock, McodeModelEntry, McodeGeneratedConfig } from "./config-export/mcode";
 export type { RaycastAbility, RaycastAbilityName, RaycastModelEntry, RaycastProviderEntry, RaycastGeneratedConfig } from "./config-export/raycast";
 export { buildRaycastClientConfig, summarizeRaycast, buildRaycastContribution } from "./config-export/raycast";
-export { droidHomeDir, droidConfigPath, buildDroidClientConfig, summarizeDroid, buildDroidContribution } from "./config-export/droid";
+export { droidHomeDir, droidConfigPath, buildDroidClientConfig, summarizeDroid, buildDroidContribution, droidReasoningModels, droidDefaultsFromOwnedRows, validateDroidReasoningDefaults } from "./config-export/droid";
 export type { DroidModelEntry, DroidGeneratedConfig } from "./config-export/droid";
 
 import type { OpencodeLaunchEnv, OpencodeCatalogModel, ExportContext, PiModelEntry, ManagedContribution, ManagedFragment, ExportClientId, ExportClientSpec } from "./config-export/contracts";
 import { OPENCODE_API_KEY_ENV_REF, OPENCODE_PROVIDER_BLOCK_DEFAULT_CONFIG, OPENCODE_CONFIG_SCHEMA, OPENCODE_PROVIDER_ID, PI_API_DIALECT, LOOPBACK_API_KEY_PLACEHOLDER, HERMES_API_KEY_ENV_REF, OPENCLAW_API_KEY_ENV_REF, OPENCODE_API_KEY_ENV, HERMES_API_KEY_ENV, OPENCLAW_API_KEY_ENV, KILO_API_KEY_ENV } from "./config-export/constants";
-import { exportModelLabel, authoritativeContextWindow, outputBudgetFor, normalizeExportModels, inputModalitiesForClient, opencodeModelCapabilities, proxyAdmissionHeaders, singleFragment } from "./config-export/model-metadata";
+import { exportModelLabel, authoritativeContextWindow, outputBudgetFor, inputBudgetFor, normalizeExportModels, inputModalitiesForClient, opencodeModelCapabilities, proxyAdmissionHeaders, singleFragment } from "./config-export/model-metadata";
+import { exportReasoningEfforts, exportDefaultReasoningEffort, legacyReasoningMetadata, type LegacyEffortVariant } from "./config-export/reasoning-metadata";
 import { buildOmpClientConfig, summarizeOmp, buildOmpContribution } from "./config-export/omp";
-import { buildDshClientConfig, summarizeDsh, buildDshContribution } from "./config-export/dsh";
+import { buildDshClientConfig, summarizeDsh, buildDshContribution, DSH_DESKTOP_PROFILE } from "./config-export/dsh";
 import { buildMcodeClientConfig, summarizeMcode, buildMcodeContribution } from "./config-export/mcode";
 import { buildZcodeClientConfig, summarizeZcode, buildZcodeContribution } from "./config-export/zcode";
 import { buildClineClientConfig, summarizeCline, buildClineContribution } from "./config-export/cline";
@@ -72,7 +74,7 @@ import { droidConfigPath, buildDroidClientConfig, summarizeDroid, buildDroidCont
 
 export interface OpencodeModelEntry {
   name: string;
-  limit?: { context: number; output: number };
+  limit?: { context: number; input?: number; output: number };
   /**
    * opencode's own capability fields, derived from the catalog row's declared input
    * modalities. Written only when the row declares at least one — an entry without them is
@@ -81,22 +83,30 @@ export interface OpencodeModelEntry {
    */
   attachment?: boolean;
   modalities?: { input: string[]; output: string[] };
+  tool_call?: boolean;
+  reasoning?: boolean;
+  interleaved?: { field: "reasoning_content" };
+  options?: { reasoningEffort: string };
+  variants?: Record<string, LegacyEffortVariant>;
 }
 
 /**
  * One selectable reasoning effort.
  *
- * opencode V2 applies these only from the `providers` block: a `variants` array under the
- * legacy `provider` block is parsed and then dropped, so the V1 block stays variant-free
- * rather than carrying fields that look configured but never reach a request.
+ * Native V2 variants use settings; legacy clients receive a separate options map.
  */
 export interface OpencodeModelVariant {
   id: string;
   settings: { reasoningEffort: string };
 }
 
-export interface OpencodeV2ModelEntry extends OpencodeModelEntry {
-  variants?: OpencodeModelVariant[];
+export interface OpencodeV2ModelEntry {
+  name: string;
+  limit?: { context: number; input?: number; output: number };
+  capabilities?: { tools: boolean; input?: string[]; output?: string[] };
+  compatibility?: { reasoningField: "reasoning_content" };
+  settings?: { reasoningEffort: string };
+  variants: OpencodeModelVariant[];
 }
 
 /** Endpoint and admission, spelled once and shared by both block generations. */
@@ -114,7 +124,7 @@ export interface OpencodeProviderBlock {
   models: Record<string, OpencodeModelEntry>;
 }
 
-/** opencode V2 provider block: `package` + `settings`. The only form whose variants apply. */
+/** opencode V2 provider block: `package` + `settings` and native variant arrays. */
 export interface OpencodeV2ProviderBlock {
   package: string;
   name: string;
@@ -147,16 +157,10 @@ export interface OpencodeGeneratedConfig {
 const OPENCODE_PROVIDER_NPM = "@ai-sdk/openai-compatible";
 
 /**
- * opencode V2's spelling of the same runtime. V2 resolves providers through its own
- * package table and ignores the V1 `npm` field, so a V2 block has to name this package
- * or the provider is not loaded at all.
- *
- * Verified end-to-end against opencode 0.0.0-beta-18684: `GET /api/model` resolves this
- * package for the provider and applies the per-model `variants`. opencode changes its
- * provider package table between releases, so re-verify the supported range whenever it
- * moves; a stale string breaks only the V2 block, silently.
+ * Canonical V2 runtime spelling. Current clients alias the old @opencode-ai scope,
+ * but exported documents use the documented package rather than depending on that alias.
  */
-const OPENCODE_V2_PROVIDER_PACKAGE = "@opencode-ai/ai/providers/openai-compatible";
+const OPENCODE_V2_PROVIDER_PACKAGE = "@opencode/ai/providers/openai-compatible";
 
 /** Display name for the provider block, identical in both generations. */
 const OPENCODE_PROVIDER_NAME = "OpenCodex";
@@ -432,6 +436,11 @@ export function dshConfigPath(env: OpencodeLaunchEnv = process.env, home: string
   return join(dshHomeDir(env, home), "settings.yaml");
 }
 
+/** The Desktop profile's patch, where DSH 0.1.7+ reads provider routes (see `DSH_PROFILE_PROVIDER_PATH`). */
+export function dshProfilePatchPath(env: OpencodeLaunchEnv = process.env, home: string = homedir()): string {
+  return join(dshHomeDir(env, home), "profiles", DSH_DESKTOP_PROFILE, "cordis.patch.yml");
+}
+
 /**
  * MiniMax Code stores runtime state under `MINIMAX_DATA_DIR`, then the legacy
  * `MAVIS_DATA_DIR`, and finally `~/.minimax`. Relative overrides are refused
@@ -672,35 +681,11 @@ function opencodeProviderConnection(baseURL: string, config: OcxConfig): Opencod
 }
 
 /**
- * Selectable reasoning efforts for one model, in canonical ladder order.
- *
- * No model-level `settings.reasoningEffort` default is emitted: the proxy already applies
- * its own configured default when a request carries no effort, and pinning one here would
- * override a default the user controls in opencodex. Variants are opt-in per selection,
- * which is the same reason we never emit `defaultModel` for MCode.
- *
- * `none` is dropped even when a ladder declares it.
- *
- * The original reason no longer holds and is recorded here so it is not repeated: the chat
- * ingress `OUTPUT_CONFIG_EFFORTS` allowlist DID omit `none`, so selecting it sent no effort
- * at all and fell back to the proxy default. That allowlist now accepts `none` (audit F7),
- * because it is the runtime's disable sentinel and dropping it let a provider default
- * re-enable thinking a caller had turned off.
- *
- * The variant stays filtered anyway, deliberately and narrowly: emitting it would change
- * what this exporter writes into a user's opencode config, and whether opencode's own
- * picker round-trips `reasoningEffort: "none"` to the wire this proxy reads has not been
- * verified here. Re-enabling it is a scoped follow-up that needs that check first, not a
- * side effect of an ingress fix. MCode and ZCode filter `none` for their own separate
- * reasons, documented at their call sites.
+ * Exact declared choices. An empty array is intentional: omitting variants lets OpenCode
+ * synthesize low/medium/high, even for a model whose upstream declares no adjustable effort.
  */
-function opencodeEffortVariants(model: OpencodeCatalogModel): OpencodeModelVariant[] | undefined {
-  if (model.reasoningEfforts === undefined) return undefined;
-  // Canonical order (none, minimal, then low..ultra) and dedupe, so the picker order does
-  // not depend on whatever order a provider listed its efforts in.
-  const efforts = canonicalizeReasoningEfforts(model.reasoningEfforts).filter(effort => effort !== "none");
-  if (efforts.length === 0) return undefined;
-  return efforts.map(effort => ({ id: effort, settings: { reasoningEffort: effort } }));
+function opencodeEffortVariants(model: OpencodeCatalogModel): OpencodeModelVariant[] {
+  return (exportReasoningEfforts(model) ?? []).map(effort => ({ id: effort, settings: { reasoningEffort: effort } }));
 }
 
 /**
@@ -712,7 +697,7 @@ function opencodeEffortVariants(model: OpencodeCatalogModel): OpencodeModelVaria
  * the pair) clamped to the context window.
  *
  * Two blocks instead of one because opencode V2 reads the `providers` map and V1 reads
- * `provider`, and only the V2 form applies `variants`. Emitting both keeps V1 installs
+ * `provider`, with native arrays versus legacy maps for variants. Emitting both keeps V1 installs
  * working: V2 merges them by provider id and model id, so a model listed in both blocks
  * appears once, with the V2 entry's name, connection, and variants.
  */
@@ -725,36 +710,37 @@ export function opencodeProviderBlocks(
   const v2Models: Record<string, OpencodeV2ModelEntry> = {};
   for (const model of expandFastExportModels(catalogModels)) {
     const key = model.namespaced;
-    const entry: OpencodeModelEntry = { name: exportModelLabel(model) };
+    const entry: OpencodeModelEntry = { name: exportModelLabel(model), ...legacyReasoningMetadata(model) };
     const context = authoritativeContextWindow(model.contextWindow);
     if (context !== undefined) {
       entry.limit = { context, output: outputBudgetFor(context, model) };
+      const input = inputBudgetFor(context, model);
+      if (input !== undefined) entry.limit.input = input;
     }
-    // `attachment` / `modalities` are fields of opencode's V1 model schema — the shape its
-    // published config.json defines and the one its loader reads (verified against opencode
-    // 1.18.30, src/provider/provider.ts: `model.attachment ?? …` / `model.modalities?.input`).
-    // They ride on both generations anyway: the two blocks are two spellings of one model list,
-    // and the V2 model schema (capabilities.{tools,input,output}, which opencode fills by
-    // migrating this same `modalities` field) ignores keys it does not define — its loader
-    // decodes with `onExcessProperty: "ignore"`. Same values on both, so a merge cannot make
-    // the two entries disagree.
+    // Native V2 decoders ignore legacy attachment/modalities fields. Emit each generation's
+    // actual capability shape rather than relying on migration of the other provider block.
     const capabilities = opencodeModelCapabilities(model.inputModalities);
     if (capabilities) {
       entry.attachment = capabilities.attachment;
       entry.modalities = capabilities.modalities;
     }
+    if (typeof model.supportsTools === "boolean") entry.tool_call = model.supportsTools;
     v1Models[key] = entry;
-    const variants = opencodeEffortVariants(model);
-    // Own `limit` and `modalities` objects, not shared references: the two blocks are
-    // serialized and reasoned about separately, and an in-place edit of one must never move
-    // the other.
+    const defaultEffort = exportDefaultReasoningEffort(model);
+    // V2 requires tools whenever capabilities exists. A partial object discards the entire
+    // native block, losing explicit variants. Unknown tools use the legacy modality migration
+    // rather than inventing a tools flag to make the native schema accept the declaration.
+    const v2Capabilities: OpencodeV2ModelEntry["capabilities"] = typeof model.supportsTools === "boolean" ? {
+      tools: model.supportsTools,
+      ...(capabilities ? { input: [...capabilities.modalities.input], output: [...capabilities.modalities.output] } : {}),
+    } : undefined;
     v2Models[key] = {
-      ...entry,
+      name: entry.name,
       ...(entry.limit ? { limit: { ...entry.limit } } : {}),
-      ...(entry.modalities
-        ? { modalities: { input: [...entry.modalities.input], output: [...entry.modalities.output] } }
-        : {}),
-      ...(variants ? { variants } : {}),
+      ...(v2Capabilities ? { capabilities: v2Capabilities } : {}),
+      ...(entry.interleaved ? { compatibility: { reasoningField: "reasoning_content" } } : {}),
+      ...(defaultEffort !== undefined ? { settings: { reasoningEffort: defaultEffort } } : {}),
+      variants: opencodeEffortVariants(model),
     };
   }
   return {

package/src/clients/omo-role-models.ts

@@ -6,7 +6,7 @@
  * dashboard or CLI pick, never creates the file, and refuses a file with comments: the write
  * re-serializes JSON, and a comment the user wrote would be lost without a word.
  */
-import { lstatSync, readFileSync } from "node:fs";
+import { closeSync, constants, fstatSync, lstatSync, openSync, readFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
 import { atomicWriteFileNoFollowUnclaimed } from "../config/atomic-write";
@@ -40,12 +40,26 @@ type Loaded =
 
 function load(path: string): Loaded {
   let text: string;
+  let fd: number | undefined;
   try {
-    if (!lstatSync(path).isFile()) return { kind: "invalid" };
-    text = readFileSync(path, "utf8");
+    // POSIX FIFOs must not block before fstat can reject them. Windows omits
+    // these flags and retains the descriptor/path identity checks below.
+    const flags = process.platform === "win32"
+      ? constants.O_RDONLY
+      : constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK;
+    fd = openSync(path, flags);
+    const opened = fstatSync(fd, { bigint: true });
+    const current = lstatSync(path, { bigint: true });
+    if (!opened.isFile() || !current.isFile() || opened.dev !== current.dev || opened.ino !== current.ino) {
+      return { kind: "invalid" };
+    }
+    text = readFileSync(fd, "utf8");
   } catch (error) {
     if ((error as NodeJS.ErrnoException).code === "ENOENT") return { kind: "absent" };
+    if ((error as NodeJS.ErrnoException).code === "ELOOP") return { kind: "invalid" };
     throw error;
+  } finally {
+    if (fd !== undefined) closeSync(fd);
   }
   if (hasJsoncComments(text)) return { kind: "comments" };
   try {