@iislee/opencodex 2.11.0 → 2.31.0

package/src/adapters/identity.ts

@@ -1,5 +1,5 @@
 /**
- * Central identity neutralization.
+ * Central routed-model identity repair.
  *
  * Codex sends the SAME GPT-5 identity line to EVERY model at request time (the per-model catalog
  * `base_instructions` is ignored on the wire). For routed, non-OpenAI providers that line is both
@@ -8,10 +8,11 @@
  * into the upstream payload — a signature no first-party client (Claude Code, Gemini CLI, Kiro) ever
  * sends, and a likely ToS trigger.
  *
- * The neutral replacement keeps ONLY the necessary instruction (don't misreport as GPT-5/OpenAI)
- * and names no proxy. Provider-native identity blocks (e.g. the anthropic OAuth "You are a Claude
- * agent..." prefix) are layered on TOP of this by the individual adapters; this module never claims
- * to be a specific first-party client.
+ * The replacement keeps the necessary instruction (don't misreport as GPT-5/OpenAI), names the
+ * model id that is actually sent on the wire when it is safe to interpolate, and names no proxy.
+ * Provider-native identity blocks (e.g. the anthropic OAuth "You are a Claude agent..." prefix)
+ * are layered on TOP of this by the individual adapters; this module never claims to be a specific
+ * first-party client.
  */
 
 /** Historical exact identity line Codex injected for every model. */
@@ -37,7 +38,39 @@ export const NEUTRAL_IDENTITY_LINE = "You are a coding agent. Do not claim to be
  * the leak can't reappear in one adapter while being fixed in another.
  */
 export function neutralizeIdentity(systemText: string): string {
-  return systemText.replace(CODEX_GPT5_IDENTITY_RE, NEUTRAL_IDENTITY_LINE);
+  // A callback avoids `$&`, `$'`, and other replacement-string substitutions if this constant ever
+  // becomes configurable. Keep the same safe form in identifyRoutedModel below.
+  return systemText.replace(CODEX_GPT5_IDENTITY_RE, () => NEUTRAL_IDENTITY_LINE);
+}
+
+function safeRoutedModelIdentity(modelName: string): string | null {
+  // Callers pass the model id after adapter-specific wire normalization. Brackets remain valid for
+  // providers that intentionally send a suffix such as `[1m]`; the OpenAI-chat adapter strips that
+  // suffix before calling us only when modelSuffixBracketStrip is enabled.
+  const trimmed = modelName.trim();
+  if (trimmed.length === 0 || trimmed.length > 128) return null;
+  const allowedPunctuation = "._/@:+-[]~";
+  for (const char of trimmed) {
+    const code = char.charCodeAt(0);
+    const isAsciiAlphaNumeric = (code >= 48 && code <= 57)
+      || (code >= 65 && code <= 90)
+      || (code >= 97 && code <= 122);
+    if (!isAsciiAlphaNumeric && !allowedPunctuation.includes(char)) return null;
+  }
+  return trimmed;
+}
+
+/**
+ * Identity for a routed model. Callers pass the concrete model id that will be sent upstream, so
+ * identity questions can name it instead of falling back to Codex/GPT identity inherited from the
+ * native template.
+ */
+export function identifyRoutedModel(systemText: string, modelName: string): string {
+  const identity = safeRoutedModelIdentity(modelName);
+  const replacement = identity
+    ? `You are a coding agent powered by the ${identity}. If asked which model you are, identify as ${identity}. Do not claim to be a different model or to have a different creator.`
+    : "You are a coding agent powered by the configured model. If asked which model you are, identify as configured model. Do not claim to be GPT-5 or made by OpenAI.";
+  return systemText.replace(CODEX_GPT5_IDENTITY_RE, () => replacement);
 }
 
 /** The catalog (static, on-disk) replacement for `base_instructions`. Same neutral wording. */

package/src/adapters/kiro-errors.ts

