@bitkyc08/opencodex 2.42.0 → 2.43.0

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

@@ -0,0 +1,69 @@
+// Shared client export constants.
+import type { OcxConfig } from "../../types";
+
+
+/** Provider key owned by this project; the only key any exporter ever emits. */
+export const OPENCODE_PROVIDER_ID = "opencodex";
+
+export const OPENCODE_CONFIG_SCHEMA = "https://opencode.ai/config.json";
+
+/**
+ * Env var carrying the proxy admission key to opencode. The config only ever holds the
+ * `{env:...}` reference, so the secret never lands on disk. opencode substitutes it at
+ * load time.
+ */
+export const OPENCODE_API_KEY_ENV = "OPENCODEX_OPENCODE_API_KEY";
+
+/** Env reference shared by apiKey and the dedicated proxy admission header. */
+export const OPENCODE_API_KEY_ENV_REF = `{env:${OPENCODE_API_KEY_ENV}}`;
+
+/**
+ * Hermes interpolates `${VAR}` anywhere in config.yaml, so the credential stays
+ * in the environment exactly as it does for OpenCode.
+ */
+export const HERMES_API_KEY_ENV = "OPENCODEX_HERMES_API_KEY";
+export const HERMES_API_KEY_ENV_REF = `\${${HERMES_API_KEY_ENV}}`;
+
+/** OpenClaw interpolates `${UPPERCASE_VAR}` and fails closed when it is unset. */
+export const OPENCLAW_API_KEY_ENV = "OPENCODEX_OPENCLAW_API_KEY";
+export const OPENCLAW_API_KEY_ENV_REF = `\${${OPENCLAW_API_KEY_ENV}}`;
+
+/**
+ * Placeholder credential for loopback-only clients (Kimi, Pi). A loopback
+ * bind needs no real admission key, so we emit the same placeholder the Grok
+ * managed block uses rather than a user secret. Pi resolves `apiKey` before
+ * building its model list and hides the provider when an env reference is unset.
+ */
+export const LOOPBACK_API_KEY_PLACEHOLDER = "opencodex-loopback";
+
+/**
+ * Gajae's `apiKeyEnv` is env-name-only and fail-closed. Its sibling `apiKey`
+ * falls back to treating the literal text as the token when the variable is
+ * unset, which would silently ship a bogus credential — so we never emit it.
+ */
+export const GAJAE_API_KEY_ENV = "OPENCODEX_GAJAE_API_KEY";
+
+/** Pi's wire-dialect selector for an OpenAI-compatible endpoint. */
+export const PI_API_DIALECT = "openai-completions";
+
+/**
+ * opencode's config schema rejects a `limit` block that carries `context` without
+ * `output`, but CatalogModel has no authoritative per-model output field. Dropping
+ * `limit` entirely would also throw away the authoritative context window we DO have,
+ * so the block is emitted with this budget standing in for the missing half.
+ *
+ * The value matches REASONING_MAX_TOKENS_CEILING in src/adapters/anthropic.ts — the
+ * project's existing "safe ceiling across current models" figure. It is a ceiling for
+ * schema validity, NOT a claim about any specific model's true maximum, and it is
+ * clamped to the context window so a small-context model can never be emitted with
+ * output > context. Pi's `maxTokens` uses the same stand-in and the same clamp.
+ */
+export const SCHEMA_REQUIRED_OUTPUT_BUDGET = 32_000;
+
+/** Deterministic loopback default for exported provider-block helpers in tests. */
+export const OPENCODE_PROVIDER_BLOCK_DEFAULT_CONFIG: OcxConfig = {
+  port: 10100,
+  hostname: "127.0.0.1",
+  defaultProvider: "mock",
+  providers: { mock: { adapter: "openai-chat", baseUrl: "http://127.0.0.1/v1" } },
+} as OcxConfig;

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

