@midhunxavier/code-flow 0.0.0-stage → 0.1.0-preview.3

package/src/adapters/codex.js

@@ -0,0 +1,311 @@
+import { prepareAgentTools } from "./agent-tools.js";
+import { discoverModels } from "./model-discovery.js";
+import { managedPermissionProblem } from "./managed-permissions.js";
+import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { homedir, tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import { codexTransport } from "../config.js";
+import { logWarn } from "../log.js";
+import { runAppServerTurn } from "./codex-app-server.js";
+import { classifyError, cliErrorLine, resetFromText } from "./errors.js";
+import { captureOutput, commandExists, describeFailure, processErrorKind, startJsonlProcess, stringify, truncate, unknownEvents } from "./process.js";
+import { adapterTeamCapabilities, prepareTeamTools } from "./team-tools.js";
+const appServerCheck = {};
+const RECHECK_MS = 10 * 6e4;
+const codexAdapter = {
+  id: "codex",
+  discoverModels: (context) => discoverModels("codex", context),
+  displayName: "Codex",
+  binary: "codex",
+  available: () => commandExists("codex"),
+  async catalog() {
+    const raw = JSON.parse(await captureOutput("codex", ["debug", "models"]));
+    const models = (raw.models ?? []).filter((m) => m.slug && m.visibility !== "hide").sort((a, b) => (a.priority ?? 999) - (b.priority ?? 999)).map((m) => ({
+      id: m.slug,
+      label: m.display_name ?? m.slug,
+      efforts: (m.supported_reasoning_levels ?? []).map((l) => l.effort).filter(Boolean),
+      defaultEffort: m.default_reasoning_level
+    }));
+    const config = await readFile(join(process.env.CODEX_HOME ?? join(homedir(), ".codex"), "config.toml"), "utf8").catch(() => "");
+    const efforts = [...new Set(models.flatMap((m) => m.efforts ?? []))];
+    return {
+      models,
+      efforts: efforts.length ? efforts : ["low", "medium", "high"],
+      defaultModel: topLevelTomlString(config, "model"),
+      defaultEffort: topLevelTomlString(config, "model_reasoning_effort"),
+      allowCustom: true
+    };
+  },
+  async run(opts, onEvent) {
+    const permissionProblem = await managedPermissionProblem("codex", opts);
+    if (permissionProblem) return permissionProblem;
+    const supportsTools = !opts.agentContainer && opts.teamTools && (await adapterTeamCapabilities("codex")).scopedTools === "tested";
+    const teamTools = supportsTools ? await prepareTeamTools(opts.teamTools) : void 0;
+    const agentTools = opts.agentTools && !opts.agentContainer && opts.permissions?.externalTools !== "disabled" ? await prepareAgentTools(opts.agentTools) : void 0;
+    if (opts.agentContainer) onEvent({ kind: "status", text: `Codex runs in Docker image ${opts.agentContainer.image}. Live team tools are unavailable in containers; use structured outcomes and next-turn replies.` });
+    else if (opts.teamTools && !teamTools) onEvent({ kind: "status", text: "This Codex CLI has no verified per-turn team tools; use structured outcomes and next-turn replies." });
+    try {
+      const sandbox = opts.mode === "read" ? "read-only" : opts.trust === "full" ? "danger-full-access" : "workspace-write";
+      const network = opts.permissions && sandbox !== "danger-full-access" ? ["-c", `sandbox_workspace_write.network_access=${opts.permissions.commandNetwork === "allowed"}`] : opts.mode === "write" && opts.trust === "trusted" ? ["-c", "sandbox_workspace_write.network_access=true"] : [];
+      const managedSandbox = opts.permissions && sandbox !== "danger-full-access" ? ["-c", "sandbox_workspace_write.writable_roots=[]", ...opts.permissions.required.includes("workspace-writes") ? ["-c", "sandbox_workspace_write.exclude_slash_tmp=true", "-c", "sandbox_workspace_write.exclude_tmpdir_env_var=true"] : []] : [];
+      const nativeTools = [...teamTools?.codexConfig ?? [], ...agentTools?.codexConfig ?? []];
+      const teamConfig = [...nativeTools, ...opts.questionProtocol === "structured" || opts.permissions?.nativeDelegation === false ? ["-c", "agents.enabled=false", "-c", "features.multi_agent=false", "-c", "features.multi_agent_v2.enabled=false", "-c", "features.hooks=false"] : []];
+      const transport = codexTransport();
+      let sessionId;
+      let finalText = "";
+      let turnError;
+      let turnErrorKind;
+      let lastError;
+      let lastErrorKind;
+      let completed = false;
+      let resultSeen = () => {
+      };
+      const unknown = unknownEvents("codex");
+      const unknownItems = /* @__PURE__ */ new Set();
+      const unknownItem = (type, id) => {
+        if (id && unknownItems.has(id)) return;
+        if (id) unknownItems.add(id);
+        unknown.add(type);
+      };
+      const handle = (msg) => {
+        switch (msg.type) {
+          case "thread.started":
+            if (!msg.thread_id) break;
+            sessionId = msg.thread_id;
+            onEvent({ kind: "session", sessionId: msg.thread_id });
+            break;
+          case "turn.started":
+            break;
+          case "item.started":
+          case "item.updated":
+          case "item.completed":
+            handleItem(msg.type, msg.item, onEvent, (text) => finalText = text, unknownItem);
+            break;
+          case "item.delta":
+            if (msg.item.type === "command_execution") onEvent({ kind: "tool_result", callId: msg.item.id, output: msg.item.text, isError: false, delta: true });
+            else onEvent({ kind: msg.item.type === "reasoning" ? "thinking" : "text", messageId: msg.item.id, text: msg.item.text, delta: true });
+            break;
+          case "turn.completed": {
+            completed = true;
+            resultSeen();
+            const cached = msg.usage?.cached_input_tokens ?? 0;
+            onEvent({
+              kind: "usage",
+              // Codex counts cached input inside input_tokens.
+              inputTokens: msg.usage?.input_tokens !== void 0 ? Math.max(0, msg.usage.input_tokens - cached) : void 0,
+              outputTokens: msg.usage?.output_tokens,
+              cacheReadTokens: cached || void 0
+            });
+            break;
+          }
+          case "turn.failed":
+            resultSeen();
+            turnError = msg.error?.message ?? lastError ?? "Codex turn failed";
+            turnErrorKind = msg.error?.kind ?? (msg.error?.message ? void 0 : lastErrorKind);
+            break;
+          case "error":
+            lastError = msg.message ?? stringify(msg);
+            lastErrorKind = msg.kind;
+            onEvent({ kind: "status", text: `Codex: ${lastError}` });
+            break;
+          // A notification app-server sent that its client doesn't know (codex-app-server.ts).
+          case "unrecognized":
+            unknown.add(msg.name);
+            break;
+          default:
+            unknown.add(msg.type);
+        }
+      };
+      const onText = (line) => onEvent({ kind: "status", text: line });
+      let outcome;
+      let schemaFile;
+      const missing = appServerCheck.missing && Date.now() - appServerCheck.missing.at < RECHECK_MS ? appServerCheck.missing : void 0;
+      if (transport === "app-server" || transport === "auto" && !missing) {
+        const served = await runAppServerTurn({
+          prompt: opts.prompt,
+          cwd: opts.cwd,
+          sandbox,
+          resumeThreadId: opts.resumeSessionId,
+          forkThreadId: !opts.resumeSessionId ? opts.forkSessionId : void 0,
+          model: opts.model,
+          effort: opts.effort,
+          outputSchema: opts.jsonSchema,
+          questionProtocol: opts.questionProtocol,
+          config: [...network, ...teamConfig, ...managedSandbox],
+          threadConfig: { ...teamTools?.codexThreadConfig, ...agentTools?.codexThreadConfig, ...Object.fromEntries([...network, ...teamConfig.slice(nativeTools.length), ...managedSandbox].filter((v) => v !== "-c").map((v) => {
+            const split = v.indexOf("=");
+            return [v.slice(0, split), JSON.parse(v.slice(split + 1))];
+          })) },
+          signal: opts.signal,
+          timeoutMs: opts.timeoutMs,
+          idleTimeoutMs: opts.idleTimeoutMs,
+          isPaused: opts.isPaused,
+          onMessage: handle,
+          onText,
+          onSteerable: opts.onSteerable,
+          interactiveApprovals: opts.interactiveApprovals,
+          onApproval: opts.onApproval,
+          onQuestion: opts.onQuestion,
+          agentContainer: opts.agentContainer
+        });
+        if (!("unavailable" in served)) {
+          outcome = served;
+          appServerCheck.missing = void 0;
+        } else if (transport === "app-server") {
+          const error = `codex app-server isn't available (${served.unavailable}); unset CODEFLOW_CODEX_TRANSPORT to fall back to codex exec`;
+          onEvent({ kind: "error", message: error });
+          return { ok: false, finalText, error, errorKind: "cli_incompatible" };
+        } else {
+          if (!appServerCheck.missing) logWarn("codex app-server isn't available; using codex exec", { reason: served.unavailable });
+          appServerCheck.missing = { reason: served.unavailable, at: Date.now() };
+          sessionId = void 0;
+          onEvent({ kind: "status", text: `codex app-server isn't available (${served.unavailable.split("\n")[0]}); using codex exec \u2014 your messages wait for the next turn` });
+        }
+      }
+      if (!outcome) {
+        if (opts.permissions?.toolApprovals) return { ok: false, finalText: "", error: "This run requires interactive approvals; Codex exec cannot preserve them. Use an available app-server transport.", errorKind: "cli_incompatible" };
+        if (opts.interactiveApprovals) onEvent({ kind: "status", text: "Native tool approvals require Codex app-server; this exec turn remains headless." });
+        const common = ["--json", "--skip-git-repo-check", ...opts.permissions ? ["-c", 'approval_policy="never"'] : [], "-c", `sandbox_mode="${sandbox}"`, ...network, ...teamConfig, ...managedSandbox];
+        if (opts.model) common.push("-m", opts.model);
+        if (opts.effort) common.push("-c", `model_reasoning_effort="${opts.effort}"`);
+        schemaFile = opts.jsonSchema ? await writeSchemaFile(opts.jsonSchema) : void 0;
+        if (schemaFile) common.push("--output-schema", schemaFile);
+        const args = opts.resumeSessionId ? ["exec", "resume", ...common, opts.resumeSessionId, "-"] : ["exec", ...common, "-C", opts.cwd, "-"];
+        const proc = startJsonlProcess({
+          command: "codex",
+          args,
+          input: opts.prompt,
+          cwd: opts.cwd,
+          signal: opts.signal,
+          timeoutMs: opts.timeoutMs,
+          idleTimeoutMs: opts.idleTimeoutMs,
+          isPaused: opts.isPaused,
+          onText,
+          onJson: handle,
+          agentContainer: opts.agentContainer ? { config: opts.agentContainer, mode: opts.mode, readOnly: schemaFile ? [schemaFile] : void 0 } : void 0
+        });
+        resultSeen = () => proc.resultSeen();
+        outcome = await proc.outcome;
+      }
+      if (schemaFile) await rm(dirname(schemaFile), { recursive: true, force: true }).catch(() => void 0);
+      const unknownCount = unknown.count;
+      const drift = unknown.report();
+      if (drift) onEvent({ kind: "status", text: drift });
+      if (!completed || turnError || outcome.aborted) {
+        const stopped = processErrorKind(outcome);
+        const said = turnError ?? (stopped ? void 0 : lastError);
+        const error = said ?? describeFailure("codex", outcome);
+        const stderrLine = cliErrorLine(outcome.stderr);
+        const fromText = classifyError(said);
+        const errorKind = stopped ?? (turnError ? turnErrorKind : lastErrorKind) ?? (turnError || fromText !== "other" ? fromText : classifyError(stderrLine));
+        const resetsAt = errorKind === "usage_limit" ? resetFromText(said) ?? (turnError ? void 0 : resetFromText(stderrLine)) : void 0;
+        onEvent({ kind: "error", message: error });
+        return {
+          ok: false,
+          finalText,
+          sessionId: errorKind === "session_not_found" ? void 0 : sessionId,
+          error,
+          errorKind,
+          ...resetsAt && { resetsAt }
+        };
+      }
+      if (!finalText.trim() && unknownCount) {
+        const error = "Codex finished the turn, but code-flow didn't recognise its output, so its answer is missing. Update codex-cli or code-flow.";
+        onEvent({ kind: "error", message: error });
+        return { ok: false, finalText, sessionId, error, errorKind: "cli_incompatible" };
+      }
+      let structured;
+      if (opts.jsonSchema) {
+        try {
+          structured = JSON.parse(finalText);
+        } catch {
+        }
+      }
+      return { ok: true, finalText, sessionId, structured };
+    } finally {
+      await teamTools?.cleanup();
+      await agentTools?.cleanup();
+    }
+  }
+};
+async function writeSchemaFile(schema) {
+  const dir = await mkdtemp(join(tmpdir(), "codeflow-schema-"));
+  const file = join(dir, "schema.json");
+  await writeFile(file, JSON.stringify(schema));
+  return file;
+}
+function topLevelTomlString(toml, key) {
+  const top = toml.split(/^\s*\[/m)[0] ?? "";
+  return top.match(new RegExp(`^\\s*${key}\\s*=\\s*"([^"]*)"`, "m"))?.[1];
+}
+function handleItem(phase, item, onEvent, setFinal, unknown) {
+  if (!item) return;
+  const done = phase === "item.completed";
+  switch (item.type) {
+    case "agent_message":
+      if (done && item.text) {
+        setFinal(item.text);
+        onEvent({ kind: "text", text: item.text, messageId: item.id, phase: item.phase });
+      } else if (done && typeof item.text !== "string") {
+        unknown("agent_message without text", item.id);
+      }
+      break;
+    case "reasoning":
+      if (done && item.text) onEvent({ kind: "thinking", text: item.text, messageId: item.id });
+      break;
+    case "command_execution":
+      if (phase === "item.started") {
+        onEvent({ kind: "tool_call", callId: item.id, name: "shell", input: item.command });
+      } else if (done) {
+        onEvent({
+          kind: "tool_result",
+          callId: item.id,
+          output: truncate(item.aggregated_output ?? ""),
+          isError: item.exit_code !== 0 && item.exit_code != null || item.status === "declined"
+        });
+      }
+      break;
+    case "file_change":
+      if (done) {
+        const changes = (item.changes ?? []).map((c) => `${c.kind} ${c.path}`).join("\n");
+        onEvent({ kind: "tool_call", callId: item.id, name: "file_change", input: changes });
+        onEvent({ kind: "tool_result", callId: item.id, output: item.status ?? "", isError: item.status === "failed" || item.status === "declined" });
+      }
+      break;
+    case "mcp_tool_call":
+      if (phase === "item.started") {
+        onEvent({
+          kind: "tool_call",
+          callId: item.id,
+          name: `${item.server}.${item.tool}`,
+          input: truncate(stringify(item.arguments ?? ""), 2e3)
+        });
+      } else if (done) {
+        onEvent({
+          kind: "tool_result",
+          callId: item.id,
+          output: truncate(Array.isArray(item.result?.content) ? item.result.content.map((content) => content.type === "text" ? content.text : `[${content.type}${content.mimeType ? `: ${content.mimeType}` : ""}]`).join("\n") : stringify(item.result ?? item.error ?? "")),
+          isError: item.status === "failed"
+        });
+      }
+      break;
+    case "web_search":
+      if (done) onEvent({ kind: "status", text: `web search: ${item.query ?? ""}` });
+      break;
+    case "todo_list":
+      if (done) {
+        const todos = (item.items ?? []).map((t) => `${t.completed ? "\u2713" : "\u25CB"} ${t.text}`).join("\n");
+        onEvent({ kind: "status", text: todos });
+      }
+      break;
+    case "error":
+      if (done) onEvent({ kind: "error", message: item.message ?? "error" });
+      break;
+    default:
+      unknown(`${item.type === "unrecognized" ? item.name ?? "(no type)" : item.type} item`, item.id);
+  }
+}
+export {
+  appServerCheck,
+  codexAdapter
+};

package/src/adapters/errors.js

@@ -0,0 +1,57 @@
+const status = (codes) => String.raw`\b(?:status|code|http(?:/[\d.]+)?|error)\b[\s:=#]*(?:${codes})\b|\b(?:${codes})\s+(?:unauthorized|too many requests|internal server error|bad gateway|service unavailable|gateway time-?out|overloaded)`;
+const PATTERNS = [
+  // Claude: "No conversation found with session ID: …"; Codex: "no rollout found for thread id …"
+  ["session_not_found", /no conversation found|no rollout found|(?:thread|conversation|session) (?:not found|does not exist)/i],
+  // commander (Claude, agy): "error: unknown option '--x'"; clap (Codex): "error: unexpected argument '--x' found"
+  ["cli_incompatible", /unknown option|unknown flag|unrecognized (?:option|argument|subcommand)|unexpected argument|wasn't expected|invalid value for '--/i],
+  [
+    "auth",
+    new RegExp(String.raw`not logged in|please run /login|run \`?\w+ login\`?|invalid api key|oauth token (?:has )?expired|token (?:has )?expired|login (?:has )?expired|authentication_error|unauthenticated|unauthorized|(?:log|sign) in again|${status("401")}`, "i")
+  ],
+  // Per-minute limits, even when worded as a quota (Google's 429s say "Quota exceeded for quota
+  // metric '… requests per minute'"). Told apart before usage limits, which stop the run and keep
+  // Auto away from the agent until the plan resets: taking a 429 for one costs far more than the
+  // reverse (a retry that fails again).
+  ["rate_limit", /\bper (?:minute|second|min\b)|\brequests per min/i],
+  // Google's RESOURCE_EXHAUSTED is also its per-minute 429: a usage limit only when it says it's the plan's or the day's.
+  ["usage_limit", /RESOURCE_EXHAUSTED[^\n]*(?:daily|per day|plan\b|usage limit)|(?:daily|per day|plan\b|usage limit)[^\n]*RESOURCE_EXHAUSTED/i],
+  [
+    "usage_limit",
+    /usage limit|hit your (?:\w+[ -])?limit|quota (?:exceeded|reached|exhausted)|exceeded (?:your|the) [\w -]{0,30}quota|out of credits|credit balance is too low/i
+  ],
+  // A plan's "limit reached" (below) is a usage limit unless it says "rate".
+  ["rate_limit", new RegExp(String.raw`too many requests|rate.?limit|RESOURCE_EXHAUSTED|${status("429")}`, "i")],
+  // "5-hour limit reached", "Weekly limit reached": not a context, token or turn limit.
+  ["usage_limit", /(?<!\b(?:context|token|tokens|turn|turns|output|length|size|depth|recursion) )limit reached/i],
+  [
+    "transient",
+    new RegExp(
+      String.raw`overloaded|internal server error|bad gateway|service unavailable|gateway timeout|temporar(?:il)?y unavailable|ECONNRESET|ECONNREFUSED|ETIMEDOUT|EAI_AGAIN|ENOTFOUND|socket hang up|fetch failed|network error|connection (?:reset|closed|error|refused|failed)|stream disconnected|${status("50[0234]|529")}`,
+      "i"
+    )
+  ]
+];
+function classifyError(text) {
+  if (!text) return "other";
+  return PATTERNS.find(([, re]) => re.test(text))?.[0] ?? "other";
+}
+function cliErrorLine(stderr) {
+  const lines = (stderr ?? "").split("\n").map((l) => l.trim()).filter(Boolean);
+  return [...lines].reverse().find((l) => /^(?:\w+ )?(?:error|fatal|panic)\b/i.test(l)) ?? lines.at(-1) ?? "";
+}
+const UNIT_MS = { d: 864e5, h: 36e5, m: 6e4, s: 1e3 };
+function resetFromText(text, now = Date.now()) {
+  if (!text) return void 0;
+  const epoch = /limit reached\|(\d{10})\b/i.exec(text);
+  if (epoch) return Number(epoch[1]) * 1e3;
+  const after = /try again in ((?:\d+\s*(?:days?|d|hours?|hrs?|h|minutes?|mins?|m|seconds?|secs?|s)\b[\s,]*(?:and\s+)?)+)/i.exec(text);
+  if (!after) return void 0;
+  let ms = 0;
+  for (const [, n, unit] of after[1].matchAll(/(\d+)\s*([a-z]+)/gi)) ms += Number(n) * (UNIT_MS[unit[0].toLowerCase()] ?? 0);
+  return ms ? now + ms : void 0;
+}
+export {
+  classifyError,
+  cliErrorLine,
+  resetFromText
+};

package/src/adapters/index.js

@@ -0,0 +1,91 @@
+import { claudeAdapter } from "./claude.js";
+import { codexAdapter } from "./codex.js";
+import { agyAdapter } from "./agy.js";
+export * from "./types.js";
+const adapters = {
+  claude: claudeAdapter,
+  codex: codexAdapter,
+  agy: agyAdapter
+};
+const AGENT_IDS = Object.keys(adapters);
+function isAgentId(value) {
+  return typeof value === "string" && Object.hasOwn(adapters, value);
+}
+function getAdapter(id) {
+  if (!Object.hasOwn(adapters, id) || !adapters[id]) throw new Error(`Provider ${id} is unavailable; restore its pinned extension or choose an installed provider`);
+  return adapters[id];
+}
+function registerProviderAdapters(providers) {
+  const ids = providers.map((provider) => provider.id);
+  if (new Set(ids).size !== ids.length || ids.some((id) => !id.startsWith("plugin:") || Object.hasOwn(adapters, id))) throw new Error("Provider IDs must be unique and cannot replace installed adapters");
+  for (const provider of providers) {
+    adapters[provider.id] = Object.freeze({ ...provider });
+    AGENT_IDS.push(provider.id);
+  }
+}
+function replaceAcpAdapters(providers) {
+  if (providers.some((provider) => !provider.id.startsWith("acp:")) || new Set(providers.map((provider) => provider.id)).size !== providers.length) throw new Error("Invalid ACP provider registration");
+  for (const id of AGENT_IDS.filter((id2) => id2.startsWith("acp:"))) {
+    delete adapters[id];
+    catalogCache.delete(id);
+  }
+  AGENT_IDS.splice(0, AGENT_IDS.length, ...AGENT_IDS.filter((id) => !id.startsWith("acp:")));
+  for (const provider of providers) {
+    adapters[provider.id] = Object.freeze({ ...provider });
+    AGENT_IDS.push(provider.id);
+  }
+}
+const CATALOG_TTL_MS = 10 * 6e4;
+const catalogCache = /* @__PURE__ */ new Map();
+function agentCatalog(id) {
+  const cached = catalogCache.get(id);
+  if (cached && Date.now() - cached.at < CATALOG_TTL_MS) return cached.value;
+  const value = getAdapter(id).catalog();
+  catalogCache.set(id, { at: Date.now(), value });
+  value.catch(() => catalogCache.delete(id));
+  return value;
+}
+const MODEL_RE = /^[A-Za-z0-9][\w.:/[\]@-]{0,99}$/;
+const EFFORT_RE = /^[a-z]{2,12}$/;
+function validateAgentSettings(input) {
+  const raw = input && typeof input === "object" ? input : {};
+  const settings = {};
+  for (const id of AGENT_IDS) {
+    const model = typeof raw[id]?.model === "string" ? raw[id].model.trim() : "";
+    const effort = typeof raw[id]?.effort === "string" ? raw[id].effort.trim() : "";
+    if (model && !(id.startsWith("acp:") ? model.length <= 256 && !/[\x00-\x1f\x7f]/.test(model) : MODEL_RE.test(model))) throw new Error(`Invalid model name for ${getAdapter(id).displayName}: "${model}"`);
+    if (effort && !(id.startsWith("acp:") ? effort.length <= 64 && !/[\x00-\x1f\x7f]/.test(effort) : EFFORT_RE.test(effort))) throw new Error(`Invalid effort for ${getAdapter(id).displayName}: "${effort}"`);
+    if (model || effort) settings[id] = { ...model && { model }, ...effort && { effort } };
+    if (raw[id]?.variants !== void 0) {
+      if (!Array.isArray(raw[id].variants) || raw[id].variants.length > 128) throw new Error("Choose at most 128 additional models per provider");
+      const variants = raw[id].variants.map((value) => {
+        if (!value || typeof value.model !== "string" || !value.model.trim() || value.variants !== void 0) throw new Error("Each additional agent needs a model");
+        const valid = validateAgentSettings({ [id]: { model: value.model, effort: value.effort } })[id];
+        return { model: valid.model, ...valid.effort ? { effort: valid.effort } : {} };
+      });
+      settings[id] = { ...settings[id], variants };
+    }
+  }
+  return settings;
+}
+async function agentAvailability() {
+  return Promise.all(
+    AGENT_IDS.map(async (id) => ({
+      id,
+      displayName: getAdapter(id).displayName,
+      binary: getAdapter(id).binary,
+      available: await getAdapter(id).available()
+    }))
+  );
+}
+export {
+  AGENT_IDS,
+  adapters,
+  agentAvailability,
+  agentCatalog,
+  getAdapter,
+  isAgentId,
+  registerProviderAdapters,
+  replaceAcpAdapters,
+  validateAgentSettings
+};

package/src/adapters/managed-permissions.js

@@ -0,0 +1,37 @@
+import { captureOutput, runJsonlProcess } from "./process.js";
+async function managedPermissionProblem(provider, opts) {
+  const p = opts.permissions;
+  if (!p) return;
+  const fail = (error) => ({ ok: false, finalText: "", error, errorKind: "cli_incompatible" });
+  if (p.nativeDelegation !== false && !opts.conversation || p.provider !== provider || p.trust !== (opts.trust ?? "standard") || p.mode !== opts.mode || p.toolApprovals !== !!opts.interactiveApprovals) return fail("Adapter options do not match the resolved run permission policy");
+  if (p.toolApprovals && (!["codex", "claude"].includes(provider) || !opts.onApproval)) return fail("The required interactive approval handler is unavailable");
+  try {
+    const probe = async (args) => {
+      if (!opts.agentContainer) return captureOutput(provider, args, 5e3);
+      let text = "";
+      const result = await runJsonlProcess({ command: provider, args, cwd: opts.cwd, signal: opts.signal, timeoutMs: 5e3, agentContainer: { config: opts.agentContainer, mode: "read" }, onText: (line) => {
+        text += line + "\n";
+      }, onJson: (value) => {
+        text += JSON.stringify(value) + "\n";
+      } });
+      if (result.exitCode !== 0 || result.aborted || result.timedOut || text.length > 128e3) throw new Error("Container CLI capability probe failed");
+      return text;
+    };
+    const help = await probe(["--help"]);
+    let nested = p.nativeDelegation || provider === "claude" && ["--disallowedTools", "--settings"].every((flag) => help.includes(flag));
+    if (provider === "codex" && !p.nativeDelegation) {
+      const version = (await probe(["--version"])).match(/codex-cli (\d+)\.(\d+)\.(\d+)/);
+      if (!version || Number(version[1]) === 0 && (Number(version[2]) < 162 || Number(version[2]) === 162 && Number(version[3]) < 1)) return fail("codex: managed delegation requires CLI 0.162.1 or newer (agents.enabled control)");
+      const features = await probe(["features", "list", "-c", "agents.enabled=false", "-c", "features.multi_agent=false", "-c", "features.multi_agent_v2.enabled=false"]);
+      nested = ["multi_agent", "multi_agent_v2"].every((key) => new RegExp(`^${key}\\s+\\S+\\s+false\\s*$`, "m").test(features));
+    }
+    const external = provider === "claude" && ["--mcp-config", "--strict-mcp-config", "--disallowedTools", "--no-chrome"].every((flag) => help.includes(flag));
+    if (!nested) return fail(`${provider}: installed CLI cannot confirm native-delegation controls; update it before launching this managed run`);
+    if (p.externalTools === "disabled" && !external) return fail(`${provider}: installed CLI cannot confirm external-tool isolation`);
+  } catch (error) {
+    return fail(`Could not verify ${provider} permission controls: ${error.message}`);
+  }
+}
+export {
+  managedPermissionProblem
+};

package/src/adapters/model-discovery.js

@@ -0,0 +1,100 @@
+import { createHash } from "node:crypto";
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { startJsonlProcess } from "./process.js";
+async function discoverModels(provider, context = {}) {
+  if (provider !== "claude" && provider !== "codex")
+    throw new Error("Model discovery is unsupported by this adapter");
+  const temporary = context.cwd ? void 0 : await mkdtemp(join(tmpdir(), "codeflow-models-"));
+  const cwd = context.cwd ?? temporary;
+  const args = provider === "codex" ? ["app-server"] : ["-p", "--input-format", "stream-json", "--output-format", "stream-json", "--verbose", "--strict-mcp-config", "--mcp-config", '{"mcpServers":{}}', "--no-chrome", "--tools", "", "--settings", '{"disableAllHooks":true,"disableWorkflows":true,"ultracode":false}'];
+  let sequence = 0, bytes = 0;
+  const pending = /* @__PURE__ */ new Map();
+  const process = startJsonlProcess({ command: provider, args, cwd, timeoutMs: 12e3, interactive: true, ...context.agentContainer ? { agentContainer: { config: context.agentContainer, mode: "read" } } : {}, onText: () => {
+  }, onJson(value) {
+    bytes += JSON.stringify(value).length;
+    if (bytes > 2e6) {
+      process.kill();
+      return;
+    }
+    const response = provider === "claude" ? value.type === "control_response" ? value.response : void 0 : value;
+    const id = response?.request_id ?? response?.id;
+    const waiter = pending.get(String(id));
+    if (!waiter)
+      return;
+    pending.delete(String(id));
+    if (response.error || response.subtype === "error")
+      waiter.reject(new Error("Provider rejected model discovery"));
+    else
+      waiter.resolve(provider === "claude" ? response.response : response.result);
+  } });
+  const request = (method, params = {}) => new Promise((resolve, reject) => {
+    const id = String(++sequence);
+    pending.set(id, { resolve, reject });
+    process.send(provider === "codex" ? { id, method, params } : { type: "control_request", request_id: id, request: { subtype: method, ...params } });
+  });
+  void process.outcome.then(() => {
+    for (const waiter of pending.values())
+      waiter.reject(new Error("Model discovery unavailable or timed out"));
+    pending.clear();
+  });
+  try {
+    const init = await request("initialize", provider === "codex" ? { clientInfo: { name: "code_flow_catalog", version: "0.1.0" } } : {});
+    let raw, account, source;
+    if (provider === "codex") {
+      process.send({ method: "initialized", params: {} });
+      account = (await request("account/read", { refreshToken: false }).catch(() => void 0))?.account;
+      raw = [];
+      let cursor;
+      for (let page = 0; page < 8; page++) {
+        const response = await request("model/list", { limit: 100, ...cursor ? { cursor } : {} });
+        if (!Array.isArray(response?.data))
+          throw new Error("Invalid model discovery response");
+        raw.push(...response.data);
+        cursor = response.nextCursor;
+        if (!cursor)
+          break;
+        if (page === 7)
+          throw new Error("Model discovery exceeds the bounded catalog");
+      }
+      source = "codex app-server model/list";
+    } else {
+      raw = init?.models;
+      account = init?.account;
+      source = "claude initialize models";
+    }
+    if (!Array.isArray(raw) || raw.length > 800)
+      throw new Error("Invalid model discovery response");
+    const models = [];
+    let defaultModel;
+    for (const m of raw) {
+      if (m.hidden === true)
+        continue;
+      const id = provider === "claude" ? m.resolvedModel ?? m.value : m.model ?? m.id;
+      if (typeof id !== "string" || !/^[A-Za-z0-9][\w.:[\]/@-]{0,199}$/.test(id))
+        continue;
+      const effortList = provider === "claude" ? m.supportedEffortLevels : m.supportedReasoningEfforts?.map((e) => e.reasoningEffort);
+      const efforts = Array.isArray(effortList) ? effortList.filter((e) => typeof e === "string" && /^[a-z]{2,12}$/.test(e) && e !== "ultracode") : m.supportsEffort === false ? [] : void 0;
+      const entry = { id, label: typeof m.displayName === "string" ? m.displayName.slice(0, 120) : id, efforts, defaultEffort: m.defaultReasoningEffort, aliases: provider === "claude" && m.value !== id ? [m.value] : [], discovery: { source, confidence: "reported", verifiedAt: Date.now() } };
+      const existing = models.find((x) => x.id === id);
+      if (existing)
+        existing.aliases = [.../* @__PURE__ */ new Set([...existing.aliases ?? [], ...entry.aliases ?? []])];
+      else
+        models.push(entry);
+      if (m.isDefault || m.value === "default")
+        defaultModel = id;
+    }
+    if (!models.length)
+      throw new Error("Provider reported no selectable models");
+    return { models, efforts: [...new Set(models.flatMap((m) => m.efforts ?? []))], defaultModel, allowCustom: true, discovery: { source, confidence: "reported", verifiedAt: Date.now() }, accountKey: account ? createHash("sha256").update(JSON.stringify(account)).digest("hex") : void 0 };
+  } finally {
+    process.kill();
+    await process.outcome;
+    if (temporary)
+      await rm(temporary, { recursive: true, force: true });
+  }
+}
+export {
+  discoverModels
+};