oh-my-knowledge 0.48.0 → 0.49.0

package/dist/executors/codex-protocol.js

@@ -0,0 +1,234 @@
+import { checkedSumTokenCounts, optionalTokenCount, splitInclusiveInputTokens, sumTokenCounts, } from '../shared/token-usage.js';
+import { extractCodexTrace, isCodexResultEvent } from './codex-cli-trace.js';
+const CODEX_EVENT_TYPES = new Set([
+    'thread.started',
+    'turn.started',
+    'turn.completed',
+    'turn.failed',
+    'item.started',
+    'item.updated',
+    'item.completed',
+    'error',
+]);
+const CODEX_ITEM_TYPES = new Set([
+    'agent_message',
+    'reasoning',
+    'command_execution',
+    'file_change',
+    'mcp_tool_call',
+    'web_search',
+    'todo_list',
+    'error',
+    // Older CLI releases emitted these directly.
+    'file_read',
+    'file_write',
+]);
+export function extractCodexUsage(events) {
+    const input = [];
+    const cached = [];
+    const output = [];
+    for (const event of events) {
+        if (!isCodexResultEvent(event) || !event.usage)
+            continue;
+        const normalized = splitInclusiveInputTokens(event.usage.input_tokens, event.usage.cached_input_tokens);
+        input.push(normalized.inputTokens);
+        cached.push(normalized.cacheReadTokens);
+        output.push(event.usage.output_tokens ?? 0);
+    }
+    return {
+        input: sumTokenCounts(...input),
+        cached: sumTokenCounts(...cached),
+        output: sumTokenCounts(...output),
+    };
+}
+/**
+ * Match @openai/codex-sdk's `finalResponse`: the latest completed
+ * agent_message is the answer. Earlier messages remain available in `turns`.
+ */
+export function extractCodexFinalOutput(events) {
+    for (let index = events.length - 1; index >= 0; index -= 1) {
+        const event = events[index];
+        if (event.type === 'item.completed' && event.item?.type === 'agent_message') {
+            return typeof event.item.text === 'string' ? event.item.text : '';
+        }
+    }
+    return '';
+}
+export function extractCodexProtocolError(events) {
+    for (let index = events.length - 1; index >= 0; index -= 1) {
+        const event = events[index];
+        if (event.type === 'error') {
+            return event.message || event.error?.message || 'codex stream error';
+        }
+    }
+    return undefined;
+}
+export function validateCodexProtocol(events) {
+    const pendingItems = new Map();
+    let openTurnCount = 0;
+    const inputCounts = [];
+    const cacheCounts = [];
+    const outputCounts = [];
+    const elapsedCounts = [];
+    for (let eventIndex = 0; eventIndex < events.length; eventIndex += 1) {
+        const event = events[eventIndex];
+        const eventType = event.type;
+        if (!eventType || !CODEX_EVENT_TYPES.has(eventType)) {
+            return `unsupported codex event type: ${eventType || '<missing>'}`;
+        }
+        if (event.elapsed_ms !== undefined) {
+            const elapsed = optionalTokenCount(event.elapsed_ms);
+            if (elapsed === undefined)
+                return `invalid codex elapsed_ms at event ${eventIndex}`;
+            elapsedCounts.push(elapsed);
+        }
+        if (eventType === 'turn.started') {
+            openTurnCount += 1;
+            continue;
+        }
+        if (eventType.startsWith('item.')) {
+            const itemType = event.item?.type;
+            if (!itemType || !CODEX_ITEM_TYPES.has(itemType)) {
+                return `unsupported codex item type: ${itemType || '<missing>'}`;
+            }
+            const itemId = event.item?.id;
+            if (typeof itemId !== 'string' || itemId.trim() === '') {
+                return `missing codex item id at event ${eventIndex}`;
+            }
+            if (eventType === 'item.started') {
+                pendingItems.set(itemId, (pendingItems.get(itemId) ?? 0) + 1);
+            }
+            else if (eventType === 'item.updated' && !pendingItems.has(itemId)) {
+                return `codex item.updated without item.started: ${itemId}`;
+            }
+            else if (eventType === 'item.completed') {
+                const pendingCount = pendingItems.get(itemId) ?? 0;
+                if (pendingCount === 1)
+                    pendingItems.delete(itemId);
+                else if (pendingCount > 1)
+                    pendingItems.set(itemId, pendingCount - 1);
+            }
+            continue;
+        }
+        if (eventType !== 'turn.completed' && eventType !== 'turn.failed')
+            continue;
+        if (pendingItems.size > 0) {
+            return `codex turn ended with incomplete item(s): ${Array.from(pendingItems.keys()).join(', ')}`;
+        }
+        if (openTurnCount > 0)
+            openTurnCount -= 1;
+        if (event.usage !== undefined || eventType === 'turn.completed') {
+            const usageError = validateCodexUsage(event.usage, eventIndex);
+            if (usageError)
+                return usageError;
+            const normalized = splitInclusiveInputTokens(event.usage?.input_tokens, event.usage?.cached_input_tokens);
+            inputCounts.push(normalized.inputTokens);
+            cacheCounts.push(normalized.cacheReadTokens);
+            outputCounts.push(event.usage?.output_tokens ?? 0);
+        }
+    }
+    if (openTurnCount > 0)
+        return 'codex stream ended before turn completion';
+    if (pendingItems.size > 0) {
+        return `codex stream ended with incomplete item(s): ${Array.from(pendingItems.keys()).join(', ')}`;
+    }
+    if (!hasSafeAggregate(inputCounts)
+        || !hasSafeAggregate(cacheCounts)
+        || !hasSafeAggregate(outputCounts)
+        || !hasSafeAggregate([...inputCounts, ...cacheCounts, ...outputCounts])) {
+        return 'codex token usage aggregate exceeds safe integer';
+    }
+    if (!hasSafeAggregate(elapsedCounts)) {
+        return 'codex elapsed_ms aggregate exceeds safe integer';
+    }
+    return undefined;
+}
+function validateCodexUsage(usage, eventIndex) {
+    if (!usage)
+        return `missing codex usage at event ${eventIndex}`;
+    const input = optionalTokenCount(usage.input_tokens);
+    const output = optionalTokenCount(usage.output_tokens);
+    const cached = usage.cached_input_tokens === undefined
+        ? 0
+        : optionalTokenCount(usage.cached_input_tokens);
+    const reasoning = usage.reasoning_output_tokens === undefined
+        ? 0
+        : optionalTokenCount(usage.reasoning_output_tokens);
+    if (input === undefined || output === undefined || cached === undefined || reasoning === undefined) {
+        return `invalid codex usage at event ${eventIndex}`;
+    }
+    if (cached > input)
+        return `codex cached_input_tokens exceeds input_tokens at event ${eventIndex}`;
+    return undefined;
+}
+function hasSafeAggregate(values) {
+    return checkedSumTokenCounts(...values) !== undefined;
+}
+export function extractCodexStopReason(events) {
+    if (extractCodexProtocolError(events) || validateCodexProtocol(events))
+        return 'error';
+    const last = [...events].reverse().find((event) => isCodexResultEvent(event));
+    if (!last)
+        return 'unknown';
+    if (last.type === 'turn.failed')
+        return 'error';
+    return last.stop_reason || 'end_turn';
+}
+export function sumCodexElapsed(resultEvents, wallClock) {
+    const total = sumTokenCounts(...resultEvents.map((event) => event.elapsed_ms ?? 0));
+    return total > 0 ? total : wallClock;
+}
+export function buildCodexResult({ events, wallClockDurationMs, source, malformedLineCount = 0, forcedError, }) {
+    const resultEvents = events.filter(isCodexResultEvent);
+    const last = resultEvents.at(-1);
+    const usage = extractCodexUsage(events);
+    const trace = extractCodexTrace(events);
+    const finalOutput = extractCodexFinalOutput(events);
+    const errors = [];
+    if (forcedError)
+        errors.push(forcedError);
+    if (malformedLineCount > 0) {
+        errors.push(`${source} output contained ${malformedLineCount} malformed line(s)`);
+    }
+    const schemaError = validateCodexProtocol(events);
+    if (schemaError)
+        errors.push(schemaError);
+    const streamError = extractCodexProtocolError(events);
+    if (streamError)
+        errors.push(streamError);
+    if (!last) {
+        errors.push(`no turn.completed/turn.failed event in ${source} output`);
+    }
+    else if (last.type === 'turn.failed' || last.error) {
+        errors.push(last.error?.message || `${source} turn.failed`);
+    }
+    else if (!finalOutput.trim()) {
+        errors.push(`${source} completed without an assistant response`);
+    }
+    const uniqueErrors = [...new Set(errors)];
+    const ok = uniqueErrors.length === 0;
+    const tokenUsageReported = !forcedError
+        && malformedLineCount === 0
+        && !schemaError
+        && Boolean(last);
+    return {
+        ok,
+        durationMs: sumCodexElapsed(resultEvents, wallClockDurationMs),
+        durationApiMs: 0,
+        inputTokens: usage.input,
+        outputTokens: usage.output,
+        cacheReadTokens: usage.cached,
+        cacheCreationTokens: 0,
+        ...(!tokenUsageReported && { tokenUsageReportedByExecutor: false }),
+        costUSD: 0,
+        costReportedByExecutor: false,
+        output: finalOutput.trim() ? finalOutput : null,
+        stopReason: ok ? extractCodexStopReason(events) : 'error',
+        ...(uniqueErrors.length > 0 && { error: uniqueErrors.join('; ') }),
+        numTurns: resultEvents.length,
+        fullNumTurns: trace.fullNumTurns,
+        numSubAgents: trace.numSubAgents,
+        ...(trace.turns.length > 0 && { turns: trace.turns }),
+        ...(trace.toolCalls.length > 0 && { toolCalls: trace.toolCalls }),
+    };
+}