@@ -109,6 +109,17 @@ function classifyKiroFailure(
       retryable: false,
     };
   }
+  // #993: a gated model demanding a profileArn gets a stable, actionable code
+  // instead of the generic validation bucket. Non-retryable by definition.
+  if (evidence.includes("profilearn") && evidence.includes("required")) {
+    return {
+      message: "kiro_profile_required: Kiro requires a CodeWhisperer profileArn for this account and model. Re-login or re-import the matching Kiro account (ocx account login kiro --reauth) so the profile is captured, then retry.",
+      status: 400,
+      errorType: "invalid_request_error",
+      code: "kiro_profile_required",
+      retryable: false,
+    };
+  }
   if (
     evidence.includes("insufficient_quota")
     || evidence.includes("quota exhausted")

package/src/adapters/kiro-events.ts

@@ -3,7 +3,8 @@ import { kiroTruncationReason } from "./kiro-truncation";
 
 export type ParsedKiroEvent =
   | { type: "content"; data?: string; modelId?: string }
-  | { type: "reasoning"; data?: string }
+  | { type: "reasoning"; data?: string; redactedContent?: string }
+  | { type: "context_usage"; contextUsagePercentage: number }
   | { type: "tool"; name?: string; toolUseId?: string; input?: string; stop?: boolean }
   | { type: "truncation"; data: string }
   | { type: "metadata"; usage?: OcxUsage; contextUsagePercentage?: number; stopReason?: string }
@@ -17,6 +18,10 @@ const KNOWN_EVENT_TYPES = new Set([
   "toolUseEvent",
   "messageMetadataEvent",
   "metadataEvent",
+  // Authoritative context pressure. Every capture (kiro-cli 2.14.1 and 2.16.0) put the percentage
+  // HERE and left `metadataEvent` carrying only `stopReason`; metadataEvent's own
+  // contextUsagePercentage stays supported as a fallback rather than being dropped.
+  "contextUsageEvent",
   "invalidStateEvent",
   "error",
 ]);
@@ -114,11 +119,17 @@ export function parseKiroEvent(eventType: string, payload: Uint8Array): ParsedKi
           : {}),
       };
     case "reasoningContentEvent":
+      // `text` is plaintext reasoning; `redactedContent` is the encrypted blob the GPT-5.6 family
+      // (sol/terra/luna) actually returns — they never send `text`. Keyed off the wire field, not
+      // the model id. Both may be absent on a bare event.
       return {
         type: "reasoning",
         ...(optionalString(eventType, parsed, "text") !== undefined
           ? { data: optionalString(eventType, parsed, "text") }
           : {}),
+        ...(optionalString(eventType, parsed, "redactedContent") !== undefined
+          ? { redactedContent: optionalString(eventType, parsed, "redactedContent") }
+          : {}),
       };
     case "toolUseEvent":
       return {
@@ -161,6 +172,13 @@ export function parseKiroEvent(eventType: string, payload: Uint8Array): ParsedKi
         ...(stopReason !== undefined ? { stopReason } : {}),
       };
     }
+    case "contextUsageEvent": {
+      const contextUsagePercentage = parsed.contextUsagePercentage;
+      if (typeof contextUsagePercentage !== "number" || !Number.isFinite(contextUsagePercentage)) {
+        return malformed(eventType, "contextUsagePercentage must be a finite number");
+      }
+      return { type: "context_usage", contextUsagePercentage };
+    }
     case "invalidStateEvent":
       return { type: "invalid_state", message: optionalString(eventType, parsed, "message") };
     case "error":

package/src/adapters/kiro-thinking.ts

@@ -75,6 +75,14 @@ export class KiroThinkingParser {
     return [];
   }
 
