@pasko70/pibo 1.16.6 → 2.0.0

package/dist/agent-runtimes/codex-native/turn.js

@@ -0,0 +1,849 @@
+import { normalizeSessionErrorDetails, runtimeSessionErrorDetails } from "../../core/session-errors.js";
+import { CodexAppServerClientError, } from "./client.js";
+import { redactCodexNativeSensitiveText, redactCodexNativeValue } from "./redaction.js";
+import { validateCodexAppServerThreadItem, validateCodexAppServerThreadStatus, validateCodexAppServerTurn, } from "./thread.js";
+const TOOL_ITEM_TYPES = new Set([
+    "collabAgentToolCall",
+    "commandExecution",
+    "dynamicToolCall",
+    "fileChange",
+    "imageGeneration",
+    "imageView",
+    "mcpToolCall",
+    "sleep",
+    "webSearch",
+]);
+export class CodexNativeTurnProtocolError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "CodexNativeTurnProtocolError";
+    }
+}
+function deferred() {
+    let resolve;
+    let reject;
+    const promise = new Promise((resolvePromise, rejectPromise) => {
+        resolve = resolvePromise;
+        reject = rejectPromise;
+    });
+    return { promise, resolve, reject };
+}
+function isRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function requiredRecord(value, label) {
+    if (!isRecord(value))
+        throw new CodexNativeTurnProtocolError(`Codex ${label} is invalid.`);
+    return value;
+}
+function redactedObject(value) {
+    const selected = redactCodexNativeValue(value);
+    return isRecord(selected) ? selected : {};
+}
+function requiredString(value, label) {
+    if (typeof value !== "string" || !value)
+        throw new CodexNativeTurnProtocolError(`Codex ${label} is invalid.`);
+    return value;
+}
+function requiredText(value, label) {
+    if (typeof value !== "string")
+        throw new CodexNativeTurnProtocolError(`Codex ${label} is invalid.`);
+    return value;
+}
+function requiredInteger(value, label) {
+    if (!Number.isSafeInteger(value))
+        throw new CodexNativeTurnProtocolError(`Codex ${label} is invalid.`);
+    return Number(value);
+}
+function requiredNonNegativeInteger(value, label) {
+    const selected = requiredInteger(value, label);
+    if (selected < 0)
+        throw new CodexNativeTurnProtocolError(`Codex ${label} is invalid.`);
+    return selected;
+}
+function safeDiagnosticText(value) {
+    return redactCodexNativeSensitiveText(value)
+        .replace(/(?:[A-Za-z]:\\|\/)(?:[^\s"'<>|]+[\\/]){2,}[^\s"'<>|]*/g, "[redacted path]")
+        .slice(0, 4_000);
+}
+function errorMessage(value) {
+    if (typeof value === "string" && value.trim())
+        return safeDiagnosticText(value);
+    if (isRecord(value)) {
+        for (const key of ["message", "additionalDetails", "details", "reason"]) {
+            const candidate = value[key];
+            if (typeof candidate === "string" && candidate.trim())
+                return safeDiagnosticText(candidate);
+        }
+    }
+    return "Codex turn failed.";
+}
+function errorCode(value) {
+    if (!isRecord(value))
+        return undefined;
+    for (const key of ["code", "type", "kind"]) {
+        const candidate = value[key];
+        if (typeof candidate === "string" && candidate.trim()) {
+            return candidate.replace(/[^A-Za-z0-9_.-]/g, "_").slice(0, 128);
+        }
+    }
+    return undefined;
+}
+function providerErrorDetails(value, message, retryable) {
+    const providerCode = errorCode(value);
+    return normalizeSessionErrorDetails(message, {
+        api: "codex-app-server",
+        provider: "openai-codex",
+        providerType: "codex",
+        ...(providerCode ? { providerCode } : {}),
+        providerMessage: message,
+        origin: "provider",
+        ...(retryable !== undefined ? { retryable } : {}),
+    });
+}
+function validateTurnStartResponse(value) {
+    const record = requiredRecord(value, "turn/start response");
+    if (!Object.hasOwn(record, "turn"))
+        throw new CodexNativeTurnProtocolError("Codex turn/start response is missing its turn.");
+    return validateCodexAppServerTurn(record.turn);
+}
+function validateTurnSteerResponse(value) {
+    return requiredString(requiredRecord(value, "turn/steer response").turnId, "steered turn id");
+}
+function tokenUsageBreakdown(value, label) {
+    const record = requiredRecord(value, label);
+    return {
+        inputTokens: requiredNonNegativeInteger(record.inputTokens, `${label} input token count`),
+        outputTokens: requiredNonNegativeInteger(record.outputTokens, `${label} output token count`),
+        cacheReadTokens: requiredNonNegativeInteger(record.cachedInputTokens, `${label} cached input token count`),
+        cacheWriteTokens: 0,
+        reasoningTokens: requiredNonNegativeInteger(record.reasoningOutputTokens, `${label} reasoning token count`),
+        totalTokens: requiredNonNegativeInteger(record.totalTokens, `${label} total token count`),
+    };
+}
+function validateTokenUsage(value) {
+    const record = requiredRecord(value, "thread token usage");
+    const usage = tokenUsageBreakdown(record.last, "last turn usage");
+    if (record.modelContextWindow !== undefined && record.modelContextWindow !== null) {
+        usage.contextWindow = requiredNonNegativeInteger(record.modelContextWindow, "model context window");
+    }
+    return usage;
+}
+function textArray(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value.filter((entry) => typeof entry === "string")
+        .map(redactCodexNativeSensitiveText);
+}
+function toolDescriptor(item) {
+    if (!TOOL_ITEM_TYPES.has(item.type))
+        return undefined;
+    if (item.type === "commandExecution") {
+        return {
+            name: "codex_command",
+            args: redactCodexNativeValue({
+                command: item.command,
+                commandActions: item.commandActions,
+                source: item.source,
+                pluginId: item.pluginId,
+                scriptPath: item.scriptPath,
+            }),
+        };
+    }
+    if (item.type === "fileChange") {
+        return { name: "codex_file_change", args: redactCodexNativeValue({ changes: item.changes }) };
+    }
+    if (item.type === "mcpToolCall") {
+        const server = typeof item.server === "string" ? redactCodexNativeSensitiveText(item.server) : "mcp";
+        const tool = typeof item.tool === "string" ? redactCodexNativeSensitiveText(item.tool) : "tool";
+        return {
+            name: `${server}/${tool}`,
+            args: redactCodexNativeValue({ server, tool, arguments: item.arguments }),
+        };
+    }
+    if (item.type === "dynamicToolCall") {
+        const tool = typeof item.tool === "string" ? redactCodexNativeSensitiveText(item.tool) : "dynamic_tool";
+        return { name: tool, args: redactCodexNativeValue({ tool, arguments: item.arguments }) };
+    }
+    if (item.type === "webSearch") {
+        return { name: "codex_web_search", args: redactCodexNativeValue({ query: item.query, action: item.action }) };
+    }
+    if (item.type === "imageView") {
+        return { name: "codex_image_view", args: { image: "[local image]" } };
+    }
+    if (item.type === "sleep") {
+        return { name: "codex_sleep", args: redactCodexNativeValue({ durationMs: item.durationMs }) };
+    }
+    if (item.type === "imageGeneration") {
+        return { name: "codex_image_generation", args: redactCodexNativeValue({ prompt: item.prompt }) };
+    }
+    const nativeTool = typeof item.tool === "string" ? item.tool : "agent_tool";
+    return {
+        name: `codex_${redactCodexNativeSensitiveText(nativeTool)}`,
+        args: redactCodexNativeValue({ tool: item.tool, prompt: item.prompt, receiverThreadIds: item.receiverThreadIds }),
+    };
+}
+function toolResult(item) {
+    if (item.type === "commandExecution") {
+        return redactCodexNativeValue({
+            status: item.status,
+            exitCode: item.exitCode,
+            durationMs: item.durationMs,
+            output: item.aggregatedOutput,
+        });
+    }
+    if (item.type === "fileChange")
+        return redactCodexNativeValue({ status: item.status, changes: item.changes });
+    if (item.type === "mcpToolCall")
+        return redactCodexNativeValue({ status: item.status, result: item.result, error: item.error });
+    if (item.type === "dynamicToolCall") {
+        return redactCodexNativeValue({ status: item.status, success: item.success, contentItems: item.contentItems });
+    }
+    if (item.type === "webSearch")
+        return redactCodexNativeValue({ query: item.query, results: item.results });
+    if (item.type === "imageView")
+        return { status: item.status ?? "completed", image: "[local image]" };
+    if (item.type === "sleep")
+        return redactCodexNativeValue({ status: item.status, durationMs: item.durationMs });
+    if (item.type === "imageGeneration") {
+        return redactCodexNativeValue({ status: item.status, result: item.result, revisedPrompt: item.revisedPrompt });
+    }
+    return redactCodexNativeValue({ status: item.status, result: item.result, receiverThreadIds: item.receiverThreadIds });
+}
+function toolFailed(item) {
+    if (item.success === false)
+        return true;
+    if (typeof item.status !== "string")
+        return false;
+    return ["declined", "failed", "error"].includes(item.status.toLowerCase());
+}
+function newPendingTurn() {
+    const completion = deferred();
+    const turnIdReady = deferred();
+    void completion.promise.catch(() => { });
+    return {
+        completion,
+        turnIdReady,
+        turnIdReadySettled: false,
+        started: false,
+        terminal: false,
+        items: new Map(),
+        itemOrder: [],
+        completedItems: new Set(),
+        assistantIndices: new Map(),
+        assistantBuffers: new Map(),
+        completedAssistantItems: new Set(),
+        nextAssistantIndex: 0,
+        reasoningStartedItems: new Set(),
+        reasoningSummaryParts: new Map(),
+        reasoningContentParts: new Map(),
+        completedReasoningItems: new Set(),
+        startedTools: new Map(),
+        completedTools: new Set(),
+    };
+}
+export class CodexNativeTurnController {
+    client;
+    threads;
+    emit;
+    pending;
+    disposed = false;
+    unsubscribeNotifications;
+    unsubscribeDiagnostics;
+    constructor(client, threads, emit) {
+        this.client = client;
+        this.threads = threads;
+        this.emit = emit;
+        this.unsubscribeNotifications = client.subscribeNotifications((notification) => {
+            if (this.disposed)
+                return;
+            try {
+                this.handleNotification(notification.method, notification.params);
+            }
+            catch (error) {
+                this.handleProtocolFailure(error);
+            }
+        });
+        this.unsubscribeDiagnostics = client.subscribeDiagnostics((diagnostic) => this.handleDiagnostic(diagnostic));
+    }
+    get streaming() {
+        return this.pending !== undefined;
+    }
+    get activeTurnId() {
+        return this.pending?.turnId;
+    }
+    async start(text, clientUserMessageId, modelOptions) {
+        if (this.disposed)
+            throw new Error("Codex native turn controller is disposed.");
+        if (this.pending)
+            throw new Error("Codex native session already has an active turn.");
+        const pending = newPendingTurn();
+        this.pending = pending;
+        const params = {
+            threadId: this.threads.thread.id,
+            input: [{ type: "text", text }],
+            ...(clientUserMessageId ? { clientUserMessageId } : {}),
+            model: modelOptions.model,
+            effort: modelOptions.effort,
+            serviceTier: modelOptions.serviceTier,
+            ...(modelOptions.summary !== undefined ? { summary: modelOptions.summary } : {}),
+            ...(modelOptions.personality !== undefined ? { personality: modelOptions.personality } : {}),
+        };
+        try {
+            const response = await this.client.request("turn/start", params);
+            const turn = validateTurnStartResponse(response);
+            this.assignTurnId(pending, turn.id);
+            if (turn.status !== "inProgress")
+                this.finishTurn(pending, turn);
+            await pending.completion.promise;
+        }
+        catch (error) {
+            if (!pending.terminal && this.pending === pending) {
+                if (pending.started || pending.turnId) {
+                    const normalized = error instanceof Error ? error : new Error("Codex turn/start failed after the native turn began.");
+                    this.failActiveTurn(pending, normalized, runtimeSessionErrorDetails(safeDiagnosticText(normalized.message)));
+                }
+                else {
+                    this.pending = undefined;
+                    this.resolveTurnId(pending, undefined);
+                }
+            }
+            throw error;
+        }
+    }
+    async steer(text, clientUserMessageId) {
+        const pending = this.pending;
+        if (!pending || pending.terminal)
+            throw new Error("Codex native steering requires an active turn.");
+        const turnId = pending.turnId ?? await pending.turnIdReady.promise;
+        if (!turnId || pending.terminal || this.pending !== pending)
+            throw new Error("Codex native steering requires an active turn.");
+        const params = {
+            threadId: this.threads.thread.id,
+            expectedTurnId: turnId,
+            input: [{ type: "text", text }],
+            ...(clientUserMessageId ? { clientUserMessageId } : {}),
+        };
+        const response = await this.client.request("turn/steer", params);
+        const returnedTurnId = validateTurnSteerResponse(response);
+        if (returnedTurnId !== turnId)
+            throw new CodexNativeTurnProtocolError("Codex turn/steer returned a different turn id.");
+    }
+    async interrupt() {
+        const pending = this.pending;
+        if (!pending || pending.terminal)
+            return;
+        const turnId = pending.turnId ?? await pending.turnIdReady.promise;
+        if (!turnId || pending.terminal || this.pending !== pending)
+            return;
+        await this.client.request("turn/interrupt", {
+            threadId: this.threads.thread.id,
+            turnId,
+        });
+    }
+    dispose() {
+        if (this.disposed)
+            return;
+        this.disposed = true;
+        this.unsubscribeNotifications();
+        this.unsubscribeDiagnostics();
+        const pending = this.pending;
+        this.pending = undefined;
+        if (pending && !pending.terminal) {
+            pending.terminal = true;
+            this.resolveTurnId(pending, undefined);
+            pending.completion.reject(new CodexAppServerClientError("closed", "Codex native turn controller was disposed"));
+        }
+    }
+    handleNotification(method, params) {
+        switch (method) {
+            case "turn/started":
+                this.handleTurnStarted(params);
+                return;
+            case "turn/completed":
+                this.handleTurnCompleted(params);
+                return;
+            case "item/started":
+                this.handleItemStarted(params);
+                return;
+            case "item/completed":
+                this.handleItemCompleted(params);
+                return;
+            case "item/agentMessage/delta":
+                this.handleAssistantDelta(params);
+                return;
+            case "item/reasoning/summaryPartAdded":
+                this.handleReasoningPartAdded(params);
+                return;
+            case "item/reasoning/summaryTextDelta":
+                this.handleReasoningDelta(params, "summaryIndex", true);
+                return;
+            case "item/reasoning/textDelta":
+                this.handleReasoningDelta(params, "contentIndex", false);
+                return;
+            case "item/commandExecution/outputDelta":
+            case "item/fileChange/outputDelta":
+                this.handleToolDelta(params, "delta");
+                return;
+            case "item/commandExecution/terminalInteraction":
+                this.handleTerminalInteraction(params);
+                return;
+            case "item/fileChange/patchUpdated":
+                this.handleToolDelta(params, "changes");
+                return;
+            case "item/mcpToolCall/progress":
+                this.handleToolDelta(params, "message");
+                return;
+            case "thread/tokenUsage/updated":
+                this.handleUsage(params);
+                return;
+            case "thread/status/changed":
+                this.handleThreadStatus(params);
+                return;
+            case "error":
+                this.handleTurnError(params);
+                return;
+            case "warning":
+            case "guardianWarning":
+            case "deprecationNotice":
+            case "configWarning":
+                this.handleWarning(method, params);
+                return;
+            case "model/rerouted":
+                this.handleModelRerouted(params);
+                return;
+            default:
+                return;
+        }
+    }
+    handleTurnStarted(value) {
+        const params = requiredRecord(value, "turn/started notification");
+        if (requiredString(params.threadId, "turn/started thread id") !== this.threads.thread.id)
+            return;
+        const pending = this.pending;
+        if (!pending || pending.terminal)
+            return;
+        const turn = validateCodexAppServerTurn(params.turn);
+        this.assignTurnId(pending, turn.id);
+        this.ensureTurnStarted(pending, turn);
+    }
+    handleTurnCompleted(value) {
+        const params = requiredRecord(value, "turn/completed notification");
+        if (requiredString(params.threadId, "turn/completed thread id") !== this.threads.thread.id)
+            return;
+        const pending = this.pending;
+        if (!pending || pending.terminal)
+            return;
+        const turn = validateCodexAppServerTurn(params.turn);
+        this.assignTurnId(pending, turn.id);
+        this.finishTurn(pending, turn);
+    }
+    handleItemStarted(value) {
+        const params = this.scopedTurnParams(value, "item/started");
+        if (!params)
+            return;
+        requiredInteger(params.record.startedAtMs, "item start timestamp");
+        const item = validateCodexAppServerThreadItem(params.record.item);
+        this.rememberItem(params.pending, item);
+        this.startItem(params.pending, item);
+    }
+    handleItemCompleted(value) {
+        const params = this.scopedTurnParams(value, "item/completed");
+        if (!params)
+            return;
+        requiredInteger(params.record.completedAtMs, "item completion timestamp");
+        const item = validateCodexAppServerThreadItem(params.record.item);
+        this.completeItem(params.pending, item);
+    }
+    handleAssistantDelta(value) {
+        const params = this.scopedTurnParams(value, "agent message delta");
+        if (!params)
+            return;
+        const itemId = requiredString(params.record.itemId, "agent message item id");
+        const delta = redactCodexNativeSensitiveText(requiredText(params.record.delta, "agent message delta"));
+        this.ensureTurnStarted(params.pending);
+        const text = `${params.pending.assistantBuffers.get(itemId) ?? ""}${delta}`;
+        this.rememberItem(params.pending, { id: itemId, type: "agentMessage", text });
+        const contentIndex = this.assistantIndex(params.pending, itemId);
+        params.pending.assistantBuffers.set(itemId, text);
+        this.emit({ type: "assistant_delta", text: delta, contentIndex });
+    }
+    handleReasoningPartAdded(value) {
+        const params = this.scopedTurnParams(value, "reasoning summary part");
+        if (!params)
+            return;
+        const itemId = requiredString(params.record.itemId, "reasoning item id");
+        const index = requiredNonNegativeInteger(params.record.summaryIndex, "reasoning summary index");
+        this.ensureReasoningStarted(params.pending, itemId);
+        const parts = this.reasoningParts(params.pending.reasoningSummaryParts, itemId);
+        if (!parts.has(index))
+            parts.set(index, "");
+    }
+    handleReasoningDelta(value, indexKey, summary) {
+        const params = this.scopedTurnParams(value, "reasoning delta");
+        if (!params)
+            return;
+        const itemId = requiredString(params.record.itemId, "reasoning item id");
+        const contentIndex = requiredNonNegativeInteger(params.record[indexKey], `reasoning ${indexKey}`);
+        const delta = redactCodexNativeSensitiveText(requiredText(params.record.delta, "reasoning delta"));
+        this.ensureReasoningStarted(params.pending, itemId);
+        const parts = this.reasoningParts(summary ? params.pending.reasoningSummaryParts : params.pending.reasoningContentParts, itemId);
+        parts.set(contentIndex, `${parts.get(contentIndex) ?? ""}${delta}`);
+        this.emit({ type: "reasoning_delta", text: delta, contentIndex });
+    }
+    handleToolDelta(value, field) {
+        const params = this.scopedTurnParams(value, "tool update");
+        if (!params)
+            return;
+        const itemId = requiredString(params.record.itemId, "tool item id");
+        const item = params.pending.items.get(itemId);
+        if (!item)
+            return;
+        const descriptor = this.ensureToolStarted(params.pending, item);
+        if (!descriptor)
+            return;
+        const selected = params.record[field];
+        if (field !== "changes")
+            requiredText(selected, `tool ${field}`);
+        else if (!Array.isArray(selected))
+            throw new CodexNativeTurnProtocolError("Codex file change patch update is invalid.");
+        this.emit({
+            type: "tool_execution_updated",
+            toolCallId: itemId,
+            toolName: descriptor.name,
+            args: descriptor.args,
+            partialResult: redactCodexNativeValue({ [field]: selected }),
+        });
+    }
+    handleTerminalInteraction(value) {
+        const params = this.scopedTurnParams(value, "terminal interaction");
+        if (!params)
+            return;
+        const itemId = requiredString(params.record.itemId, "terminal interaction item id");
+        requiredString(params.record.processId, "terminal interaction process id");
+        const stdin = requiredText(params.record.stdin, "terminal interaction input");
+        const item = params.pending.items.get(itemId);
+        if (!item)
+            return;
+        const descriptor = this.ensureToolStarted(params.pending, item);
+        if (!descriptor)
+            return;
+        this.emit({
+            type: "tool_execution_updated",
+            toolCallId: itemId,
+            toolName: descriptor.name,
+            args: descriptor.args,
+            partialResult: { terminalInput: redactCodexNativeSensitiveText(stdin) },
+        });
+    }
+    handleUsage(value) {
+        const params = this.scopedTurnParams(value, "thread token usage");
+        if (!params)
+            return;
+        params.pending.usage = validateTokenUsage(params.record.tokenUsage);
+    }
+    handleThreadStatus(value) {
+        const params = requiredRecord(value, "thread status notification");
+        if (requiredString(params.threadId, "thread status thread id") !== this.threads.thread.id)
+            return;
+        this.threads.setStatus(validateCodexAppServerThreadStatus(params.status));
+    }
+    handleTurnError(value) {
+        const params = this.scopedTurnParams(value, "turn error");
+        if (!params)
+            return;
+        if (typeof params.record.willRetry !== "boolean")
+            throw new CodexNativeTurnProtocolError("Codex turn retry state is invalid.");
+        const message = errorMessage(params.record.error);
+        const details = providerErrorDetails(params.record.error, message, params.record.willRetry);
+        if (params.record.willRetry) {
+            const warningDetails = { willRetry: true };
+            const code = details.providerCode ?? details.code;
+            if (code)
+                warningDetails.code = code;
+            this.emit({ type: "warning", message, details: warningDetails });
+            return;
+        }
+        params.pending.lastError = { message, details };
+        this.emit({ type: "error", message, details });
+    }
+    handleWarning(method, value) {
+        const params = requiredRecord(value, `${method} notification`);
+        if (params.threadId !== undefined && params.threadId !== null) {
+            if (requiredString(params.threadId, `${method} thread id`) !== this.threads.thread.id)
+                return;
+        }
+        const messageValue = params.message ?? params.summary ?? params.details;
+        if (typeof messageValue !== "string" || !messageValue.trim())
+            return;
+        this.emit({
+            type: "warning",
+            message: safeDiagnosticText(messageValue),
+            details: redactedObject({ method, summary: params.summary, details: params.details }),
+        });
+    }
+    handleModelRerouted(value) {
+        const params = this.scopedTurnParams(value, "model reroute");
+        if (!params)
+            return;
+        const fromModel = requiredString(params.record.fromModel, "rerouted source model");
+        const toModel = requiredString(params.record.toModel, "rerouted target model");
+        this.emit({
+            type: "warning",
+            message: `Codex rerouted the active turn from ${safeDiagnosticText(fromModel)} to ${safeDiagnosticText(toModel)}.`,
+            details: redactedObject({ reason: params.record.reason }),
+        });
+    }
+    scopedTurnParams(value, label) {
+        const record = requiredRecord(value, `${label} notification`);
+        if (requiredString(record.threadId, `${label} thread id`) !== this.threads.thread.id)
+            return undefined;
+        const pending = this.pending;
+        if (!pending || pending.terminal)
+            return undefined;
+        const turnId = requiredString(record.turnId, `${label} turn id`);
+        if (!pending.turnId || pending.turnId !== turnId)
+            return undefined;
+        return { record, pending };
+    }
+    assignTurnId(pending, turnId) {
+        if (pending.turnId && pending.turnId !== turnId) {
+            throw new CodexNativeTurnProtocolError("Codex emitted events for a different active turn.");
+        }
+        pending.turnId = turnId;
+        this.resolveTurnId(pending, turnId);
+    }
+    resolveTurnId(pending, turnId) {
+        if (pending.turnIdReadySettled)
+            return;
+        pending.turnIdReadySettled = true;
+        pending.turnIdReady.resolve(turnId);
+    }
+    ensureTurnStarted(pending, turn) {
+        if (pending.started)
+            return;
+        pending.started = true;
+        this.threads.setStatus({ type: "active", activeFlags: [] });
+        this.emit({ type: "turn_started", turnId: pending.turnId ?? turn?.id });
+    }
+    rememberItem(pending, item) {
+        if (!pending.items.has(item.id))
+            pending.itemOrder.push(item.id);
+        pending.items.set(item.id, structuredClone(item));
+    }
+    startItem(pending, item) {
+        this.ensureTurnStarted(pending);
+        if (item.type === "reasoning")
+            this.ensureReasoningStarted(pending, item.id);
+        else if (item.type === "contextCompaction") {
+            this.emit({ type: "compaction_start", reason: "codex_context_compaction" });
+        }
+        else {
+            this.ensureToolStarted(pending, item);
+        }
+    }
+    completeItem(pending, item) {
+        this.rememberItem(pending, item);
+        if (pending.completedItems.has(item.id))
+            return;
+        pending.completedItems.add(item.id);
+        this.startItem(pending, item);
+        if (item.type === "agentMessage" && typeof item.text === "string") {
+            const text = redactCodexNativeSensitiveText(item.text);
+            pending.assistantBuffers.set(item.id, text);
+            pending.completedAssistantItems.add(item.id);
+            this.emit({
+                type: "assistant_message",
+                text,
+                contentIndex: this.assistantIndex(pending, item.id),
+            });
+            return;
+        }
+        if (item.type === "reasoning") {
+            const summary = textArray(item.summary);
+            const content = textArray(item.content);
+            const assembled = summary.length > 0
+                ? summary.join("\n")
+                : content.length > 0
+                    ? content.join("\n")
+                    : this.assembledReasoning(pending, item.id);
+            pending.completedReasoningItems.add(item.id);
+            this.emit({ type: "reasoning_finished", text: assembled, contentIndex: 0 });
+            return;
+        }
+        if (item.type === "contextCompaction") {
+            this.emit({
+                type: "compaction_end",
+                reason: "codex_context_compaction",
+                result: redactCodexNativeValue(item),
+                aborted: false,
+            });
+            return;
+        }
+        const descriptor = this.ensureToolStarted(pending, item);
+        if (!descriptor || pending.completedTools.has(item.id))
+            return;
+        pending.completedTools.add(item.id);
+        this.emit({
+            type: "tool_execution_finished",
+            toolCallId: item.id,
+            toolName: descriptor.name,
+            result: toolResult(item),
+            isError: toolFailed(item),
+        });
+    }
+    assistantIndex(pending, itemId) {
+        const existing = pending.assistantIndices.get(itemId);
+        if (existing !== undefined)
+            return existing;
+        const selected = pending.nextAssistantIndex++;
+        pending.assistantIndices.set(itemId, selected);
+        return selected;
+    }
+    ensureReasoningStarted(pending, itemId) {
+        this.ensureTurnStarted(pending);
+        this.rememberItem(pending, pending.items.get(itemId) ?? { id: itemId, type: "reasoning", summary: [], content: [] });
+        if (pending.reasoningStartedItems.has(itemId))
+            return;
+        pending.reasoningStartedItems.add(itemId);
+        this.emit({ type: "reasoning_started", contentIndex: 0 });
+    }
+    reasoningParts(store, itemId) {
+        let selected = store.get(itemId);
+        if (!selected) {
+            selected = new Map();
+            store.set(itemId, selected);
+        }
+        return selected;
+    }
+    assembledReasoning(pending, itemId) {
+        const assemble = (parts) => [...(parts?.entries() ?? [])]
+            .sort(([left], [right]) => left - right)
+            .map(([, text]) => text)
+            .filter(Boolean)
+            .join("\n");
+        return assemble(pending.reasoningSummaryParts.get(itemId)) || assemble(pending.reasoningContentParts.get(itemId));
+    }
+    ensureToolStarted(pending, item) {
+        const descriptor = toolDescriptor(item);
+        if (!descriptor)
+            return undefined;
+        const existing = pending.startedTools.get(item.id);
+        if (existing)
+            return existing;
+        pending.startedTools.set(item.id, descriptor);
+        this.emit({
+            type: "tool_call",
+            toolCallId: item.id,
+            toolName: descriptor.name,
+            args: descriptor.args,
+            argsComplete: true,
+        });
+        this.emit({
+            type: "tool_execution_started",
+            toolCallId: item.id,
+            toolName: descriptor.name,
+            args: descriptor.args,
+        });
+        return descriptor;
+    }
+    finishTurn(pending, turn) {
+        if (pending.terminal || this.pending !== pending)
+            return;
+        if (turn.status === "inProgress")
+            throw new CodexNativeTurnProtocolError("Codex turn/completed reported an in-progress turn.");
+        this.assignTurnId(pending, turn.id);
+        this.ensureTurnStarted(pending, turn);
+        for (const item of turn.items)
+            this.completeItem(pending, item);
+        this.finishIncompleteItems(pending, turn.status);
+        if (pending.usage)
+            this.emit({ type: "usage", usage: pending.usage });
+        const persistedItems = pending.itemOrder
+            .map((itemId) => pending.items.get(itemId))
+            .filter((item) => item !== undefined);
+        const persistedTurn = {
+            ...turn,
+            items: persistedItems,
+            itemsView: "full",
+        };
+        this.threads.recordTurn(persistedTurn);
+        pending.terminal = true;
+        this.pending = undefined;
+        if (turn.status === "failed") {
+            const message = pending.lastError?.message ?? errorMessage(turn.error);
+            const details = pending.lastError?.details ?? providerErrorDetails(turn.error, message, false);
+            this.emit({ type: "turn_failed", message, details, turnId: turn.id });
+        }
+        else {
+            this.emit({ type: "turn_completed", status: turn.status, turnId: turn.id });
+        }
+        pending.completion.resolve(persistedTurn);
+    }
+    finishIncompleteItems(pending, status) {
+        for (const [itemId, text] of pending.assistantBuffers) {
+            if (pending.completedAssistantItems.has(itemId) || !text)
+                continue;
+            pending.completedAssistantItems.add(itemId);
+            this.emit({ type: "assistant_message", text, contentIndex: this.assistantIndex(pending, itemId) });
+        }
+        for (const itemId of pending.reasoningStartedItems) {
+            if (pending.completedReasoningItems.has(itemId))
+                continue;
+            pending.completedReasoningItems.add(itemId);
+            this.emit({
+                type: "reasoning_finished",
+                text: this.assembledReasoning(pending, itemId),
+                contentIndex: 0,
+            });
+        }
+        for (const [itemId, descriptor] of pending.startedTools) {
+            if (pending.completedTools.has(itemId))
+                continue;
+            pending.completedTools.add(itemId);
+            this.emit({
+                type: "tool_execution_finished",
+                toolCallId: itemId,
+                toolName: descriptor.name,
+                result: { status, message: "Codex turn ended before item/completed." },
+                isError: true,
+            });
+        }
+    }
+    handleDiagnostic(diagnostic) {
+        if (this.disposed)
+            return;
+        const safeMessage = safeDiagnosticText(diagnostic.message);
+        if (diagnostic.level === "warning") {
+            if (this.pending)
+                this.emit({ type: "warning", message: safeMessage, details: { code: diagnostic.code } });
+            return;
+        }
+        const pending = this.pending;
+        if (!pending || pending.terminal)
+            return;
+        this.failActiveTurn(pending, new CodexAppServerClientError("process_exited", safeMessage), runtimeSessionErrorDetails(safeMessage));
+    }
+    handleProtocolFailure(error) {
+        const pending = this.pending;
+        if (!pending || pending.terminal)
+            return;
+        const normalized = error instanceof Error ? error : new CodexNativeTurnProtocolError("Codex emitted an invalid turn notification.");
+        const message = safeDiagnosticText(normalized.message);
+        this.failActiveTurn(pending, normalized, runtimeSessionErrorDetails(message));
+        void this.client.close().catch(() => { });
+    }
+    failActiveTurn(pending, error, details) {
+        if (pending.terminal || this.pending !== pending)
+            return;
+        pending.terminal = true;
+        this.ensureTurnStarted(pending);
+        this.finishIncompleteItems(pending, "failed");
+        this.threads.setStatus({ type: "systemError" });
+        this.pending = undefined;
+        this.resolveTurnId(pending, undefined);
+        const message = safeDiagnosticText(error.message || "Codex native turn failed.");
+        this.emit({ type: "turn_failed", message, details, turnId: pending.turnId });
+        pending.completion.reject(error);
+    }
+}