@@ -0,0 +1,154 @@
+// Shared client export contracts.
+import type { OcxConfig } from "../../types";
+import type { ConfigFormat } from "../../integrations/serialize";
+
+/**
+ * One entry opencodex owns inside a client's config: the JSON path to it and
+ * the value we put there.
+ *
+ * A path list rather than a single provider key because ownership is not
+ * always one entry — Kimi owns its provider block AND one model entry per
+ * model, and a writer that only knew about the provider would strand the rest
+ * (devlog 260802 006 §2).
+ */
+export interface ManagedFragment {
+  path: readonly string[];
+  value: unknown;
+}
+
+/** Everything opencodex contributes to one client's config, as one unit. */
+export interface ManagedContribution {
+  clientId: ExportClientId;
+  fragments: readonly ManagedFragment[];
+}
+
+export type BuildContribution = (ctx: ExportContext) => ManagedContribution;
+
+export interface OpencodeLaunchEnv {
+  [key: string]: string | undefined;
+}
+
+/** Visible catalog entry keyed by the proxy's canonical namespaced selector. */
+export interface OpencodeCatalogModel {
+  namespaced: string;
+  /** Hub-resolved Fast availability. Missing metadata means unavailable. */
+  fastRowAvailable?: boolean;
+  native?: boolean;
+  provider?: string;
+  id?: string;
+  contextWindow?: number;
+  displayName?: string;
+  /** Declared effort ladder. Exported as opencode model variants where the client reads them. */
+  reasoningEfforts?: readonly string[];
+  /**
+   * Declared default effort. Carried so every client export reads one deduped, visibility-
+   * filtered ladder per model. The opencode serializer deliberately does NOT turn it into a
+   * model-level setting — see {@link opencodeEffortVariants} for why.
+   */
+  defaultReasoningEffort?: string;
+}
+
+/**
+ * One proxy-routed model destined for a client config. Deliberately narrower than
+ * `CatalogModel` so a serializer cannot reach for a field that does not survive the
+ * `/api/models` boundary.
+ */
+export interface ExportModel {
+  /** Canonical proxy selector: `provider/id`, or bare slug for native. */
+  namespaced: string;
+  /** Hub-resolved Fast availability; exporters never infer it from local config. */
+  fastRowAvailable?: boolean;
+  provider: string;
+  id: string;
+  /** Native OpenAI entry. Read by the shared label rule. */
+  native?: boolean;
+  displayName?: string;
+  contextWindow?: number;
+  inputModalities?: string[];
+  /** Optional effort ladder exported only to clients that support it. */
+  reasoningEfforts?: string[];
+  defaultReasoningEffort?: string;
+}
+
+export interface ExportContext {
+  /** `http://host:port/v1` — the OpenAI-compatible surface the client dials. */
+  baseUrl: string;
+  models: readonly ExportModel[];
+  /**
+   * Live proxy config. Only the OpenCode path reads it: a non-loopback bind moves
+   * admission from `apiKey` to the `x-opencodex-api-key` header.
+   */
+  config?: OcxConfig;
+}
+
+export type ExportClientId =
+  | "opencode"
+  | "pi"
+  | "omp"
+  | "hermes"
+  | "openclaw"
+  | "kimi"
+  | "gajae"
+  | "dsh"
+  | "mcode"
+  | "zcode"
+  | "prime"
+  | "aside";
+
+export interface ExportClientSpec {
+  id: ExportClientId;
+  /** Download filename; matches the destination file's own name (003 §5). */
+  filename: string;
+  /** Canonical destination for humans. Never written to. */
+  destination: (env: NodeJS.ProcessEnv) => string;
+  /** Env var the config references; the value is never serialized. */
+  apiKeyEnv: string;
+  /** Shell line the user runs before launching the client. */
+  exportHint: string;
+  build: (ctx: ExportContext) => unknown;
+  /**
+   * Text format of the client's config file. `filename` already carries the
+   * extension; this drives serialization and the download media type so no
+   * consumer has to infer either from the name.
+   */
+  format: ConfigFormat;
+  /**
+   * Count models in THIS client's document shape. Required so a new client
+   * cannot be added without teaching the summarizer about it — the old
+   * "anything that is not OpenCode must be Pi" branch was a latent bug.
+   */
+  summarize: (document: unknown) => { modelCount: number; modelsWithoutLimits: number };
+  /**
+   * The fragments opencodex owns inside this client's config. Only the builder
+   * knows where a client keeps our entries, so ownership paths originate here
+   * rather than being re-derived by the writer.
+   */
+  buildContribution: BuildContribution;
+  /**
+   * True when the generated integration deliberately supports loopback only.
+   *
+   * `/v1/chat/completions` rejects bearer credentials and requires the
+   * dedicated `x-opencodex-api-key` header (AUTH_MATRIX in
+   * src/server/auth-cors.ts). If this exporter cannot safely emit that header,
+   * it refuses a remote bind rather than generating a config that 401s. Same
+   * reasoning as the Grok managed block's non-loopback refusal.
+   */
+  loopbackOnly: boolean;
+}
+
+export interface PiModelEntry {
+  id: string;
+  name: string;
+  input: string[];
+  contextWindow?: number;
+  maxTokens?: number;
+  /** Advertised when the catalog row carries a non-empty effort ladder. */
+  reasoning?: true;
+  /**
+   * Constrains pi's own level scale (minimal..max) to the declared ladder: members map to
+   * themselves, everything else is hidden (`null`). Without it pi would offer levels the
+   * ladder does not contain — harmless for provider-config ladders (the proxy clamps those
+   * at the wire) but a real 400 risk for custom-row ladders, which are advertisement-only.
+   */
+  thinkingLevelMap?: Record<string, string | null>;
+}

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