+  /** Release any partial tag/content carry when the owning stream stops early. */
+  dispose(): void {
+    this.replaceCarry("preBuffer", "");
+    this.replaceCarry("thinkingBuffer", "");
+    this.closeTag = "";
+    this.state = "streaming";
+  }
+
   private drainThinking(): AdapterEvent[] {
     const close = this.closeTag;
     const idx = this.thinkingBuffer.indexOf(close);
@@ -89,8 +97,16 @@ export class KiroThinkingParser {
       return events;
     }
     if (this.thinkingBuffer.length <= MAX_CLOSE_TAG) return [];
-    const send = this.thinkingBuffer.slice(0, -MAX_CLOSE_TAG);
-    this.replaceCarry("thinkingBuffer", this.thinkingBuffer.slice(-MAX_CLOSE_TAG));
+    // Never split a surrogate pair at the send boundary: a lone high
+    // surrogate at the end of one delta encodes as U+FFFD. Move the cut one
+    // unit earlier so the whole pair stays in the carry.
+    let cut = this.thinkingBuffer.length - MAX_CLOSE_TAG;
+    if (cut > 0 && cut < this.thinkingBuffer.length) {
+      const atCut = this.thinkingBuffer.charCodeAt(cut - 1);
+      if (atCut >= 0xd800 && atCut <= 0xdbff) cut -= 1;
+    }
+    const send = this.thinkingBuffer.slice(0, cut);
+    this.replaceCarry("thinkingBuffer", this.thinkingBuffer.slice(cut));
     return send ? [{ type: "reasoning_raw_delta", text: send }] : [];
   }
 }

package/src/adapters/kiro-tools.ts

