@zhixuan92/multi-model-agent-core 3.12.7 → 4.0.0

package/dist/runners/codex-runner.js

@@ -1,992 +0,0 @@
-import OpenAI from 'openai';
-import { z } from 'zod';
-import { createHash } from 'node:crypto';
-import { getCodexAuth } from '../auth/codex-oauth.js';
-import { withTimeout, } from '../types.js';
-import { priceTokens, subtractTokens, resolveRateCard } from '../cost/compute.js';
-import { READONLY_TOOL_IDS } from '../tools/definitions.js';
-import { FileTracker } from '../tools/tracker.js';
-import { createToolImplementations } from '../tools/definitions.js';
-import { TextScratchpad } from '../tools/scratchpad.js';
-import { CostMeter } from '../cost/cost-meter.js';
-import { CallCache } from '../tools/call-cache.js';
-import { buildSystemPrompt, buildBudgetHint, buildReGroundingMessage, buildFormatConstraintSuffix, RE_GROUNDING_INTERVAL_TURNS, } from './prevention.js';
-import { validateSubAgentOutput, buildRePrompt, sameDegenerateOutput, hasCompletedWork, MAX_DEGENERATE_RETRIES, } from './supervision.js';
-import { injectionTypeFor } from './injection-type.js';
-import { classifyError, isRateLimit, isProviderContextLimit } from './error-classification.js';
-import { buildOkResult as sharedBuildOkResult, buildIncompleteResult as sharedBuildIncompleteResult, buildMaxTurnsExitResult as sharedBuildMaxTurnsExitResult, buildTimeCeilingResult as sharedBuildTimeCeilingResult, } from './base/result-builders.js';
-import { checkTimeCeiling } from './base/time-check.js';
-import { mergeUsage, makeEmptyUsage } from './base/usage-accumulator.js';
-// CODEX_DEBUG=1 causes the runner to log raw HTTP request/response bodies to
-// stderr. Those bodies routinely include the user's prompt, file contents,
-// tool arguments, and other sensitive data — fine for local debugging,
-// dangerous in any deployment that ships logs anywhere. Surface a one-time
-// warning at module load so an operator who flipped the env var without
-// thinking sees it immediately.
-if (process.env.CODEX_DEBUG === '1') {
-    // eslint-disable-next-line no-console
-    console.warn('[multi-model-agent] WARNING: CODEX_DEBUG=1 is set. Raw request/response ' +
-        'bodies (including prompts and file contents) will be logged to stderr. ' +
-        'Disable in any environment where logs may be retained or shared.');
-}
-export function createCodexClient(capture) {
-    const debug = process.env.CODEX_DEBUG === '1';
-    // A custom fetch that tees error-response bodies into `capture`.
-    const wrappedFetch = async (url, init) => {
-        const res = await fetch(url, init);
-        if (!res.ok && capture) {
-            const cloned = res.clone();
-            let bodyText = '';
-            try {
-                bodyText = await cloned.text();
-            }
-            catch { /* ignore */ }
-            capture.last = {
-                status: res.status,
-                bodyText,
-                url: String(url),
-                requestBodyPreview: typeof init?.body === 'string' ? init.body.slice(0, 2000) : undefined,
-            };
-            if (debug) {
-                // eslint-disable-next-line no-console
-                console.error('[codex-runner] HTTP', res.status, String(url));
-                // eslint-disable-next-line no-console
-                if (bodyText)
-                    console.error('[codex-runner] body:', bodyText.slice(0, 1000));
-                // eslint-disable-next-line no-console
-                if (typeof init?.body === 'string')
-                    console.error('[codex-runner] request:', init.body.slice(0, 1000));
-            }
-        }
-        return res;
-    };
-    // Try Codex OAuth first — route through chatgpt.com backend API
-    const auth = getCodexAuth();
-    if (auth) {
-        return new OpenAI({
-            apiKey: auth.accessToken,
-            baseURL: 'https://chatgpt.com/backend-api/codex',
-            defaultHeaders: {
-                'chatgpt-account-id': auth.accountId,
-            },
-            fetch: wrappedFetch,
-        });
-    }
-    // Fall back to OPENAI_API_KEY env var — uses standard api.openai.com
-    const apiKey = process.env.OPENAI_API_KEY;
-    if (apiKey) {
-        return new OpenAI({ apiKey, fetch: wrappedFetch });
-    }
-    throw new Error('No Codex credentials found. Run `codex login` or set OPENAI_API_KEY environment variable.');
-}
-function buildCodexTools(impl, sandboxPolicy, toolMode = 'full') {
-    if (toolMode === 'none')
-        return [];
-    const tools = [
-        {
-            name: 'read_file',
-            description: 'Read the contents of a file at the given path. Returns the full file content as a string.',
-            parameters: z.toJSONSchema(z.object({
-                path: z.string().describe('Absolute or relative file path'),
-            })),
-            execute: async (args) => impl.readFile(args.path),
-        },
-        {
-            name: 'write_file',
-            description: 'Write content to a file, creating parent directories if needed. Overwrites existing files.',
-            parameters: z.toJSONSchema(z.object({
-                path: z.string().describe('File path to write to'),
-                content: z.string().describe('Content to write'),
-            })),
-            execute: async (args) => {
-                await impl.writeFile(args.path, args.content);
-                return `File written: ${args.path}`;
-            },
-        },
-        {
-            name: 'edit_file',
-            description: 'Replace a unique string in an existing file. Use this instead of write_file ' +
-                'when you need to change a specific part of a file without rewriting the whole thing. ' +
-                'oldContent must match exactly one location in the file — include enough surrounding ' +
-                'context (nearby lines) to make it unique.',
-            parameters: z.toJSONSchema(z.object({
-                path: z.string().describe('File path to edit'),
-                oldContent: z.string().describe('Exact string to find (must be unique in file)'),
-                newContent: z.string().describe('Replacement string'),
-            })),
-            execute: async (args) => {
-                await impl.editFile(args.path, args.oldContent, args.newContent);
-                return `File edited: ${args.path}`;
-            },
-        },
-        {
-            name: 'glob',
-            description: 'Find files matching a glob pattern in the working directory.',
-            parameters: z.toJSONSchema(z.object({
-                pattern: z.string().describe('Glob pattern (e.g., "*.ts", "src/**/*.js")'),
-            })),
-            execute: async (args) => {
-                const files = await impl.glob(args.pattern);
-                return files.join('\n') || 'No files found.';
-            },
-        },
-        {
-            name: 'grep',
-            description: 'Search for a pattern in a file. Returns matching lines with line numbers.',
-            parameters: z.toJSONSchema(z.object({
-                pattern: z.string().describe('Search pattern (regex)'),
-                path: z.string().describe('File path to search in'),
-            })),
-            execute: async (args) => {
-                const result = await impl.grep(args.pattern, args.path);
-                return result || 'No matches found.';
-            },
-        },
-        {
-            name: 'list_files',
-            description: 'List files and directories at the given path. Directories have a trailing "/".',
-            parameters: z.toJSONSchema(z.object({
-                path: z.string().default('.').describe('Directory path to list'),
-            })),
-            execute: async (args) => {
-                const entries = await impl.listFiles(args.path ?? '.');
-                return entries.join('\n') || 'Empty directory.';
-            },
-        },
-    ];
-    if (toolMode === 'full') {
-        tools.push({
-            name: 'run_shell',
-            description: 'Execute a shell command and return stdout, stderr, and exit code. Use for running tests, installing packages, etc.',
-            parameters: z.toJSONSchema(z.object({
-                command: z.string().describe('Shell command to execute'),
-            })),
-            execute: async (args) => {
-                const result = await impl.runShell(args.command);
-                return JSON.stringify(result);
-            },
-        });
-    }
-    if (toolMode === 'readonly') {
-        return tools.filter(t => READONLY_TOOL_IDS.includes(t.name));
-    }
-    return tools;
-}
-export async function runCodex(prompt, options, providerConfig, defaults) {
-    const timeoutMs = options.timeoutMs ?? providerConfig.timeoutMs ?? defaults.timeoutMs;
-    const toolMode = options.tools ?? defaults.tools;
-    const cwd = options.cwd ?? process.cwd();
-    const sandboxPolicy = options.sandboxPolicy ?? providerConfig.sandboxPolicy ?? 'cwd-only';
-    const effort = options.effort ?? providerConfig.effort;
-    const abortController = new AbortController();
-    // --- Progress event emission (Task 11) ----------------------------------
-    //
-    // `onProgress` is already wrapped in `safeSink` by the orchestrator
-    // (Task 8), so any throw from the consumer callback is swallowed
-    // upstream and cannot corrupt this loop. We do not need to wrap it
-    // again here.
-    const onProgress = options.onProgress;
-    const emit = (event) => {
-        if (onProgress)
-            onProgress(event);
-    };
-    // Accumulated state (hoisted so the timeout callback can read partial
-    // progress, AND so the FileTracker callback closure — constructed below
-    // — can read the running turn count at firing time).
-    //
-    // Turn attribution for tool calls: in codex-runner, tool calls fire in
-    // the tool-execution loop AFTER the model's stream for that turn has
-    // completed but BEFORE the next iteration of `while` starts. The `turns`
-    // variable already reflects the current turn at that point (it was
-    // incremented at the top of the iteration), so the callback can read it
-    // directly — no +1 offset.
-    let usage = makeEmptyUsage();
-    let turns = 0;
-    const tracker = new FileTracker((summary) => {
-        emit({ kind: 'tool_call', turn: turns, toolSummary: summary });
-    });
-    const toolImpls = createToolImplementations(tracker, cwd, sandboxPolicy, abortController.signal);
-    // --- Cost meter (Task 25) ------------------------------------------------
-    const costMeter = new CostMeter({ ceiling: options.maxCostUSD });
-    // --- Call cache (Task 25) ------------------------------------------------
-    const callCache = new CallCache();
-    const agentType = providerConfig.type ?? 'codex';
-    // Track last turn cost for estimating next turn cost
-    let lastTurnCostUSD = 0;
-    // Per-turn cumulative → delta tracking state (§4.2)
-    let lastCumulative = {
-        inputTokens: 0, outputTokens: 0,
-        cachedReadTokens: 0, cachedCreationTokens: 0, reasoningTokens: 0,
-    };
-    /**
-     * Check if we can afford the next turn based on previous turn cost estimate.
-     */
-    function canAffordNextTurn() {
-        if (!costMeter.canProceed(lastTurnCostUSD > 0 ? lastTurnCostUSD : 0.001)) {
-            return false;
-        }
-        return true;
-    }
-    /**
-     * Build a cost_exceeded result.
-     */
-    function buildCostExceededResult() {
-        const tc = usageTokenCounts(usage);
-        const workerCard = resolveProviderRateCard(providerConfig);
-        const costUSD = workerCard ? priceTokens(tc, workerCard) : null;
-        let costDeltaVsParentUSD = null;
-        if (costUSD !== null && parentModel) {
-            const parentCard = resolveRateCard(parentModel);
-            if (parentCard) {
-                costDeltaVsParentUSD = costUSD - priceTokens(tc, parentCard);
-            }
-        }
-        return {
-            output: `Cost ceiling exceeded: maxCostUSD=${options.maxCostUSD}`,
-            status: 'cost_exceeded',
-            usage: {
-                inputTokens: usage.inputTokens,
-                outputTokens: usage.outputTokens,
-                totalTokens: usage.inputTokens + usage.outputTokens,
-                costUSD: costUSD ?? 0,
-                costDeltaVsParentUSD,
-                cachedTokens: usage.cachedReadTokens,
-                cachedReadTokens: usage.cachedReadTokens,
-                cachedCreationTokens: usage.cachedCreationTokens,
-                reasoningTokens: usage.reasoningTokens,
-            },
-            turns,
-            filesRead: tracker.getReads(),
-            directoriesListed: tracker.getDirectoriesListed(),
-            filesWritten: tracker.getWrites(),
-            toolCalls: tracker.getToolCalls(),
-            outputIsDiagnostic: true,
-            escalationLog: [],
-            parsedFindings: null,
-            durationMs: Date.now() - taskStartMs,
-        };
-    }
-    const codexTools = buildCodexTools(toolImpls, sandboxPolicy, toolMode);
-    const toolsByName = new Map(codexTools.map(t => [t.name, t]));
-    const responsesTools = codexTools.map(t => ({
-        type: 'function',
-        name: t.name,
-        description: t.description,
-        parameters: t.parameters,
-        strict: false,
-    }));
-    // Auto-enable web_search for codex unless the user explicitly set hostedTools
-    // (including an explicit empty array to opt out). This keeps the capability
-    // matrix's claim that codex has web_search true at default settings — the
-    // user's guiding principle is to minimize required config.
-    const configuredHostedTools = providerConfig.hostedTools ?? ['web_search'];
-    const hostedTools = toolMode !== 'none'
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        ? configuredHostedTools.map(t => ({ type: t }))
-        : [];
-    const allTools = [...responsesTools, ...hostedTools];
-    // --- Custom toolset injection (explore executor, taskIndex=1) ---
-    if (options.customToolset && options.customToolset.length > 0) {
-        for (const ct of options.customToolset) {
-            const jsonSchema = ct.inputSchema instanceof z.ZodType
-                ? z.toJSONSchema(ct.inputSchema)
-                : ct.inputSchema;
-            const codexTool = {
-                name: ct.name,
-                description: ct.description,
-                parameters: jsonSchema,
-                execute: async (args) => {
-                    const result = await ct.invoke(args);
-                    return typeof result === 'string' ? result : JSON.stringify(result);
-                },
-            };
-            toolsByName.set(ct.name, codexTool);
-            allTools.push({
-                type: 'function',
-                name: ct.name,
-                description: ct.description,
-                parameters: jsonSchema,
-                strict: false,
-            });
-        }
-    }
-    // --- Prevention layer: system prompt + budget hint ---
-    //
-    // buildSystemPrompt() is deliberately static and parameter-free. The budget
-    // hint is prepended to the user prompt so the model sees it as part of its
-    // task brief, while the system prompt is threaded through the Responses API
-    // `instructions` field.
-    const systemPrompt = buildSystemPrompt() + buildFormatConstraintSuffix(options.formatConstraints ?? {});
-    const instructions = options.instructionsSuffix
-        ? `${systemPrompt}\n\n${options.instructionsSuffix}`
-        : systemPrompt;
-    const budgetHint = buildBudgetHint({ timeoutMs, maxCostUSD: options.maxCostUSD });
-    const promptWithBudgetHint = `${budgetHint}\n\n${prompt}`;
-    // --- onInitialRequest (Task 12) ----------------------------------------
-    //
-    // Fire once per attempt with the canonical orchestrator-side initial
-    // brief: `${systemPrompt}\n\n${promptWithBudgetHint}`. This is NOT the
-    // literal request body the OpenAI Responses API transmits — codex
-    // sends the systemPrompt via the Responses API `instructions` field
-    // and the user prompt as a structured `input` message array. We hash
-    // the canonical form instead so the hash is cross-runner stable:
-    // openai-runner and claude-runner compute the same hash from the same
-    // canonical string. See `AttemptRecord.initialPromptHash` in types.ts
-    // for the full wire-level caveat.
-    if (options.onInitialRequest) {
-        const canonicalInitialBrief = `${systemPrompt}\n\n${promptWithBudgetHint}`;
-        try {
-            options.onInitialRequest({
-                lengthChars: canonicalInitialBrief.length,
-                sha256: createHash('sha256').update(canonicalInitialBrief).digest('hex'),
-            });
-        }
-        catch {
-            // Swallow — a broken callback must not affect dispatch.
-        }
-    }
-    // --- Scratchpad: buffers every text emission the codex backend streams
-    // through our loop. Every termination path (ok / incomplete / max_turns /
-    // error / timeout) salvages `scratchpad.latest()` when the final message
-    // is empty or degenerate. ---
-    const scratchpad = new TextScratchpad();
-    // --- Task timing + parent model (Task 9) --------------------------------
-    const taskStartMs = Date.now();
-    const parentModel = options.parentModel;
-    const run = async () => {
-        const capture = {};
-        const client = createCodexClient(capture);
-        const input = [
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            { role: 'user', content: promptWithBudgetHint },
-        ];
-        let output = '';
-        // --- Abort-path investigation (plan Step 2) ---------------------------
-        //
-        // The 2026-04-10 Fate dispatch captured an error "Request was aborted |
-        // last response status: completed". The "completed" suffix was
-        // misleading: it was captured from a PREVIOUS successful turn, not the
-        // failed one. Mechanism:
-        //
-        //   1. Turn N's stream emits `response.completed` with status
-        //      `'completed'`. We update `lastResponseStatus = 'completed'`.
-        //   2. Turn N+1 starts; `client.responses.create(...)` opens a new
-        //      stream, but the abort signal fires before any
-        //      `response.completed` event is received.
-        //   3. The thrown error is caught below. The catch branch reads
-        //      `lastResponseStatus` — which is STILL `'completed'` from turn N
-        //      — and appends it as "last response status: completed", making
-        //      the error look like it originated from a successful response.
-        //
-        // Fix: track which turn the status was captured on. If the status was
-        // NOT captured on the current (failed) turn, drop the suffix. That way
-        // we never emit a status that belongs to a different, already-
-        // concluded request. Users saw the misleading suffix and wasted time
-        // debugging a phantom "the request completed but was aborted" condition
-        // that doesn't exist.
-        let lastResponseStatus = null;
-        let lastResponseStatusTurn = null;
-        // --- Supervision bookkeeping ---
-        // Monitor model: only count degenerate retries when worker has NO tool calls.
-        let degenerateRetries = 0;
-        let stallTurnCounter = 0;
-        let lastFilesRead = tracker.getReads().length;
-        let lastFilesWritten = tracker.getWrites().length;
-        // Initialised to `null` (NOT ''): on the first turn there is no
-        // previous degenerate output to compare against, so the same-output
-        // early-out must be skipped. Initialising to '' would cause
-        // sameDegenerateOutput('', '') to fire on a first-turn empty output
-        // and break the loop before any retries run. See openai-runner
-        // regression #5.
-        let lastDegenerateOutput = null;
-        try {
-            while (true) {
-                turns++;
-                // Emit turn_start AFTER incrementing so `turn` matches the 1-indexed
-                // turn number we use everywhere else in this runner (the scratchpad
-                // append, error diagnostics, result.turns).
-                emit({ kind: 'turn_start', turn: turns, provider: 'codex', model: providerConfig.model });
-                // Time ceiling check before dispatching a provider call.
-                const timeCeilingMs = checkTimeCeiling(taskStartMs, timeoutMs);
-                if (timeCeilingMs !== null) {
-                    const tc = usageTokenCounts(usage);
-                    const workerCard = resolveProviderRateCard(providerConfig);
-                    const costUSD = workerCard ? priceTokens(tc, workerCard) : null;
-                    let costDeltaVsParentUSD = null;
-                    if (costUSD !== null && parentModel) {
-                        const parentCard = resolveRateCard(parentModel);
-                        if (parentCard) {
-                            costDeltaVsParentUSD = costUSD - priceTokens(tc, parentCard);
-                        }
-                    }
-                    return sharedBuildTimeCeilingResult({
-                        usage: {
-                            inputTokens: usage.inputTokens,
-                            outputTokens: usage.outputTokens,
-                            totalTokens: usage.inputTokens + usage.outputTokens,
-                            costUSD,
-                            costDeltaVsParentUSD,
-                            cachedTokens: usage.cachedReadTokens,
-                            cachedReadTokens: usage.cachedReadTokens,
-                            cachedCreationTokens: usage.cachedCreationTokens,
-                            reasoningTokens: usage.reasoningTokens,
-                        },
-                        turns,
-                        tracker,
-                        scratchpad,
-                        wallClockMs: timeCeilingMs,
-                        timeoutMs,
-                        durationMs: Date.now() - taskStartMs,
-                    });
-                }
-                // Codex backend requires streaming. The Codex backend's
-                // `response.completed` event does NOT populate `response.output` —
-                // we must accumulate content from individual stream events.
-                // `instructions` carries the prevention-layer system prompt; the
-                // per-run budget hint is already prepended to the first user input.
-                const stream = await client.responses.create({
-                    model: providerConfig.model,
-                    instructions,
-                    input,
-                    stream: true,
-                    store: false,
-                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                    tools: allTools.length > 0 ? allTools : undefined,
-                    // Honor `effort` when set and not 'none'. Codex backend accepts
-                    // reasoning.effort for reasoning-capable models (gpt-5-codex, o3, etc.).
-                    // 'none' skips the reasoning block entirely.
-                    ...(effort && effort !== 'none' && {
-                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                        reasoning: { effort },
-                    }),
-                }, { signal: abortController.signal });
-                let textThisTurn = '';
-                const toolCalls = [];
-                const itemTypesSeen = [];
-                const completedItems = [];
-                let sawCompleted = false;
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                for await (const event of stream) {
-                    const et = event?.type;
-                    if (!et)
-                        continue;
-                    if (et === 'response.output_text.delta') {
-                        textThisTurn += event.delta ?? '';
-                    }
-                    else if (et === 'response.output_item.added') {
-                        if (event.item?.type)
-                            itemTypesSeen.push(event.item.type);
-                    }
-                    else if (et === 'response.output_item.done') {
-                        const item = event.item;
-                        if (item) {
-                            completedItems.push(item);
-                            if (item.type === 'function_call') {
-                                toolCalls.push({
-                                    call_id: item.call_id,
-                                    name: item.name,
-                                    arguments: item.arguments ?? '',
-                                    item,
-                                });
-                            }
-                        }
-                    }
-                    else if (et === 'response.completed') {
-                        sawCompleted = true;
-                        const r = event.response;
-                        if (r?.usage) {
-                            // Codex SDK ResponseUsage type doesn't declare cached_input_tokens /
-                            // reasoning_tokens, but the wire payload carries them when the model
-                            // emits them. Cast to a wider shape to read; null when absent.
-                            const wideUsage = r.usage;
-                            const turnUsage = {
-                                inputTokens: wideUsage.input_tokens ?? 0,
-                                outputTokens: wideUsage.output_tokens ?? 0,
-                                cachedReadTokens: wideUsage.cached_input_tokens ?? null,
-                                cachedCreationTokens: null,
-                                reasoningTokens: wideUsage.reasoning_tokens ?? null,
-                            };
-                            usage = mergeUsage(usage, turnUsage);
-                        }
-                        if (r?.status) {
-                            lastResponseStatus = r.status;
-                            lastResponseStatusTurn = turns;
-                        }
-                    }
-                }
-                if (process.env.CODEX_DEBUG === '1') {
-                    // eslint-disable-next-line no-console
-                    console.error('[codex-runner] item types streamed:', itemTypesSeen.join(', ') || '(none)');
-                    // eslint-disable-next-line no-console
-                    console.error('[codex-runner] text this turn:', JSON.stringify(textThisTurn));
-                    // eslint-disable-next-line no-console
-                    console.error('[codex-runner] tool calls:', toolCalls.length);
-                }
-                if (!sawCompleted) {
-                    throw new Error('Codex stream ended without a response.completed event');
-                }
-                // Buffer this turn's text into the scratchpad BEFORE any exit so
-                // every termination path (including supervision exhaustion) can
-                // salvage it. Codex does not emit <think> tags
-                // by default, so there is no stripping step here.
-                if (textThisTurn) {
-                    scratchpad.append(turns, textThisTurn);
-                    emit({
-                        kind: 'text_emission',
-                        turn: turns,
-                        chars: textThisTurn.length,
-                        preview: textThisTurn.slice(0, 200),
-                    });
-                    output = textThisTurn;
-                }
-                // Replay only function_call items into the next turn's input.
-                //
-                // We send `store: false` to the Responses API, which means the server
-                // does NOT persist any items it generates (reasoning items with `rs_`
-                // ids, message items with `msg_` ids, etc.). Replaying those items
-                // wholesale causes a 404 on the next turn:
-                //   "Item with id 'rs_...' not found. Items are not persisted when
-                //    `store` is set to false."
-                //
-                // function_call items are part of the tool-call protocol — the next
-                // turn needs them so each function_call_output we push can be paired
-                // with its originating call_id. We strip the server-generated `id`
-                // field and rebuild the item from its protocol fields only, so the
-                // server has nothing to look up against unpersisted state.
-                //
-                // Reasoning, message, and other server-generated items are dropped.
-                // The model still sees its previous tool calls + their outputs, which
-                // is enough to continue a multi-turn agent loop.
-                for (const item of completedItems) {
-                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                    const it = item;
-                    if (it?.type === 'function_call') {
-                        input.push({
-                            type: 'function_call',
-                            call_id: it.call_id,
-                            name: it.name,
-                            arguments: it.arguments ?? '',
-                            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                        });
-                    }
-                }
-                // --- Periodic re-grounding inside the loop ---------------------
-                if (turns > 0 && turns % RE_GROUNDING_INTERVAL_TURNS === 0) {
-                    if (!canAffordNextTurn()) {
-                        return buildCostExceededResult();
-                    }
-                    const reground = buildReGroundingMessage({
-                        originalPromptExcerpt: prompt,
-                        elapsedMs: Date.now() - taskStartMs,
-                        timeoutMs,
-                        toolCallsSoFar: tracker.getToolCalls().length,
-                        filesReadSoFar: tracker.getReads().length,
-                    });
-                    input.push({
-                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                        role: 'user',
-                        content: reground,
-                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                    });
-                    emit({
-                        kind: 'injection',
-                        injectionType: 'reground',
-                        turn: turns,
-                        contentLengthChars: reground.length,
-                    });
-                }
-                // --- turn_complete: one event per while-iteration. Fires after the
-                // re-grounding checks have run (so cumulative token counts and any
-                // injection events are already on the wire) and BEFORE the supervision branching / tool-execution loop. Every
-                // continue/return in the branches below happens AFTER this event,
-                // so the sequence "turn_start ... text_emission ... turn_complete"
-                // is guaranteed per iteration.
-                emit({
-                    kind: 'turn_complete',
-                    turn: turns,
-                    cumulativeInputTokens: usage.inputTokens,
-                    cumulativeOutputTokens: usage.outputTokens,
-                    ...(usage.cachedReadTokens != null && { cumulativeCachedReadTokens: usage.cachedReadTokens }),
-                    ...(usage.cachedCreationTokens != null && { cumulativeCachedCreationTokens: usage.cachedCreationTokens }),
-                    ...(usage.reasoningTokens != null && { cumulativeReasoningTokens: usage.reasoningTokens }),
-                });
-                // Track cost for this turn using per-turn delta from cumulative
-                const cur = usageTokenCounts(usage);
-                const turnTokens = subtractTokens(cur, lastCumulative);
-                lastCumulative = cur;
-                const rateCard = resolveProviderRateCard(providerConfig);
-                const turnCost = rateCard ? priceTokens(turnTokens, rateCard) : null;
-                if (turnCost !== null) {
-                    lastTurnCostUSD = turnCost;
-                    costMeter.add(turnCost);
-                }
-                // If the model made no tool calls, the turn ended with either a
-                // final answer or a degenerate emission. Wrap in the supervision
-                // state machine: valid text is an immediate ok-exit; degenerate
-                // either re-prompts (and continues the loop) or — if the retry
-                // budget is spent / same-output early-out fires — exits as
-                // incomplete with scratchpad salvage.
-                if (toolCalls.length === 0) {
-                    const stripped = textThisTurn; // codex does not emit <think> tags
-                    const validation = validateSubAgentOutput(stripped, {
-                        expectedCoverage: options.expectedCoverage,
-                        skipCompletionHeuristic: options.skipCompletionHeuristic,
-                        hasCompletedWork: hasCompletedWork(tracker.getToolCalls()),
-                    });
-                    if (validation.valid) {
-                        const ok = buildCodexOkResult({
-                            tracker,
-                            scratchpad,
-                            providerConfig,
-                            inputTokens: usage.inputTokens,
-                            outputTokens: usage.outputTokens,
-                            cachedReadTokens: usage.cachedReadTokens,
-                            reasoningTokens: usage.reasoningTokens,
-                            turns,
-                            output: stripped,
-                            durationMs: Date.now() - taskStartMs,
-                            parentModel,
-                        });
-                        emit({ kind: 'done', status: ok.status });
-                        return ok;
-                    }
-                    // Same-output early-out: only compare when we have a previous
-                    // degenerate output. First-turn degeneracy must still get
-                    // retries — see openai-runner regression #5.
-                    if ((lastDegenerateOutput !== null &&
-                        sameDegenerateOutput(stripped, lastDegenerateOutput)) ||
-                        degenerateRetries >= MAX_DEGENERATE_RETRIES) {
-                        const exhausted = buildCodexIncompleteResult({
-                            tracker,
-                            scratchpad,
-                            providerConfig,
-                            inputTokens: usage.inputTokens,
-                            outputTokens: usage.outputTokens,
-                            cachedReadTokens: usage.cachedReadTokens,
-                            reasoningTokens: usage.reasoningTokens,
-                            turns,
-                            reason: `supervision loop exhausted after ${degenerateRetries} degenerate retries without tool calls (last kind: ${validation.kind ?? 'unknown'})`,
-                            durationMs: Date.now() - taskStartMs,
-                            parentModel,
-                        });
-                        emit({ kind: 'done', status: exhausted.status });
-                        return exhausted;
-                    }
-                    // Inject the re-prompt as the next user input and continue
-                    // the loop. The next turn of the codex backend will respond
-                    // to the re-prompt directly.
-                    lastDegenerateOutput = stripped;
-                    // Only count as degenerate when worker has NO tool calls this turn.
-                    // If the worker is still calling tools, it's making progress.
-                    if (!hasCompletedWork(tracker.getToolCalls())) {
-                        degenerateRetries++;
-                    }
-                    if (!canAffordNextTurn()) {
-                        return buildCostExceededResult();
-                    }
-                    const rePrompt = buildRePrompt(validation);
-                    input.push({
-                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                        role: 'user',
-                        content: rePrompt,
-                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                    });
-                    emit({
-                        kind: 'injection',
-                        injectionType: injectionTypeFor(validation.kind),
-                        turn: turns,
-                        contentLengthChars: rePrompt.length,
-                    });
-                    continue;
-                }
-                // Execute tool calls and feed outputs back
-                for (const call of toolCalls) {
-                    const tool = toolsByName.get(call.name);
-                    let result;
-                    if (!tool) {
-                        result = `Error: unknown tool "${call.name}"`;
-                    }
-                    else {
-                        try {
-                            const args = call.arguments ? JSON.parse(call.arguments) : {};
-                            result = await tool.execute(args);
-                        }
-                        catch (err) {
-                            result = `Tool error: ${err instanceof Error ? err.message : String(err)}`;
-                        }
-                    }
-                    input.push({
-                        type: 'function_call_output',
-                        call_id: call.call_id,
-                        output: result,
-                    });
-                }
-            }
-            // Loop exited without producing a clean final answer — salvage.
-            const incompleteResult = buildCodexMaxTurnsExitResult({
-                tracker,
-                scratchpad,
-                providerConfig,
-                inputTokens: usage.inputTokens,
-                outputTokens: usage.outputTokens,
-                cachedReadTokens: usage.cachedReadTokens,
-                reasoningTokens: usage.reasoningTokens,
-                turns,
-                lastOutput: output,
-                reason: `loop exited after ${turns} turns without producing a clean final answer`,
-                durationMs: Date.now() - taskStartMs,
-                parentModel,
-            });
-            emit({ kind: 'done', status: incompleteResult.status });
-            return incompleteResult;
-        }
-        catch (err) {
-            // OpenAI SDK's APIError carries status/body/headers — surface them
-            // since the Codex backend returns 400 with no body on shape mismatches.
-            // We also consult `capture.last` which holds the raw HTTP body captured
-            // by our wrapped fetch (the SDK strips the body when it can't parse JSON).
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            const e = err;
-            const pieces = [];
-            if (err instanceof Error)
-                pieces.push(err.message);
-            if (e?.status)
-                pieces.push(`HTTP ${e.status}`);
-            if (e?.error) {
-                try {
-                    pieces.push(`sdk_body=${JSON.stringify(e.error)}`);
-                }
-                catch { /* ignore */ }
-            }
-            if (capture.last) {
-                pieces.push(`raw_status=${capture.last.status}`);
-                // Only leak request/response body snippets when debug is explicitly enabled;
-                // they may contain sensitive content (prompt, tools, file contents).
-                if (process.env.CODEX_DEBUG === '1' && capture.last.bodyText)
-                    pieces.push(`raw_body=${capture.last.bodyText.slice(0, 500)}`);
-                if (process.env.CODEX_DEBUG === '1' && capture.last.requestBodyPreview)
-                    pieces.push(`req_body=${capture.last.requestBodyPreview.slice(0, 500)}`);
-            }
-            if (e?.requestID)
-                pieces.push(`req_id=${e.requestID}`);
-            // Only include `last response status` when it was captured on the
-            // CURRENT (failing) turn — otherwise it belongs to a previous,
-            // separate request and appending it is actively misleading. See the
-            // abort-path investigation comment at the top of `run()`.
-            if (lastResponseStatus && lastResponseStatusTurn === turns) {
-                pieces.push(`last response status: ${lastResponseStatus}`);
-            }
-            else if (lastResponseStatus && lastResponseStatusTurn !== turns) {
-                pieces.push(`note: a previous request (turn ${lastResponseStatusTurn}) completed with status ` +
-                    `"${lastResponseStatus}" — it is unrelated to this failure`);
-            }
-            const detailed = pieces.join(' | ') || String(err);
-            // Classify the thrown error into a finer-grained RunStatus. Task 7
-            // introduces api_aborted / api_error / network_error alongside the
-            // catch-all 'error' status. The turn-scoped `lastResponseStatus`
-            // disambiguation above is ORTHOGONAL to this classification: the
-            // `detailed` message is still the rich operator-facing diagnostic,
-            // and `classifyError` only decides which RunStatus bucket the
-            // failure lands in.
-            const { status } = classifyError(err);
-            const errorCode = isProviderContextLimit(err) ? 'provider_context_limit' : undefined;
-            // Salvage: if the scratchpad has buffered text from earlier turns,
-            // return it as the output. Pre-Task-5 behavior returned only the
-            // error string, losing 30k+ tokens of work on abort.
-            emit({ kind: 'done', status });
-            const hasSalvage = !scratchpad.isEmpty();
-            const tc = usageTokenCounts(usage);
-            const workerCard = resolveProviderRateCard(providerConfig);
-            const costUSD = workerCard ? priceTokens(tc, workerCard) : null;
-            let costDeltaVsParentUSD = null;
-            if (costUSD !== null && parentModel) {
-                const parentCard = resolveRateCard(parentModel);
-                if (parentCard) {
-                    costDeltaVsParentUSD = costUSD - priceTokens(tc, parentCard);
-                }
-            }
-            return {
-                output: hasSalvage ? scratchpad.latest() : `Sub-agent error: ${detailed}`,
-                status,
-                usage: {
-                    inputTokens: usage.inputTokens,
-                    outputTokens: usage.outputTokens,
-                    totalTokens: usage.inputTokens + usage.outputTokens,
-                    costUSD,
-                    costDeltaVsParentUSD,
-                    cachedTokens: usage.cachedReadTokens,
-                    cachedReadTokens: usage.cachedReadTokens,
-                    cachedCreationTokens: usage.cachedCreationTokens,
-                    reasoningTokens: usage.reasoningTokens,
-                },
-                turns,
-                filesRead: tracker.getReads(),
-                directoriesListed: tracker.getDirectoriesListed(),
-                filesWritten: tracker.getWrites(),
-                toolCalls: tracker.getToolCalls(),
-                outputIsDiagnostic: !hasSalvage,
-                escalationLog: [],
-                parsedFindings: null,
-                error: detailed,
-                durationMs: Date.now() - taskStartMs,
-                ...(errorCode !== undefined && { errorCode }),
-                ...(isRateLimit(err) && {
-                    structuredError: { code: 'rate_limit_exceeded', message: 'rate limited by provider', where: 'runner:codex' },
-                }),
-            };
-        }
-    };
-    return withTimeout(run(), timeoutMs, () => {
-        emit({ kind: 'done', status: 'timeout' });
-        const hasSalvage = !scratchpad.isEmpty();
-        const tc = usageTokenCounts(usage);
-        const workerCard = resolveProviderRateCard(providerConfig);
-        const costUSD = workerCard ? priceTokens(tc, workerCard) : null;
-        let costDeltaVsParentUSD = null;
-        if (costUSD !== null && parentModel) {
-            const parentCard = resolveRateCard(parentModel);
-            if (parentCard) {
-                costDeltaVsParentUSD = costUSD - priceTokens(tc, parentCard);
-            }
-        }
-        return {
-            // Preserve any text the scratchpad buffered before the timeout fired.
-            // Partial usage is read from the running accumulators hoisted above —
-            // hardcoded zeros would discard every token counted on partial turns.
-            output: hasSalvage ? scratchpad.latest() : `Agent timed out after ${timeoutMs}ms.`,
-            status: 'timeout',
-            filesRead: tracker.getReads(),
-            directoriesListed: tracker.getDirectoriesListed(),
-            filesWritten: tracker.getWrites(),
-            toolCalls: tracker.getToolCalls(),
-            usage: {
-                inputTokens: usage.inputTokens,
-                outputTokens: usage.outputTokens,
-                totalTokens: usage.inputTokens + usage.outputTokens,
-                costUSD,
-                costDeltaVsParentUSD,
-                cachedTokens: usage.cachedReadTokens,
-                cachedReadTokens: usage.cachedReadTokens,
-                cachedCreationTokens: usage.cachedCreationTokens,
-                reasoningTokens: usage.reasoningTokens,
-            },
-            turns,
-            outputIsDiagnostic: !hasSalvage,
-            escalationLog: [],
-            parsedFindings: null,
-            durationMs: Date.now() - taskStartMs,
-        };
-    }, abortController, options.abortSignal);
-}
-function resolveProviderRateCard(config) {
-    return resolveRateCard(config.model, {
-        inputCostPerMTok: config.inputCostPerMTok,
-        outputCostPerMTok: config.outputCostPerMTok,
-    });
-}
-function usageTokenCounts(u) {
-    const cachedRead = u.cachedReadTokens ?? 0;
-    return {
-        inputTokens: Math.max(0, u.inputTokens - cachedRead),
-        outputTokens: u.outputTokens,
-        cachedReadTokens: cachedRead,
-        cachedCreationTokens: 0,
-        reasoningTokens: u.reasoningTokens ?? 0,
-    };
-}
-function codexUsage(args) {
-    const { providerConfig, inputTokens, outputTokens, cachedReadTokens, reasoningTokens, parentModel } = args;
-    const cachedRead = cachedReadTokens ?? 0;
-    const nonCachedInput = Math.max(0, inputTokens - cachedRead);
-    const workerCard = resolveProviderRateCard(providerConfig);
-    const tokenCounts = {
-        inputTokens: nonCachedInput,
-        outputTokens,
-        cachedReadTokens: cachedRead,
-        cachedCreationTokens: 0,
-        reasoningTokens: reasoningTokens ?? 0,
-    };
-    const costUSD = workerCard ? priceTokens(tokenCounts, workerCard) : null;
-    let costDeltaVsParentUSD = null;
-    if (costUSD !== null && parentModel) {
-        const parentCard = resolveRateCard(parentModel);
-        if (parentCard) {
-            costDeltaVsParentUSD = costUSD - priceTokens(tokenCounts, parentCard);
-        }
-    }
-    return {
-        inputTokens,
-        outputTokens,
-        totalTokens: inputTokens + outputTokens,
-        costUSD,
-        costDeltaVsParentUSD,
-        cachedTokens: cachedReadTokens,
-        cachedReadTokens,
-        cachedCreationTokens: null,
-        reasoningTokens,
-    };
-}
-function buildCodexOkResult(args) {
-    return sharedBuildOkResult({
-        output: args.output,
-        usage: codexUsage(args),
-        turns: args.turns,
-        tracker: args.tracker,
-        durationMs: args.durationMs,
-    });
-}
-/**
- * Supervision-exhausted path: retry cap hit or same-output early-out. Prefer
- * scratchpad salvage; fall back to the incomplete diagnostic.
- */
-function buildCodexIncompleteResult(args) {
-    return sharedBuildIncompleteResult({
-        usage: codexUsage(args),
-        turns: args.turns,
-        tracker: args.tracker,
-        scratchpad: args.scratchpad,
-        buildDiagnostic: buildCodexIncompleteDiagnostic,
-        durationMs: args.durationMs,
-        reason: args.reason,
-        stampExhausted: true,
-    });
-}
-function buildCodexMaxTurnsExitResult(args) {
-    return sharedBuildMaxTurnsExitResult({
-        usage: codexUsage(args),
-        turns: args.turns,
-        tracker: args.tracker,
-        scratchpad: args.scratchpad,
-        lastOutput: args.lastOutput,
-        reason: args.reason,
-        durationMs: args.durationMs,
-    });
-}
-function buildCodexIncompleteDiagnostic(opts) {
-    return [
-        '[codex sub-agent terminated without producing a final answer]',
-        '',
-        'The model emitted no tool calls and no usable text on its final turn, and',
-        'supervision re-prompts did not recover a valid response.',
-        '',
-        `Turns used:    ${opts.turns}`,
-        `Input tokens:  ${opts.inputTokens}`,
-        `Output tokens: ${opts.outputTokens}`,
-        `Files read:    ${opts.filesRead.length}`,
-        `Files written: ${opts.filesWritten.length}`,
-        '',
-        'Recommended action: re-dispatch with a tighter brief, or escalate provider tier.',
-    ].join('\n');
-}
-/**
- * Review-mode entry: routes `systemPrefix` into the Responses API
- * `instructions` field (which the Codex backend can cache when the rubric
- * is stable across calls) and `userBody` as the first user input message.
- */
-export async function runCodexReview(parts, options, providerConfig, defaults) {
-    return runCodex(parts.userBody, {
-        ...options,
-        instructionsSuffix: parts.systemPrefix,
-    }, providerConfig, defaults);
-}
-//# sourceMappingURL=codex-runner.js.map