@bitkyc08/opencodex 2.48.0 → 2.49.0

package/src/adapters/coding-agent/turn.ts

@@ -0,0 +1,353 @@
+import { spawn as nodeSpawn, type ChildProcess, type SpawnOptions } from "node:child_process";
+import type { AdapterEvent, OcxParsedRequest, OcxProviderConfig } from "../../types";
+import { commandInvocation } from "../../lib/win-exec";
+import type { IncomingMeta } from "../base";
+import { buildConversationInput, CodingAgentProtocolError, mapStreamMessageToEvents, readJsonLines, type StreamParseState } from "./protocol";
+import { resolveCodingAgentBinary, resolveProfileByBaseUrl, type CodingAgentProviderProfile, type WhichFn } from "./profile";
+
+/** Injectable spawn for tests; production uses node:child_process. */
+export type SpawnFn = (command: string, args: readonly string[], options: SpawnOptions) => ChildProcess;
+
+/** Per-turn injectables: spawn/which seams for tests plus wall-clock ceilings for timeout, kill grace, and bounded reap. */
+export interface CodingAgentDeps {
+  spawn?: SpawnFn;
+  which?: WhichFn;
+  /** Overall wall-clock ceiling for one turn (ms). */
+  timeoutMs?: number;
+  /** Grace period between SIGTERM and SIGKILL (ms). */
+  killGraceMs?: number;
+  /** Maximum time to wait for a child that never reports close after termination (ms). */
+  reapTimeoutMs?: number;
+  /** Test seam for Windows command-shim invocation. */
+  platform?: NodeJS.Platform;
+}
+
+const DEFAULT_TIMEOUT_MS = 300_000;
+const DEFAULT_KILL_GRACE_MS = 2_000;
+/** Bound captured stderr so an error message can never carry an unbounded (or secret) payload. */
+const MAX_STDERR_BYTES = 8 * 1024;
+
+/** Env keys a CLI needs to run; everything else is dropped so the child env is scoped and deterministic. */
+const INHERITED_ENV_KEYS = [
+  "PATH", "HOME", "USERPROFILE", "LANG", "LC_ALL", "LC_CTYPE", "TMPDIR", "TEMP", "TMP",
+  "SHELL", "SYSTEMROOT", "APPDATA", "LOCALAPPDATA", "PROGRAMFILES", "PROGRAMFILES(X86)",
+  "COMSPEC", "PATHEXT", "SYSTEMDRIVE", "USERNAME", "TZ",
+] as const;
+
+/**
+ * Base scoped child-process environment (§六/§十四).
+ *
+ * Never mutates `process.env` (no cross-provider pollution under concurrency) and never inherits a
+ * parent vendor variable, so a stray region switch in the host shell cannot flip a provider's
+ * region: the profile is the sole authority. Family builders layer the credential + region vars on
+ * top of this.
+ */
+export function baseScopedEnv(): Record<string, string> {
+  const env: Record<string, string> = {};
+  for (const key of INHERITED_ENV_KEYS) {
+    const value = process.env[key];
+    if (typeof value === "string" && value.length > 0) env[key] = value;
+  }
+  return env;
+}
+
+/** Redact the profile's credential and common secret shapes before surfacing diagnostics. */
+export function redactSecrets(text: string, tokenEnv: string, credential?: string): string {
+  const escaped = tokenEnv.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  let redacted = text;
+  if (credential) redacted = redacted.split(credential).join("[redacted]");
+  return redacted
+    .replace(new RegExp(`(${escaped}\\s*[:=]\\s*)\\S+`, "gi"), "$1[redacted]")
+    .replace(/(authorization\s*[:=]\s*)\S+/gi, "$1[redacted]")
+    .replace(/\b(sk-[A-Za-z0-9_-]{6,})\b/g, "[redacted]");
+}
+
+/** Inputs for one headless CLI turn: region profiles, request context, and family-specific arg/env builders. */
+export interface CodingAgentTurnInput {
+  /** Region profiles for this family; the turn fails closed if the base URL matches none. */
+  profiles: readonly CodingAgentProviderProfile[];
+  provider: OcxProviderConfig;
+  parsed: OcxParsedRequest;
+  incoming: IncomingMeta;
+  emit: (event: AdapterEvent) => void;
+  /** Family-specific headless argument builder (tools disabled, model, reasoning, system prompt). */
+  buildArgs: (profile: CodingAgentProviderProfile, parsed: OcxParsedRequest, provider: OcxProviderConfig) => string[];
+  /** Family-specific scoped env builder (credential + region switch on top of baseScopedEnv). */
+  buildEnv: (profile: CodingAgentProviderProfile, apiKey: string) => Record<string, string>;
+  deps: CodingAgentDeps;
+}
+
+/**
+ * Run one headless coding-agent CLI turn as an OpenCodex `runTurn` (§七/§三十).
+ *
+ * Single transport for every official coding-agent CLI provider: fail closed on a non-canonical
+ * destination, pre-flight the credential and binary, spawn with a scoped env and tools disabled, feed
+ * the replayed conversation over stream-json, map the vendor's Anthropic-aligned frames to
+ * AdapterEvents, and always reap the process. Codex retains tool ownership: the CLI runs with its own
+ * tools disabled, so this turn yields text/reasoning (the control-protocol tool bridge is a
+ * documented fast-follow).
+ */
+export async function runCodingAgentTurn(input: CodingAgentTurnInput): Promise<void> {
+  const { profiles, provider, parsed, incoming, emit, buildArgs, buildEnv, deps } = input;
+  const spawnFn = deps.spawn ?? nodeSpawn;
+  const timeoutMs = deps.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  const killGraceMs = deps.killGraceMs ?? DEFAULT_KILL_GRACE_MS;
+  const reapTimeoutMs = deps.reapTimeoutMs ?? (killGraceMs * 2 + 250);
+
+  if (incoming.abortSignal?.aborted) {
+    emit({ type: "error", message: "Coding-agent turn was aborted before start." });
+    return;
+  }
+
+  // Fail closed on a non-canonical destination BEFORE any credential is placed in an env (§十六).
+  const profile = resolveProfileByBaseUrl(profiles, provider.baseUrl);
+  if (!profile) {
+    emit({
+      type: "error",
+      message: "Provider base URL is not a canonical region destination; the credential was not sent.",
+      status: 400,
+      errorType: "invalid_request_error",
+      code: "non_canonical_destination",
+      retryable: false,
+    });
+    return;
+  }
+  const apiKey = provider.apiKey;
+  if (!apiKey) {
+    emit({
+      type: "error",
+      message: `${profile.label} credential missing — add an API key for this provider (${profile.tokenEnv}).`,
+      status: 401,
+      errorType: "authentication_error",
+      code: "missing_credential",
+      retryable: false,
+    });
+    return;
+  }
+  // Pre-flight binary discovery so a missing CLI is a clear error, not a mid-turn ENOENT (§二十六).
+  const binary = resolveCodingAgentBinary(profile, deps.which);
+  if (!binary) {
+    emit({
+      type: "error",
+      message: `${profile.label} CLI not found on PATH. Install it with: ${profile.installHint}`,
+      status: 500,
+      errorType: "upstream_error",
+      code: "cli_not_found",
+      retryable: false,
+    });
+    return;
+  }
+
+  const args = buildArgs(profile, parsed, provider);
+  const env = buildEnv(profile, apiKey);
+  const invocation = commandInvocation(binary, args, deps.platform ?? process.platform, { env });
+
+  let child: ChildProcess;
+  try {
+    child = spawnFn(invocation.file, invocation.args, {
+      ...invocation.options,
+      env,
+      stdio: ["pipe", "pipe", "pipe"],
+      windowsHide: true,
+    });
+  } catch (err) {
+    emit({
+      type: "error",
+      message: redactSecrets(err instanceof Error ? err.message : String(err), profile.tokenEnv, apiKey),
+      status: 500,
+      errorType: "upstream_error",
+      code: "cli_spawn_failed",
+      retryable: false,
+    });
+    return;
+  }
+
+  // `spawn()` reports launch failures such as ENOENT asynchronously through `error`; they are not
+  // reliably thrown by the call above. Subscribe immediately and create the lifecycle promise now,
+  // before stdout can end, so neither a fast close nor a launch failure can be missed by the reap step.
+  let childProcessError: Error | undefined;
+  const processLifecycle = new Promise<void>(resolve => {
+    let settled = false;
+    const settle = (): void => {
+      if (settled) return;
+      settled = true;
+      resolve();
+    };
+    child.once("error", err => {
+      childProcessError = err;
+      // A launch failure has no process to reap and is not guaranteed to emit `close` on every runtime.
+      if (child.pid === undefined) settle();
+    });
+    child.once("close", settle);
+    if (child.exitCode !== null) settle();
+  });
+
+  let terminalEmitted = false;
+  const emitOnce = (event: AdapterEvent): void => {
+    if (event.type === "done" || event.type === "error" || event.type === "incomplete") {
+      if (terminalEmitted) return;
+      terminalEmitted = true;
+    }
+    emit(event);
+  };
+
+  const stderrChunks: string[] = [];
+  let killed = false;
+  let killTimer: ReturnType<typeof setTimeout> | undefined;
+  const kill = (): void => {
+    if (killed || child.killed) return;
+    killed = true;
+    try { child.kill("SIGTERM"); } catch { /* already gone */ }
+    killTimer = setTimeout(() => {
+      try { child.kill("SIGKILL"); } catch { /* already gone */ }
+    }, killGraceMs);
+  };
+
+  const stopStream = (): void => {
+    try { child.stdout?.destroy(); } catch { /* already closed */ }
+  };
+  const onAbort = (): void => {
+    kill();
+    stopStream();
+  };
+  incoming.abortSignal?.addEventListener("abort", onAbort, { once: true });
+  const timeoutTimer = setTimeout(() => {
+    kill();
+    stopStream();
+    emitOnce({ type: "error", message: `${profile.label} turn timed out.`, status: 504, errorType: "upstream_error", code: "timeout", retryable: true });
+  }, timeoutMs);
+
+  child.stderr?.setEncoding("utf8");
+  child.stderr?.on("data", (chunk: string) => {
+    if (stderrChunks.join("").length < MAX_STDERR_BYTES) stderrChunks.push(chunk);
+  });
+
+  const cleanup = (): void => {
+    clearTimeout(timeoutTimer);
+    incoming.abortSignal?.removeEventListener("abort", onAbort);
+    try { child.stdin?.destroy(); } catch { /* ignore */ }
+    // Termination is owned by the reap step below, not here: killing in cleanup would set
+    // `child.killed` and let the wait resolve before the process is actually reaped (§三十).
+  };
+
+  let streamProtocolError: string | undefined;
+  let turnError: string | undefined;
+  const state: StreamParseState = {
+    sawPartialText: false,
+    sawPartialThinking: false,
+    sawTerminalResult: false,
+    openToolCallId: undefined,
+  };
+
+  try {
+    // Write the replayed conversation, then close stdin so a single-shot turn can complete.
+    const stdin = child.stdin;
+    if (stdin) {
+      stdin.on("error", () => { /* EPIPE if the CLI exits early; surfaced via close/stderr */ });
+      for (const line of buildConversationInput(parsed)) stdin.write(`${line}\n`);
+      stdin.end();
+    }
+    const stdout = child.stdout;
+    if (!stdout) throw new CodingAgentProtocolError(`${profile.label} CLI produced no stdout stream`);
+    try {
+      for await (const message of readJsonLines(stdout)) {
+        if (incoming.abortSignal?.aborted) break;
+        for (const event of mapStreamMessageToEvents(message, state)) {
+          emitOnce(event.type === "error"
+            ? { ...event, message: redactSecrets(event.message, profile.tokenEnv, apiKey) }
+            : event);
+        }
+        if (terminalEmitted) break;
+      }
+    } catch (err) {
+      kill();
+      streamProtocolError = err instanceof Error ? err.message : String(err);
+    }
+  } catch (err) {
+    kill();
+    turnError = err instanceof Error ? err.message : String(err);
+  } finally {
+    cleanup();
+  }
+
+  // Reap the process so no zombie is left behind (§三十): wait for the real `close`, and
+  // force-terminate only if it lingers past the grace window after the stream ended.
+  const graceTimer = setTimeout(() => { kill(); }, killGraceMs);
+  let reapTimer: ReturnType<typeof setTimeout> | undefined;
+  await Promise.race([
+    processLifecycle,
+    new Promise<void>(resolve => {
+      reapTimer = setTimeout(resolve, reapTimeoutMs);
+    }),
+  ]);
+  clearTimeout(graceTimer);
+  if (reapTimer) clearTimeout(reapTimer);
+  if (killTimer) clearTimeout(killTimer);
+
+  if (!terminalEmitted) {
+    const stderr = redactSecrets(boundedStderr(stderrChunks), profile.tokenEnv, apiKey);
+    if (incoming.abortSignal?.aborted) {
+      emitOnce({ type: "error", message: `${profile.label} turn was aborted.`, retryable: false });
+    } else if (childProcessError) {
+      emitOnce({
+        type: "error",
+        message: `${profile.label} CLI failed to start: ${redactSecrets(childProcessError.message, profile.tokenEnv, apiKey)}`,
+        status: 500,
+        errorType: "upstream_error",
+        code: "cli_spawn_failed",
+        retryable: false,
+      });
+    } else if (turnError) {
+      emitOnce({
+        type: "error",
+        message: redactSecrets(turnError, profile.tokenEnv, apiKey),
+        status: 502,
+        errorType: "upstream_error",
+      });
+    } else if (streamProtocolError) {
+      emitOnce({
+        type: "error",
+        message: redactSecrets(streamProtocolError, profile.tokenEnv, apiKey),
+        status: 502,
+        errorType: "upstream_error",
+        code: "protocol_error",
+        retryable: false,
+      });
+    } else if (child.exitCode !== null && child.exitCode !== 0) {
+      const exitMsg = stderr
+        ? `${profile.label} CLI exited with code ${child.exitCode}: ${stderr}`
+        : `${profile.label} CLI exited with non-zero exit code ${child.exitCode}`;
+      emitOnce({
+        type: "error",
+        message: exitMsg,
+        status: 502,
+        errorType: "upstream_error",
+        code: "process_exit_error",
+        retryable: false,
+      });
+    } else if (!state.sawTerminalResult) {
+      const msg = stderr
+        ? `${profile.label} CLI ended without a terminal result frame: ${stderr}`
+        : `${profile.label} CLI ended without a terminal result frame`;
+      emitOnce({
+        type: "error",
+        message: msg,
+        status: 502,
+        errorType: "upstream_error",
+        code: "protocol_error",
+        retryable: false,
+      });
+    }
+  }
+}
+
+function boundedStderr(chunks: string[]): string {
+  let total = 0;
+  const kept: string[] = [];
+  for (const chunk of chunks) {
+    if (total >= MAX_STDERR_BYTES) break;
+    kept.push(chunk);
+    total += chunk.length;
+  }
+  return kept.join("").slice(0, MAX_STDERR_BYTES).trim();
+}