@@ -0,0 +1,132 @@
+// DSH config export.
+import type { ExportModel, ExportContext, ManagedContribution } from "./contracts";
+import type { OcxConfig } from "../../types";
+import { providerCodexAccountMode } from "../../providers/registry";
+import { normalizeExportModels, authoritativeContextWindow, exportModelLabel, singleFragment } from "./model-metadata";
+import { OPENCODE_PROVIDER_ID } from "./constants";
+
+
+/** DSH rc.6 accepts text/image; unknown values degrade to text, while audio-only cannot be represented. */
+function dshInputModalities(modalities: readonly string[] | undefined): string[] | null {
+  const declared = modalities ?? [];
+  if (declared.length === 0) return ["text"];
+  const kept: string[] = [];
+  for (const value of declared) {
+    if ((value === "text" || value === "image") && !kept.includes(value)) kept.push(value);
+  }
+  if (kept.length > 0) return kept;
+  return declared.every(value => value === "audio") ? null : ["text"];
+}
+
+export type DshReasoningEffort = "low" | "medium" | "high" | "xhigh" | "max";
+export type DshWireReasoningEffort = DshReasoningEffort | "ultra";
+
+export interface DshModelEntry {
+  id: string;
+  name: string;
+  input: string[];
+  contextWindow?: number;
+  reasoningEfforts?: Partial<Record<DshReasoningEffort, DshWireReasoningEffort>>;
+}
+
+export interface DshProviderBlock {
+  displayName: "OpenCodex";
+  api: "openai-responses";
+  baseURL: string;
+  headers: { Authorization: "Bearer ocx_data_dsh" };
+  models: DshModelEntry[];
+}
+
+export interface DshGeneratedConfig {
+  "llm-pi-ai": {
+    providers: Record<string, DshProviderBlock>;
+  };
+}
+
+const DSH_EFFORT_ORDER: readonly DshReasoningEffort[] = ["low", "medium", "high", "xhigh", "max"];
+
+function dshReasoningEfforts(model: ExportModel): DshModelEntry["reasoningEfforts"] {
+  const offered = new Set<string>();
+  for (const raw of model.reasoningEfforts ?? []) {
+    const effort = raw.trim().toLowerCase();
+    if (effort === "ultra" || DSH_EFFORT_ORDER.includes(effort as DshReasoningEffort)) offered.add(effort);
+  }
+  if (offered.size === 0) return undefined;
+  const entries: Array<[DshReasoningEffort, DshWireReasoningEffort]> = [];
+  for (const effort of DSH_EFFORT_ORDER) {
+    if (effort !== "max") {
+      if (offered.has(effort)) entries.push([effort, effort]);
+      continue;
+    }
+    // DSH's key is the selectable level; the value is what it sends on the
+    // wire. Preserve OpenCodex's `ultra` spelling when that is the only
+    // highest effort, exactly like the rc.6 `max: ultra` contract.
+    if (offered.has("max")) entries.push(["max", "max"]);
+    else if (offered.has("ultra")) entries.push(["max", "ultra"]);
+  }
+  return Object.fromEntries(entries);
+}
+
+function isKnownSafeDshCombo(model: ExportModel, config: OcxConfig): boolean {
+  const combos = (config as { combos?: unknown }).combos;
+  if (typeof combos !== "object" || combos === null || Array.isArray(combos)) return false;
+  const combo = (combos as Record<string, unknown>)[model.id];
+  if (typeof combo !== "object" || combo === null || Array.isArray(combo)) return false;
+  const targets = (combo as { targets?: unknown }).targets;
+  if (!Array.isArray(targets) || targets.length === 0) return false;
+  return targets.every(target => {
+    if (typeof target !== "object" || target === null || Array.isArray(target)) return false;
+    const provider = (target as { provider?: unknown }).provider;
+    const modelId = (target as { model?: unknown }).model;
+    return typeof provider === "string"
+      && provider.length > 0
+      && provider === provider.trim()
+      && provider !== "openai"
+      && typeof modelId === "string"
+      && modelId.length > 0
+      && modelId === modelId.trim();
+  });
+}
+
+export function buildDshClientConfig(ctx: ExportContext): DshGeneratedConfig {
+  const direct = providerCodexAccountMode("openai", ctx.config?.providers?.openai) === "direct";
+  const models: DshModelEntry[] = [];
+  for (const model of normalizeExportModels(ctx.models)) {
+    if (direct && (model.native === true || model.provider === "openai")) continue;
+    if (direct && model.provider === "combo" && (!ctx.config || !isKnownSafeDshCombo(model, ctx.config))) continue;
+    const input = dshInputModalities(model.inputModalities);
+    if (input === null) continue;
+    const contextWindow = authoritativeContextWindow(model.contextWindow);
+    const reasoningEfforts = dshReasoningEfforts(model);
+    models.push({
+      id: model.namespaced,
+      name: exportModelLabel(model),
+      input,
+      ...(contextWindow !== undefined ? { contextWindow } : {}),
+      ...(reasoningEfforts ? { reasoningEfforts } : {}),
+    });
+  }
+  return {
+    "llm-pi-ai": {
+      providers: {
+        [OPENCODE_PROVIDER_ID]: {
+          displayName: "OpenCodex",
+          api: "openai-responses",
+          baseURL: ctx.baseUrl,
+          headers: { Authorization: "Bearer ocx_data_dsh" },
+          models,
+        },
+      },
+    },
+  };
+}
+
+export function summarizeDsh(document: unknown): { modelCount: number; modelsWithoutLimits: number } {
+  const models = (document as DshGeneratedConfig | undefined)?.["llm-pi-ai"]?.providers?.[OPENCODE_PROVIDER_ID]?.models ?? [];
+  return { modelCount: models.length, modelsWithoutLimits: models.filter(model => model.contextWindow === undefined).length };
+}
+
+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]);
+}