package/dist/executors/codex-sdk.js

@@ -1,12 +1,11 @@
 import { existsSync } from 'node:fs';
-import { mkdtemp, symlink } from 'node:fs/promises';
+import { copyFile, mkdtemp, rm } from 'node:fs/promises';
 import { homedir, tmpdir } from 'node:os';
 import { join } from 'node:path';
-import { extractCodexTrace, isCodexResultEvent } from './codex-cli-trace.js';
-import { asErrorLike, buildExecEnv, DEFAULT_TIMEOUT_MS, errorMessage, timeoutExecResult, } from './shared.js';
-import { extractCodexFinalOutput, extractCodexStopReason, extractCodexUsage, isolateCodexCwd, sumCodexElapsed, } from './codex-cli.js';
+import { buildCodexResult } from './codex-protocol.js';
+import { asErrorLike, buildExecEnv, DEFAULT_TIMEOUT_MS, errorMessage, interruptedExecResult, normalizeCodexProtocolEvent, registerSigintSubscriber, timeoutExecResult, } from './shared.js';
+import { isolateCodexCwd } from './codex-cli.js';
 let CodexCtor = null;
-let codexHomePromise = null;
 let hasWarnedSystem = false;
 let hasWarnedCost = false;
 async function getCodexCtor() {
@@ -24,37 +23,31 @@ async function getCodexCtor() {
 // instructions, tool config)into the eval and pollute `~/.codex/sessions/`
 // across runs.
 //
-// Mitigation: redirect $CODEX_HOME to a per-process tmp dir for codex-sdk only.
-// auth.json is symlinked from the real CODEX_HOME so the SDK can still
-// authenticate; config.toml + sessions/ stay isolated. Tmp dir stays alive for
-// the OS to rotate(no explicit cleanup, matches DEFAULT_TIMEOUT_MS scope).
+// Mitigation: redirect $CODEX_HOME to a fresh tmp dir for every codex-sdk run.
+// auth.json is copied from the real CODEX_HOME so token refreshes cannot mutate
+// the user's credential file through a symlink; config.toml + sessions/ stay
+// isolated and the tmp dir is removed after the SDK child exits.
 //
-// Best-effort on Windows where symlink may need elevated privileges; on
-// failure, the codex-sdk executor still runs but lands in the user's real
-// CODEX_HOME with a stderr warning.
+// The SDK still does not expose codex CLI's `--ignore-rules`. Project
+// execpolicy is therefore part of codex-sdk's runtime context; use codex-cli
+// when that final isolation boundary matters.
 export async function getIsolatedCodexHome() {
-    if (!codexHomePromise) {
-        codexHomePromise = (async () => {
-            const tmpHome = await mkdtemp(join(tmpdir(), 'omk-codex-sdk-'));
-            const realHome = process.env.CODEX_HOME || join(homedir(), '.codex');
-            const realAuth = join(realHome, 'auth.json');
-            if (existsSync(realAuth)) {
-                try {
-                    await symlink(realAuth, join(tmpHome, 'auth.json'));
-                }
-                catch (err) {
-                    process.stderr.write(`[codex-sdk] CODEX_HOME isolation: auth.json symlink failed (${err.message}); SDK will use bare tmp home and may fail to authenticate\n`);
-                }
-            }
-            return tmpHome;
-        })();
+    const tmpHome = await mkdtemp(join(tmpdir(), 'omk-codex-sdk-'));
+    const realHome = process.env.CODEX_HOME || join(homedir(), '.codex');
+    const realAuth = join(realHome, 'auth.json');
+    if (existsSync(realAuth)) {
+        try {
+            await copyFile(realAuth, join(tmpHome, 'auth.json'));
+        }
+        catch (err) {
+            process.stderr.write(`[codex-sdk] CODEX_HOME isolation: auth.json copy failed (${err.message}); SDK will use bare tmp home and may fail to authenticate\n`);
+        }
     }
-    return codexHomePromise;
+    return tmpHome;
 }
 // exported for test isolation
 export function __resetCodexSdkStateForTest() {
     CodexCtor = null;
-    codexHomePromise = null;
     hasWarnedSystem = false;
     hasWarnedCost = false;
 }
@@ -79,7 +72,7 @@ export async function createCodexSdkClient(env) {
     return new CodexClient(buildCodexSdkClientOptions(env));
 }
 function normalizeSdkEvent(event) {
-    return event;
+    return normalizeCodexProtocolEvent(event) ?? {};
 }
 export async function codexSdkExecutor({ model, system, prompt, cwd, skillDir, timeoutMs = DEFAULT_TIMEOUT_MS, allowedSkills, verbose }) {
     isolateCodexCwd(allowedSkills, cwd, 'codex-sdk');
@@ -95,7 +88,16 @@ export async function codexSdkExecutor({ model, system, prompt, cwd, skillDir, t
     const env = buildExecEnv(skillDir);
     const start = Date.now();
     const abortController = new AbortController();
-    const timer = setTimeout(() => abortController.abort(), timeoutMs);
+    let abortReason;
+    const abort = (reason) => {
+        if (abortReason)
+            return;
+        abortReason = reason;
+        abortController.abort();
+    };
+    const timer = setTimeout(() => {
+        abort('timeout');
+    }, timeoutMs);
     // SIGINT propagation: PR #33 helper only tracks child process refs registered
     // via spawnWithSigintPropagation; @openai/codex-sdk does its own spawn()
     // internally and the SDK child is not in that registry. Hook the
@@ -103,111 +105,57 @@ export async function codexSdkExecutor({ model, system, prompt, cwd, skillDir, t
     // abortSignal pipeline (SDK passes `signal: args.signal` to spawn). Without
     // this, Ctrl+C in a nested host orphans the codex SDK child until DEFAULT
     // timeout elapses, regressing PR #33's nested-host fix.
-    const sigintListener = () => abortController.abort();
-    process.on('SIGINT', sigintListener);
+    const unregisterSigint = registerSigintSubscriber(() => abort('interrupted'));
     const events = [];
+    let isolatedCodexHome;
     try {
-        env.CODEX_HOME = await getIsolatedCodexHome();
+        isolatedCodexHome = await getIsolatedCodexHome();
+        env.CODEX_HOME = isolatedCodexHome;
         const codex = await createCodexSdkClient(env);
         const thread = codex.startThread(buildCodexSdkThreadOptions({ model, cwd }));
         const streamed = await thread.runStreamed(finalPrompt, { signal: abortController.signal });
         for await (const event of streamed.events) {
             events.push(normalizeSdkEvent(event));
         }
-        const durationMs = Date.now() - start;
-        const resultEvents = events.filter(isCodexResultEvent);
-        if (resultEvents.length === 0) {
-            return {
-                ok: false,
-                error: 'no turn.completed/turn.failed event in codex-sdk output',
-                durationMs,
-                durationApiMs: 0,
-                inputTokens: 0,
-                outputTokens: 0,
-                cacheReadTokens: 0,
-                cacheCreationTokens: 0,
-                costUSD: 0,
-                costReportedByExecutor: false,
-                output: null,
-                stopReason: 'error',
-                numTurns: 0,
-            };
-        }
-        const last = resultEvents[resultEvents.length - 1];
-        const usage = extractCodexUsage(events);
-        const trace = extractCodexTrace(events);
-        const stopReason = extractCodexStopReason(events);
-        const finalOutput = extractCodexFinalOutput(events);
-        const ok = last.type !== 'turn.failed' && !last.error;
-        return {
-            ok,
-            durationMs: sumCodexElapsed(resultEvents, durationMs),
-            durationApiMs: 0,
-            inputTokens: usage.input,
-            outputTokens: usage.output,
-            cacheReadTokens: usage.cached,
-            cacheCreationTokens: 0,
-            costUSD: 0,
-            costReportedByExecutor: false,
-            output: finalOutput,
-            stopReason,
-            ...(!ok && { error: last.error?.message || 'codex-sdk turn.failed' }),
-            numTurns: resultEvents.length,
-            fullNumTurns: trace.fullNumTurns,
-            numSubAgents: trace.numSubAgents,
-            ...(trace.turns.length > 0 && { turns: trace.turns }),
-            ...(trace.toolCalls.length > 0 && { toolCalls: trace.toolCalls }),
-        };
+        return buildCodexResult({
+            events,
+            wallClockDurationMs: Date.now() - start,
+            source: 'codex-sdk',
+        });
     }
     catch (err) {
         const durationMs = Date.now() - start;
         const details = asErrorLike(err);
-        const isAbort = details.name === 'AbortError' || abortController.signal.aborted;
-        if (isAbort)
+        if (abortReason === 'interrupted') {
+            return { ...interruptedExecResult(durationMs), costReportedByExecutor: false };
+        }
+        if (abortReason === 'timeout') {
             return { ...timeoutExecResult(timeoutMs, durationMs), costReportedByExecutor: false };
-        const resultEvents = events.filter(isCodexResultEvent);
-        if (resultEvents.length > 0) {
-            const last = resultEvents[resultEvents.length - 1];
-            const usage = extractCodexUsage(events);
-            const trace = extractCodexTrace(events);
-            return {
-                ok: false,
-                error: last.error?.message || errorMessage(err),
-                durationMs: sumCodexElapsed(resultEvents, durationMs),
-                durationApiMs: 0,
-                inputTokens: usage.input,
-                outputTokens: usage.output,
-                cacheReadTokens: usage.cached,
-                cacheCreationTokens: 0,
-                costUSD: 0,
-                costReportedByExecutor: false,
-                output: extractCodexFinalOutput(events) || null,
-                stopReason: 'error',
-                numTurns: resultEvents.length,
-                fullNumTurns: trace.fullNumTurns,
-                numSubAgents: trace.numSubAgents,
-                ...(trace.turns.length > 0 && { turns: trace.turns }),
-                ...(trace.toolCalls.length > 0 && { toolCalls: trace.toolCalls }),
-            };
         }
-        return {
-            ok: false,
-            error: errorMessage(err),
-            durationMs,
-            durationApiMs: 0,
-            inputTokens: 0,
-            outputTokens: 0,
-            cacheReadTokens: 0,
-            cacheCreationTokens: 0,
-            costUSD: 0,
-            costReportedByExecutor: false,
-            output: null,
-            stopReason: 'error',
-            numTurns: 0,
-        };
+        return buildCodexResult({
+            events,
+            wallClockDurationMs: durationMs,
+            source: 'codex-sdk',
+            forcedError: details.name === 'AbortError'
+                ? 'codex-sdk execution aborted'
+                : errorMessage(err),
+        });
     }
     finally {
         clearTimeout(timer);
-        process.removeListener('SIGINT', sigintListener);
+        unregisterSigint();
+        if (isolatedCodexHome) {
+            try {
+                await rm(isolatedCodexHome, {
+                    recursive: true,
+                    force: true,
+                    maxRetries: 3,
+                    retryDelay: 50,
+                });
+            }
+            catch (err) {
+                process.stderr.write(`[codex-sdk] unable to remove isolated CODEX_HOME ${isolatedCodexHome}: ${errorMessage(err)}\n`);
+            }
+        }
     }
 }

package/dist/executors/gemini.js

@@ -1,4 +1,5 @@
 import { DEFAULT_TIMEOUT_MS, errorMessage, interruptedExecResult, parseJson, spawnWithSigintPropagation, timeoutExecResult, } from './shared.js';
+import { optionalTokenCount } from '../shared/token-usage.js';
 export async function geminiExecutor({ model, system, prompt, timeoutMs = DEFAULT_TIMEOUT_MS }) {
     const fullPrompt = system ? `${system}\n\n${prompt}` : prompt;
     const start = Date.now();
@@ -10,6 +11,7 @@ export async function geminiExecutor({ model, system, prompt, timeoutMs = DEFAUL
             env: { ...process.env },
             timeoutMs,
         });
+        child.stdin?.on('error', () => undefined);
         child.stdin?.write(fullPrompt);
         child.stdin?.end();
         let output;
@@ -23,30 +25,81 @@ export async function geminiExecutor({ model, system, prompt, timeoutMs = DEFAUL
                 return timeoutExecResult(timeoutMs, Date.now() - start);
             if (details.killedBySignal)
                 return interruptedExecResult(Date.now() - start);
-            // gemini 退出码非 0 但有 stdout 时仍按成功路径解析(原行为);只在 stdout 为空时才视为失败
-            if (details.stdout && details.stdout.length > 0) {
-                output = details.stdout;
-            }
-            else {
-                throw err;
-            }
+            const durationMs = Date.now() - start;
+            return {
+                ok: false,
+                error: details.stderr?.trim() || details.message || `gemini exited with code ${details.code ?? '?'}`,
+                durationMs,
+                durationApiMs: 0,
+                inputTokens: 0,
+                outputTokens: 0,
+                cacheReadTokens: 0,
+                cacheCreationTokens: 0,
+                tokenUsageReportedByExecutor: false,
+                costUSD: 0,
+                costReportedByExecutor: false,
+                output: details.stdout?.trim() || null,
+                stopReason: 'error',
+                numTurns: 0,
+            };
         }
         const durationMs = Date.now() - start;
         let text = output;
         let inputTokens = 0;
         let outputTokens = 0;
+        let tokenUsageReported = false;
         try {
-            const data = parseJson(output);
-            if (data.response)
-                text = data.response;
-            if (data.stats) {
-                inputTokens = data.stats.inputTokens || 0;
-                outputTokens = data.stats.outputTokens || 0;
+            const parsed = parseJson(output);
+            if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+                const record = parsed;
+                const declaresProtocol = Object.hasOwn(record, 'response')
+                    || Object.hasOwn(record, 'stats');
+                if (declaresProtocol) {
+                    const data = parsed;
+                    if (typeof data.response !== 'string') {
+                        return invalidGeminiProtocolResult(durationMs, '"response" must be a string');
+                    }
+                    text = data.response;
+                    if (data.stats !== undefined
+                        && (!data.stats
+                            || typeof data.stats !== 'object'
+                            || Array.isArray(data.stats))) {
+                        return invalidGeminiProtocolResult(durationMs, '"stats" must be an object when present');
+                    }
+                    if (data.stats !== undefined) {
+                        const parsedInput = optionalTokenCount(data.stats.inputTokens);
+                        const parsedOutput = optionalTokenCount(data.stats.outputTokens);
+                        if (parsedInput === undefined || parsedOutput === undefined) {
+                            return invalidGeminiProtocolResult(durationMs, 'invalid token usage');
+                        }
+                        inputTokens = parsedInput;
+                        outputTokens = parsedOutput;
+                        tokenUsageReported = true;
+                    }
+                }
             }
         }
         catch {
             text = output.trim();
         }
+        if (!text.trim()) {
+            return {
+                ok: false,
+                error: 'gemini completed without model output',
+                durationMs,
+                durationApiMs: 0,
+                inputTokens,
+                outputTokens,
+                cacheReadTokens: 0,
+                cacheCreationTokens: 0,
+                ...(!tokenUsageReported && { tokenUsageReportedByExecutor: false }),
+                costUSD: 0,
+                costReportedByExecutor: false,
+                output: null,
+                stopReason: 'error',
+                numTurns: 1,
+            };
+        }
         return {
             ok: true,
             durationMs,
@@ -55,7 +108,9 @@ export async function geminiExecutor({ model, system, prompt, timeoutMs = DEFAUL
             outputTokens,
             cacheReadTokens: 0,
             cacheCreationTokens: 0,
+            ...(!tokenUsageReported && { tokenUsageReportedByExecutor: false }),
             costUSD: 0,
+            costReportedByExecutor: false,
             output: text,
             stopReason: 'end',
             numTurns: 1,
@@ -72,10 +127,30 @@ export async function geminiExecutor({ model, system, prompt, timeoutMs = DEFAUL
             outputTokens: 0,
             cacheReadTokens: 0,
             cacheCreationTokens: 0,
+            tokenUsageReportedByExecutor: false,
             costUSD: 0,
+            costReportedByExecutor: false,
             output: null,
             stopReason: 'error',
             numTurns: 0,
         };
     }
 }
+function invalidGeminiProtocolResult(durationMs, message) {
+    return {
+        ok: false,
+        error: `gemini returned malformed protocol JSON: ${message}`,
+        durationMs,
+        durationApiMs: 0,
+        inputTokens: 0,
+        outputTokens: 0,
+        cacheReadTokens: 0,
+        cacheCreationTokens: 0,
+        tokenUsageReportedByExecutor: false,
+        costUSD: 0,
+        costReportedByExecutor: false,
+        output: null,
+        stopReason: 'error',
+        numTurns: 1,
+    };
+}

package/dist/executors/index.d.ts

@@ -1,6 +1,5 @@
 import type { ExecutorFn } from '../types/index.js';
 import { extractAgentTrace } from './claude-sdk-trace.js';
 import { createScriptExecutor } from './script.js';
-import { DEFAULT_MODEL, JUDGE_MODEL } from './shared.js';
-export { DEFAULT_MODEL, JUDGE_MODEL, extractAgentTrace, createScriptExecutor };
-export declare function createExecutor(name?: string): ExecutorFn;
+export { extractAgentTrace, createScriptExecutor };
+export declare function createExecutor(name: string): ExecutorFn;

package/dist/executors/index.js

@@ -7,7 +7,6 @@ import { codexSdkExecutor } from './codex-sdk.js';
 import { geminiExecutor } from './gemini.js';
 import { openAiApiExecutor } from './openai-api.js';
 import { createScriptExecutor } from './script.js';
-import { DEFAULT_MODEL, JUDGE_MODEL } from './shared.js';
 // 命名一致性:provider HTTP 路径统一用 `<vendor>-api`(`anthropic-api` / `openai-api`),
 // vendor coding agent CLI 用 vendor 名(`claude` / `codex`)。`openai` 这个不带 -api 后缀的
 // 旧 alias 历史上指 openai-cli 子进程实现,删除后不再设别名 — 用 `--executor openai-api`。
@@ -20,7 +19,10 @@ const EXECUTOR_REGISTRY = {
     'anthropic-api': anthropicApiExecutor,
     'openai-api': openAiApiExecutor,
 };
-export { DEFAULT_MODEL, JUDGE_MODEL, extractAgentTrace, createScriptExecutor };
-export function createExecutor(name = 'claude') {
+export { extractAgentTrace, createScriptExecutor };
+export function createExecutor(name) {
+    if (name.trim().length === 0) {
+        throw new Error('executor name or script command is required');
+    }
     return EXECUTOR_REGISTRY[name] || createScriptExecutor(name);
 }