@@ -149,7 +149,16 @@ function toolDescriptionLimit(modelId: string): number {
 function truncateDescription(description: string, limit: number): string {
   if (description.length <= limit) return description;
   if (limit <= 1) return description.slice(0, limit);
-  return `${description.slice(0, limit - 1)}…`;
+  let end = limit - 1;
+  // Never end the kept text on a lone high surrogate; one step back keeps
+  // the whole pair out instead of a U+FFFD-producing half.
+  if (description.charCodeAt(end - 1) >= 0xd800 && description.charCodeAt(end - 1) <= 0xdbff) end -= 1;
+  return `${description.slice(0, end)}…`;
+}
+
+/** Test-only: exercise the surrogate-safe description truncation directly. */
+export function truncateDescriptionForTests(description: string, limit: number): string {
+  return truncateDescription(description, limit);
 }
 
 function serializedToolCatalogBytes(tools: readonly unknown[]): number {

package/src/adapters/kiro.ts

@@ -19,6 +19,8 @@ import { createKiroToolNameRegistry, fallbackToolUseId, fingerprint, invocationI
 import { namespacedToolName } from "../types";
 import {
   isTranslatorBudgetExceededError,
+  releaseTranslatedEvent,
+  retainTranslatedEvent,
   type TranslatorBudget,
 } from "../lib/translator-budget";
 import type {
@@ -39,7 +41,7 @@ import { extractKiroImages, normalizeKiroImages, type KiroImage } from "./kiro-i
 import { sniffImageDimensions } from "./anthropic-image-guard";
 import { fetchKiroWithRetry, noteKiroTransientThrottle } from "./kiro-retry";
 import { convertKiroToolContext } from "./kiro-tools";
-import { neutralizeIdentity } from "./identity";
+import { identifyRoutedModel } from "./identity";
 import { buildNonOpenAIToolCatalogNudgeFromNames } from "./tool-catalog-nudge";
 import {
   KIRO_COMPLETION_INSTRUCTIONS,
@@ -99,7 +101,11 @@ interface KiroUserInputMessage {
 }
 interface KiroHistoryEntry {
   userInputMessage?: KiroUserInputMessage;
-  assistantResponseMessage?: { content: string; toolUses?: KiroToolUse[] };
+  assistantResponseMessage?: {
+    content: string;
+    toolUses?: KiroToolUse[];
+    reasoningContent?: { redactedContent: string };
+  };
 }
 
 function kiroToolWireNames(tools: readonly unknown[]): string[] {
@@ -326,7 +332,7 @@ function validateKiroCapabilities(parsed: OcxParsedRequest): void {
 
 type KiroTurn =
   | { kind: "user"; content: string; images: KiroImage[]; toolResults: KiroToolResult[] }
-  | { kind: "assistant"; content: string; toolUses: KiroToolUse[] };
+  | { kind: "assistant"; content: string; toolUses: KiroToolUse[]; redactedReasoning?: string };
 
 function appendTurnText(target: string, next: string): string {
   if (!next) return target;
@@ -381,9 +387,21 @@ function validateKiroConversationState(history: KiroHistoryEntry[], currentMessa
 function boundedInjectedInstruction(text: string, used: { value: number }): string | undefined {
   const remaining = MAX_KIRO_INJECTED_INSTRUCTION_CHARS - used.value;
   if (remaining <= 0 || !text) return undefined;
-  const result = text.length <= remaining ? text : text.slice(0, remaining);
+  let result = text.length <= remaining ? text : text.slice(0, remaining);
+  // Never end the slice on a lone high surrogate: encoding it substitutes
+  // U+FFFD into the injected instruction. One step back keeps a valid pair
+  // out instead of a broken half.
+  if (result.length > 0) {
+    const last = result.charCodeAt(result.length - 1);
+    if (last >= 0xd800 && last <= 0xdbff) result = result.slice(0, -1);
+  }
   used.value += result.length;
-  return result;
+  return result.length > 0 ? result : undefined;
+}
+
+/** Test-only: exercise the surrogate-safe instruction bound directly. */
+export function boundedInjectedInstructionForTests(text: string, used: { value: number }): string | undefined {
+  return boundedInjectedInstruction(text, used);
 }
 
 function kiroCompletionTool(): Record<string, unknown> {
@@ -431,14 +449,24 @@ export function buildKiroPayload(
   const nameMap = toolContext.nameMap;
   const systemParts: string[] = [];
   const injectedChars = { value: 0 };
-  // Neutralize Codex's GPT-5 identity line so a routed Kiro model never misreports as GPT-5/OpenAI
-  // and the proxy identity never leaks upstream.
-  if (parsed.context.systemPrompt?.length) systemParts.push(neutralizeIdentity(parsed.context.systemPrompt.join("\n\n")));
+  // Name the Kiro model id actually sent on the wire without leaking the proxy identity upstream.
+  if (parsed.context.systemPrompt?.length) {
+    systemParts.push(identifyRoutedModel(parsed.context.systemPrompt.join("\n\n"), modelId));
+  }
   for (const addition of toolContext.systemAdditions) {
     const boundedAddition = boundedInjectedInstruction(addition, injectedChars);
     if (boundedAddition) systemParts.push(boundedAddition);
   }
-  const toolCatalogNudge = buildNonOpenAIToolCatalogNudgeFromNames(kiroToolWireNames(kiroTools));
+  // Kiro renames tools to satisfy its wire constraints, so resolve neighbor names through the
+  // registry's existing aliases; a bare-name comparison would forbid tools this turn actually
+  // advertises. Read the recorded mapping instead of calling `alias()`, which would REGISTER a
+  // name for a tool that was never advertised and pollute the collision domain.
+  const advertisedAlias = new Map<string, string>();
+  for (const [alias, wireName] of registry.nameMap) advertisedAlias.set(wireName, alias);
+  const toolCatalogNudge = buildNonOpenAIToolCatalogNudgeFromNames(
+    kiroToolWireNames(kiroTools),
+    name => advertisedAlias.get(name) ?? name,
+  );
   const boundedNudge = toolCatalogNudge ? boundedInjectedInstruction(toolCatalogNudge, injectedChars) : undefined;
   if (boundedNudge) systemParts.push(boundedNudge);
   if (completionMode !== "disabled") {
@@ -458,13 +486,15 @@ export function buildKiroPayload(
       turns.push({ kind: "user", content, images: [...images], toolResults: [...toolResults] });
     }
   };
-  const pushAssistant = (content: string, toolUses: KiroToolUse[]): void => {
+  const pushAssistant = (content: string, toolUses: KiroToolUse[], redactedReasoning?: string): void => {
     const last = turns.at(-1);
     if (last?.kind === "assistant") {
       last.content = appendTurnText(last.content, content);
       last.toolUses.push(...toolUses);
+      // Merged turns keep the newest blob: it covers the reasoning up to the merged turn's end.
+      if (redactedReasoning) last.redactedReasoning = redactedReasoning;
     } else {
-      turns.push({ kind: "assistant", content, toolUses: [...toolUses] });
+      turns.push({ kind: "assistant", content, toolUses: [...toolUses], ...(redactedReasoning ? { redactedReasoning } : {}) });
     }
   };
 
@@ -494,7 +524,7 @@ export function buildKiroPayload(
         const hasReasoning = aMsg.content.some(part => part.type === "thinking" && part.thinking.trim());
         if (hasReasoning) continue;
       }
-      pushAssistant(text, toolUses);
+      pushAssistant(text, toolUses, aMsg.kiroRedactedReasoning);
     } else if (msg.role === "toolResult") {
       const tr = msg as OcxToolResultMessage;
       if (tr.containsEncryptedContent) {
@@ -548,6 +578,7 @@ export function buildKiroPayload(
         assistantResponseMessage: {
           content: turn.content,
           ...(turn.toolUses.length > 0 ? { toolUses: turn.toolUses } : {}),
+          ...(turn.redactedReasoning ? { reasoningContent: { redactedContent: turn.redactedReasoning } } : {}),
         },
       }
     : {
@@ -607,8 +638,8 @@ export function buildKiroPayload(
 
 // Stream parsing (shared by parseStream + parseResponse)
 // CodeWhisperer GenerateAssistantResponse ALWAYS returns an AWS eventstream body (there is no
-// non-streaming mode), so both the streaming bridge and the non-streaming web-search sidecar loop
-// decode the same way — parseResponse just collects what parseStream yields.
+// non-streaming wire mode), so the streaming bridge and non-streaming Responses path decode the
+// same way — parseResponse just collects what parseStream yields.
 interface KiroAttemptParseResult {
   terminal?: AdapterEvent;
   needsFallback?: boolean;
@@ -830,16 +861,12 @@ async function* parseKiroAttempt(
   );
   let handedOff = false;
   try {
-    let next = await attempt.next();
-    while (!next.done) {
-      yield next.value;
-      next = await attempt.next();
-    }
+    const result = yield* attempt;
     for (const event of deferred.splice(0)) {
       try { yield event; } finally { retention.releaseEvent(event); }
     }
     handedOff = true;
-    return { ...next.value, releaseRetained: () => retention.releaseAll() };
+    return { ...result, releaseRetained: () => retention.releaseAll() };
   } finally {
     if (!handedOff) retention.releaseAll();
   }
@@ -868,6 +895,12 @@ async function* parseKiroAttemptEvents(
   }
 
   let open: { id: string; name: string; chunks: string[]; completion: boolean } | null = null;
+  let openCallId: string | undefined;
+  const closeOpenCall = () => {
+    if (!openCallId) return;
+    budget.closeCall(openCallId);
+    openCallId = undefined;
+  };
   let outputChars = "";
   let outputCharsBytes = 0;
   let contextUsagePercentage: number | undefined;
@@ -1080,7 +1113,7 @@ async function* parseKiroAttemptEvents(
     if (!open) return { events: [] };
     const tool = open;
     open = null;
-    budget.closeCall(tool.id);
+    closeOpenCall();
     const input = tool.chunks.join("");
     if (!isCompleteKiroToolInput(input)) {
       return { events: [], terminal: protocolTerminal(kiroTruncationErrorMessage("incomplete tool input JSON"), tool.completion) };
@@ -1170,6 +1203,12 @@ async function* parseKiroAttemptEvents(
           if (ev.data) {
             yield* emitRetained(stage({ type: "reasoning_raw_delta", text: ev.data }));
           }
+          if (ev.redactedContent) {
+            yield* emitRetained(stage({ type: "kiro_redacted_reasoning", data: ev.redactedContent }));
+          }
+          break;
+        case "context_usage":
+          if (ev.contextUsagePercentage > 0) contextUsagePercentage = ev.contextUsagePercentage;
           break;
         case "tool": {
           for (const contentEvent of thinking.flush()) {
@@ -1186,11 +1225,12 @@ async function* parseKiroAttemptEvents(
             if (started.terminal) return { assistantText, sawReasoning, terminal: started.terminal };
             open = started.tool!;
             budget.openCall(open.id);
+            openCallId = open.id;
           } else if (
             (ev.toolUseId && ev.toolUseId !== open.id)
             || (ev.name && open.name !== "unknown" && ev.name !== open.name)
           ) {
-            budget.closeCall(open.id);
+            closeOpenCall();
             open = null;
             return { assistantText, sawReasoning, terminal: protocolTerminal(kiroTruncationErrorMessage("tool input changed identity before stop")) };
           }
@@ -1454,7 +1494,7 @@ async function* parseKiroAttemptEvents(
     };
   } catch (err) {
     if (isTranslatorBudgetExceededError(err)) {
-      if (open) budget.closeCall(open.id);
+      closeOpenCall();
       return {
         assistantText,
         sawReasoning,
@@ -1496,6 +1536,9 @@ async function* parseKiroAttemptEvents(
         usage: usage(),
       },
     };
+  } finally {
+    thinking.dispose();
+    closeOpenCall();
   }
 }
 
@@ -1512,7 +1555,7 @@ export async function* parseKiroStream(
   contextInputEstimate?: number,
 ): AsyncGenerator<AdapterEvent> {
   const contextWindowState: KiroContextWindowState = { value: contextWindow };
-  const first = parseKiroAttempt(
+  const firstResult = yield* parseKiroAttempt(
     response,
     budget,
     completionMode,
@@ -1524,12 +1567,6 @@ export async function* parseKiroStream(
     contextInputEstimate,
     false,
   );
-  let firstNext = await first.next();
-  while (!firstNext.done) {
-    yield firstNext.value;
-    firstNext = await first.next();
-  }
-  const firstResult = firstNext.value;
   try {
     if (!firstResult.needsFallback) {
       if (firstResult.terminal) yield firstResult.terminal;
@@ -1607,7 +1644,7 @@ export async function* parseKiroStream(
       return;
     }
 
-    const second = parseKiroAttempt(
+    const secondResult = yield* parseKiroAttempt(
       fallback.response,
       budget,
       "text_fallback",
@@ -1621,12 +1658,6 @@ export async function* parseKiroStream(
       // A zero-output transport failure here must stay non-retryable to avoid duplicating that text.
       priorEmittedOutput,
     );
-    let secondNext = await second.next();
-    while (!secondNext.done) {
-      yield secondNext.value;
-      secondNext = await second.next();
-    }
-    const secondResult = secondNext.value;
     try {
       if (!secondResult.terminal) {
         yield retryableKiroIncomplete(
@@ -1874,25 +1905,32 @@ export function createKiroAdapter(provider: OcxProviderConfig): ProviderAdapter
       return safeKiroHttpErrorMessage(status, headers, payloadText);
     },
 
-    // Non-streaming path used by the web-search sidecar loop (loop.ts runs each iteration
-    // non-streamed so it can inspect tool calls). CW only ever event-streams, so we drain the
-    // same decoder into an array. Without this, any Codex request that includes the web_search
-    // tool failed with "web-search sidecar requires a non-streaming adapter" (kiro-only).
+    // Kiro always returns an event stream, including for non-streaming Responses requests. Drain
+    // the decoder into a budget-owned batch so an upstream stream cannot grow this array without
+    // bound while the caller waits for the complete JSON response.
     async parseResponse(response: Response, budget: TranslatorBudget): Promise<AdapterEvent[]> {
       const events: AdapterEvent[] = [];
-      for await (const e of parseKiroStream(
-        response,
-        budget,
-        modelId,
-        inputTokens,
-        contextWindow,
-        toolNameMap,
-        conversationId,
-        completionMode,
-        completionMode === "required" ? fallbackFactory : undefined,
-        contextInputEstimate,
-      )) events.push(e);
-      return events;
+      try {
+        for await (const e of parseKiroStream(
+          response,
+          budget,
+          modelId,
+          inputTokens,
+          contextWindow,
+          toolNameMap,
+          conversationId,
+          completionMode,
+          completionMode === "required" ? fallbackFactory : undefined,
+          contextInputEstimate,
+        )) {
+          retainTranslatedEvent(e, budget, events.at(-1));
+          events.push(e);
+        }
+        return events;
+      } catch (error) {
+        for (const event of events) releaseTranslatedEvent(event, budget);
+        throw error;
+      }
     },
   };
 }

package/src/adapters/mimo-free.ts

@@ -40,6 +40,18 @@ function randomUserAgent(): string {
   return USER_AGENTS[Math.floor(Math.random() * USER_AGENTS.length)]!;
 }
 
+function isCanonicalMimoFreeEndpoint(baseUrl: string): boolean {
+  try {
+    const actual = new URL(baseUrl.trim());
+    const expected = new URL(MIMO_CHAT_URL);
+    actual.pathname = actual.pathname.replace(/\/+$/, "") || "/";
+    expected.pathname = expected.pathname.replace(/\/+$/, "") || "/";
+    return actual.toString().replace(/\/$/, "") === expected.toString().replace(/\/$/, "");
+  } catch {
+    return false;
+  }
+}
+
 /**
  * Anonymous per-install client id for the bootstrap `client` field. A random UUID
  * persisted under the config dir (OPENCODEX_HOME-aware) — deliberately NOT derived
@@ -194,6 +206,11 @@ export function injectMimoSystemMarker(body: unknown): unknown {
  * On 401/403, flushes the JWT cache and retries once via fetchResponse.
  */
 export function createMimoFreeAdapter(provider: OcxProviderConfig): ProviderAdapter {
+  if (!isCanonicalMimoFreeEndpoint(provider.baseUrl)) {
+    throw new Error(
+      "The mimo-free adapter only supports the canonical Xiaomi MiMo Free endpoint. Use openai-chat for a custom endpoint.",
+    );
+  }
   const base = createOpenAIChatAdapter(provider);
   // Per-adapter session-affinity id (random, per process instance).
   const sessionId = `ses_${Math.random().toString(36).slice(2, 26)}`;

package/src/adapters/openai-chat-url.ts

@@ -0,0 +1,11 @@
+const TRAILING_SLASHES = /\/+$/;
+const TRAILING_CHAT_COMPLETIONS = /\/chat\/completions\/?$/;
+
+/** Build the openai-chat send URL from a configured baseUrl.
+ *  Accepts /v1, /v1/, /v1/chat/completions, and /v1/chat/completions/.
+ */
+export function openaiChatCompletionsUrl(baseUrl: string): string {
+  const trimmed = baseUrl.trim().replace(TRAILING_SLASHES, "");
+  const withoutEndpoint = trimmed.replace(TRAILING_CHAT_COMPLETIONS, "");
+  return `${withoutEndpoint}/chat/completions`;
+}