package/src/clients/config-export/fast-models.ts

@@ -0,0 +1,29 @@
+import type { OpencodeCatalogModel } from "./contracts";
+
+const FAST_ROW_SUFFIX = "--fast";
+
+/**
+ * Expand only hub-resolved availability; older hubs without the field advertise no Fast.
+ * Reserve every exact input selector before synthesis and retain the first duplicate.
+ * Keep routing/capability metadata intact: only the selector, label and availability change.
+ */
+export function expandFastExportModels<T extends OpencodeCatalogModel>(models: readonly T[]): T[] {
+  const exact = new Map<string, T>();
+  for (const model of models) {
+    if (!exact.has(model.namespaced)) exact.set(model.namespaced, model);
+  }
+  const expanded = [...exact.values()];
+  for (const model of exact.values()) {
+    if (model.fastRowAvailable !== true) continue;
+    const namespaced = `${model.namespaced}${FAST_ROW_SUFFIX}`;
+    if (exact.has(namespaced)) continue;
+    expanded.push({
+      ...model,
+      namespaced,
+      displayName: `${model.displayName || model.id || model.namespaced} Fast`,
+      // Re-normalizing cannot synthesize a Fast row from this synthetic row.
+      fastRowAvailable: false,
+    });
+  }
+  return expanded;
+}

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