package/src/adapters/google.ts

@@ -429,6 +429,18 @@ function messagesToGeminiFormat(
     }
   }
 
+  // Gemini API and Claude-on-Antigravity reject assistant-tail (model-tail in Gemini terms)
+  // histories. Gemini fails upstream with "Requests ending with a model turn are not supported"
+  // (HTTP 400), while Claude fails with "This model does not support assistant message prefill.
+  // The conversation must end with a user message." Context compaction, previous_response_id
+  // expansion, subagent orchestration, and interrupted-turn replay can all produce a
+  // model-tail history. Append a user "(continue)" nudge, mirroring the anthropic adapter's
+  // tail guard (src/adapters/anthropic.ts).
+  const lastTurn = contents.length > 0 ? (contents[contents.length - 1] as { role?: string }) : undefined;
+  if (!lastTurn || lastTurn.role === "model") {
+    contents.push({ role: "user", parts: [{ text: "(continue)" }] });
+  }
+
   return { systemInstruction, contents, replayedCallIds };
 }
 
@@ -894,17 +906,9 @@ export function createGoogleAdapter(provider: OcxProviderConfig): ProviderAdapte
           // fills a first functionCall that replay could not sign. Outside the cache branch too,
           // because the turn still needs a signature when no session was ever recorded.
           applyAntigravityThoughtSignatureFallback(wireModelId, contents);
