@martinloop/mcp 0.5.0 → 0.5.3

package/dist/vendor/adapters/claude-cli.js

@@ -68,7 +68,22 @@ function calculateUsageCost(usage, pricing) {
         (usage.cacheCreationInputTokens / 1000) * (pricing.cacheCreationInputPer1K ?? pricing.inputPer1K) +
         (usage.outputTokens / 1000) * pricing.outputPer1K);
 }
-function extractUsage(parsed, modelLabel) {
+const EMBEDDED_PRICING_VERSION = "embedded-v1";
+function extractClaudeObservedModel(stdout) {
+    for (const line of stdout.split(/\r?\n/u)) {
+        try {
+            const event = JSON.parse(line);
+            if (event.type === "system" && event.subtype === "init" && typeof event.model === "string") {
+                return event.model;
+            }
+        }
+        catch {
+            // Ignore non-JSON stream fragments.
+        }
+    }
+    return undefined;
+}
+function extractUsage(parsed, modelLabel, modelSource) {
     if (!parsed?.usage) {
         return normalizeUsage({
             actualUsd: 0,
@@ -102,15 +117,24 @@ function extractUsage(parsed, modelLabel) {
         tokensIn,
         tokensOut,
         cachedInputTokens,
-        provenance: hasAuthoritativeCost ? "actual" : pricingResolution.pricing ? "estimated" : "unavailable",
+        provenance: hasAuthoritativeCost ? "actual" : pricingResolution.pricing ? "calculated" : "unavailable",
         providerSettlement: {
             providerId: "claude",
-            model: modelLabel ?? "claude",
+            ...(modelLabel ? { model: modelLabel } : {}),
             transport: "cli",
             source: "claude_json",
             inputTokens: promptTokens + cacheCreationInputTokens,
             cachedInputTokens,
+            cacheCreationInputTokens,
             outputTokens: tokensOut,
+            billingMode: "unknown",
+            modelSource,
+            pricingSource: hasAuthoritativeCost
+                ? "provider_reported_total"
+                : pricingResolution.pricing
+                    ? "static_catalog"
+                    : "none",
+            ...(pricingResolution.pricing ? { pricingVersion: EMBEDDED_PRICING_VERSION } : {}),
             rawUsageAvailable: true,
             settledAt: new Date().toISOString()
         }
@@ -152,7 +176,7 @@ function extractCodexJsonlResult(stdout, modelLabel) {
                 provenance: "unavailable",
                 providerSettlement: {
                     providerId: "codex",
-                    model: modelLabel ?? "codex",
+                    ...(modelLabel ? { model: modelLabel } : {}),
                     transport: "cli",
                     source: "unavailable",
                     inputTokens: 0,
@@ -169,8 +193,8 @@ function extractCodexJsonlResult(stdout, modelLabel) {
     const reasoningOutputTokens = latestTurnCompleted.usage.reasoning_output_tokens ?? 0;
     const tokensIn = promptTokens + cachedInputTokens;
     const tokensOut = outputTokens + reasoningOutputTokens;
-    const pricing = (modelLabel ? MODEL_PRICING[modelLabel] : undefined) ??
-        MODEL_PRICING["codex"] ??
+    const exactPricing = modelLabel ? MODEL_PRICING[modelLabel] : undefined;
+    const pricing = exactPricing ?? MODEL_PRICING["codex"] ??
         { inputPer1K: BLENDED_INPUT_COST_PER_1K, outputPer1K: BLENDED_OUTPUT_COST_PER_1K };
     const actualUsd = (promptTokens / 1000) * pricing.inputPer1K +
         (cachedInputTokens / 1000) * (pricing.cachedInputPer1K ?? pricing.inputPer1K) +
@@ -183,16 +207,20 @@ function extractCodexJsonlResult(stdout, modelLabel) {
             tokensOut,
             cachedInputTokens,
             reasoningTokensOut: reasoningOutputTokens,
-            provenance: "actual",
+            provenance: exactPricing ? "calculated" : "estimated",
             providerSettlement: {
                 providerId: "codex",
-                model: modelLabel ?? "codex",
+                ...(modelLabel ? { model: modelLabel } : {}),
                 transport: "cli",
                 source: "codex_jsonl",
                 inputTokens: promptTokens,
                 cachedInputTokens,
                 outputTokens,
                 reasoningOutputTokens,
+                billingMode: "unknown",
+                modelSource: modelLabel ? "explicit_override" : "agent_default",
+                pricingSource: exactPricing ? "static_catalog" : "blended_fallback",
+                pricingVersion: EMBEDDED_PRICING_VERSION,
                 rawUsageAvailable: true,
                 settledAt: new Date().toISOString()
             }
@@ -228,7 +256,7 @@ function extractGeminiJsonResult(stdout, modelLabel) {
                 provenance: "unavailable",
                 providerSettlement: {
                     providerId: "gemini",
-                    model: modelLabel ?? "flash",
+                    ...(modelLabel ? { model: modelLabel } : {}),
                     transport: "cli",
                     source: "unavailable",
                     inputTokens: 0,
@@ -254,16 +282,20 @@ function extractGeminiJsonResult(stdout, modelLabel) {
             tokensOut,
             cachedInputTokens,
             reasoningTokensOut: reasoningOutputTokens,
-            provenance: "actual",
+            provenance: "estimated",
             providerSettlement: {
                 providerId: "gemini",
-                model: modelLabel ?? "flash",
+                ...(modelLabel ? { model: modelLabel } : {}),
                 transport: "cli",
                 source: "gemini_json",
                 inputTokens: promptTokens,
                 cachedInputTokens,
                 outputTokens,
                 reasoningOutputTokens,
+                billingMode: "unknown",
+                modelSource: modelLabel ? "explicit_override" : "agent_default",
+                pricingSource: "blended_fallback",
+                pricingVersion: EMBEDDED_PRICING_VERSION,
                 rawUsageAvailable: true,
                 settledAt: new Date().toISOString()
             }
@@ -497,7 +529,7 @@ export function createAgentCliAdapter(options) {
         label: options.label ?? `${options.command} CLI adapter`,
         metadata: {
             providerId: options.command,
-            model: options.model ?? options.command,
+            ...(options.model ? { model: options.model } : {}),
             transport: "cli",
             capabilities: createAdapterCapabilities({
                 preflight: true,
@@ -665,8 +697,15 @@ export function createAgentCliAdapter(options) {
                 parsed?.result ??
                 agentResult.stdout.trim();
             const summary = truncate(agentText, 2000);
+            const observedClaudeModel = options.streamingUsageCap
+                ? extractClaudeObservedModel(agentResult.stdout)
+                : undefined;
             const usage = parsed?.usage
-                ? extractUsage(parsed, options.model)
+                ? extractUsage(parsed, observedClaudeModel ?? options.model, observedClaudeModel
+                    ? "provider_reported"
+                    : options.model
+                        ? "explicit_override"
+                        : "agent_default")
                 : codexJsonlResult?.usage ??
                     geminiJsonResult?.usage ??
                     normalizeUsage({
@@ -678,7 +717,7 @@ export function createAgentCliAdapter(options) {
                         providerSettlement: options.command === "codex"
                             ? {
                                 providerId: "codex",
-                                model: options.model ?? "codex",
+                                ...(options.model ? { model: options.model } : {}),
                                 transport: "cli",
                                 source: "estimated_fallback",
                                 inputTokens: estimatedUsage.tokensIn,
@@ -689,7 +728,7 @@ export function createAgentCliAdapter(options) {
                             : options.command === "gemini"
                                 ? {
                                     providerId: "gemini",
-                                    model: options.model ?? "flash",
+                                    ...(options.model ? { model: options.model } : {}),
                                     transport: "cli",
                                     source: "estimated_fallback",
                                     inputTokens: estimatedUsage.tokensIn,
@@ -830,18 +869,6 @@ export function createAgentCliAdapter(options) {
                     ...(classHint ? { classHint } : {})
                 }
             };
-        },
-        /**
-         * Return a new adapter instance with a different model.
-         * Used by run-martin.ts when a change_model intervention fires.
-         * Model escalation order: haiku → sonnet → opus (cheapest-first, escalate on repeated failure).
-         */
-        withModel(newModel) {
-            return createAgentCliAdapter({
-                ...options,
-                model: newModel,
-                adapterIdSuffix: `${options.adapterIdSuffix ?? options.command}:${newModel}`
-            });
         }
     };
     return adapter;
@@ -870,7 +897,7 @@ export function createClaudeCliAdapter(options = {}) {
     return createAgentCliAdapter({
         command: "claude",
         adapterIdSuffix: "claude",
-        model: options.model ?? "claude-sonnet-4-6",
+        model: options.model,
         label: options.label ?? "Claude CLI adapter",
         workingDirectory: options.workingDirectory,
         timeoutMs: options.timeoutMs,
@@ -921,7 +948,7 @@ export function createCodexCliAdapter(options = {}) {
     return createAgentCliAdapter({
         command,
         adapterIdSuffix: "codex",
-        model: options.model ?? "codex",
+        model: options.model,
         label: options.label ?? "Codex CLI adapter",
         workingDirectory,
         timeoutMs: options.timeoutMs,
@@ -942,7 +969,7 @@ export function createCodexCliAdapter(options = {}) {
 // Pre-configured: Gemini CLI
 // ---------------------------------------------------------------------------
 /**
- * Spawns `gemini --model <model> --prompt "" --approval-mode <mode> --output-format json [...]`.
+ * Spawns `gemini [--model <explicit-model>] --prompt "" --approval-mode <mode> --output-format json [...]`.
  *
  * The prompt is delivered via stdin while forcing headless mode with `--prompt ""`,
  * which keeps large MartinLoop prompts off the command line on Windows.
@@ -951,13 +978,12 @@ export function createCodexCliAdapter(options = {}) {
  *   npm install -g @google/gemini-cli
  */
 export function createGeminiCliAdapter(options = {}) {
-    const model = options.model ?? "flash";
     const approvalMode = options.approvalMode ?? "yolo";
     const extraArgs = options.extraArgs ?? [];
     return createAgentCliAdapter({
         command: "gemini",
         adapterIdSuffix: "gemini",
-        model,
+        model: options.model,
         label: options.label ?? "Gemini CLI adapter",
         workingDirectory: options.workingDirectory,
         timeoutMs: options.timeoutMs,
@@ -965,8 +991,7 @@ export function createGeminiCliAdapter(options = {}) {
         supportsJsonOutput: false,
         spawnImpl: options.spawnImpl,
         argsBuilder: () => [
-            "--model",
-            model,
+            ...(options.model ? ["--model", options.model] : []),
             "--prompt",
             "",
             "--approval-mode",

package/dist/vendor/adapters/codex-capabilities.d.ts

@@ -0,0 +1,60 @@
+import { spawnSync } from "node:child_process";
+export type CodexFlagScope = "global" | "exec";
+export type CodexPromptTransport = "stdin-dash" | "argv";
+export type CodexWriteStrategy = "sandbox+approval" | "sandbox" | "automation" | "approval" | "default";
+export interface CodexCapabilityFlag {
+    flag: string;
+    scope: CodexFlagScope;
+}
+export interface CodexSandboxCapability extends CodexCapabilityFlag {
+    values: string[];
+}
+export interface CodexApprovalCapability extends CodexCapabilityFlag {
+    semantics: "approval-policy" | "automation-mode";
+    value?: string;
+}
+export interface CodexCapabilityProfile {
+    binaryPath: string;
+    supportsExec: boolean;
+    probeSucceeded: boolean;
+    probeError?: string;
+    model?: CodexCapabilityFlag;
+    cwd?: CodexCapabilityFlag;
+    sandbox?: CodexSandboxCapability;
+    /** Preferred compatibility alias. `automation` and `approvalPolicy` are authoritative. */
+    approval?: CodexApprovalCapability;
+    automation?: CodexApprovalCapability;
+    approvalPolicy?: CodexApprovalCapability;
+    json?: CodexCapabilityFlag;
+    color?: CodexCapabilityFlag & {
+        neverValue?: string;
+    };
+    userConfigIsolation?: CodexCapabilityFlag;
+    promptTransport: CodexPromptTransport;
+    promptTransports?: CodexPromptTransport[];
+    selectedWriteStrategy?: CodexWriteStrategy;
+}
+export interface CodexExecArgsOptions {
+    command?: string;
+    workingDirectory: string;
+    sandbox?: "read-only" | "workspace-write" | "danger-full-access";
+    model?: string;
+    extraArgs?: string[];
+    mode?: "prompt" | "probe";
+    prompt?: string;
+    capabilityProfile?: CodexCapabilityProfile;
+    promptTransport?: CodexPromptTransport;
+    writeStrategy?: CodexWriteStrategy;
+}
+type SpawnSyncLike = typeof spawnSync;
+export declare function clearCodexCapabilityCacheForTests(): void;
+export declare function cacheCodexCapabilityProfile(profile: CodexCapabilityProfile, platform?: NodeJS.Platform): CodexCapabilityProfile;
+export declare function probeCodexCapabilities(binaryPath: string, options?: {
+    platform?: NodeJS.Platform;
+    spawnSyncImpl?: SpawnSyncLike;
+    cache?: boolean;
+}): CodexCapabilityProfile;
+export declare function codexWriteStrategies(profile: CodexCapabilityProfile): CodexWriteStrategy[];
+export declare function buildCodexExecArgs(options: CodexExecArgsOptions): string[];
+export declare function buildCodexStdin(profile: CodexCapabilityProfile, prompt: string, transport?: CodexPromptTransport): string | undefined;
+export {};

package/dist/vendor/adapters/codex-capabilities.js

@@ -0,0 +1,237 @@
+import { spawnSync } from "node:child_process";
+import { extname } from "node:path";
+import { createSpawnPlan, resolveNpmShimScript } from "./cli-bridge.js";
+const capabilityCache = new Map();
+function escapeRegex(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
+}
+function flagPattern(flag) {
+    return new RegExp(`(?:^|\\s)${escapeRegex(flag)}(?=\\s|[=,<\\[]|$)`, "imu");
+}
+function locateFlag(globalHelp, execHelp, candidates) {
+    for (const flag of candidates) {
+        if (flagPattern(flag).test(execHelp))
+            return { flag, scope: "exec" };
+    }
+    for (const flag of candidates) {
+        if (flagPattern(flag).test(globalHelp))
+            return { flag, scope: "global" };
+    }
+    return undefined;
+}
+function flagContext(help, flag) {
+    const lines = help.split(/\r?\n/u);
+    const index = lines.findIndex((line) => line.includes(flag));
+    if (index < 0)
+        return "";
+    return lines.slice(Math.max(0, index - 1), Math.min(lines.length, index + 3)).join("\n");
+}
+function buildInjectedSpawnPlan(binaryPath, args, platform) {
+    if (platform !== "win32")
+        return { command: binaryPath, args };
+    const extension = extname(binaryPath).toLowerCase();
+    if (extension === ".cmd" || extension === ".bat" || extension === ".ps1") {
+        const script = resolveNpmShimScript(binaryPath);
+        if (script)
+            return { command: process.execPath, args: [script, ...args] };
+        if (extension === ".ps1") {
+            return {
+                command: "powershell.exe",
+                args: ["-NoProfile", "-ExecutionPolicy", "Bypass", "-File", binaryPath, ...args]
+            };
+        }
+        return {
+            command: process.env.ComSpec || "cmd.exe",
+            args: ["/d", "/c", binaryPath, ...args]
+        };
+    }
+    return { command: binaryPath, args };
+}
+function runHelpProbe(input) {
+    const plan = input.injected
+        ? buildInjectedSpawnPlan(input.binaryPath, input.args, input.platform)
+        : createSpawnPlan(input.binaryPath, input.args, process.cwd(), false);
+    const result = input.spawnSyncImpl(plan.command, plan.args, {
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "pipe"],
+        timeout: 8_000
+    });
+    return {
+        text: `${result.stdout ?? ""}\n${result.stderr ?? ""}`,
+        status: result.status,
+        ...(result.error ? { error: result.error.message } : {})
+    };
+}
+function parsePromptTransports(execHelp) {
+    const transports = [];
+    const stdinAdvertised = /\bstdin\b/iu.test(execHelp) || /(?:^|\s)-(?:\s|,|$).*prompt/imu.test(execHelp);
+    const argvAdvertised = /(?:\[|<)PROMPT(?:\]|>)/iu.test(execHelp) || /\bPROMPT\b/iu.test(execHelp);
+    if (stdinAdvertised)
+        transports.push("stdin-dash");
+    if (argvAdvertised || !stdinAdvertised)
+        transports.push("argv");
+    return [...new Set(transports)];
+}
+export function clearCodexCapabilityCacheForTests() {
+    capabilityCache.clear();
+}
+export function cacheCodexCapabilityProfile(profile, platform = process.platform) {
+    capabilityCache.set(`${platform}:${profile.binaryPath}`, profile);
+    return profile;
+}
+export function probeCodexCapabilities(binaryPath, options = {}) {
+    const platform = options.platform ?? process.platform;
+    const key = `${platform}:${binaryPath}`;
+    const useCache = options.cache ?? options.spawnSyncImpl === undefined;
+    if (useCache) {
+        const cached = capabilityCache.get(key);
+        if (cached)
+            return cached;
+    }
+    const spawnSyncImpl = options.spawnSyncImpl ?? spawnSync;
+    const injected = options.spawnSyncImpl !== undefined;
+    const globalProbe = runHelpProbe({
+        binaryPath,
+        args: ["--help"],
+        platform,
+        spawnSyncImpl,
+        injected
+    });
+    const execProbe = runHelpProbe({
+        binaryPath,
+        args: ["exec", "--help"],
+        platform,
+        spawnSyncImpl,
+        injected
+    });
+    const globalHelp = globalProbe.text;
+    const execHelp = execProbe.text;
+    const supportsExec = execProbe.status === 0 &&
+        !/(unknown command|unrecognized subcommand|unexpected argument ['"]?exec)/iu.test(execHelp);
+    const sandboxFlag = locateFlag(globalHelp, execHelp, ["--sandbox", "-s"]);
+    const sandboxHelp = sandboxFlag
+        ? `${flagContext(globalHelp, sandboxFlag.flag)}\n${flagContext(execHelp, sandboxFlag.flag)}`
+        : "";
+    const sandboxValues = ["read-only", "workspace-write", "danger-full-access"].filter((value) => new RegExp(`\\b${escapeRegex(value)}\\b`, "iu").test(sandboxHelp));
+    const automationFlag = locateFlag(globalHelp, execHelp, ["--approve-for-me", "--full-auto"]);
+    const automation = automationFlag
+        ? { ...automationFlag, semantics: "automation-mode" }
+        : undefined;
+    const approvalFlag = locateFlag(globalHelp, execHelp, ["--ask-for-approval", "-a"]);
+    const approvalHelp = approvalFlag
+        ? `${flagContext(globalHelp, approvalFlag.flag)}\n${flagContext(execHelp, approvalFlag.flag)}`
+        : "";
+    const approvalPolicy = approvalFlag && /\bnever\b/iu.test(approvalHelp)
+        ? { ...approvalFlag, semantics: "approval-policy", value: "never" }
+        : undefined;
+    const colorFlag = locateFlag(globalHelp, execHelp, ["--color"]);
+    const colorHelp = colorFlag
+        ? `${flagContext(globalHelp, colorFlag.flag)}\n${flagContext(execHelp, colorFlag.flag)}`
+        : "";
+    const promptTransports = parsePromptTransports(execHelp);
+    const probeError = globalProbe.error ?? execProbe.error;
+    const profile = {
+        binaryPath,
+        supportsExec,
+        probeSucceeded: supportsExec && `${globalHelp}\n${execHelp}`.trim().length > 0,
+        ...(probeError ? { probeError } : {}),
+        ...(locateFlag(globalHelp, execHelp, ["--model", "-m"])
+            ? { model: locateFlag(globalHelp, execHelp, ["--model", "-m"]) }
+            : {}),
+        ...(locateFlag(globalHelp, execHelp, ["--cd", "--cwd", "--working-dir", "-C"])
+            ? { cwd: locateFlag(globalHelp, execHelp, ["--cd", "--cwd", "--working-dir", "-C"]) }
+            : {}),
+        ...(sandboxFlag ? { sandbox: { ...sandboxFlag, values: sandboxValues } } : {}),
+        ...(automation ? { automation, approval: automation } : {}),
+        ...(approvalPolicy
+            ? {
+                approvalPolicy,
+                ...(!automation ? { approval: approvalPolicy } : {})
+            }
+            : {}),
+        ...(locateFlag(globalHelp, execHelp, ["--json"])
+            ? { json: locateFlag(globalHelp, execHelp, ["--json"]) }
+            : {}),
+        ...(colorFlag
+            ? {
+                color: {
+                    ...colorFlag,
+                    ...(/\bnever\b/iu.test(colorHelp) ? { neverValue: "never" } : {})
+                }
+            }
+            : {}),
+        ...(locateFlag(globalHelp, execHelp, ["--ignore-user-config", "--no-user-config"])
+            ? { userConfigIsolation: locateFlag(globalHelp, execHelp, ["--ignore-user-config", "--no-user-config"]) }
+            : {}),
+        promptTransport: promptTransports[0] ?? "argv",
+        promptTransports
+    };
+    if (useCache)
+        cacheCodexCapabilityProfile(profile, platform);
+    return profile;
+}
+function pushCapabilityArg(globalArgs, execArgs, capability, ...values) {
+    (capability.scope === "global" ? globalArgs : execArgs).push(capability.flag, ...values);
+}
+export function codexWriteStrategies(profile) {
+    const strategies = [];
+    const hasWorkspaceWrite = profile.sandbox?.values.includes("workspace-write") === true;
+    if (hasWorkspaceWrite && profile.approvalPolicy?.value === "never")
+        strategies.push("sandbox+approval");
+    if (hasWorkspaceWrite)
+        strategies.push("sandbox");
+    if (profile.automation)
+        strategies.push("automation");
+    if (profile.approvalPolicy?.value === "never")
+        strategies.push("approval");
+    strategies.push("default");
+    return [...new Set(strategies)];
+}
+export function buildCodexExecArgs(options) {
+    const profile = options.capabilityProfile ?? probeCodexCapabilities(options.command ?? "codex");
+    if (!profile.supportsExec) {
+        throw new Error(`Resolved Codex binary ${profile.binaryPath} does not advertise a usable exec subcommand.`);
+    }
+    const globalArgs = [];
+    const execArgs = [];
+    const requestedSandbox = options.sandbox ?? "workspace-write";
+    const strategy = options.writeStrategy ?? profile.selectedWriteStrategy ?? codexWriteStrategies(profile)[0] ?? "default";
+    const promptTransport = options.promptTransport ?? profile.promptTransport;
+    if (profile.userConfigIsolation)
+        pushCapabilityArg(globalArgs, execArgs, profile.userConfigIsolation);
+    if (profile.cwd)
+        pushCapabilityArg(globalArgs, execArgs, profile.cwd, options.workingDirectory);
+    if (requestedSandbox === "workspace-write") {
+        if ((strategy === "sandbox" || strategy === "sandbox+approval") && profile.sandbox?.values.includes("workspace-write")) {
+            pushCapabilityArg(globalArgs, execArgs, profile.sandbox, "workspace-write");
+        }
+        if (strategy === "automation" && profile.automation) {
+            pushCapabilityArg(globalArgs, execArgs, profile.automation);
+        }
+        if ((strategy === "approval" || strategy === "sandbox+approval") && profile.approvalPolicy?.value) {
+            pushCapabilityArg(globalArgs, execArgs, profile.approvalPolicy, profile.approvalPolicy.value);
+        }
+    }
+    else {
+        if (!profile.sandbox?.values.includes(requestedSandbox)) {
+            throw new Error(`Resolved Codex binary ${profile.binaryPath} does not advertise requested sandbox mode ${requestedSandbox}.`);
+        }
+        pushCapabilityArg(globalArgs, execArgs, profile.sandbox, requestedSandbox);
+    }
+    if (profile.json)
+        pushCapabilityArg(globalArgs, execArgs, profile.json);
+    if (profile.color?.neverValue)
+        pushCapabilityArg(globalArgs, execArgs, profile.color, profile.color.neverValue);
+    if (options.model) {
+        if (!profile.model) {
+            throw new Error(`Resolved Codex binary ${profile.binaryPath} does not advertise a model override flag.`);
+        }
+        pushCapabilityArg(globalArgs, execArgs, profile.model, options.model);
+    }
+    const prompt = options.prompt ?? "";
+    const promptArgs = promptTransport === "stdin-dash" ? ["-"] : prompt ? [prompt] : [];
+    return [...globalArgs, "exec", ...execArgs, ...(options.extraArgs ?? []), ...promptArgs];
+}
+export function buildCodexStdin(profile, prompt, transport = profile.promptTransport) {
+    return transport === "stdin-dash" ? prompt : undefined;
+}

package/dist/vendor/adapters/codex-cli.d.ts

@@ -0,0 +1,22 @@
+import { type CodexCliAdapterOptions as LegacyCodexCliAdapterOptions } from "./claude-cli.js";
+import { type CodexCapabilityProfile } from "./codex-launcher.js";
+export interface CodexCliAdapterOptions extends Omit<LegacyCodexCliAdapterOptions, "command"> {
+    /** Exact resolved executable selected by the Codex launch probe. */
+    command?: string;
+    /**
+     * Optional pre-probed capability profile. Production callers normally omit
+     * this because probeCodexCapabilities caches profiles by exact binary path
+     * for the process lifetime. Exposed for deterministic integrations/tests.
+     */
+    capabilityProfile?: CodexCapabilityProfile;
+}
+/**
+ * Capability-driven Codex CLI adapter.
+ *
+ * Provider identity remains `codex` even when doctor/preflight selected an
+ * absolute native binary or npm shim. The selected binary's cached capability
+ * profile builds both the real argv and stdin transport, while the spawn router
+ * sends only the Codex subprocess to that exact executable. Git/verifier
+ * subprocesses retain their normal commands.
+ */
+export declare function createCodexCliAdapter(options?: CodexCliAdapterOptions): import("../core/index.js").MartinAdapter;

package/dist/vendor/adapters/codex-cli.js

@@ -0,0 +1,62 @@
+import { spawn } from "node:child_process";
+import { createAgentCliAdapter } from "./claude-cli.js";
+import { buildCodexExecArgs, buildCodexStdin, probeCodexCapabilities } from "./codex-launcher.js";
+import { createSpawnPlan } from "./cli-bridge.js";
+function createCodexSpawnRouter(input) {
+    if (input.injectedSpawn) {
+        return (command, args = [], options) => input.injectedSpawn?.(command === "codex" ? input.selectedBinary : command, args, options);
+    }
+    return (command, args = [], options) => {
+        const executable = command === "codex" ? input.selectedBinary : command;
+        const cwd = typeof options?.cwd === "string" ? options.cwd : input.workingDirectory;
+        const plan = createSpawnPlan(executable, [...args], cwd, false);
+        return spawn(plan.command, plan.args, options ?? {});
+    };
+}
+/**
+ * Capability-driven Codex CLI adapter.
+ *
+ * Provider identity remains `codex` even when doctor/preflight selected an
+ * absolute native binary or npm shim. The selected binary's cached capability
+ * profile builds both the real argv and stdin transport, while the spawn router
+ * sends only the Codex subprocess to that exact executable. Git/verifier
+ * subprocesses retain their normal commands.
+ */
+export function createCodexCliAdapter(options = {}) {
+    const workingDirectory = options.workingDirectory ?? process.cwd();
+    const selectedBinary = options.command ?? "codex";
+    const capabilityProfile = options.capabilityProfile ?? probeCodexCapabilities(selectedBinary);
+    const sandbox = options.sandbox ?? "workspace-write";
+    const extraArgs = options.extraArgs ?? [];
+    const launchModel = options.model;
+    const spawnImpl = createCodexSpawnRouter({
+        selectedBinary,
+        workingDirectory,
+        ...(options.spawnImpl ? { injectedSpawn: options.spawnImpl } : {})
+    });
+    return createAgentCliAdapter({
+        // Keep semantic provider identity stable for usage parsing, pricing,
+        // diagnostics, and adapter metadata. The spawn router maps this to the
+        // exact selected binary at process launch time.
+        command: "codex",
+        adapterIdSuffix: "codex",
+        model: options.model,
+        label: options.label ?? "Codex CLI adapter",
+        workingDirectory,
+        timeoutMs: options.timeoutMs,
+        verifyTimeoutMs: options.verifyTimeoutMs,
+        supportsJsonOutput: false,
+        spawnImpl,
+        argsBuilder: (prompt) => buildCodexExecArgs({
+            command: selectedBinary,
+            workingDirectory,
+            sandbox,
+            ...(launchModel ? { model: launchModel } : {}),
+            extraArgs,
+            mode: "prompt",
+            prompt,
+            capabilityProfile
+        }),
+        stdinBuilder: (prompt) => buildCodexStdin(capabilityProfile, prompt)
+    });
+}