@getpaseo/server 0.1.2 → 0.1.3

package/dist/server/server/agent/providers/codex/tool-call-mapper.js

@@ -1,10 +1,16 @@
 import { z } from "zod";
-import { CommandValueSchema } from "../tool-call-detail-primitives.js";
-import { coerceToolCallId, extractCodexShellOutput, truncateDiffText, } from "../tool-call-mapper-utils.js";
-import { CODEX_BUILTIN_TOOL_NAMES, deriveCodexToolDetail, normalizeCodexFilePath, } from "./tool-call-detail-parser.js";
+import { extractCodexShellOutput, truncateDiffText, } from "../tool-call-mapper-utils.js";
+import { deriveCodexToolDetail, normalizeCodexFilePath, } from "./tool-call-detail-parser.js";
 const FAILED_STATUSES = new Set(["failed", "error", "errored", "rejected", "denied"]);
 const CANCELED_STATUSES = new Set(["canceled", "cancelled", "interrupted", "aborted"]);
 const COMPLETED_STATUSES = new Set(["completed", "complete", "done", "success", "succeeded"]);
+const CodexCommandValueSchema = z.union([z.string(), z.array(z.string())]);
+const CodexToolCallStatusSchema = z.enum([
+    "running",
+    "completed",
+    "failed",
+    "canceled",
+]);
 const CodexRolloutToolCallParamsSchema = z
     .object({
     callId: z.string().optional().nullable(),
@@ -14,16 +20,145 @@ const CodexRolloutToolCallParamsSchema = z
     error: z.unknown().optional(),
 })
     .passthrough();