-          // Claude-on-Antigravity rejects assistant-tail (model-tail in Gemini terms) histories
-          // as prefill: "This model does not support assistant message prefill. The conversation
-          // must end with a user message." Context compaction, previous_response_id expansion,
-          // and interrupted-turn replay can all produce a model-tail history. Append a user
-          // "(continue)" nudge, mirroring the anthropic adapter's tail guard (src/adapters/anthropic.ts).
-          if (/claude/i.test(wireModelId)) {
-            const last = contents.length > 0 ? contents[contents.length - 1] as { role?: string } : undefined;
-            if (!last || last.role === "model") {
-              contents.push({ role: "user", parts: [{ text: "(continue)" }] });
-            }
-          }
+          // The model-tail "(continue)" guard runs once, in messagesToGeminiFormat, so CCA,
+          // Vertex and AI Studio share one decision. A second check here would append a
+          // duplicate nudge whenever signature sanitization reshapes the tail afterwards.
         }
         const envelope = {
           model: wireModelId,

package/src/adapters/mimo-free.ts

@@ -110,6 +110,7 @@ async function fetchJwt(signal?: AbortSignal): Promise<string> {
   const combined = signal ? AbortSignal.any([signal, timeout]) : timeout;
   const response = await fetch(BOOTSTRAP_URL, {
     method: "POST",
+    redirect: "manual",
     headers: {
       "Content-Type": "application/json",
       "User-Agent": randomUserAgent(),
@@ -249,6 +250,7 @@ export function createMimoFreeAdapter(provider: OcxProviderConfig): ProviderAdap
     async fetchResponse(request: AdapterRequest, ctx): Promise<Response> {
       const response = await fetch(request.url, {
         method: request.method,
+        redirect: "manual",
         headers: request.headers as Record<string, string>,
         body: request.body,
         signal: ctx?.abortSignal,
@@ -268,6 +270,7 @@ export function createMimoFreeAdapter(provider: OcxProviderConfig): ProviderAdap
         };
         return fetch(request.url, {
           method: request.method,
+          redirect: "manual",
           headers: retryHeaders,
           body: request.body,
           signal: ctx?.abortSignal,

package/src/adapters/openai-chat.ts

@@ -27,7 +27,7 @@ import {
   type ResolvedFastPolicy,
 } from "../providers/fastwire";
 import { openaiChatCompletionsUrl } from "./openai-chat-url";
-import { stripResponsesOnlyEncryptedMarker } from "./responses-tool-schema";
+import { stripResponsesOnlyEncryptedMarker, stripUnicodePropertyPatterns } from "./responses-tool-schema";
 import { agentRouterDefaultHeaders, frameAgentRouterMessages } from "./agentrouter";
 import {
   isXaiSchemaTarget,
@@ -1331,7 +1331,7 @@ function toolsToChatFormat(parsed: OcxParsedRequest, provider: OcxProviderConfig
       : moonshotTarget
         ? normalizeMoonshotToolParameters(t.parameters)
         : ensureRootObjectType(t.parameters);
-    const parameters = stripResponsesOnlyEncryptedMarker(normalized);
+    const parameters = stripUnicodePropertyPatterns(stripResponsesOnlyEncryptedMarker(normalized));
 
     if (parameters === undefined) return [];
     return [{

package/src/adapters/openai-responses.ts

@@ -25,6 +25,7 @@ import { rewriteRoutedToolSearchForUpstream } from "../responses/tool-search-com
 import { rewriteRoutedNamespaceToolsForUpstream } from "../responses/namespace-tool-compat";
 import { openaiResponsesUrl } from "./openai-responses-url";
 import { normalizeResponsesCodeMode } from "./responses-code-mode";
+import { stripUnicodePropertyPatterns } from "./responses-tool-schema";
 import { injectXaiResponsesXSearch, normalizeXaiResponsesWebSearch } from "./xai-web-search";
 import { EMPTY_TOOL_OUTPUT_ANNOTATION, isWhitespaceOnlyTextPartArray } from "./empty-tool-output-annotation";
 import {
@@ -649,14 +650,18 @@ function mapRoutedResponsesReasoningEffort(
 
 function normalizeFunctionToolSchema(tool: unknown, xaiTarget: boolean): unknown | undefined {
   if (!isPlainObject(tool) || tool.type !== "function") return tool;
+  // Runs for every Responses destination, forward auth included: the ChatGPT backend is where
+  // the `\p{…}` rejection was observed, and it reaches this function through the same seam.
+  const compatible = stripUnicodePropertyPatterns(tool);
+  const source = isPlainObject(compatible) ? compatible : tool;
   if (xaiTarget) {
-    const parameters = normalizeXaiToolParameters(isPlainObject(tool.parameters) ? tool.parameters : {});
-    return parameters === undefined ? undefined : { ...tool, parameters };
+    const parameters = normalizeXaiToolParameters(isPlainObject(source.parameters) ? source.parameters : {});
+    return parameters === undefined ? undefined : { ...source, parameters };
   }
-  if (isPlainObject(tool.parameters) && tool.parameters.type === "object") return tool;
+  if (isPlainObject(source.parameters) && source.parameters.type === "object") return source;
   return {
-    ...tool,
-    parameters: { ...(isPlainObject(tool.parameters) ? tool.parameters : {}), type: "object" },
+    ...source,
+    parameters: { ...(isPlainObject(source.parameters) ? source.parameters : {}), type: "object" },
   };
 }
 
@@ -2134,6 +2139,7 @@ const MUSE_SPARK_WEB_SEARCH_STRICT_MODELS = new Set([
 const MUSE_SPARK_WEB_SEARCH_STRICT_RESPONSE_URLS = new Set([
   "https://opencode.ai/zen/v1/responses",
   "https://opencode.ai/zen/go/v1/responses",
+  "https://api.meta.ai/v1/responses",
 ]);
 
 const MUSE_SPARK_UNSUPPORTED_WEB_SEARCH_FIELDS = [
@@ -2142,12 +2148,13 @@ const MUSE_SPARK_UNSUPPORTED_WEB_SEARCH_FIELDS = [
 ] as const;
 
 /**
- * OpenCode Zen / Go Muse Spark Responses gateway refuses a short list of Codex
- * `web_search` fields. `web_search_preview` keeps its accepted shape, and Luna
- * remains untouched. Match the exact effective request URL; malformed, credentialed,
- * or parameterized destinations keep their original body instead of assuming this
- * gateway contract. Keep the rejected names together so a newly identified field is
- * a one-line compatibility update rather than another bespoke rewrite.
+ * OpenCode Zen / Go and the direct Meta Muse Spark Responses gateways refuse a
+ * short list of Codex `web_search` fields. `web_search_preview` keeps its accepted
+ * shape, and Luna remains untouched. Match the exact effective request URL;
+ * malformed, credentialed, or parameterized destinations keep their original body
+ * instead of assuming this gateway contract. Keep the rejected names together so a
+ * newly identified field is a one-line compatibility update rather than another
+ * bespoke rewrite.
  */
 function stripMuseSparkUnsupportedWebSearchFields(
   body: unknown,

package/src/adapters/qoder/adapter.ts

@@ -0,0 +1,70 @@
+import type { AdapterEvent, OcxParsedRequest, OcxProviderConfig } from "../../types";
+import type { AdapterRequest, ProviderAdapter } from "../base";
+import { mapReasoningEffort } from "../../reasoning-effort";
+import { buildSystemPrompt } from "../coding-agent/protocol";
+import { baseScopedEnv, runCodingAgentTurn, type CodingAgentDeps } from "../coding-agent/turn";
+import { QODER_PROFILES, type QoderProfile } from "./profiles";
+
+export type QoderAdapterDeps = CodingAgentDeps;
+
+export function buildQoderChildEnv(profile: QoderProfile, apiKey: string): Record<string, string> {
+  return { ...baseScopedEnv(), NO_COLOR: "1", [profile.tokenEnv]: apiKey };
+}
+
+/** Single-shot, tools-disabled Qoder CLI invocation; Codex remains the tool owner. */
+export function buildQoderArgs(parsed: OcxParsedRequest, provider: OcxProviderConfig): string[] {
+  const args = [
+    "-p",
+    "--output-format", "stream-json",
+    "--input-format", "stream-json",
+    "--tools", "",
+    "--strict-mcp-config",
+    "--setting-sources", "",
+    "--max-turns", "1",
+    "--no-session-persistence",
+    "--model", parsed.modelId,
+  ];
+  const effort = mapReasoningEffort(provider, parsed.modelId, parsed.options.reasoning);
+  if (effort) args.push("--reasoning-effort", effort);
+  const system = buildSystemPrompt(parsed);
+  if (system) args.push("--append-system-prompt", system);
+  return args;
+}
+
+export function createQoderAdapter(provider: OcxProviderConfig, deps: QoderAdapterDeps = {}): ProviderAdapter {
+  return {
+    name: "qoder",
+    buildRequest(): AdapterRequest {
+      return { url: provider.baseUrl, method: "POST", headers: {}, body: "" };
+    },
+    async *parseStream(): AsyncGenerator<AdapterEvent> {
+      yield { type: "error", message: "Qoder adapter uses runTurn; the fetch/parseStream path is disabled." };
+    },
+    async runTurn(parsed, incoming, emit): Promise<void> {
+      const hasImage = parsed.context.messages.some(message =>
+        Array.isArray(message.content) && message.content.some(part => part.type === "image"),
+      );
+      if (hasImage) {
+        emit({
+          type: "error",
+          message: "Qoder image input is not enabled because the CLI provider route has no verified multimodal contract.",
+          status: 400,
+          errorType: "invalid_request_error",
+          code: "unsupported_input_modality",
+          retryable: false,
+        });
+        return;
+      }
+      await runCodingAgentTurn({
+        profiles: QODER_PROFILES,
+        provider,
+        parsed,
+        incoming,
+        emit,
+        buildArgs: (_profile, req, prov) => buildQoderArgs(req, prov),
+        buildEnv: (profile, apiKey) => buildQoderChildEnv(profile as QoderProfile, apiKey),
+        deps,
+      });
+    },
+  };
+}

package/src/adapters/qoder/live-models.ts

@@ -0,0 +1,89 @@
+import { execFile } from "node:child_process";
+import { commandInvocation } from "../../lib/win-exec";
+import { isValidModelDiscoveryModelId } from "../../providers/model-discovery-limits";
+import { baseScopedEnv, redactSecrets } from "../coding-agent/turn";
+import { resolveCodingAgentBinary, type WhichFn } from "../coding-agent/profile";
+import type { QoderProfile } from "./profiles";
+
+const MAX_OUTPUT_BYTES = 256 * 1024;
+const MAX_MODELS = 256;
+
+export type QoderModelsResult =
+  | { ok: true; models: string[] }
+  | { ok: false; error: "auth" | "cli_not_found" | "timeout" | "process" | "invalid_output" | "empty" | "too_large"; detail?: string };
+
+export interface QoderExecResult { stdout: string; stderr: string }
+export type QoderExecFn = (
+  command: string,
+  args: readonly string[],
+  options: { env: Record<string, string>; timeout: number; maxBuffer: number; windowsHide: boolean; windowsVerbatimArguments?: boolean },
+) => Promise<QoderExecResult>;
+
+export interface QoderModelsDeps {
+  which?: WhichFn;
+  platform?: NodeJS.Platform;
+  timeoutMs?: number;
+  exec?: QoderExecFn;
+}
+
+type QoderModelsFetcher = (profile: QoderProfile, apiKey: string) => QoderModelsResult | Promise<QoderModelsResult>;
+let qoderModelsFetcherForTests: QoderModelsFetcher | null = null;
+
+export function setFetchQoderModelsForTests(next: QoderModelsFetcher | null): void {
+  qoderModelsFetcherForTests = next;
+}
+
+export function parseQoderModelList(stdout: string): QoderModelsResult {
+  if (Buffer.byteLength(stdout) > MAX_OUTPUT_BYTES) return { ok: false, error: "too_large" };
+  const lines = stdout.split(/\r?\n/);
+  const header = lines.findIndex(raw => /^model$/i.test(raw.trim()));
+  if (header < 0) return { ok: false, error: "invalid_output", detail: "Qoder model list header is missing" };
+  const models: string[] = [];
+  const seen = new Set<string>();
+  for (const raw of lines.slice(header + 1)) {
+    const id = raw.trim();
+    if (!id || seen.has(id) || !isValidModelDiscoveryModelId(id)) continue;
+    seen.add(id);
+    models.push(id);
+    if (models.length >= MAX_MODELS) break;
+  }
+  return models.length > 0 ? { ok: true, models } : { ok: false, error: "empty" };
+}
+
+function execQoder(command: string, args: readonly string[], options: Parameters<QoderExecFn>[2]): Promise<QoderExecResult> {
+  return new Promise((resolve, reject) => {
+    execFile(command, [...args], { ...options, encoding: "utf8" }, (error, stdout, stderr) => {
+      if (error) {
+        reject(Object.assign(error, { stdout, stderr }));
+        return;
+      }
+      resolve({ stdout, stderr });
+    });
+  });
+}
+
+/** Discover the roster exposed to this exact PAT via the documented `--list-models` command. */
+export async function fetchQoderModels(profile: QoderProfile, apiKey: string, deps: QoderModelsDeps = {}): Promise<QoderModelsResult> {
+  if (qoderModelsFetcherForTests) return qoderModelsFetcherForTests(profile, apiKey);
+  const binary = resolveCodingAgentBinary(profile, deps.which);
+  if (!binary) return { ok: false, error: "cli_not_found", detail: profile.installHint };
+  const env = { ...baseScopedEnv(), NO_COLOR: "1", [profile.tokenEnv]: apiKey };
+  const invocation = commandInvocation(binary, ["--list-models"], deps.platform ?? process.platform, { env });
+  try {
+    const result = await (deps.exec ?? execQoder)(invocation.file, invocation.args, {
+      ...invocation.options,
+      env,
+      timeout: deps.timeoutMs ?? 8_000,
+      maxBuffer: MAX_OUTPUT_BYTES,
+      windowsHide: true,
+    });
+    return parseQoderModelList(result.stdout);
+  } catch (error) {
+    const failure = error as NodeJS.ErrnoException & { killed?: boolean; stderr?: string };
+    const stderr = redactSecrets(failure.stderr ?? failure.message ?? String(error), profile.tokenEnv, apiKey).trim().slice(0, 512);
+    if (failure.killed || failure.code === "ETIMEDOUT") return { ok: false, error: "timeout", detail: "Qoder model discovery timed out" };
+    if (failure.code === "ERR_CHILD_PROCESS_STDIO_MAXBUFFER") return { ok: false, error: "too_large" };
+    const auth = /not logged in|invalid (?:personal access )?token|authentication/i.test(stderr);
+    return { ok: false, error: auth ? "auth" : "process", ...(stderr ? { detail: stderr } : {}) };
+  }
+}