@@ -0,0 +1,83 @@
+// MiniMax Code config export.
+import type { ExportContext, ManagedContribution } from "./contracts";
+import { normalizeExportModels, authoritativeContextWindow, singleFragment } from "./model-metadata";
+import { sanitizeCodexReasoningEfforts } from "../../reasoning-effort";
+import { OPENCODE_PROVIDER_ID, LOOPBACK_API_KEY_PLACEHOLDER } from "./constants";
+
+
+export interface McodeProviderBlock {
+  name: "OpenCodex";
+  kind: "custom";
+  enabled: true;
+  api: "anthropic-messages";
+  options: {
+    apiKey: string;
+    baseURL: string;
+    authMode: "api-key";
+  };
+  models: Record<string, McodeModelEntry>;
+}
+
+export interface McodeModelEntry {
+  /** MCode uses this value for context accounting and compaction. */
+  limit?: { context: number };
+  /** MCode exposes these exact levels in `/model` and sends the selected effort. */
+  thinking?: { effortOptions: string[] };
+}
+
+export interface McodeGeneratedConfig {
+  custom_provider: Record<string, McodeProviderBlock>;
+}
+
+/**
+ * MiniMax Code's `provider add` command persists custom providers under
+ * `custom_provider.<id>`. Its current model schema reads `limit.context` for
+ * context accounting and `thinking.effortOptions` for the `/model` effort
+ * control. Do not emit the removed `thinking.effort` / `defaultEffort` fields:
+ * MCode 0.1.6 migrates those into options and keeps the selected effort in the
+ * session. Do not emit `defaultModel` either: connecting a client must not
+ * silently replace the user's current model selection.
+ */
+export function buildMcodeClientConfig(ctx: ExportContext): McodeGeneratedConfig {
+  const models: Record<string, McodeModelEntry> = {};
+  for (const model of normalizeExportModels(ctx.models)) {
+    const entry: McodeModelEntry = {};
+    const context = authoritativeContextWindow(model.contextWindow);
+    if (context !== undefined) entry.limit = { context };
+    // `none` is an internal Codex catalog sentinel, not an MCode effort. MCode
+    // forwards every option as `output_config.effort` while keeping adaptive
+    // thinking enabled, and the Anthropic ingress deliberately accepts only
+    // minimal..ultra. Advertising `none` would therefore create a selectable
+    // value that cannot disable reasoning and is not forwarded as an effort.
+    const efforts = sanitizeCodexReasoningEfforts(model.reasoningEfforts)
+      ?.filter(effort => effort !== "none");
+    if (efforts && efforts.length > 0) entry.thinking = { effortOptions: efforts };
+    models[model.namespaced] = entry;
+  }
+  return {
+    custom_provider: {
+      [OPENCODE_PROVIDER_ID]: {
+        name: "OpenCodex",
+        kind: "custom",
+        enabled: true,
+        api: "anthropic-messages",
+        options: {
+          apiKey: LOOPBACK_API_KEY_PLACEHOLDER,
+          baseURL: ctx.baseUrl.replace(/\/v1\/?$/, ""),
+          authMode: "api-key",
+        },
+        models,
+      },
+    },
+  };
+}
+
+export function summarizeMcode(document: unknown): { modelCount: number; modelsWithoutLimits: number } {
+  const models = Object.values((document as McodeGeneratedConfig | undefined)?.custom_provider?.[OPENCODE_PROVIDER_ID]?.models ?? {});
+  return { modelCount: models.length, modelsWithoutLimits: models.filter(model => !model.limit).length };
+}
+
+export function buildMcodeContribution(ctx: ExportContext): ManagedContribution {
+  const doc = buildMcodeClientConfig(ctx);
+  return singleFragment("mcode", ["custom_provider", OPENCODE_PROVIDER_ID], doc.custom_provider[OPENCODE_PROVIDER_ID]);
+}

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