+const CodexNormalizedToolCallPass1Schema = z
+    .object({
+    callId: z.string().min(1),
+    name: z.string().min(1),
+    input: z.unknown().nullable(),
+    output: z.unknown().nullable(),
+    status: CodexToolCallStatusSchema,
+    error: z.unknown().nullable(),
+    metadata: z.record(z.string(), z.unknown()).optional(),
+    cwd: z.string().nullable().optional(),
+})
+    .passthrough();
+const CodexShellToolNameSchema = z.union([
+    z.literal("Bash"),
+    z.literal("shell"),
+    z.literal("bash"),
+    z.literal("exec"),
+    z.literal("exec_command"),
+    z.literal("command"),
+]);
+const CodexReadToolNameSchema = z.union([z.literal("read"), z.literal("read_file")]);
+const CodexWriteToolNameSchema = z.union([
+    z.literal("write"),
+    z.literal("write_file"),
+    z.literal("create_file"),
+]);
+const CodexEditToolNameSchema = z.union([
+    z.literal("edit"),
+    z.literal("apply_patch"),
+    z.literal("apply_diff"),
+]);
+const CodexSearchToolNameSchema = z.union([z.literal("search"), z.literal("web_search")]);
+const CodexSpeakToolNameSchema = z.literal("paseo.speak");
+const CodexToolKindSchema = z.enum(["shell", "read", "write", "edit", "search", "speak", "unknown"]);
+const CodexToolCallPass2BaseSchema = CodexNormalizedToolCallPass1Schema.extend({
+    toolKind: CodexToolKindSchema,
+});
+const CodexToolCallPass2EnvelopeSchema = z.union([
+    CodexNormalizedToolCallPass1Schema.extend({
+        name: CodexShellToolNameSchema,
+    }).transform((envelope) => ({ ...envelope, toolKind: "shell" })),
+    CodexNormalizedToolCallPass1Schema.extend({
+        name: CodexReadToolNameSchema,
+    }).transform((envelope) => ({ ...envelope, toolKind: "read" })),
+    CodexNormalizedToolCallPass1Schema.extend({
+        name: CodexWriteToolNameSchema,
+    }).transform((envelope) => ({ ...envelope, toolKind: "write" })),
+    CodexNormalizedToolCallPass1Schema.extend({
+        name: CodexEditToolNameSchema,
+    }).transform((envelope) => ({ ...envelope, toolKind: "edit" })),
+    CodexNormalizedToolCallPass1Schema.extend({
+        name: CodexSearchToolNameSchema,
+    }).transform((envelope) => ({ ...envelope, toolKind: "search" })),
+    CodexNormalizedToolCallPass1Schema.extend({
+        name: CodexSpeakToolNameSchema,
+    }).transform((envelope) => ({ ...envelope, toolKind: "speak" })),
+    CodexNormalizedToolCallPass1Schema.transform((envelope) => ({
+        ...envelope,
+        name: envelope.name.trim(),
+        toolKind: "unknown",
+    })),
+]);
+const CodexNormalizedToolCallPass2Schema = z.discriminatedUnion("toolKind", [
+    CodexToolCallPass2BaseSchema.extend({
+        toolKind: z.literal("shell"),
+        name: CodexShellToolNameSchema,
+    }),
+    CodexToolCallPass2BaseSchema.extend({
+        toolKind: z.literal("read"),
+        name: CodexReadToolNameSchema,
+    }),
+    CodexToolCallPass2BaseSchema.extend({
+        toolKind: z.literal("write"),
+        name: CodexWriteToolNameSchema,
+    }),
+    CodexToolCallPass2BaseSchema.extend({
+        toolKind: z.literal("edit"),
+        name: CodexEditToolNameSchema,
+    }),
+    CodexToolCallPass2BaseSchema.extend({
+        toolKind: z.literal("search"),
+        name: CodexSearchToolNameSchema,
+    }),
+    CodexToolCallPass2BaseSchema.extend({
+        toolKind: z.literal("speak"),
+        name: CodexSpeakToolNameSchema,
+    }),
+    CodexToolCallPass2BaseSchema.extend({
+        toolKind: z.literal("unknown"),
+    }),
+]);
+function toToolCallTimelineItem(envelope) {
+    const name = envelope.toolKind === "speak" ? "speak" : envelope.name;
+    const parsedDetail = deriveCodexToolDetail({
+        name,
+        input: envelope.input,
+        output: envelope.output,
+        cwd: envelope.cwd ?? null,
+    });
+    const detail = envelope.toolKind === "edit" &&
+        envelope.status !== "running" &&
+        !hasRenderableEditDetail(parsedDetail)
+        ? {
+            type: "unknown",
+            input: envelope.input,
+            output: envelope.output,
+        }
+        : parsedDetail;
+    if (envelope.status === "failed") {
+        return {
+            type: "tool_call",
+            callId: envelope.callId,
+            name,
+            status: "failed",
+            error: envelope.error ?? { message: "Tool call failed" },
+            detail,
+            ...(envelope.metadata ? { metadata: envelope.metadata } : {}),
+        };
+    }
+    return {
+        type: "tool_call",
+        callId: envelope.callId,
+        name,
+        status: envelope.status,
+        error: null,
+        detail,
+        ...(envelope.metadata ? { metadata: envelope.metadata } : {}),
+    };
+}
 // ---------------------------------------------------------------------------
 // Thread-item parsing
 // ---------------------------------------------------------------------------
 const CodexCommandExecutionItemSchema = z
     .object({
     type: z.literal("commandExecution"),
-    id: z.string().optional(),
+    id: z.string().min(1),
     status: z.string().optional(),
     error: z.unknown().optional(),
-    command: CommandValueSchema.optional(),
+    command: CodexCommandValueSchema.optional(),
     cwd: z.string().optional(),
     aggregatedOutput: z.string().optional(),
     exitCode: z.number().nullable().optional(),
@@ -32,7 +167,7 @@ const CodexCommandExecutionItemSchema = z
 const CodexFileChangeItemSchema = z
     .object({
     type: z.literal("fileChange"),
-    id: z.string().optional(),
+    id: z.string().min(1),
     status: z.string().optional(),
     error: z.unknown().optional(),
     changes: z
@@ -42,10 +177,7 @@ const CodexFileChangeItemSchema = z
         kind: z.string().optional(),
         diff: z.string().optional(),
         patch: z.string().optional(),
-        unified_diff: z.string().optional(),
-        unifiedDiff: z.string().optional(),
         content: z.string().optional(),
-        newString: z.string().optional(),
     })
         .passthrough())
         .optional(),
@@ -54,12 +186,10 @@ const CodexFileChangeItemSchema = z
 const CodexMcpToolCallItemSchema = z
     .object({
     type: z.literal("mcpToolCall"),
-    id: z.string().optional(),
-    callID: z.string().optional(),
-    call_id: z.string().optional(),
+    id: z.string().min(1),
     status: z.string().optional(),
     error: z.unknown().optional(),
-    tool: z.string().optional(),
+    tool: z.string().min(1),
     server: z.string().optional(),
     arguments: z.unknown().optional(),
     result: z.unknown().optional(),
@@ -68,7 +198,7 @@ const CodexMcpToolCallItemSchema = z
 const CodexWebSearchItemSchema = z
     .object({
     type: z.literal("webSearch"),
-    id: z.string().optional(),
+    id: z.string().min(1),
     status: z.string().optional(),
     error: z.unknown().optional(),
     query: z.string().optional(),
@@ -81,14 +211,6 @@ const CodexThreadItemSchema = z.discriminatedUnion("type", [
     CodexMcpToolCallItemSchema,
     CodexWebSearchItemSchema,
 ]);
-function coerceCallId(raw, name, input) {
-    return coerceToolCallId({
-        providerPrefix: "codex",
-        rawCallId: raw,
-        toolName: name,
-        input,
-    });
-}
 function maybeUnwrapShellWrapperCommand(command) {
     const trimmed = command.trim();
     const wrapperMatch = trimmed.match(/^(?:\/bin\/)?(?:zsh|bash|sh)\s+-(?:lc|c)\s+([\s\S]+)$/);
@@ -136,6 +258,9 @@ function looksLikeUnifiedDiff(text) {
         normalized.startsWith("--- ") ||
         normalized.startsWith("+++ "));
 }
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
 function parseCodexApplyPatchDirective(line) {
     const trimmed = line.trim();
     if (trimmed.startsWith("*** Add File:")) {
@@ -149,6 +274,15 @@ function parseCodexApplyPatchDirective(line) {
     }
     return null;
 }
+function extractPatchPrimaryFilePath(patch) {
+    for (const line of patch.split(/\r?\n/)) {
+        const directive = parseCodexApplyPatchDirective(line);
+        if (directive && directive.path.length > 0) {
+            return directive.path;
+        }
+    }
+    return undefined;
+}
 function looksLikeCodexApplyPatch(text) {
     const normalized = text.trimStart();
     if (!normalized) {
@@ -230,17 +364,50 @@ function asEditTextFields(text) {
     }
     return { newString: text };
 }
-function asEditFileOutputFields(text) {
-    if (typeof text !== "string" || text.length === 0) {
-        return {};
+function normalizeRolloutEditInput(input) {
+    if (typeof input === "string") {
+        const textFields = asEditTextFields(input);
+        const path = extractPatchPrimaryFilePath(input);
+        return {
+            ...(path ? { path } : {}),
+            ...(textFields.unifiedDiff ? { patch: textFields.unifiedDiff } : {}),
+            ...(textFields.newString ? { content: textFields.newString } : {}),
+        };
     }
-    const classified = classifyDiffLikeText(text);
-    if (classified.isDiff) {
-        return { patch: truncateDiffText(classified.text) };
+    if (!isRecord(input)) {
+        return input;
     }
-    return { content: text };
+    const candidatePatchText = (typeof input.patch === "string" && input.patch) ||
+        (typeof input.diff === "string" && input.diff) ||
+        (typeof input.unified_diff === "string" && input.unified_diff) ||
+        (typeof input.unifiedDiff === "string" && input.unifiedDiff) ||
+        (typeof input.content === "string" && input.content) ||
+        undefined;
+    if (!candidatePatchText) {
+        return input;
+    }
+    const textFields = asEditTextFields(candidatePatchText);
+    const rawPath = (typeof input.path === "string" && input.path.trim().length > 0 ? input.path : undefined) ||
+        (typeof input.file_path === "string" && input.file_path.trim().length > 0
+            ? input.file_path
+            : undefined) ||
+        (typeof input.filePath === "string" && input.filePath.trim().length > 0
+            ? input.filePath
+            : undefined) ||
+        extractPatchPrimaryFilePath(candidatePatchText);
+    const { patch: _patch, diff: _diff, unified_diff: _unifiedDiffSnake, unifiedDiff: _unifiedDiffCamel, ...rest } = input;
+    const normalized = {
+        ...rest,
+        ...(rawPath ? { path: rawPath } : {}),
+        ...(textFields.unifiedDiff ? { patch: textFields.unifiedDiff } : {}),
+        ...(textFields.newString ? { content: textFields.newString } : {}),
+    };
+    if (textFields.unifiedDiff && "content" in normalized) {
+        delete normalized.content;
+    }
+    return normalized;
 }
-function asPatchOrContentFields(text) {
+function asEditFileOutputFields(text) {
     if (typeof text !== "string" || text.length === 0) {
         return {};
     }
@@ -250,14 +417,6 @@ function asPatchOrContentFields(text) {
     }
     return { content: text };
 }
-function hasRenderableEditContent(detail) {
-    if (detail.type !== "edit") {
-        return false;
-    }
-    return ((typeof detail.unifiedDiff === "string" && detail.unifiedDiff.length > 0) ||
-        (typeof detail.newString === "string" && detail.newString.length > 0) ||
-        (typeof detail.oldString === "string" && detail.oldString.length > 0));
-}
 function pickFirstPatchLikeString(values) {
     for (const value of values) {
         if (typeof value === "string" && value.length > 0) {
@@ -266,9 +425,13 @@ function pickFirstPatchLikeString(values) {
     }
     return undefined;
 }
-function removePatchLikeFields(input) {
-    const { patch: _patch, diff: _diff, unified_diff: _unifiedDiffSnake, unifiedDiff: _unifiedDiffCamel, ...rest } = input;
-    return rest;
+function hasRenderableEditDetail(detail) {
+    if (detail.type !== "edit") {
+        return true;
+    }
+    return ((typeof detail.unifiedDiff === "string" && detail.unifiedDiff.trim().length > 0) ||
+        (typeof detail.newString === "string" && detail.newString.trim().length > 0) ||
+        (typeof detail.oldString === "string" && detail.oldString.trim().length > 0));
 }
 function resolveStatus(rawStatus, error, output) {
     if (error !== undefined && error !== null) {
@@ -291,36 +454,11 @@ function resolveStatus(rawStatus, error, output) {
     }
     return output !== null && output !== undefined ? "completed" : "running";
 }
-function buildToolCall(params) {
-    if (params.status === "failed") {
-        return {
-            type: "tool_call",
-            callId: params.callId,
-            name: params.name,
-            status: "failed",
-            error: params.error ?? { message: "Tool call failed" },
-            detail: params.detail,
-            ...(params.metadata ? { metadata: params.metadata } : {}),
-        };
-    }
-    return {
-        type: "tool_call",
-        callId: params.callId,
-        name: params.name,
-        status: params.status,
-        error: null,
-        detail: params.detail,
-        ...(params.metadata ? { metadata: params.metadata } : {}),
-    };
-}
 function buildMcpToolName(server, tool) {
     const trimmedTool = tool.trim();
     if (!trimmedTool) {
         return "tool";
     }
-    if (CODEX_BUILTIN_TOOL_NAMES.has(trimmedTool)) {
-        return trimmedTool;
-    }
     const trimmedServer = typeof server === "string" ? server.trim() : "";
     if (trimmedServer.length > 0) {
         return `${trimmedServer}.${trimmedTool}`;
@@ -330,86 +468,16 @@ function buildMcpToolName(server, tool) {
 function toNullableObject(value) {
     return Object.keys(value).length > 0 ? value : null;
 }
-function extractPatchPrimaryFilePath(patch) {
-    for (const line of patch.split(/\r?\n/)) {
-        const trimmed = line.trim();
-        if (trimmed.startsWith("*** Add File:")) {
-            return trimmed.replace("*** Add File:", "").trim();
-        }
-        if (trimmed.startsWith("*** Update File:")) {
-            return trimmed.replace("*** Update File:", "").trim();
-        }
-        if (trimmed.startsWith("*** Delete File:")) {
-            return trimmed.replace("*** Delete File:", "").trim();
-        }
-    }
-    return undefined;
-}
-function isRecord(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function normalizeApplyPatchInput(input) {
-    if (typeof input === "string") {
-        const filePath = extractPatchPrimaryFilePath(input);
-        const textFields = asPatchOrContentFields(input);
-        return filePath ? { path: filePath, ...textFields } : textFields;
-    }
-    if (!isRecord(input)) {
-        return input;
-    }
-    const existingPath = (typeof input.path === "string" && input.path.trim().length > 0 && input.path.trim()) ||
-        (typeof input.file_path === "string" &&
-            input.file_path.trim().length > 0 &&
-            input.file_path.trim()) ||
-        (typeof input.filePath === "string" &&
-            input.filePath.trim().length > 0 &&
-            input.filePath.trim());
-    const patchText = (typeof input.patch === "string" && input.patch) ||
-        (typeof input.diff === "string" && input.diff) ||
-        (typeof input.unified_diff === "string" && input.unified_diff) ||
-        (typeof input.unifiedDiff === "string" && input.unifiedDiff) ||
-        undefined;
-    const contentText = typeof input.content === "string" ? input.content : undefined;
-    const inferredPatchFromContent = !patchText && typeof contentText === "string" ? contentText : undefined;
-    const patchOrContentText = patchText ?? inferredPatchFromContent;
-    if (existingPath && !patchOrContentText) {
-        return input;
-    }
-    if (!patchOrContentText) {
-        return input;
-    }
-    const base = removePatchLikeFields(input);
-    if (inferredPatchFromContent) {
-        delete base.content;
-    }
-    const filePath = existingPath || extractPatchPrimaryFilePath(patchOrContentText);
-    const textFields = asPatchOrContentFields(patchOrContentText);
-    return filePath ? { ...base, path: filePath, ...textFields } : { ...base, ...textFields };
-}
-function deriveApplyPatchDetailFromInput(input, cwd) {
-    if (!isRecord(input)) {
+function toToolCallFromNormalizedEnvelope(envelope) {
+    const pass2Envelope = CodexToolCallPass2EnvelopeSchema.safeParse(envelope);
+    if (!pass2Envelope.success) {
         return null;
     }
-    const pathValue = (typeof input.path === "string" && input.path.trim()) ||
-        (typeof input.file_path === "string" && input.file_path.trim()) ||
-        (typeof input.filePath === "string" && input.filePath.trim()) ||
-        "";
-    if (!pathValue) {
+    const parsed = CodexNormalizedToolCallPass2Schema.safeParse(pass2Envelope.data);
+    if (!parsed.success) {
         return null;
     }
-    const normalizedPath = normalizeCodexFilePath(pathValue, cwd) ?? pathValue;
-    const diffText = (typeof input.patch === "string" && input.patch) ||
-        (typeof input.diff === "string" && input.diff) ||
-        (typeof input.unified_diff === "string" && input.unified_diff) ||
-        (typeof input.unifiedDiff === "string" && input.unifiedDiff) ||
-        (typeof input.content === "string" && input.content) ||
-        undefined;
-    const textFields = asEditTextFields(diffText);
-    return {
-        type: "edit",
-        filePath: normalizedPath,
-        ...textFields,
-    };
+    return toToolCallTimelineItem(parsed.data);
 }
 function mapCommandExecutionItem(item) {
     const command = normalizeCommandExecutionCommand(item.command);
@@ -425,30 +493,18 @@ function mapCommandExecutionItem(item) {
             ...(item.exitCode !== undefined ? { exitCode: item.exitCode } : {}),
         }
         : null;
-    const detail = command
-        ? {
-            type: "shell",
-            command,
-            ...(item.cwd ? { cwd: item.cwd } : {}),
-            ...(parsedOutput ? { output: parsedOutput } : {}),
-            ...(item.exitCode !== undefined ? { exitCode: item.exitCode } : {}),
-        }
-        : {
-            type: "unknown",
-            input,
-            output,
-        };
     const name = "shell";
-    const callId = coerceCallId(item.id, name, input);
     const error = item.error ?? null;
     const status = resolveStatus(item.status, error, output);
-    return buildToolCall({
-        callId,
+    return {
+        callId: item.id,
         name,
+        input,
+        output,
         status,
         error,
-        detail,
-    });
+        cwd: item.cwd ?? null,
+    };
 }
 function mapFileChangeItem(item, options) {
     const changes = item.changes ?? [];
@@ -463,15 +519,12 @@ function mapFileChangeItem(item, options) {
             diff: pickFirstPatchLikeString([
                 change.diff,
                 change.patch,
-                change.unified_diff,
-                change.unifiedDiff,
                 change.content,
-                change.newString,
             ]),
         };
     })
         .filter((change) => change.path !== undefined);
-    const input = toNullableObject({
+    const inputBase = {
         ...(files.length > 0
             ? {
                 files: files.map((file) => ({
@@ -480,7 +533,7 @@ function mapFileChangeItem(item, options) {
                 })),
             }
             : {}),
-    });
+    };
     const output = toNullableObject({
         ...(files.length > 0
             ? {
@@ -492,149 +545,123 @@ function mapFileChangeItem(item, options) {
             }
             : {}),
     });
-    const firstFile = files[0];
-    const firstTextFields = asEditTextFields(firstFile?.diff);
-    const hasFirstTextFields = Object.keys(firstTextFields).length > 0;
-    const detail = firstFile?.path
-        ? hasFirstTextFields
-            ? {
-                type: "edit",
-                filePath: firstFile.path,
-                ...firstTextFields,
-            }
-            : {
-                type: "unknown",
-                input,
-                output,
-            }
-        : {
-            type: "unknown",
-            input,
-            output,
-        };
     const name = "apply_patch";
-    const callId = coerceCallId(item.id, name, input);
     const error = item.error ?? null;
     const status = resolveStatus(item.status, error, output);
-    return buildToolCall({
-        callId,
+    const firstFile = files[0];
+    const firstTextFields = asEditTextFields(firstFile?.diff);
+    const hasFirstTextFields = Object.keys(firstTextFields).length > 0;
+    const input = toNullableObject({
+        ...inputBase,
+        ...(firstFile?.path && hasFirstTextFields ? { path: firstFile.path } : {}),
+        ...(hasFirstTextFields && firstTextFields.unifiedDiff
+            ? { patch: firstTextFields.unifiedDiff }
+            : {}),
+        ...(hasFirstTextFields && firstTextFields.newString
+            ? { content: firstTextFields.newString }
+            : {}),
+    });
+    return {
+        callId: item.id,
         name,
+        input,
+        output,
         status,
         error,
-        detail,
-    });
+        cwd: options?.cwd ?? null,
+    };
 }
 function mapMcpToolCallItem(item, options) {
-    const tool = item.tool?.trim() || "tool";
+    const tool = item.tool.trim();
+    if (!tool) {
+        return null;
+    }
     const name = buildMcpToolName(item.server, tool);
     const input = item.arguments ?? null;
     const output = item.result ?? null;
     const error = item.error ?? null;
-    const callId = coerceCallId(item.id ?? item.callID ?? item.call_id, name, input);
     const status = resolveStatus(item.status, error, output);
-    const detail = deriveCodexToolDetail({
-        name: tool,
+    return {
+        callId: item.id,
+        name,
         input,
         output,
-        cwd: options?.cwd ?? null,
-    });
-    return buildToolCall({
-        callId,
-        name,
         status,
         error,
-        detail,
-    });
+        cwd: options?.cwd ?? null,
+    };
 }
 function mapWebSearchItem(item) {
     const input = item.query !== undefined ? { query: item.query } : null;
     const output = item.action ?? null;
     const name = "web_search";
-    const callId = coerceCallId(item.id, name, input);
     const error = item.error ?? null;
     const status = resolveStatus(item.status ?? "completed", error, output);
-    const detail = item.query
-        ? {
-            type: "search",
-            query: item.query,
-        }
-        : {
-            type: "unknown",
-            input,
-            output,
-        };
-    return buildToolCall({
-        callId,
+    return {
+        callId: item.id,
         name,
+        input,
+        output,
         status,
         error,
-        detail,
-    });
+        cwd: null,
+    };
 }
-function createCodexThreadItemToTimelineSchema(options) {
-    return CodexThreadItemSchema.transform((item) => {
-        switch (item.type) {
-            case "commandExecution":
-                return mapCommandExecutionItem(item);
-            case "fileChange":
-                return mapFileChangeItem(item, options);
-            case "mcpToolCall":
-                return mapMcpToolCallItem(item, options);
-            case "webSearch":
-                return mapWebSearchItem(item);
-            default: {
-                const exhaustiveCheck = item;
-                throw new Error(`Unhandled Codex thread item type: ${String(exhaustiveCheck)}`);
-            }
+function mapThreadItemToNormalizedEnvelope(item, options) {
+    switch (item.type) {
+        case "commandExecution":
+            return mapCommandExecutionItem(item);
+        case "fileChange":
+            return mapFileChangeItem(item, options);
+        case "mcpToolCall":
+            return mapMcpToolCallItem(item, options);
+        case "webSearch":
+            return mapWebSearchItem(item);
+        default: {
+            const exhaustiveCheck = item;
+            throw new Error(`Unhandled Codex thread item type: ${String(exhaustiveCheck)}`);
         }
-    });
+    }
 }
 // ---------------------------------------------------------------------------
 // Public API
 // ---------------------------------------------------------------------------
 export function mapCodexToolCallFromThreadItem(item, options) {
-    const parsed = createCodexThreadItemToTimelineSchema(options).safeParse(item);
+    const parsed = CodexThreadItemSchema.safeParse(item);
     if (!parsed.success) {
         return null;
     }
-    return parsed.data;
+    const envelope = mapThreadItemToNormalizedEnvelope(parsed.data, options);
+    if (!envelope) {
+        return null;
+    }
+    return toToolCallFromNormalizedEnvelope(envelope);
 }
 export function mapCodexRolloutToolCall(params) {
-    const parsed = CodexRolloutToolCallParamsSchema.parse(params);
-    const rawInput = parsed.input ?? null;
-    const normalizedName = parsed.name.trim().toLowerCase();
-    const input = normalizedName === "apply_patch" || normalizedName === "apply_diff"
-        ? normalizeApplyPatchInput(rawInput)
-        : rawInput;
-    const output = parsed.output ?? null;
-    const error = parsed.error ?? null;
-    const status = resolveStatus("completed", error, output);
-    const callId = coerceCallId(parsed.callId, parsed.name, input);
-    let detail = deriveCodexToolDetail({
-        name: parsed.name,
-        input,
-        output,
+    const parsed = CodexRolloutToolCallParamsSchema.safeParse(params);
+    if (!parsed.success) {
+        return null;
+    }
+    const normalizedName = parsed.data.name.trim();
+    const normalizedInput = normalizedName === "apply_patch" || normalizedName === "apply_diff"
+        ? normalizeRolloutEditInput(parsed.data.input ?? null)
+        : parsed.data.input ?? null;
+    const pass1 = CodexNormalizedToolCallPass1Schema.safeParse({
+        callId: typeof parsed.data.callId === "string" ? parsed.data.callId.trim() : "",
+        name: normalizedName,
+        input: normalizedInput,
+        output: parsed.data.output ?? null,
+        error: parsed.data.error ?? null,
+        status: resolveStatus("completed", parsed.data.error ?? null, parsed.data.output ?? null),
         cwd: params.cwd ?? null,
     });
-    if (detail.type === "unknown" && (normalizedName === "apply_patch" || normalizedName === "apply_diff")) {
-        const fallbackDetail = deriveApplyPatchDetailFromInput(input, params.cwd ?? null);
-        if (fallbackDetail) {
-            detail = fallbackDetail;
-        }
+    if (!pass1.success) {
+        return null;
     }
-    if (detail.type === "edit" && !hasRenderableEditContent(detail)) {
-        detail = {
-            type: "unknown",
-            input,
-            output,
-        };
+    const mapped = toToolCallFromNormalizedEnvelope(pass1.data);
+    if (!mapped) {
+        return null;
     }
-    return buildToolCall({
-        callId,
-        name: parsed.name,
-        status,
-        error,
-        detail,
-    });
+    return mapped;
 }
 //# sourceMappingURL=tool-call-mapper.js.map