@messenger-agent/codex-agent 0.24.0-alpha.2 → 0.24.0-alpha.3

package/dist/routes/chat.js

@@ -1,909 +1,2 @@
-import { Hono } from "hono";
-import { HTTPException } from "hono/http-exception";
-import { zValidator } from "@hono/zod-validator";
-import { streamSSE } from "hono/streaming";
-import { randomUUID } from "node:crypto";
-import { sessionManager, WorkdirNotFoundError } from "../codex.js";
-import { logger } from "@messenger-agent/shared/logger";
-import { ChatBodySchema, RequestUserInputToolPartSchema } from "../schemas.js";
-import { appConfig } from "../config.js";
-import { setManagedTaskToolContext } from "../dynamic-tools.js";
-import { resolveAgentWorkspaceRoot } from "@messenger-agent/shared/agent-workspaces";
-import { saveUploadedFilePart } from "@messenger-agent/shared/uploaded-files";
-import { commandExecutionItem, addTokenUsage, displayCommand, dynamicToolCallItem, dynamicToolCallOutput, fileChangeItem, itemText, mcpToolCallItem, mcpToolCallOutput, toUsage, turnOptions, webSearchItem, webSearchPayload, } from "./shared.js";
-const chat = new Hono();
-const liveConversations = new Map();
-const activeStreams = new Set();
-const pendingDiffs = new Map();
-const pendingClientToolWaits = new Map();
-export function codexActivitySnapshot() {
-    const waitingConversations = new Set([...pendingClientToolWaits.values()].map((wait) => wait.conversationId).filter((id) => !!id));
-    return { active: activeStreams.size, waiting: waitingConversations.size };
-}
-function conversationNotFound(conversationId) {
-    return {
-        type: "not_found_error",
-        code: "conversation_not_found",
-        message: `Conversation not found or already completed: ${conversationId}`,
-        param: "conversation_id",
-    };
-}
-function matrixThreadRef(headers) {
-    const roomId = chatHeader(headers, "X-Matrix-Room-Id")?.trim();
-    const threadId = chatHeader(headers, "X-Matrix-Thread-ID")?.trim();
-    return roomId && threadId ? `${roomId}/${threadId}` : undefined;
-}
-function matrixEventRef(headers) {
-    const roomId = chatHeader(headers, "X-Matrix-Room-Id")?.trim();
-    const eventId = chatHeader(headers, "X-Matrix-Event-ID")?.trim();
-    const threadRootEventId = chatHeader(headers, "X-Matrix-Thread-ID")?.trim();
-    if (!roomId || !eventId)
-        return undefined;
-    return { roomId, eventId, ...(threadRootEventId ? { threadRootEventId } : null) };
-}
-export class ChatRequestError extends Error {
-    status;
-    constructor(status, message) {
-        super(message);
-        this.status = status;
-        this.name = "ChatRequestError";
-    }
-}
-function chatHeader(headers, name) {
-    return headers?.get(name) ?? undefined;
-}
-export async function cancelCodexConversation(conversationId) {
-    const state = liveConversations.get(conversationId);
-    if (!state)
-        return false;
-    state.cancelRequested = true;
-    while (true) {
-        const transition = state.transition;
-        await transition;
-        if (transition !== state.transition)
-            continue;
-        break;
-    }
-    if (state.thread && state.turnId) {
-        if (!state.interrupt) {
-            state.interrupt = state.thread.interrupt(state.turnId).finally(() => {
-                state.interrupt = undefined;
-            });
-        }
-        await state.interrupt;
-    }
-    state.owner?.abortController.abort();
-    state.resolveOwnerReady?.();
-    if (liveConversations.get(conversationId) === state) {
-        liveConversations.delete(conversationId);
-    }
-    return true;
-}
-function reserveLiveConversation(conversationId) {
-    let state = liveConversations.get(conversationId);
-    if (!state) {
-        state = {
-            conversationId,
-            generation: 0,
-            cancelRequested: false,
-            transition: Promise.resolve(),
-        };
-        liveConversations.set(conversationId, state);
-    }
-    const generation = ++state.generation;
-    const abortController = new AbortController();
-    const ownsOutput = !state.owner;
-    if (ownsOutput) {
-        state.owner = { generation, abortController };
-        state.ownerReady = new Promise((resolve) => {
-            state.resolveOwnerReady = resolve;
-        });
-    }
-    return { state, generation, abortController, ownsOutput };
-}
-function isCurrentReservation(reservation) {
-    return (liveConversations.get(reservation.state.conversationId) === reservation.state &&
-        reservation.state.owner?.generation === reservation.generation);
-}
-async function runLiveTransition(state, operation) {
-    const previous = state.transition;
-    let release;
-    const current = new Promise((resolve) => {
-        release = resolve;
-    });
-    state.transition = previous.then(() => current);
-    await previous;
-    try {
-        return await operation();
-    }
-    finally {
-        release();
-    }
-}
-async function startOrSteerLiveTurn(reservation, thread, prompt, options) {
-    if (!reservation.ownsOutput && !reservation.state.turnId) {
-        await reservation.state.ownerReady;
-    }
-    try {
-        return await runLiveTransition(reservation.state, async () => {
-            const { state } = reservation;
-            if (liveConversations.get(state.conversationId) !== state || state.cancelRequested) {
-                throw new DOMException("Chat stream was cancelled before the turn started", "AbortError");
-            }
-            state.thread = thread;
-            const result = state.turnId
-                ? await thread.steerStreamed(prompt, state.turnId, { signal: reservation.abortController.signal })
-                : await thread.runStreamed(prompt, { ...options, signal: reservation.abortController.signal });
-            state.turnId = result.turnId;
-            return result;
-        });
-    }
-    finally {
-        if (reservation.ownsOutput)
-            reservation.state.resolveOwnerReady?.();
-    }
-}
-async function continueLiveTurn(reservation, thread, operation) {
-    return runLiveTransition(reservation.state, async () => {
-        const { state } = reservation;
-        if (!isCurrentReservation(reservation) || state.cancelRequested) {
-            throw new DOMException("Chat stream was cancelled before user input was submitted", "AbortError");
-        }
-        state.thread = thread;
-        const result = await operation();
-        state.turnId = result.turnId;
-        state.resolveOwnerReady?.();
-        return result;
-    });
-}
-async function submitLiveUserInput(reservation, thread, itemId, response) {
-    return runLiveTransition(reservation.state, async () => {
-        const { state } = reservation;
-        if (liveConversations.get(state.conversationId) !== state || state.cancelRequested) {
-            throw new DOMException("Chat stream was cancelled before user input was submitted", "AbortError");
-        }
-        state.thread = thread;
-        const turnId = await thread.submitPendingUserInput(itemId, response);
-        if (turnId)
-            state.turnId = turnId;
-        return turnId;
-    });
-}
-async function restartAfterPendingUserInput(reservation, thread, pendingWait, prompt, options) {
-    return runLiveTransition(reservation.state, async () => {
-        const { state } = reservation;
-        if (liveConversations.get(state.conversationId) !== state || state.cancelRequested) {
-            throw new DOMException("Chat stream was cancelled before the turn started", "AbortError");
-        }
-        state.thread = thread;
-        await thread.interruptPendingUserInput(pendingWait.turnId, pendingWait.toolCallId);
-        state.turnId = undefined;
-        const result = await thread.runStreamed(prompt, { ...options, signal: reservation.abortController.signal });
-        state.turnId = result.turnId;
-        return result;
-    });
-}
-function updateLiveTurn(reservation, thread, turnId) {
-    reservation.state.thread = thread;
-    reservation.state.turnId = turnId;
-}
-function completeLiveTurn(reservation) {
-    const { state } = reservation;
-    if (!isCurrentReservation(reservation))
-        return;
-    state.owner = undefined;
-    state.resolveOwnerReady?.();
-    state.turnId = undefined;
-    if (liveConversations.get(state.conversationId) === state) {
-        liveConversations.delete(state.conversationId);
-    }
-}
-function releaseLiveOwner(reservation) {
-    if (isCurrentReservation(reservation)) {
-        reservation.state.owner = undefined;
-        reservation.state.resolveOwnerReady?.();
-        if (!reservation.state.turnId && liveConversations.get(reservation.state.conversationId) === reservation.state) {
-            liveConversations.delete(reservation.state.conversationId);
-        }
-    }
-}
-function abandonLiveReservation(reservation) {
-    if (!isCurrentReservation(reservation))
-        return;
-    releaseLiveOwner(reservation);
-    reservation.state.resolveOwnerReady?.();
-    if (!reservation.state.turnId && liveConversations.get(reservation.state.conversationId) === reservation.state) {
-        liveConversations.delete(reservation.state.conversationId);
-    }
-}
-function pendingWaitKey(conversationId, toolCallId) {
-    return `${conversationId ?? "unknown"}:${toolCallId}`;
-}
-function pendingWaitForConversation(conversationId) {
-    if (!conversationId)
-        return undefined;
-    return [...pendingClientToolWaits.values()].find((wait) => wait.conversationId === conversationId);
-}
-function pendingDiffKey(activeConversationId, threadId) {
-    return activeConversationId ?? threadId;
-}
-function isUploadedFilePart(part) {
-    return (part.type === "file" &&
-        "mediaType" in part &&
-        typeof part.mediaType === "string" &&
-        "url" in part &&
-        typeof part.url === "string" &&
-        (!("filename" in part) || part.filename === undefined || typeof part.filename === "string"));
-}
-async function partSummary(part) {
-    if (part.type === "text" && typeof part.text === "string")
-        return part.text;
-    if (isUploadedFilePart(part)) {
-        return saveUploadedFilePart(part, appConfig.fileUploads.tempDir);
-    }
-    throw new HTTPException(400, {
-        message: `Unsupported message part type: ${part.type}`,
-    });
-}
-async function messageToPrompt(parts) {
-    const summaries = await Promise.all(parts.map(partSummary));
-    const prompt = summaries
-        .filter((text) => Boolean(text && text.trim().length > 0))
-        .join("\n")
-        .trim();
-    if (!prompt) {
-        throw new HTTPException(400, { message: "No supported message content found" });
-    }
-    return prompt;
-}
-function requestUserInputResponse(parts) {
-    const hasToolPart = parts.some((part) => part.type === "tool");
-    if (!hasToolPart)
-        return undefined;
-    if (parts.length !== 1) {
-        throw new HTTPException(400, {
-            message: "When a tool part is present, the message must contain exactly one part",
-        });
-    }
-    const result = RequestUserInputToolPartSchema.safeParse(parts[0]);
-    if (!result.success) {
-        throw new HTTPException(400, {
-            message: `Invalid requestUserInput tool part: ${result.error.message}`,
-        });
-    }
-    return {
-        itemId: result.data.toolCallId,
-        response: result.data.output,
-        sourceTurnId: result.data.sourceTurnId,
-    };
-}
-function toolCallId(ids, conversationId, itemId, suffix) {
-    const key = [conversationId, itemId, suffix].filter(Boolean).join(":");
-    const existing = ids.get(key);
-    if (existing)
-        return existing;
-    const id = randomUUID();
-    ids.set(key, id);
-    return id;
-}
-function toolErrorText(value, fallback) {
-    return value && value.length > 0 ? value : fallback;
-}
-function logStreamEvent(event) {
-    logger.debug("Received chat stream event:", event);
-}
-function workdirNotFoundPath(err) {
-    if (err instanceof WorkdirNotFoundError)
-        return err.path;
-    if (err && typeof err === "object" && "path" in err && typeof err.path === "string")
-        return err.path;
-    if (err instanceof Error && err.message.startsWith("Workdir not found: ")) {
-        return err.message.slice("Workdir not found: ".length);
-    }
-    return undefined;
-}
-chat.post("/v1/chat/:conversation_id/cancel", async (c) => {
-    const conversationId = c.req.param("conversation_id");
-    try {
-        if (!(await cancelCodexConversation(conversationId))) {
-            return c.json({ error: conversationNotFound(conversationId) }, 404);
-        }
-        return c.json({ success: true });
-    }
-    catch (err) {
-        const message = err instanceof Error ? err.message : "Failed to interrupt Codex conversation";
-        logger.error(`Failed to cancel Codex conversation ${conversationId}:`, err);
-        return c.json({ error: { type: "server_error", code: "cancel_failed", message } }, 500);
-    }
-});
-chat.get("/admin/status", (c) => c.json({
-    activeTaskCount: activeStreams.size,
-    waitingClientToolCount: pendingClientToolWaits.size,
-    clientToolWaits: [...pendingClientToolWaits.values()].map(({ conversationId, toolCallId, toolName, since }) => ({
-        conversationId,
-        toolCallId,
-        toolName,
-        since,
-    })),
-}));
-export async function prepareCodexChatStream({ body, headers }) {
-    const { conversationId, fork, model, message } = body;
-    const botName = chatHeader(headers, "X-Matrix-Bot-Name");
-    const workdir = chatHeader(headers, "X-Matrix-Workdir");
-    const workspaceId = chatHeader(headers, "X-Matrix-Workspace-ID");
-    const agentMode = chatHeader(headers, "X-Matrix-Agent-Mode");
-    const requestedLlmProxyBinding = chatHeader(headers, "X-Elevo-LLM-Binding")?.trim() || undefined;
-    const storedLlmProxyBinding = !fork ? sessionManager.bindingFor(conversationId) : undefined;
-    if (requestedLlmProxyBinding && storedLlmProxyBinding && requestedLlmProxyBinding !== storedLlmProxyBinding) {
-        throw new ChatRequestError(409, "LLM proxy binding does not match the existing conversation");
-    }
-    const llmProxyBinding = storedLlmProxyBinding ?? requestedLlmProxyBinding;
-    const threadRef = matrixThreadRef(headers);
-    const matrixEvent = matrixEventRef(headers);
-    const explicitUserInputResponse = requestUserInputResponse(message.parts);
-    const prompt = explicitUserInputResponse ? undefined : await messageToPrompt(message.parts);
-    const pendingTextWait = explicitUserInputResponse ? undefined : pendingWaitForConversation(conversationId);
-    const userInputResponse = explicitUserInputResponse;
-    const interruptedTextWait = prompt && pendingTextWait ? pendingTextWait : undefined;
-    let liveReservation = !fork && conversationId ? reserveLiveConversation(conversationId) : undefined;
-    const workspaceRoot = (() => {
-        try {
-            return resolveAgentWorkspaceRoot(appConfig, workspaceId);
-        }
-        catch (err) {
-            throw new ChatRequestError(400, err instanceof Error ? err.message : "Invalid workspace");
-        }
-    })();
-    const { thread, isNewSession } = await (async () => {
-        try {
-            if (fork) {
-                if (!("threadId" in fork)) {
-                    throw new ChatRequestError(400, "Codex fork requires threadId and turnId");
-                }
-                return await sessionManager.fork(fork, botName, workdir, workspaceId, model, "danger-full-access", llmProxyBinding);
-            }
-            return await sessionManager.getOrCreate(conversationId, botName, workdir, workspaceId, model, "danger-full-access", llmProxyBinding);
-        }
-        catch (err) {
-            if (liveReservation)
-                abandonLiveReservation(liveReservation);
-            const path = workdirNotFoundPath(err);
-            if (path) {
-                throw new ChatRequestError(400, `Workdir not found: ${path}`);
-            }
-            throw err;
-        }
-    })();
-    liveReservation ??= reserveLiveConversation(thread.id);
-    setManagedTaskToolContext(thread.id, {
-        workspaceRoot,
-        threadRef,
-        matrixEvent,
-        llmProxyBinding,
-    });
-    const turnRunOptions = turnOptions(agentMode, model);
-    return {
-        run: async (writer, signal) => {
-            const reservation = liveReservation;
-            const abortController = reservation.abortController;
-            activeStreams.add(abortController);
-            const abortFromParent = () => {
-                if (isCurrentReservation(reservation)) {
-                    cancelCodexConversation(reservation.state.conversationId).catch((err) => logger.error("Failed to cancel disconnected Codex stream:", err));
-                }
-            };
-            if (signal?.aborted)
-                abortFromParent();
-            signal?.addEventListener("abort", abortFromParent, { once: true });
-            let responseStarted = !!userInputResponse;
-            let stepStarted = !!userInputResponse;
-            let completed = false;
-            let activeConversationId;
-            let currentThreadId = thread.id;
-            let currentTurnId;
-            let liveTurnCompleted = false;
-            let heartbeatTimer;
-            const textStartedItems = new Set();
-            const reasoningStartedItems = new Set();
-            const deltaReceivedItems = new Set();
-            const toolIds = new Map();
-            const compactStarts = new Set();
-            const compactEnds = new Set();
-            const subagentActivities = new Set();
-            let lastErrorMessage;
-            let pendingUsage;
-            let turnUsage;
-            const scheduleHeartbeat = () => {
-                heartbeatTimer = setTimeout(() => {
-                    writeData({ type: "heartbeat" }).catch(() => { });
-                }, 60_000);
-            };
-            const writeEnvelope = async (message) => {
-                if (heartbeatTimer)
-                    clearTimeout(heartbeatTimer);
-                if (message.data === "[DONE]") {
-                    await writer.writeDone();
-                }
-                else {
-                    await writer.writeData(JSON.parse(String(message.data)));
-                }
-                scheduleHeartbeat();
-            };
-            const writeData = async (data) => {
-                await writeEnvelope({ data: JSON.stringify(data) });
-            };
-            const writeDone = async () => {
-                await writeEnvelope({ data: "[DONE]" });
-            };
-            const writePendingDiff = async () => {
-                const key = pendingDiffKey(activeConversationId, thread.id);
-                const diff = pendingDiffs.get(key);
-                if (!diff)
-                    return;
-                pendingDiffs.delete(key);
-                await writeData({ type: "data", kind: "diff", data: { diff } });
-            };
-            const writeCompactActivity = async (item, phase) => {
-                if (item.type !== "contextCompaction")
-                    return false;
-                if (phase === "end" && !compactStarts.has(item.id))
-                    return true;
-                const emitted = phase === "start" ? compactStarts : compactEnds;
-                if (emitted.has(item.id))
-                    return true;
-                emitted.add(item.id);
-                await writeData({
-                    type: "data",
-                    kind: "compact",
-                    data: phase === "start" ? { phase, activityId: item.id } : { phase, activityId: item.id, status: "completed" },
-                });
-                return true;
-            };
-            const writeSubagentActivity = async (item) => {
-                if (item.type !== "subAgentActivity")
-                    return false;
-                if (subagentActivities.has(item.id))
-                    return true;
-                subagentActivities.add(item.id);
-                const id = toolCallId(toolIds, activeConversationId, item.id);
-                const input = {
-                    activity: item.kind,
-                    agentThreadId: item.agentThreadId,
-                    ...(item.agentPath ? { agentPath: item.agentPath } : null),
-                };
-                await writeData({
-                    type: "tool-input-available",
-                    toolCallId: id,
-                    toolName: `subagent_${item.kind}`,
-                    ...(item.agentPath ? { title: item.agentPath } : null),
-                    input,
-                });
-                await writeData(item.kind === "interrupted"
-                    ? { type: "tool-output-error", toolCallId: id, errorText: "Subagent interrupted" }
-                    : { type: "tool-output-available", toolCallId: id, output: input });
-                return true;
-            };
-            scheduleHeartbeat();
-            const activateConversation = (id) => {
-                if (activeConversationId === id)
-                    return;
-                activeConversationId = id;
-                if (isNewSession) {
-                    sessionManager.persist(id, botName, workdir, workspaceId, llmProxyBinding);
-                }
-            };
-            const writeStart = async (id, turnId) => {
-                if (responseStarted)
-                    return;
-                responseStarted = true;
-                activateConversation(id);
-                await writeData({
-                    type: "start",
-                    messageMetadata: {
-                        conversationId: id,
-                        threadId: id,
-                        ...(turnId ? { turnId } : null),
-                    },
-                });
-                await writeData({ type: "start-step" });
-                stepStarted = true;
-            };
-            const writeFinish = async (finishReason) => {
-                if (completed)
-                    return;
-                completed = true;
-                if (stepStarted) {
-                    await writePendingDiff();
-                    if (finishReason === "stop" && pendingUsage) {
-                        await writeData({ type: "data", kind: "token_usage", data: pendingUsage });
-                    }
-                    await writeData({ type: "finish-step" });
-                }
-                await writeData({ type: "finish", finishReason });
-                await writeDone();
-            };
-            const ensureTextStarted = async (item) => {
-                if (textStartedItems.has(item.id))
-                    return;
-                textStartedItems.add(item.id);
-                const textMetadata = item.type === "plan" ? { type: "plan" } : undefined;
-                await writeData({ type: "text-start", id: item.id, ...(textMetadata ? { textMetadata } : {}) });
-            };
-            const ensureReasoningStarted = async (item) => {
-                if (reasoningStartedItems.has(item.id))
-                    return;
-                reasoningStartedItems.add(item.id);
-                await writeData({ type: "reasoning-start", id: item.id });
-            };
-            const handleToolStarted = async (item) => {
-                const commandItem = commandExecutionItem(item);
-                if (commandItem) {
-                    await writeData({
-                        type: "tool-input-available",
-                        toolCallId: toolCallId(toolIds, activeConversationId, item.id),
-                        toolName: "bash",
-                        input: displayCommand(commandItem.command),
-                    });
-                    return true;
-                }
-                const fileItem = fileChangeItem(item);
-                if (fileItem) {
-                    for (const [index, change] of fileItem.changes.entries()) {
-                        await writeData({
-                            type: "tool-input-available",
-                            toolCallId: toolCallId(toolIds, activeConversationId, item.id, String(index)),
-                            toolName: change.kind.type === "update" ? "Edit" : change.kind.type === "add" ? "Add" : "Delete",
-                            title: change.path,
-                            input: change,
-                        });
-                    }
-                    return true;
-                }
-                const mcpItem = mcpToolCallItem(item);
-                if (mcpItem) {
-                    await writeData({
-                        type: "tool-input-available",
-                        toolCallId: toolCallId(toolIds, activeConversationId, item.id),
-                        toolName: mcpItem.tool,
-                        input: mcpItem.arguments,
-                    });
-                    return true;
-                }
-                const dynamicItem = dynamicToolCallItem(item);
-                if (dynamicItem) {
-                    await writeData({
-                        type: "tool-input-available",
-                        toolCallId: toolCallId(toolIds, activeConversationId, item.id),
-                        toolName: dynamicItem.tool,
-                        input: dynamicItem.arguments,
-                    });
-                    return true;
-                }
-                const searchItem = webSearchItem(item);
-                if (searchItem) {
-                    await writeData({
-                        type: "tool-input-available",
-                        toolCallId: toolCallId(toolIds, activeConversationId, item.id),
-                        toolName: "web_search",
-                        title: searchItem.query,
-                        input: webSearchPayload(searchItem),
-                    });
-                    return true;
-                }
-                return false;
-            };
-            const handleToolCompleted = async (item) => {
-                const commandItem = commandExecutionItem(item);
-                if (commandItem) {
-                    const isError = commandItem.status === "failed" || commandItem.status === "declined";
-                    await writeData(isError
-                        ? {
-                            type: "tool-output-error",
-                            toolCallId: toolCallId(toolIds, activeConversationId, item.id),
-                            errorText: toolErrorText(commandItem.aggregatedOutput, "Command execution failed"),
-                        }
-                        : {
-                            type: "tool-output-available",
-                            toolCallId: toolCallId(toolIds, activeConversationId, item.id),
-                            output: commandItem.aggregatedOutput ?? "",
-                        });
-                    return true;
-                }
-                const fileItem = fileChangeItem(item);
-                if (fileItem) {
-                    const isError = fileItem.status === "failed" || fileItem.status === "declined";
-                    for (const [index] of fileItem.changes.entries()) {
-                        await writeData(isError
-                            ? {
-                                type: "tool-output-error",
-                                toolCallId: toolCallId(toolIds, activeConversationId, item.id, String(index)),
-                                errorText: fileItem.status,
-                            }
-                            : {
-                                type: "tool-output-available",
-                                toolCallId: toolCallId(toolIds, activeConversationId, item.id, String(index)),
-                                output: fileItem.status,
-                                preliminary: false,
-                            });
-                    }
-                    return true;
-                }
-                const mcpItem = mcpToolCallItem(item);
-                if (mcpItem) {
-                    const isError = mcpItem.status === "failed";
-                    await writeData(isError
-                        ? {
-                            type: "tool-output-error",
-                            toolCallId: toolCallId(toolIds, activeConversationId, item.id),
-                            errorText: mcpItem.error?.message ?? "MCP tool call failed",
-                        }
-                        : {
-                            type: "tool-output-available",
-                            toolCallId: toolCallId(toolIds, activeConversationId, item.id),
-                            output: mcpToolCallOutput(mcpItem),
-                        });
-                    return true;
-                }
-                const dynamicItem = dynamicToolCallItem(item);
-                if (dynamicItem) {
-                    const isError = dynamicItem.status === "failed" || dynamicItem.success === false;
-                    const output = dynamicToolCallOutput(dynamicItem);
-                    await writeData(isError
-                        ? {
-                            type: "tool-output-error",
-                            toolCallId: toolCallId(toolIds, activeConversationId, item.id),
-                            errorText: output || "Dynamic tool call failed",
-                        }
-                        : {
-                            type: "tool-output-available",
-                            toolCallId: toolCallId(toolIds, activeConversationId, item.id),
-                            output,
-                        });
-                    return true;
-                }
-                const searchItem = webSearchItem(item);
-                if (searchItem) {
-                    await writeData({
-                        type: "tool-output-available",
-                        toolCallId: toolCallId(toolIds, activeConversationId, item.id),
-                        output: webSearchPayload(searchItem),
-                    });
-                    return true;
-                }
-                return false;
-            };
-            try {
-                if (userInputResponse && !reservation.ownsOutput) {
-                    await submitLiveUserInput(reservation, thread, userInputResponse.itemId, userInputResponse.response);
-                    pendingClientToolWaits.delete(pendingWaitKey(conversationId, userInputResponse.itemId));
-                    await writeDone();
-                    return;
-                }
-                const result = interruptedTextWait
-                    ? await restartAfterPendingUserInput(reservation, thread, interruptedTextWait, prompt, turnRunOptions)
-                    : userInputResponse
-                        ? await continueLiveTurn(reservation, thread, () => thread.continueWithUserInput(userInputResponse.itemId, userInputResponse.response, {
-                            signal: abortController.signal,
-                            sourceTurnId: userInputResponse.sourceTurnId,
-                        }))
-                        : await startOrSteerLiveTurn(reservation, thread, prompt, turnRunOptions);
-                if (userInputResponse) {
-                    pendingClientToolWaits.delete(pendingWaitKey(conversationId, userInputResponse.itemId));
-                }
-                else if (interruptedTextWait) {
-                    pendingClientToolWaits.delete(pendingWaitKey(conversationId, interruptedTextWait.toolCallId));
-                }
-                updateLiveTurn(reservation, thread, result.turnId);
-                if (!reservation.ownsOutput) {
-                    await writeDone();
-                    return;
-                }
-                if (userInputResponse) {
-                    await writeData({
-                        type: "data",
-                        kind: "agent_session",
-                        data: {
-                            agentType: "codex",
-                            threadId: thread.id,
-                            turnId: result.turnId,
-                        },
-                    });
-                    await writeData({
-                        type: "tool-output-available",
-                        toolCallId: userInputResponse.itemId,
-                        toolName: "request_user_input",
-                        output: userInputResponse.response,
-                    });
-                }
-                else if (interruptedTextWait) {
-                    await writeData({
-                        type: "tool-output-error",
-                        toolCallId: interruptedTextWait.toolCallId,
-                        toolName: "request_user_input",
-                        errorText: "Question interrupted by text response",
-                    });
-                }
-                for await (const event of result.events) {
-                    if (event.type !== "item.delta") {
-                        logStreamEvent(event);
-                    }
-                    if (event.type === "thread.started") {
-                        currentThreadId = event.thread_id;
-                        activateConversation(currentThreadId);
-                    }
-                    else if (event.type === "turn.started") {
-                        currentTurnId = event.turn_id;
-                        updateLiveTurn(reservation, thread, currentTurnId);
-                        await writeStart(currentThreadId, currentTurnId);
-                    }
-                    else if (event.type === "item.started") {
-                        if (!responseStarted) {
-                            await writeStart(currentThreadId, currentTurnId);
-                        }
-                        if (await writeCompactActivity(event.item, "start"))
-                            continue;
-                        if (await writeSubagentActivity(event.item))
-                            continue;
-                        if (await handleToolStarted(event.item))
-                            continue;
-                        if (event.item.type === "agentMessage" || event.item.type === "plan") {
-                            await ensureTextStarted(event.item);
-                        }
-                        else if (event.item.type === "reasoning") {
-                            await ensureReasoningStarted(event.item);
-                        }
-                    }
-                    else if (event.type === "item.delta") {
-                        if (!responseStarted) {
-                            await writeStart(currentThreadId, currentTurnId);
-                        }
-                        if (event.item_type === "agentMessage" || event.item_type === "plan") {
-                            deltaReceivedItems.add(event.item_id);
-                            await writeData({ type: "text-delta", id: event.item_id, delta: event.delta });
-                        }
-                        else if (event.item_type === "reasoning") {
-                            deltaReceivedItems.add(event.item_id);
-                            await writeData({ type: "reasoning-delta", id: event.item_id, delta: event.delta });
-                        }
-                    }
-                    else if (event.type === "item.updated") {
-                        if (await writeSubagentActivity(event.item))
-                            continue;
-                    }
-                    else if (event.type === "item.completed") {
-                        if (!responseStarted) {
-                            await writeStart(currentThreadId, currentTurnId);
-                        }
-                        if (await writeCompactActivity(event.item, "end"))
-                            continue;
-                        if (await writeSubagentActivity(event.item))
-                            continue;
-                        if (await handleToolCompleted(event.item))
-                            continue;
-                        if (event.item.type === "agentMessage" || event.item.type === "plan") {
-                            await ensureTextStarted(event.item);
-                            const text = itemText(event.item) ?? "";
-                            if (text && !deltaReceivedItems.has(event.item.id)) {
-                                await writeData({ type: "text-delta", id: event.item.id, delta: text });
-                            }
-                            await writeData({ type: "text-end", id: event.item.id });
-                        }
-                        else if (event.item.type === "reasoning") {
-                            await ensureReasoningStarted(event.item);
-                            const text = itemText(event.item) ?? "";
-                            if (text && !deltaReceivedItems.has(event.item.id)) {
-                                await writeData({ type: "reasoning-delta", id: event.item.id, delta: text });
-                            }
-                            await writeData({ type: "reasoning-end", id: event.item.id });
-                        }
-                    }
-                    else if (event.type === "item.tool.requestUserInput") {
-                        if (!responseStarted) {
-                            await writeStart(currentThreadId, currentTurnId);
-                        }
-                        pendingClientToolWaits.set(pendingWaitKey(activeConversationId, event.params.itemId), {
-                            conversationId: activeConversationId,
-                            toolCallId: event.params.itemId,
-                            toolName: "request_user_input",
-                            turnId: event.params.turnId,
-                            since: new Date().toISOString(),
-                        });
-                        await writeData({
-                            type: "tool-input-available",
-                            toolCallId: event.params.itemId,
-                            toolName: "request_user_input",
-                            input: event.params,
-                        });
-                        // Chat paused until user answers the input request
-                        await writeDone();
-                        return;
-                    }
-                    else if (event.type === "turn.diff.updated") {
-                        if (!responseStarted) {
-                            await writeStart(currentThreadId, currentTurnId);
-                        }
-                        pendingDiffs.set(pendingDiffKey(activeConversationId, thread.id), event.diff);
-                    }
-                    else if (event.type === "thread.tokenUsage.updated") {
-                        const usage = toUsage(event.usage);
-                        if (usage) {
-                            const nextTurnUsage = addTokenUsage(turnUsage, usage.last);
-                            if (nextTurnUsage) {
-                                turnUsage = nextTurnUsage;
-                                pendingUsage = { ...usage, last: nextTurnUsage };
-                            }
-                        }
-                    }
-                    else if (event.type === "turn.failed") {
-                        if (lastErrorMessage !== event.error.message) {
-                            await writeData({ type: "error", errorText: event.error.message });
-                        }
-                        await writeFinish("error");
-                        liveTurnCompleted = true;
-                        completeLiveTurn(reservation);
-                        return;
-                    }
-                    else if (event.type === "error") {
-                        lastErrorMessage = event.message;
-                        await writeData({ type: "error", errorText: event.message });
-                    }
-                }
-                liveTurnCompleted = !abortController.signal.aborted;
-                if (liveTurnCompleted)
-                    completeLiveTurn(reservation);
-                if (!responseStarted) {
-                    await writeStart(currentThreadId, currentTurnId);
-                }
-                await writeFinish("stop");
-            }
-            catch (err) {
-                const message = err instanceof Error ? err.message : "Chat stream failed";
-                if (!responseStarted) {
-                    await writeStart(currentThreadId, currentTurnId);
-                }
-                await writeData({ type: "error", errorText: message });
-                await writeFinish("error");
-            }
-            finally {
-                if (heartbeatTimer)
-                    clearTimeout(heartbeatTimer);
-                signal?.removeEventListener("abort", abortFromParent);
-                activeStreams.delete(abortController);
-                if (!liveTurnCompleted)
-                    releaseLiveOwner(reservation);
-            }
-        },
-    };
-}
-export async function handleCodexChatStream({ body, headers, signal }, writer) {
-    const prepared = await prepareCodexChatStream({ body, headers });
-    await prepared.run(writer, signal);
-}
-chat.post("/v1/chat/stream", zValidator("json", ChatBodySchema), async (c) => {
-    const body = c.req.valid("json");
-    const prepared = await (async () => {
-        try {
-            return await prepareCodexChatStream({ body, headers: c.req.raw.headers });
-        }
-        catch (err) {
-            if (err instanceof ChatRequestError) {
-                throw new HTTPException(err.status, { message: err.message });
-            }
-            throw err;
-        }
-    })();
-    return streamSSE(c, async (sse) => {
-        const writeSSE = async (message) => {
-            await sse.writeSSE(message);
-        };
-        await prepared.run({
-            writeData: async (data) => {
-                await writeSSE({ data: JSON.stringify(data) });
-            },
-            writeDone: async () => {
-                await writeSSE({ data: "[DONE]" });
-            },
-        }, c.req.raw.signal);
-    });
-});
-export default chat;
+import{Hono as zt}from"hono";import{HTTPException as D}from"hono/http-exception";import{zValidator as Ht}from"@hono/zod-validator";import{streamSSE as Jt}from"hono/streaming";import{randomUUID as Kt}from"node:crypto";import{sessionManager as j,WorkdirNotFoundError as Qt}from"../codex.js";import{logger as at}from"@messenger-agent/shared/logger";import{ChatBodySchema as Vt,RequestUserInputToolPartSchema as Gt}from"../schemas.js";import{appConfig as vt}from"../config.js";import{setManagedTaskToolContext as Yt}from"../dynamic-tools.js";import{resolveAgentWorkspaceRoot as Zt}from"@messenger-agent/shared/agent-workspaces";import{saveUploadedFilePart as te}from"@messenger-agent/shared/uploaded-files";import{commandExecutionItem as xt,addTokenUsage as ee,displayCommand as ne,dynamicToolCallItem as bt,dynamicToolCallOutput as ae,fileChangeItem as Tt,itemText as St,mcpToolCallItem as Et,mcpToolCallOutput as re,toUsage as oe,turnOptions as ie,webSearchItem as Rt,webSearchPayload as kt}from"./shared.js";const B=new zt,f=new Map,z=new Set,rt=new Map,k=new Map;function Ue(){const t=new Set([...k.values()].map(e=>e.conversationId).filter(e=>!!e));return{active:z.size,waiting:t.size}}function se(t){return{type:"not_found_error",code:"conversation_not_found",message:`Conversation not found or already completed: ${t}`,param:"conversation_id"}}function de(t){const e=v(t,"X-Matrix-Room-Id")?.trim(),r=v(t,"X-Matrix-Thread-ID")?.trim();return e&&r?`${e}/${r}`:void 0}function ue(t){const e=v(t,"X-Matrix-Room-Id")?.trim(),r=v(t,"X-Matrix-Event-ID")?.trim(),o=v(t,"X-Matrix-Thread-ID")?.trim();if(!(!e||!r))return{roomId:e,eventId:r,...o?{threadRootEventId:o}:null}}class q extends Error{status;constructor(e,r){super(r),this.status=e,this.name="ChatRequestError"}}function v(t,e){return t?.get(e)??void 0}async function Ot(t){const e=f.get(t);if(!e)return!1;for(e.cancelRequested=!0;;){const r=e.transition;if(await r,r===e.transition)break}return e.thread&&e.turnId&&(e.interrupt||(e.interrupt=e.thread.interrupt(e.turnId).finally(()=>{e.interrupt=void 0})),await e.interrupt),e.owner?.abortController.abort(),e.resolveOwnerReady?.(),f.get(t)===e&&f.delete(t),!0}function _t(t){let e=f.get(t);e||(e={conversationId:t,generation:0,cancelRequested:!1,transition:Promise.resolve()},f.set(t,e));const r=++e.generation,o=new AbortController,i=!e.owner;return i&&(e.owner={generation:r,abortController:o},e.ownerReady=new Promise(d=>{e.resolveOwnerReady=d})),{state:e,generation:r,abortController:o,ownsOutput:i}}function N(t){return f.get(t.state.conversationId)===t.state&&t.state.owner?.generation===t.generation}async function H(t,e){const r=t.transition;let o;const i=new Promise(d=>{o=d});t.transition=r.then(()=>i),await r;try{return await e()}finally{o()}}async function le(t,e,r,o){!t.ownsOutput&&!t.state.turnId&&await t.state.ownerReady;try{return await H(t.state,async()=>{const{state:i}=t;if(f.get(i.conversationId)!==i||i.cancelRequested)throw new DOMException("Chat stream was cancelled before the turn started","AbortError");i.thread=e;const d=i.turnId?await e.steerStreamed(r,i.turnId,{signal:t.abortController.signal}):await e.runStreamed(r,{...o,signal:t.abortController.signal});return i.turnId=d.turnId,d})}finally{t.ownsOutput&&t.state.resolveOwnerReady?.()}}async function ce(t,e,r){return H(t.state,async()=>{const{state:o}=t;if(!N(t)||o.cancelRequested)throw new DOMException("Chat stream was cancelled before user input was submitted","AbortError");o.thread=e;const i=await r();return o.turnId=i.turnId,o.resolveOwnerReady?.(),i})}async function pe(t,e,r,o){return H(t.state,async()=>{const{state:i}=t;if(f.get(i.conversationId)!==i||i.cancelRequested)throw new DOMException("Chat stream was cancelled before user input was submitted","AbortError");i.thread=e;const d=await e.submitPendingUserInput(r,o);return d&&(i.turnId=d),d})}async function fe(t,e,r,o,i){return H(t.state,async()=>{const{state:d}=t;if(f.get(d.conversationId)!==d||d.cancelRequested)throw new DOMException("Chat stream was cancelled before the turn started","AbortError");d.thread=e,await e.interruptPendingUserInput(r.turnId,r.toolCallId),d.turnId=void 0;const x=await e.runStreamed(o,{...i,signal:t.abortController.signal});return d.turnId=x.turnId,x})}function Mt(t,e,r){t.state.thread=e,t.state.turnId=r}function Pt(t){const{state:e}=t;N(t)&&(e.owner=void 0,e.resolveOwnerReady?.(),e.turnId=void 0,f.get(e.conversationId)===e&&f.delete(e.conversationId))}function Dt(t){N(t)&&(t.state.owner=void 0,t.state.resolveOwnerReady?.(),!t.state.turnId&&f.get(t.state.conversationId)===t.state&&f.delete(t.state.conversationId))}function me(t){N(t)&&(Dt(t),t.state.resolveOwnerReady?.(),!t.state.turnId&&f.get(t.state.conversationId)===t.state&&f.delete(t.state.conversationId))}function J(t,e){return`${t??"unknown"}:${e}`}function we(t){if(t)return[...k.values()].find(e=>e.conversationId===t)}function qt(t,e){return t??e}function ye(t){return t.type==="file"&&"mediaType"in t&&typeof t.mediaType=="string"&&"url"in t&&typeof t.url=="string"&&(!("filename"in t)||t.filename===void 0||typeof t.filename=="string")}async function ge(t){if(t.type==="text"&&typeof t.text=="string")return t.text;if(ye(t))return te(t,vt.fileUploads.tempDir);throw new D(400,{message:`Unsupported message part type: ${t.type}`})}async function Ie(t){const r=(await Promise.all(t.map(ge))).filter(o=>!!(o&&o.trim().length>0)).join(`
+`).trim();if(!r)throw new D(400,{message:"No supported message content found"});return r}function he(t){if(!t.some(o=>o.type==="tool"))return;if(t.length!==1)throw new D(400,{message:"When a tool part is present, the message must contain exactly one part"});const r=Gt.safeParse(t[0]);if(!r.success)throw new D(400,{message:`Invalid requestUserInput tool part: ${r.error.message}`});return{itemId:r.data.toolCallId,response:r.data.output,sourceTurnId:r.data.sourceTurnId}}function m(t,e,r,o){const i=[e,r,o].filter(Boolean).join(":"),d=t.get(i);if(d)return d;const x=Kt();return t.set(i,x),x}function Ce(t,e){return t&&t.length>0?t:e}function ve(t){at.debug("Received chat stream event:",t)}function xe(t){if(t instanceof Qt||t&&typeof t=="object"&&"path"in t&&typeof t.path=="string")return t.path;if(t instanceof Error&&t.message.startsWith("Workdir not found: "))return t.message.slice(19)}B.post("/v1/chat/:conversation_id/cancel",async t=>{const e=t.req.param("conversation_id");try{return await Ot(e)?t.json({success:!0}):t.json({error:se(e)},404)}catch(r){const o=r instanceof Error?r.message:"Failed to interrupt Codex conversation";return at.error(`Failed to cancel Codex conversation ${e}:`,r),t.json({error:{type:"server_error",code:"cancel_failed",message:o}},500)}}),B.get("/admin/status",t=>t.json({activeTaskCount:z.size,waitingClientToolCount:k.size,clientToolWaits:[...k.values()].map(({conversationId:e,toolCallId:r,toolName:o,since:i})=>({conversationId:e,toolCallId:r,toolName:o,since:i}))}));async function Nt({body:t,headers:e}){const{conversationId:r,fork:o,model:i,message:d}=t,x=v(e,"X-Matrix-Bot-Name"),K=v(e,"X-Matrix-Workdir"),U=v(e,"X-Matrix-Workspace-ID"),Ut=v(e,"X-Matrix-Agent-Mode"),Q=v(e,"X-Elevo-LLM-Binding")?.trim()||void 0,V=o?void 0:j.bindingFor(r);if(Q&&V&&Q!==V)throw new q(409,"LLM proxy binding does not match the existing conversation");const L=V??Q,Lt=de(e),At=ue(e),G=he(d.parts),Y=G?void 0:await Ie(d.parts),ot=G?void 0:we(r),c=G,O=Y&&ot?ot:void 0;let A=!o&&r?_t(r):void 0;const Wt=(()=>{try{return Zt(vt,U)}catch(S){throw new q(400,S instanceof Error?S.message:"Invalid workspace")}})(),{thread:y,isNewSession:Ft}=await(async()=>{try{if(o){if(!("threadId"in o))throw new q(400,"Codex fork requires threadId and turnId");return await j.fork(o,x,K,U,i,"danger-full-access",L)}return await j.getOrCreate(r,x,K,U,i,"danger-full-access",L)}catch(S){A&&me(A);const _=xe(S);throw _?new q(400,`Workdir not found: ${_}`):S}})();A??=_t(y.id),Yt(y.id,{workspaceRoot:Wt,threadRef:Lt,matrixEvent:At,llmProxyBinding:L});const it=ie(Ut,i);return{run:async(S,_)=>{const w=A,W=w.abortController;z.add(W);const Z=()=>{N(w)&&Ot(w.state.conversationId).catch(a=>at.error("Failed to cancel disconnected Codex stream:",a))};_?.aborted&&Z(),_?.addEventListener("abort",Z,{once:!0});let b=!!c,st=!!c,dt=!1,l,I=y.id,h,F=!1,P;const ut=new Set,lt=new Set,X=new Set,p=new Map,ct=new Set,Xt=new Set,pt=new Set;let ft,tt,mt;const wt=()=>{P=setTimeout(()=>{s({type:"heartbeat"}).catch(()=>{})},6e4)},yt=async a=>{P&&clearTimeout(P),a.data==="[DONE]"?await S.writeDone():await S.writeData(JSON.parse(String(a.data))),wt()},s=async a=>{await yt({data:JSON.stringify(a)})},$=async()=>{await yt({data:"[DONE]"})},$t=async()=>{const a=qt(l,y.id),n=rt.get(a);n&&(rt.delete(a),await s({type:"data",kind:"diff",data:{diff:n}}))},gt=async(a,n)=>{if(a.type!=="contextCompaction")return!1;if(n==="end"&&!ct.has(a.id))return!0;const u=n==="start"?ct:Xt;return u.has(a.id)||(u.add(a.id),await s({type:"data",kind:"compact",data:n==="start"?{phase:n,activityId:a.id}:{phase:n,activityId:a.id,status:"completed"}})),!0},et=async a=>{if(a.type!=="subAgentActivity")return!1;if(pt.has(a.id))return!0;pt.add(a.id);const n=m(p,l,a.id),u={activity:a.kind,agentThreadId:a.agentThreadId,...a.agentPath?{agentPath:a.agentPath}:null};return await s({type:"tool-input-available",toolCallId:n,toolName:`subagent_${a.kind}`,...a.agentPath?{title:a.agentPath}:null,input:u}),await s(a.kind==="interrupted"?{type:"tool-output-error",toolCallId:n,errorText:"Subagent interrupted"}:{type:"tool-output-available",toolCallId:n,output:u}),!0};wt();const It=a=>{l!==a&&(l=a,Ft&&j.persist(a,x,K,U,L))},E=async(a,n)=>{b||(b=!0,It(a),await s({type:"start",messageMetadata:{conversationId:a,threadId:a,...n?{turnId:n}:null}}),await s({type:"start-step"}),st=!0)},nt=async a=>{dt||(dt=!0,st&&(await $t(),a==="stop"&&tt&&await s({type:"data",kind:"token_usage",data:tt}),await s({type:"finish-step"})),await s({type:"finish",finishReason:a}),await $())},ht=async a=>{if(ut.has(a.id))return;ut.add(a.id);const n=a.type==="plan"?{type:"plan"}:void 0;await s({type:"text-start",id:a.id,...n?{textMetadata:n}:{}})},Ct=async a=>{lt.has(a.id)||(lt.add(a.id),await s({type:"reasoning-start",id:a.id}))},jt=async a=>{const n=xt(a);if(n)return await s({type:"tool-input-available",toolCallId:m(p,l,a.id),toolName:"bash",input:ne(n.command)}),!0;const u=Tt(a);if(u){for(const[T,C]of u.changes.entries())await s({type:"tool-input-available",toolCallId:m(p,l,a.id,String(T)),toolName:C.kind.type==="update"?"Edit":C.kind.type==="add"?"Add":"Delete",title:C.path,input:C});return!0}const g=Et(a);if(g)return await s({type:"tool-input-available",toolCallId:m(p,l,a.id),toolName:g.tool,input:g.arguments}),!0;const R=bt(a);if(R)return await s({type:"tool-input-available",toolCallId:m(p,l,a.id),toolName:R.tool,input:R.arguments}),!0;const M=Rt(a);return M?(await s({type:"tool-input-available",toolCallId:m(p,l,a.id),toolName:"web_search",title:M.query,input:kt(M)}),!0):!1},Bt=async a=>{const n=xt(a);if(n){const T=n.status==="failed"||n.status==="declined";return await s(T?{type:"tool-output-error",toolCallId:m(p,l,a.id),errorText:Ce(n.aggregatedOutput,"Command execution failed")}:{type:"tool-output-available",toolCallId:m(p,l,a.id),output:n.aggregatedOutput??""}),!0}const u=Tt(a);if(u){const T=u.status==="failed"||u.status==="declined";for(const[C]of u.changes.entries())await s(T?{type:"tool-output-error",toolCallId:m(p,l,a.id,String(C)),errorText:u.status}:{type:"tool-output-available",toolCallId:m(p,l,a.id,String(C)),output:u.status,preliminary:!1});return!0}const g=Et(a);if(g){const T=g.status==="failed";return await s(T?{type:"tool-output-error",toolCallId:m(p,l,a.id),errorText:g.error?.message??"MCP tool call failed"}:{type:"tool-output-available",toolCallId:m(p,l,a.id),output:re(g)}),!0}const R=bt(a);if(R){const T=R.status==="failed"||R.success===!1,C=ae(R);return await s(T?{type:"tool-output-error",toolCallId:m(p,l,a.id),errorText:C||"Dynamic tool call failed"}:{type:"tool-output-available",toolCallId:m(p,l,a.id),output:C}),!0}const M=Rt(a);return M?(await s({type:"tool-output-available",toolCallId:m(p,l,a.id),output:kt(M)}),!0):!1};try{if(c&&!w.ownsOutput){await pe(w,y,c.itemId,c.response),k.delete(J(r,c.itemId)),await $();return}const a=O?await fe(w,y,O,Y,it):c?await ce(w,y,()=>y.continueWithUserInput(c.itemId,c.response,{signal:W.signal,sourceTurnId:c.sourceTurnId})):await le(w,y,Y,it);if(c?k.delete(J(r,c.itemId)):O&&k.delete(J(r,O.toolCallId)),Mt(w,y,a.turnId),!w.ownsOutput){await $();return}c?(await s({type:"data",kind:"agent_session",data:{agentType:"codex",threadId:y.id,turnId:a.turnId}}),await s({type:"tool-output-available",toolCallId:c.itemId,toolName:"request_user_input",output:c.response})):O&&await s({type:"tool-output-error",toolCallId:O.toolCallId,toolName:"request_user_input",errorText:"Question interrupted by text response"});for await(const n of a.events)if(n.type!=="item.delta"&&ve(n),n.type==="thread.started")I=n.thread_id,It(I);else if(n.type==="turn.started")h=n.turn_id,Mt(w,y,h),await E(I,h);else if(n.type==="item.started"){if(b||await E(I,h),await gt(n.item,"start")||await et(n.item)||await jt(n.item))continue;n.item.type==="agentMessage"||n.item.type==="plan"?await ht(n.item):n.item.type==="reasoning"&&await Ct(n.item)}else if(n.type==="item.delta")b||await E(I,h),n.item_type==="agentMessage"||n.item_type==="plan"?(X.add(n.item_id),await s({type:"text-delta",id:n.item_id,delta:n.delta})):n.item_type==="reasoning"&&(X.add(n.item_id),await s({type:"reasoning-delta",id:n.item_id,delta:n.delta}));else if(n.type==="item.updated"){if(await et(n.item))continue}else if(n.type==="item.completed"){if(b||await E(I,h),await gt(n.item,"end")||await et(n.item)||await Bt(n.item))continue;if(n.item.type==="agentMessage"||n.item.type==="plan"){await ht(n.item);const u=St(n.item)??"";u&&!X.has(n.item.id)&&await s({type:"text-delta",id:n.item.id,delta:u}),await s({type:"text-end",id:n.item.id})}else if(n.item.type==="reasoning"){await Ct(n.item);const u=St(n.item)??"";u&&!X.has(n.item.id)&&await s({type:"reasoning-delta",id:n.item.id,delta:u}),await s({type:"reasoning-end",id:n.item.id})}}else if(n.type==="item.tool.requestUserInput"){b||await E(I,h),k.set(J(l,n.params.itemId),{conversationId:l,toolCallId:n.params.itemId,toolName:"request_user_input",turnId:n.params.turnId,since:new Date().toISOString()}),await s({type:"tool-input-available",toolCallId:n.params.itemId,toolName:"request_user_input",input:n.params}),await $();return}else if(n.type==="turn.diff.updated")b||await E(I,h),rt.set(qt(l,y.id),n.diff);else if(n.type==="thread.tokenUsage.updated"){const u=oe(n.usage);if(u){const g=ee(mt,u.last);g&&(mt=g,tt={...u,last:g})}}else if(n.type==="turn.failed"){ft!==n.error.message&&await s({type:"error",errorText:n.error.message}),await nt("error"),F=!0,Pt(w);return}else n.type==="error"&&(ft=n.message,await s({type:"error",errorText:n.message}));F=!W.signal.aborted,F&&Pt(w),b||await E(I,h),await nt("stop")}catch(a){const n=a instanceof Error?a.message:"Chat stream failed";b||await E(I,h),await s({type:"error",errorText:n}),await nt("error")}finally{P&&clearTimeout(P),_?.removeEventListener("abort",Z),z.delete(W),F||Dt(w)}}}}async function Le({body:t,headers:e,signal:r},o){await(await Nt({body:t,headers:e})).run(o,r)}B.post("/v1/chat/stream",Ht("json",Vt),async t=>{const e=t.req.valid("json"),r=await(async()=>{try{return await Nt({body:e,headers:t.req.raw.headers})}catch(o){throw o instanceof q?new D(o.status,{message:o.message}):o}})();return Jt(t,async o=>{const i=async d=>{await o.writeSSE(d)};await r.run({writeData:async d=>{await i({data:JSON.stringify(d)})},writeDone:async()=>{await i({data:"[DONE]"})}},t.req.raw.signal)})});var Ae=B;export{q as ChatRequestError,Ot as cancelCodexConversation,Ue as codexActivitySnapshot,Ae as default,Le as handleCodexChatStream,Nt as prepareCodexChatStream};