@@ -0,0 +1,108 @@
+// Shared client export model metadata.
+import { SCHEMA_REQUIRED_OUTPUT_BUDGET } from "./constants";
+import { expandFastExportModels } from "./fast-models";
+import type { OpencodeCatalogModel, ExportModel, ExportClientId, ManagedContribution } from "./contracts";
+import type { OcxConfig } from "../../types";
+import { shouldInjectApiAuthHeader } from "../../codex/inject";
+
+
+/**
+ * Authoritative context window, or undefined. Never guesses: a missing, non-finite, or
+ * non-positive value means the serializer omits every context-derived field.
+ */
+export function authoritativeContextWindow(contextWindow: number | undefined): number | undefined {
+  if (typeof contextWindow === "number" && Number.isFinite(contextWindow) && contextWindow > 0) {
+    const integer = Math.floor(contextWindow);
+    return integer > 0 ? integer : undefined;
+  }
+  return undefined;
+}
+
+/** Schema-required output budget for a known context window. */
+export function outputBudgetFor(context: number): number {
+  return Math.min(SCHEMA_REQUIRED_OUTPUT_BUDGET, context);
+}
+
+/**
+ * Modalities a given client's schema will actually accept.
+ *
+ * Our internal vocabulary is `text | image | audio` (ALLOWED_INPUT_MODALITIES in
+ * src/server/management/model-routes.ts). Pi and Gajae accept only
+ * `text | image`, and both reject the WHOLE config file over one out-of-enum
+ * value — Gajae reports `/providers/opencodex/models/N/input/2: Invalid option`
+ * and falls back to its built-in list, Pi returns an empty model config. So a
+ * single `audio` model takes every routed model down with it. That is not
+ * hypothetical: zenmux/meta-muse-spark-1.1 advertises audio and did exactly
+ * this. It is also the same defect the Codex catalog had with `video`, where
+ * the app showed zero apps (tests/codex-integration/catalog-input-modality-enum.test.ts).
+ *
+ * UNKNOWN and INCOMPATIBLE are different inputs, and the Codex fix could
+ * conflate them safely only because its enum is wider. A model with nothing
+ * declared is unknown, and `text` is the honest floor — every routed model takes
+ * prompts. A model declaring `["audio"]` and nothing else is incompatible with a
+ * text|image client, and rewriting it to `["text"]` would advertise a capability
+ * it does not have. That input is reachable three ways: `ocx models add
+ * --modalities audio`, `/api/custom-models`, and provider discovery.
+ *
+ * So unknown falls back to text and incompatible returns null, which drops the
+ * row. Omitting a model costs the user a line in a picker; fabricating `text`
+ * costs them a model that fails at call time with no explanation.
+ *
+ * Deliberately NOT applied in `ExportModel` construction: the management and CLI
+ * boundaries carry catalog modalities verbatim on purpose, and stripping `audio`
+ * globally would destroy valid metadata before the destination is known.
+ */
+const CLIENT_INPUT_MODALITIES: Record<"pi" | "gajae", ReadonlySet<string>> = {
+  pi: new Set(["text", "image"]),
+  gajae: new Set(["text", "image"]),
+};
+
+/** `null` means the model cannot be represented for this client — drop the row. */
+export function inputModalitiesForClient(
+  client: "pi" | "gajae",
+  modalities: readonly string[] | undefined,
+): string[] | null {
+  const declared = modalities ?? [];
+  if (declared.length === 0) return ["text"];
+  const accepted = CLIENT_INPUT_MODALITIES[client];
+  const kept: string[] = [];
+  for (const value of declared) {
+    if (accepted.has(value) && !kept.includes(value)) kept.push(value);
+  }
+  return kept.length > 0 ? kept : null;
+}
+
+/**
+ * Label shared by every client: `"<displayName|id> (<native|provider|routed>)"`. The
+ * provider suffix is what makes two same-named models from different upstreams
+ * distinguishable in a client's model picker.
+ */
+export function exportModelLabel(model: OpencodeCatalogModel): string {
+  const providerLabel = model.native ? "native" : (model.provider ?? "routed");
+  const id = model.id ?? model.namespaced;
+  if (model.displayName && model.displayName.length > 0) {
+    return `${model.displayName} (${providerLabel})`;
+  }
+  return `${id} (${providerLabel})`;
+}
+
+/**
+ * Shared precondition for every serializer: expand hub-approved Fast rows, drop duplicate
+ * `namespaced` (first wins, native rows lead `/api/models`) and sort so calls with the same
+ * models produce identical bytes. Stability matters because the GUI shows a diffable
+ * preview and agents may checksum the payload.
+ */
+export function normalizeExportModels(models: readonly ExportModel[]): ExportModel[] {
+  return expandFastExportModels(models)
+    .sort((a, b) => (a.namespaced < b.namespaced ? -1 : a.namespaced > b.namespaced ? 1 : 0));
+}
+
+/** Extra headers a non-loopback bind needs, or nothing on loopback. */
+export function proxyAdmissionHeaders(config: OcxConfig | undefined, envRef: string): Record<string, string> | undefined {
+  return shouldInjectApiAuthHeader(config) ? { "x-opencodex-api-key": envRef } : undefined;
+}
+
+/** One fragment at `path`, built from this client's own document. */
+export function singleFragment(clientId: ExportClientId, path: readonly string[], value: unknown): ManagedContribution {
+  return { clientId, fragments: [{ path, value }] };
+}

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

