yepanywhere 0.6.0 → 0.6.2

package/dist/codex/normalization.js

@@ -1,19 +1,20 @@
+import { createCodexCodeModeGroupInput, extractCodexCodeModeCalls, extractCodexCodeModeTextOutput, } from "./codeModeExec.js";
+import { analyzeCodexCommand, stripOuterQuotes, toToolDisplayActions, unwrapCodexShellLauncherCommand, } from "./displayActions.js";
+import { parseCodexWebRunOutput } from "./webRun.js";
 export const CODEX_TOOL_NAME_ALIASES = {
     shell_command: "Bash",
     exec_command: "Bash",
     write_stdin: "WriteStdin",
+    // A detached code-mode script cell is polled with `wait`; it shares the
+    // shell-session presentation ("waiting for output") with stdin polls.
+    wait: "WriteStdin",
     update_plan: "UpdatePlan",
     apply_patch: "Edit",
     web_search_call: "WebSearch",
     search_query: "WebSearch",
+    // Code-mode flattening of the namespaced `web.run` browsing tool.
+    web__run: "Web",
 };
-const SHELL_EXECUTABLES = new Set(["bash", "sh", "zsh", "dash"]);
-const POWERSHELL_EXECUTABLES = new Set([
-    "pwsh",
-    "pwsh.exe",
-    "powershell",
-    "powershell.exe",
-]);
 const INLINE_IMAGE_DATA_URL_PREFIX_RE = /^data:(image\/[a-z0-9.+-]+)(?:;[^,]*)?,/i;
 const INLINE_IMAGE_DATA_URL_GLOBAL_RE = /data:image\/[a-z0-9.+-]+(?:;[a-z0-9=.+-]+)*,[A-Za-z0-9+/=_-]+/gi;
 export function parseCodexToolArguments(argumentsText) {
@@ -52,21 +53,44 @@ export function normalizeCodexToolInvocation(toolName, input) {
     if (!command) {
         return { toolName: "Bash", input: normalizedInput };
     }
-    const normalizedCommand = unwrapShellLauncherCommand(command);
-    const readShellInfo = parseReadShellCommand(normalizedCommand);
-    if (readShellInfo) {
-        return {
-            toolName: "Read",
-            input: createReadToolInput(readShellInfo),
-            readShellInfo,
-        };
-    }
-    const grepInput = parseRipgrepCommand(normalizedCommand);
-    if (grepInput) {
-        return {
-            toolName: "Grep",
-            input: grepInput,
-        };
+    const normalizedCommand = unwrapCodexShellLauncherCommand(command);
+    const workingDirectory = isRecord(normalizedInput)
+        ? (getStringField(normalizedInput, "workdir") ??
+            getStringField(normalizedInput, "cwd"))
+        : undefined;
+    const commandAnalysis = analyzeCodexCommand(command, workingDirectory);
+    const displayActions = commandAnalysis
+        ? toToolDisplayActions(commandAnalysis.actions)
+        : undefined;
+    if (commandAnalysis?.actions.length === 1) {
+        const action = commandAnalysis.actions[0];
+        if (action?.kind === "read") {
+            const readShellInfo = {
+                filePath: action.filePath,
+                ...(action.startLine !== undefined
+                    ? { startLine: action.startLine }
+                    : {}),
+                ...(action.endLine !== undefined ? { endLine: action.endLine } : {}),
+                stripLineNumbers: action.stripLineNumbers,
+            };
+            return {
+                toolName: "Read",
+                input: createReadToolInput(readShellInfo),
+                displayActions,
+                readShellInfo,
+            };
+        }
+        if (action?.kind === "search") {
+            return {
+                toolName: "Grep",
+                input: {
+                    pattern: action.query,
+                    output_mode: "content",
+                    ...(action.path ? { path: action.path } : {}),
+                },
+                displayActions,
+            };
+        }
     }
     const writeShellInfo = parseHeredocWriteShellCommand(normalizedCommand);
     if (writeShellInfo) {
@@ -76,49 +100,36 @@ export function normalizeCodexToolInvocation(toolName, input) {
             writeShellInfo,
         };
     }
-    return { toolName: "Bash", input: normalizedInput };
+    return {
+        toolName: "Bash",
+        input: normalizedInput,
+        ...(displayActions ? { displayActions } : {}),
+    };
 }
-export function normalizeCodexCommandActionInvocation(command, commandActions) {
-    if (!Array.isArray(commandActions) || commandActions.length !== 1) {
-        return null;
-    }
-    const action = commandActions[0];
-    if (!isRecord(action)) {
-        return null;
-    }
-    const actionType = getStringField(action, "type");
-    if (actionType === "read") {
-        const path = getStringField(action, "path");
-        if (!path) {
-            return null;
+export function normalizeCodexCustomToolInvocation(rawToolName, rawInput) {
+    const codeModeCalls = rawToolName === "exec" ? extractCodexCodeModeCalls(rawInput) : [];
+    if (codeModeCalls.length === 1) {
+        const nestedCall = codeModeCalls[0];
+        if (nestedCall) {
+            return normalizeCodexToolInvocation(canonicalizeCodexToolName(nestedCall.toolName), nestedCall.input);
         }
-        const commandReadInfo = parseReadShellCommand(unwrapShellLauncherCommand(command));
-        const readShellInfo = {
-            ...(commandReadInfo ?? { stripLineNumbers: false }),
-            filePath: path,
-        };
-        return {
-            toolName: "Read",
-            input: createReadToolInput(readShellInfo),
-            readShellInfo,
-        };
     }
-    if (actionType === "search") {
-        const query = getStringField(action, "query");
-        if (!query) {
-            return null;
-        }
-        const input = {
-            pattern: query,
-            output_mode: "content",
+    if (codeModeCalls.length > 1 && typeof rawInput === "string") {
+        const normalizedCalls = codeModeCalls.map((call) => normalizeCodexToolInvocation(canonicalizeCodexToolName(call.toolName), call.input));
+        const displayActions = normalizedCalls.every((call) => call.displayActions && call.displayActions.length > 0)
+            ? normalizedCalls.flatMap((call) => call.displayActions ?? [])
+            : undefined;
+        return {
+            toolName: "Exec",
+            input: createCodexCodeModeGroupInput(rawInput, codeModeCalls),
+            ...(displayActions ? { displayActions } : {}),
         };
-        const path = getStringField(action, "path");
-        if (path) {
-            input.path = path;
-        }
-        return { toolName: "Grep", input };
     }
-    return null;
+    const canonicalToolName = canonicalizeCodexToolName(rawToolName);
+    const normalizedInput = canonicalToolName === "Edit" && typeof rawInput === "string"
+        ? { _rawPatch: rawInput }
+        : rawInput;
+    return normalizeCodexToolInvocation(canonicalToolName, normalizedInput);
 }
 export function normalizeCodexToolOutputWithContext(output, context) {
     const normalized = normalizeCodexToolOutput(output);
@@ -160,12 +171,61 @@ export function normalizeCodexToolOutputWithContext(output, context) {
         }
     }
     else if (context?.toolName === "Bash") {
-        const bashContent = extractCodexShellOutputContent(content);
+        let bashContent = extractCodexShellOutputContent(content);
+        let bashExitCode = exitCode;
+        const chunk = parseCodexUnifiedExecChunkOutput(bashContent);
+        if (chunk) {
+            bashContent = chunk.output;
+            if (chunk.exitCode !== undefined) {
+                bashExitCode = chunk.exitCode;
+                isError = chunk.exitCode !== 0;
+            }
+        }
         structured = createBashToolResult(interrupted ? "" : bashContent, isError, backgroundTaskId, interrupted, 
         // Carry a recoverable exit code so reloaded (function_call_output-only)
         // Bash results match the live-stream structured result. Equivalence is a
         // contract — see topics/stream-persisted-render-parity.md.
-        exitCode);
+        bashExitCode, 
+        // Command runtime, from the chunk record or the shell envelope (spec:
+        // topics/provider-output-contract.md § Command execution metadata).
+        chunk?.durationSeconds ?? extractWallTimeSecondsFromText(content));
+    }
+    else if (context?.toolName === "WriteStdin") {
+        const chunk = parseCodexUnifiedExecChunkOutput(content);
+        if (chunk) {
+            content = chunk.output;
+            // Raw chunk fields pass through; normalized command metadata and a
+            // stdout alias ride alongside so renderers need no chunk knowledge.
+            structured = {
+                ...chunk.record,
+                stdout: chunk.output,
+                ...(chunk.exitCode !== undefined ? { exitCode: chunk.exitCode } : {}),
+                ...(chunk.durationSeconds !== undefined
+                    ? { durationSeconds: chunk.durationSeconds }
+                    : {}),
+            };
+            if (chunk.exitCode !== undefined) {
+                isError = chunk.exitCode !== 0;
+            }
+        }
+    }
+    else if (context?.toolName === "Web") {
+        const webRun = parseCodexWebRunOutput(content);
+        if (webRun) {
+            structured = webRun.result;
+            content = webRun.contentText;
+            // The envelope's "Script completed" confirms the browse ran; page text
+            // that merely contains "Error:" must not mark the call failed.
+            isError = false;
+        }
+    }
+    else if (context?.toolName === "Edit" && context.patchApplyResult) {
+        const patchOutput = context.patchApplyResult.success
+            ? context.patchApplyResult.stdout
+            : context.patchApplyResult.stderr || context.patchApplyResult.stdout;
+        if (patchOutput)
+            content = patchOutput;
+        isError = !context.patchApplyResult.success;
     }
     return { content, structured, isError };
 }
@@ -229,350 +289,6 @@ function extractBashCommand(input) {
     }
     return "";
 }
-function tokenizeShellCommand(command) {
-    const tokens = [];
-    let current = "";
-    let quote = null;
-    let escaping = false;
-    for (let i = 0; i < command.length; i++) {
-        const char = command[i];
-        if (!char)
-            continue;
-        if (escaping) {
-            current += char;
-            escaping = false;
-            continue;
-        }
-        if (quote) {
-            if (char === quote) {
-                quote = null;
-            }
-            else if (quote === '"' &&
-                char === "\\" &&
-                shouldEscapeShellChar(command[i + 1])) {
-                escaping = true;
-            }
-            else {
-                current += char;
-            }
-            continue;
-        }
-        if (char === "\\" && shouldEscapeShellChar(command[i + 1])) {
-            escaping = true;
-            continue;
-        }
-        if (char === "'" || char === '"') {
-            quote = char;
-            continue;
-        }
-        if (/\s/.test(char)) {
-            if (current.length > 0) {
-                tokens.push(current);
-                current = "";
-            }
-            continue;
-        }
-        current += char;
-    }
-    if (current.length > 0) {
-        tokens.push(current);
-    }
-    return tokens;
-}
-function getExecutableName(token) {
-    const normalized = token.replace(/\\/g, "/");
-    return (normalized.split("/").pop() || token).toLowerCase();
-}
-function isShellExecutable(token) {
-    return SHELL_EXECUTABLES.has(getExecutableName(token));
-}
-function isPowerShellExecutable(token) {
-    const executableName = getExecutableName(token);
-    return (POWERSHELL_EXECUTABLES.has(executableName) ||
-        executableName.endsWith("pwsh.exe") ||
-        executableName.endsWith("powershell.exe"));
-}
-function shouldEscapeShellChar(next) {
-    return (next !== undefined &&
-        (/\s/.test(next) || next === "\\" || next === "'" || next === '"'));
-}
-function getShellLauncherPrefixLength(tokens) {
-    if (tokens.length < 3) {
-        return 0;
-    }
-    const first = tokens[0] || "";
-    const second = tokens[1] || "";
-    const third = tokens[2] || "";
-    // /usr/bin/env bash -lc "command"
-    if (getExecutableName(first) === "env" &&
-        isShellExecutable(second) &&
-        third === "-lc" &&
-        tokens.length >= 4) {
-        return 3;
-    }
-    // /bin/bash -lc "command"
-    if (isShellExecutable(first) && second === "-lc" && tokens.length >= 3) {
-        return 2;
-    }
-    if (isPowerShellExecutable(first)) {
-        for (let i = 1; i < tokens.length - 1; i++) {
-            const token = tokens[i]?.toLowerCase();
-            if (token === "-command" || token === "-c") {
-                return i + 1;
-            }
-        }
-    }
-    return 0;
-}
-function unwrapShellLauncherCommand(command) {
-    let normalized = command.trim();
-    // Allow nested wrappers, e.g. `bash -lc "env bash -lc \"...\""`
-    for (let i = 0; i < 3; i++) {
-        const tokens = tokenizeShellCommand(normalized);
-        const launcherPrefixLength = getShellLauncherPrefixLength(tokens);
-        if (launcherPrefixLength === 0 || tokens.length <= launcherPrefixLength) {
-            break;
-        }
-        normalized = tokens.slice(launcherPrefixLength).join(" ").trim();
-    }
-    return normalized;
-}
-function parseLineRangeToken(token) {
-    const match = token.match(/^(\d+)(?:,(\d+))?p$/);
-    if (!match?.[1])
-        return null;
-    const startLine = Number.parseInt(match[1], 10);
-    const endLine = match[2] ? Number.parseInt(match[2], 10) : startLine;
-    if (!Number.isFinite(startLine) || !Number.isFinite(endLine)) {
-        return null;
-    }
-    return {
-        startLine,
-        endLine: Math.max(startLine, endLine),
-    };
-}
-function parseReadShellCommand(command) {
-    const tokens = tokenizeShellCommand(command);
-    if (tokens.length === 0)
-        return null;
-    if (tokens[0] === "cat" && tokens.length === 2) {
-        const filePath = tokens[1];
-        if (!filePath || filePath.startsWith("-")) {
-            return null;
-        }
-        return {
-            filePath,
-            stripLineNumbers: false,
-        };
-    }
-    if (tokens[0] === "sed" && tokens[1] === "-n" && tokens.length === 4) {
-        const range = parseLineRangeToken(tokens[2] ?? "");
-        const filePath = tokens[3];
-        if (!range || !filePath || filePath.startsWith("-")) {
-            return null;
-        }
-        return {
-            filePath,
-            startLine: range.startLine,
-            endLine: range.endLine,
-            stripLineNumbers: false,
-        };
-    }
-    const isNlSedCommand = tokens[0] === "nl" &&
-        tokens[1] === "-ba" &&
-        tokens[3] === "|" &&
-        tokens[4] === "sed" &&
-        tokens[5] === "-n" &&
-        tokens.length === 7;
-    if (isNlSedCommand) {
-        const filePath = tokens[2];
-        const range = parseLineRangeToken(tokens[6] ?? "");
-        if (!filePath || !range)
-            return null;
-        return {
-            filePath,
-            startLine: range.startLine,
-            endLine: range.endLine,
-            stripLineNumbers: true,
-        };
-    }
-    const powershellRead = parsePowerShellGetContentCommand(tokens);
-    if (powershellRead) {
-        return powershellRead;
-    }
-    return null;
-}
-function parsePowerShellGetContentCommand(tokens) {
-    const command = tokens[0]?.toLowerCase();
-    if (command !== "get-content") {
-        return null;
-    }
-    // Compound commands aren't simple reads. A single pipe into Select-Object is
-    // handled below (Codex emits `Get-Content … | Select-Object -Skip -First` for
-    // partial reads, the PowerShell analogue of `sed -n`).
-    if (tokens.some((token) => token === "&&" || token === ";")) {
-        return null;
-    }
-    const pipeIndex = tokens.indexOf("|");
-    const getContentTokens = pipeIndex === -1 ? tokens : tokens.slice(0, pipeIndex);
-    let selectWindow = null;
-    if (pipeIndex !== -1) {
-        selectWindow = parseSelectObjectWindow(tokens.slice(pipeIndex + 1));
-        if (!selectWindow) {
-            return null;
-        }
-    }
-    const flagsWithValue = new Set([
-        "-credential",
-        "-delimiter",
-        "-encoding",
-        "-erroraction",
-        "-exclude",
-        "-filter",
-        "-include",
-        "-readcount",
-        "-stream",
-    ]);
-    let filePath = "";
-    let totalCount;
-    for (let i = 1; i < getContentTokens.length; i++) {
-        const token = getContentTokens[i];
-        if (!token)
-            continue;
-        const normalized = token.toLowerCase();
-        if (normalized === "-path" || normalized === "-literalpath") {
-            const next = getContentTokens[i + 1];
-            if (!next || next.startsWith("-")) {
-                return null;
-            }
-            filePath = next;
-            i += 1;
-            continue;
-        }
-        if (normalized.startsWith("-path:")) {
-            filePath = token.slice("-path:".length);
-            continue;
-        }
-        if (normalized.startsWith("-literalpath:")) {
-            filePath = token.slice("-literalpath:".length);
-            continue;
-        }
-        if (normalized === "-totalcount" || normalized === "-head") {
-            const next = getContentTokens[i + 1];
-            const parsed = next ? Number.parseInt(next, 10) : Number.NaN;
-            if (!Number.isFinite(parsed) || parsed < 0) {
-                return null;
-            }
-            totalCount = parsed;
-            i += 1;
-            continue;
-        }
-        if (normalized.startsWith("-totalcount:")) {
-            const parsed = Number.parseInt(token.slice("-totalcount:".length), 10);
-            if (!Number.isFinite(parsed) || parsed < 0) {
-                return null;
-            }
-            totalCount = parsed;
-            continue;
-        }
-        if (normalized.startsWith("-head:")) {
-            const parsed = Number.parseInt(token.slice("-head:".length), 10);
-            if (!Number.isFinite(parsed) || parsed < 0) {
-                return null;
-            }
-            totalCount = parsed;
-            continue;
-        }
-        if (flagsWithValue.has(normalized)) {
-            i += 1;
-            continue;
-        }
-        if (token.startsWith("-")) {
-            continue;
-        }
-        if (!filePath) {
-            filePath = token;
-        }
-    }
-    filePath = stripOuterQuotes(filePath);
-    if (!filePath || filePath.startsWith("-")) {
-        return null;
-    }
-    if (selectWindow) {
-        const startLine = selectWindow.skip + 1;
-        return {
-            filePath,
-            startLine,
-            ...(selectWindow.first !== undefined && selectWindow.first > 0
-                ? { endLine: selectWindow.skip + selectWindow.first }
-                : {}),
-            stripLineNumbers: false,
-        };
-    }
-    return {
-        filePath,
-        ...(totalCount !== undefined && totalCount > 0
-            ? { startLine: 1, endLine: totalCount }
-            : {}),
-        stripLineNumbers: false,
-    };
-}
-// Parses the tail of a `Get-Content … | Select-Object …` pipeline. Only the
-// line-window flags `-Skip`/`-First` (and their inline `-Skip:N` forms) are
-// recognized; any other token disqualifies the pipeline so we don't mislabel a
-// real transform as a read.
-function parseSelectObjectWindow(tokens) {
-    if (tokens[0]?.toLowerCase() !== "select-object") {
-        return null;
-    }
-    let skip;
-    let first;
-    for (let i = 1; i < tokens.length; i++) {
-        const token = tokens[i];
-        if (!token)
-            continue;
-        const normalized = token.toLowerCase();
-        if (normalized === "-skip" || normalized === "-first") {
-            const next = tokens[i + 1];
-            const parsed = next ? Number.parseInt(next, 10) : Number.NaN;
-            if (!Number.isFinite(parsed) || parsed < 0) {
-                return null;
-            }
-            if (normalized === "-skip") {
-                skip = parsed;
-            }
-            else {
-                first = parsed;
-            }
-            i += 1;
-            continue;
-        }
-        if (normalized.startsWith("-skip:") || normalized.startsWith("-first:")) {
-            const prefixLength = normalized.startsWith("-skip:")
-                ? "-skip:".length
-                : "-first:".length;
-            const parsed = Number.parseInt(token.slice(prefixLength), 10);
-            if (!Number.isFinite(parsed) || parsed < 0) {
-                return null;
-            }
-            if (normalized.startsWith("-skip:")) {
-                skip = parsed;
-            }
-            else {
-                first = parsed;
-            }
-            continue;
-        }
-        return null;
-    }
-    if (skip === undefined && first === undefined) {
-        return null;
-    }
-    return {
-        skip: skip ?? 0,
-        ...(first !== undefined ? { first } : {}),
-    };
-}
 function parseHeredocWriteShellCommand(command) {
     const normalized = command.replace(/\r\n/g, "\n").trimEnd();
     const lines = normalized.split("\n");
@@ -635,90 +351,6 @@ function createWriteToolInput(writeInfo) {
         content: writeInfo.content,
     };
 }
-function parseRipgrepCommand(command) {
-    const tokens = tokenizeShellCommand(command);
-    if (tokens[0] !== "rg" || tokens.length < 2) {
-        return null;
-    }
-    if (tokens.some((token) => token === "|" || token === "&&" || token === ";")) {
-        return null;
-    }
-    const flagsWithValue = new Set([
-        "-g",
-        "--glob",
-        "-e",
-        "--regexp",
-        "-f",
-        "--file",
-        "-m",
-        "--max-count",
-        "-A",
-        "--after-context",
-        "-B",
-        "--before-context",
-        "-C",
-        "--context",
-        "-t",
-        "--type",
-        "-T",
-        "--type-not",
-    ]);
-    let pattern = "";
-    const searchPaths = [];
-    for (let i = 1; i < tokens.length; i++) {
-        const token = tokens[i];
-        if (!token)
-            continue;
-        if (token === "--") {
-            const rest = tokens.slice(i + 1).filter(Boolean);
-            if (!pattern && rest[0]) {
-                pattern = rest[0];
-            }
-            if (pattern) {
-                searchPaths.push(...rest.slice(1));
-            }
-            break;
-        }
-        if (token === "-e" || token === "--regexp") {
-            const next = tokens[i + 1];
-            if (next && !pattern) {
-                pattern = next;
-            }
-            i += 1;
-            continue;
-        }
-        if (flagsWithValue.has(token)) {
-            i += 1;
-            continue;
-        }
-        if (token.startsWith("--glob=") || token.startsWith("--regexp=")) {
-            if (token.startsWith("--regexp=") && !pattern) {
-                pattern = token.slice("--regexp=".length);
-            }
-            continue;
-        }
-        if (token.startsWith("-")) {
-            continue;
-        }
-        if (!pattern) {
-            pattern = token;
-        }
-        else {
-            searchPaths.push(token);
-        }
-    }
-    if (!pattern) {
-        return null;
-    }
-    const input = {
-        pattern,
-        output_mode: "content",
-    };
-    if (searchPaths.length > 0) {
-        input.path = searchPaths.join(" ");
-    }
-    return input;
-}
 function isRecord(value) {
     return !!value && typeof value === "object" && !Array.isArray(value);
 }
@@ -800,6 +432,10 @@ function extractSessionIdFromText(output) {
     return Number.parseInt(taskId, 10);
 }
 function normalizeCodexToolOutput(output) {
+    const codeModeText = extractCodexCodeModeTextOutput(output);
+    if (codeModeText !== undefined) {
+        return normalizeCodexToolOutput(codeModeText);
+    }
     if (typeof output === "string") {
         let structured;
         let isError = false;
@@ -951,6 +587,57 @@ function formatByteSize(bytes) {
         return `${Math.round(bytes / 1024)}\u202fkb`;
     return `${Math.round((bytes / (1024 * 1024)) * 10) / 10}\u202fmb`;
 }
+const UNIFIED_EXEC_CHUNK_MARKERS = [
+    "chunk_id",
+    "session_id",
+    "wall_time_seconds",
+    "original_token_count",
+];
+/**
+ * Recognize a unified-exec result record printed as a tool output — the
+ * shape `tools.exec_command`/`wait` return for detached shell sessions:
+ * `{"chunk_id":…,"wall_time_seconds":…,"exit_code":…,"output":"…"}`.
+ * The embedded `output` is the command's real text; showing the raw JSON
+ * hides it. Anything not exactly one such object fails closed.
+ */
+function parseCodexUnifiedExecChunkOutput(content) {
+    const body = extractCodexShellOutputContent(content).trim();
+    if (!body.startsWith("{") || !body.endsWith("}"))
+        return undefined;
+    let parsed;
+    try {
+        parsed = JSON.parse(body);
+    }
+    catch {
+        return undefined;
+    }
+    if (!isRecord(parsed) || typeof parsed.output !== "string")
+        return undefined;
+    if (!UNIFIED_EXEC_CHUNK_MARKERS.some((marker) => marker in parsed)) {
+        return undefined;
+    }
+    const exitCode = parsed.exit_code;
+    const durationSeconds = parsed.wall_time_seconds;
+    return {
+        ...(typeof exitCode === "number" && Number.isFinite(exitCode)
+            ? { exitCode }
+            : {}),
+        ...(typeof durationSeconds === "number" && Number.isFinite(durationSeconds)
+            ? { durationSeconds }
+            : {}),
+        output: parsed.output,
+        record: parsed,
+    };
+}
+/** Command runtime from the shell envelope: "Wall time[:] 30.0 seconds". */
+function extractWallTimeSecondsFromText(content) {
+    const match = content.match(/(?:^|\n)\s*Wall time:?\s+([\d.]+)\s*seconds?\b/i);
+    if (!match?.[1]) {
+        return undefined;
+    }
+    const parsed = Number.parseFloat(match[1]);
+    return Number.isFinite(parsed) ? parsed : undefined;
+}
 function extractCodexShellOutputContent(content) {
     const normalized = content.replace(/\r\n/g, "\n");
     const inlineMarker = "Output:\n";
@@ -965,7 +652,7 @@ function extractCodexShellOutputContent(content) {
     const rawOutput = normalized.slice(markerIndex + marker.length);
     return rawOutput.startsWith("\n") ? rawOutput.slice(1) : rawOutput;
 }
-function createBashToolResult(output, isError, backgroundTaskId, interrupted = false, exitCode) {
+function createBashToolResult(output, isError, backgroundTaskId, interrupted = false, exitCode, durationSeconds) {
     return {
         stdout: interrupted || isError ? "" : output,
         stderr: interrupted ? "" : isError ? output : "",
@@ -973,6 +660,7 @@ function createBashToolResult(output, isError, backgroundTaskId, interrupted = f
         isImage: false,
         ...(backgroundTaskId ? { backgroundTaskId } : {}),
         ...(exitCode !== undefined ? { exitCode } : {}),
+        ...(durationSeconds !== undefined ? { durationSeconds } : {}),
     };
 }
 function normalizeRipgrepOutput(output, pattern) {
@@ -1106,15 +794,4 @@ function countContentLines(content) {
     }
     return lines.length;
 }
-function stripOuterQuotes(value) {
-    if (value.length < 2) {
-        return value;
-    }
-    const first = value[0];
-    const last = value[value.length - 1];
-    if ((first === "'" && last === "'") || (first === '"' && last === '"')) {
-        return value.slice(1, -1);
-    }
-    return value;
-}
 //# sourceMappingURL=normalization.js.map