@@ -0,0 +1,104 @@
+// Oh My Pi config export.
+import type { PiModelEntry, ExportModel, ExportContext, ManagedContribution } from "./contracts";
+import { PI_API_DIALECT, OPENCODE_PROVIDER_ID, LOOPBACK_API_KEY_PLACEHOLDER } from "./constants";
+import { normalizeExportModels, inputModalitiesForClient, exportModelLabel, authoritativeContextWindow, outputBudgetFor, singleFragment } from "./model-metadata";
+
+
+/**
+ * omp accepts a model-level API override. Keep the provider on Chat
+ * Completions so routed providers retain their established wire format, while
+ * native OpenAI models can use the lossless Responses surface.
+ */
+export interface OmpModelEntry extends PiModelEntry {
+  api?: "openai-responses";
+  /** omp requires this flag before it honors a thinking block. */
+  reasoning?: true;
+  thinking?: {
+    mode: "effort";
+    efforts: string[];
+    defaultLevel?: string;
+  };
+}
+
+export interface OmpProviderBlock {
+  baseUrl: string;
+  api: typeof PI_API_DIALECT;
+  apiKey: string;
+  models: OmpModelEntry[];
+}
+
+export interface OmpGeneratedConfig {
+  providers: Record<string, OmpProviderBlock>;
+}
+
+/**
+ * omp validates model entries strictly. These are its documented effort
+ * values; omit an unknown value rather than invalidating the whole provider.
+ */
+const OMP_EFFORT_VOCABULARY = new Set(["minimal", "low", "medium", "high", "xhigh", "max"]);
+
+function ompEfforts(model: ExportModel): string[] {
+  const efforts: string[] = [];
+  for (const effort of model.reasoningEfforts ?? []) {
+    const normalized = effort.trim().toLowerCase();
+    if (OMP_EFFORT_VOCABULARY.has(normalized) && !efforts.includes(normalized)) {
+      efforts.push(normalized);
+    }
+  }
+  return efforts;
+}
+
+/**
+ * omp's models.yml is Pi-like, but it supports effort metadata and a per-model
+ * API dialect. Native OpenAI models use Responses; all routed models inherit
+ * the provider's existing Chat Completions dialect.
+ */
+export function buildOmpClientConfig(ctx: ExportContext): OmpGeneratedConfig {
+  const models: OmpModelEntry[] = [];
+  for (const model of normalizeExportModels(ctx.models)) {
+    const input = inputModalitiesForClient("pi", model.inputModalities);
+    if (input === null) continue;
+    const entry: OmpModelEntry = {
+      id: model.namespaced,
+      name: exportModelLabel(model),
+      input,
+      ...(model.native && model.provider === "openai" ? { api: "openai-responses" } : {}),
+    };
+    const context = authoritativeContextWindow(model.contextWindow);
+    if (context !== undefined) {
+      entry.contextWindow = context;
+      entry.maxTokens = outputBudgetFor(context);
+    }
+    const efforts = ompEfforts(model);
+    if (efforts.length > 0) {
+      const defaultLevel = model.defaultReasoningEffort?.trim().toLowerCase();
+      entry.reasoning = true;
+      entry.thinking = {
+        mode: "effort",
+        efforts,
+        ...(defaultLevel && efforts.includes(defaultLevel) ? { defaultLevel } : {}),
+      };
+    }
+    models.push(entry);
+  }
+  return {
+    providers: {
+      [OPENCODE_PROVIDER_ID]: {
+        baseUrl: ctx.baseUrl,
+        api: PI_API_DIALECT,
+        apiKey: LOOPBACK_API_KEY_PLACEHOLDER,
+        models,
+      },
+    },
+  };
+}
+
+export function summarizeOmp(document: unknown): { modelCount: number; modelsWithoutLimits: number } {
+  const models = (document as OmpGeneratedConfig | undefined)?.providers?.[OPENCODE_PROVIDER_ID]?.models ?? [];
+  return { modelCount: models.length, modelsWithoutLimits: models.filter(model => model.contextWindow === undefined).length };
+}
+
+export function buildOmpContribution(ctx: ExportContext): ManagedContribution {
+  const doc = buildOmpClientConfig(ctx);
+  return singleFragment("omp", ["providers", OPENCODE_PROVIDER_ID], doc.providers[OPENCODE_PROVIDER_ID]);
+}