@messenger-agent/claude-agent 0.24.0-alpha.2

package/dist/routes/chat.js

@@ -0,0 +1,1229 @@
+import { randomUUID } from "node:crypto";
+import { existsSync, mkdirSync } from "node:fs";
+import { Hono } from "hono";
+import { HTTPException } from "hono/http-exception";
+import { zValidator } from "@hono/zod-validator";
+import { streamSSE } from "hono/streaming";
+import { claudePlatformInstructions } from "../platform-instructions.js";
+import { logger } from "@messenger-agent/shared/logger";
+import { appConfig } from "../config.js";
+import { resolveAgentWorkdir, resolveAgentWorkspaceRoot } from "@messenger-agent/shared/agent-workspaces";
+import { isManagedTaskToolName } from "@messenger-agent/shared/managed-task-tools";
+import { saveUploadedFilePart } from "@messenger-agent/shared/uploaded-files";
+import { answerPendingApproval, answerPendingAsk, deletePendingClientTool, findPendingClientToolByConversation, listPendingClientTools, loadPendingClientTool, savePendingAsk, savePendingApproval, updatePendingAskConversation, waitPendingApproval, waitPendingAsk, } from "../pending-asks.js";
+import { AgentAnswerToolPartSchema, ChatBodySchema, } from "../schemas.js";
+import { createTaskAggregator } from "../task-aggregator.js";
+import { createManagedTaskMcpServer, MANAGED_TASK_MCP_SERVER_NAME } from "../managed-task-mcp.js";
+import { claudeContextSnapshot, claudeTokenUsage, } from "../token-usage.js";
+import { SessionManager } from "../session-manager.js";
+import { getLlmProxyBinding, moveLlmProxyBinding, setLlmProxyBinding } from "../llm-proxy-bindings.js";
+const chat = new Hono();
+const sessionManager = new SessionManager(() => appConfig.claude.sessionIdleTimeoutMs ?? 3_600_000);
+const activeStreams = new Set();
+function isManagedTaskTool(toolName) {
+    if (isManagedTaskToolName(toolName))
+        return true;
+    const prefix = `mcp__${MANAGED_TASK_MCP_SERVER_NAME}__`;
+    return toolName.startsWith(prefix) && isManagedTaskToolName(toolName.slice(prefix.length));
+}
+function managedTaskStructuredOutput(toolUseResult) {
+    if (!toolUseResult || typeof toolUseResult !== "object" || Array.isArray(toolUseResult))
+        return undefined;
+    const structuredContent = toolUseResult.structuredContent;
+    return structuredContent && typeof structuredContent === "object" && !Array.isArray(structuredContent)
+        ? structuredContent
+        : undefined;
+}
+export function claudeActivitySnapshot() {
+    const waitingConversations = new Set(listPendingClientTools().map((record) => record.conversationId));
+    return { active: activeStreams.size, waiting: waitingConversations.size };
+}
+export class ChatRequestError extends Error {
+    status;
+    constructor(status, message) {
+        super(message);
+        this.status = status;
+        this.name = "ChatRequestError";
+    }
+}
+const liveTurns = new Map();
+function resolveAgentMode(value) {
+    return value?.trim().toLowerCase() === "plan" ? "plan" : "default";
+}
+function claudePermissionOptions(agentMode) {
+    if (agentMode === "plan") {
+        return { permissionMode: "plan" };
+    }
+    return { permissionMode: "bypassPermissions", allowDangerouslySkipPermissions: true };
+}
+function conversationNotFound(conversationId) {
+    return {
+        type: "not_found_error",
+        code: "conversation_not_found",
+        message: `Conversation not found or already completed: ${conversationId}`,
+        param: "conversation_id",
+    };
+}
+function isRecord(value) {
+    return Boolean(value && typeof value === "object");
+}
+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);
+    }
+    if (part.type === "step-start")
+        return undefined;
+    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 clientToolAnswer(parts) {
+    for (const part of parts) {
+        const parsed = AgentAnswerToolPartSchema.safeParse(part);
+        if (parsed.success)
+            return parsed.data;
+    }
+    return undefined;
+}
+function answerText(output) {
+    if (typeof output === "string")
+        return output;
+    if (isRecord(output)) {
+        if (typeof output.answer === "string")
+            return output.answer;
+        if (typeof output.text === "string")
+            return output.text;
+        if (isRecord(output.answers)) {
+            return Object.values(output.answers)
+                .map((answer) => String(answer))
+                .join("\n");
+        }
+        if (Array.isArray(output.answers)) {
+            return output.answers
+                .map((answer) => {
+                if (typeof answer === "string")
+                    return answer;
+                if (isRecord(answer)) {
+                    if (typeof answer.answer === "string")
+                        return answer.answer;
+                    if (typeof answer.text === "string")
+                        return answer.text;
+                }
+                return JSON.stringify(answer);
+            })
+                .join("\n");
+        }
+    }
+    return JSON.stringify(output);
+}
+function answerPrompt(output) {
+    if (isRecord(output) && isRecord(output.answers)) {
+        const lines = Object.entries(output.answers).map(([question, answer]) => `- ${question}:${String(answer)}`);
+        if (lines.length > 0) {
+            return ["User answered previous question:", ...lines].join("\n");
+        }
+    }
+    return answerText(output);
+}
+function toolResultText(content) {
+    if (typeof content === "string")
+        return content;
+    return JSON.stringify(content);
+}
+function questionText(question, index) {
+    if (isRecord(question) && typeof question.question === "string")
+        return question.question;
+    return `Question ${index + 1}`;
+}
+function questionsFromInput(input) {
+    if (isRecord(input) && Array.isArray(input.questions))
+        return input.questions;
+    return [];
+}
+function answerMapFromOutput(input, output) {
+    const questions = questionsFromInput(input);
+    if (isRecord(output)) {
+        if (isRecord(output.answers)) {
+            return Object.fromEntries(Object.entries(output.answers).map(([key, value]) => [key, String(value)]));
+        }
+    }
+    if (questions.length > 0) {
+        return Object.fromEntries(questions.map((question, index) => [questionText(question, index), answerText(output)]));
+    }
+    return { answer: answerText(output) };
+}
+function pendingAskToolOutput(pendingAsk, answerPart, prompt) {
+    if (answerPart && answerPart.state === "output-available")
+        return answerPart.output;
+    return { answers: prompt };
+}
+function pendingAskLiveAnswer(input, answerPart, prompt) {
+    if (answerPart && answerPart.state === "output-available") {
+        return {
+            answers: answerMapFromOutput(input, answerPart.output),
+            output: answerPart.output,
+        };
+    }
+    return { answers: prompt };
+}
+function pendingAskResumePrompt(answerPart, prompt) {
+    if (!answerPart || answerPart.state !== "output-available")
+        return `User answered previous question: ${prompt}`;
+    return answerPrompt(answerPart.output);
+}
+function planText(input) {
+    if (isRecord(input) && typeof input.plan === "string")
+        return input.plan;
+    return JSON.stringify(input);
+}
+function approvalDeniedFromText(text) {
+    const trimmed = text.trim();
+    return {
+        approved: false,
+        reason: trimmed || undefined,
+    };
+}
+function pendingApprovalToolOutput(pendingApproval, answerPart, prompt) {
+    if (answerPart && answerPart.state === "approval-responded")
+        return answerPart.approval;
+    return {
+        id: pendingApproval.approveId,
+        ...approvalDeniedFromText(prompt),
+    };
+}
+function pendingApprovalLiveAnswer(pendingApproval, answerPart, prompt) {
+    const output = pendingApprovalToolOutput(pendingApproval, answerPart, prompt);
+    if (output.id !== pendingApproval.approveId) {
+        throw new HTTPException(400, { message: "Tool approval id does not match pending approval" });
+    }
+    return {
+        approved: output.approved,
+        reason: output.reason,
+    };
+}
+function pendingApprovalResumePrompt(pendingApproval, answerPart, prompt) {
+    const approval = pendingApprovalLiveAnswer(pendingApproval, answerPart, prompt);
+    const lines = [
+        approval.approved
+            ? `User approved tool ${pendingApproval.toolName} plan:`
+            : `User rejected tool ${pendingApproval.toolName} plan:`,
+        planText(pendingApproval.input),
+    ];
+    if (approval.reason)
+        lines.push(`Reason: ${approval.reason}`);
+    return lines.join("\n");
+}
+function isAskUserAnswerPart(answerPart) {
+    return Boolean(answerPart &&
+        answerPart.state === "output-available" &&
+        (answerPart.toolName === "AskUserQuestion" || answerPart.toolName === "ask_user_question"));
+}
+function isApprovalAnswerPart(answerPart) {
+    return Boolean(answerPart && answerPart.state === "approval-responded");
+}
+async function promptFromClientToolAnswer(answerPart, parts) {
+    if (!answerPart)
+        return messageToPrompt(parts);
+    if (answerPart.state === "approval-responded")
+        return answerPart.approval.reason ?? "";
+    return answerPrompt(answerPart.output);
+}
+function resolveWorkdir(workspaceId, subpath) {
+    return resolveAgentWorkdir(appConfig, workspaceId, subpath);
+}
+function isAskUserQuestionTool(name) {
+    return name === "AskUserQuestion";
+}
+function isExitPlanModeTool(name) {
+    return name === "ExitPlanMode";
+}
+/**
+ * Subagent messages are produced inside a parent tool call and must not be
+ * forwarded downstream. They are marked by a non-empty `subagent_type` or
+ * `parent_tool_use_id` on the SDK message.
+ */
+function isSubagentMessage(message) {
+    const subagentType = "subagent_type" in message ? message.subagent_type : undefined;
+    const parentToolUseId = "parent_tool_use_id" in message ? message.parent_tool_use_id : undefined;
+    return Boolean(subagentType) || Boolean(parentToolUseId);
+}
+/** Read the session id from any SDK message that carries one. */
+function messageSessionId(message) {
+    return "session_id" in message ? message.session_id : undefined;
+}
+function isNoopTaskNotificationResult(message) {
+    return (message.subtype === "success" &&
+        message.origin?.kind === "task-notification" &&
+        message.num_turns === 0 &&
+        message.result === "" &&
+        message.usage.input_tokens === 0 &&
+        message.usage.output_tokens === 0 &&
+        message.usage.cache_creation_input_tokens === 0 &&
+        message.usage.cache_read_input_tokens === 0 &&
+        Object.keys(message.modelUsage).length === 0);
+}
+function chatHeader(headers, name) {
+    return headers?.get(name) ?? undefined;
+}
+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) };
+}
+chat.post("/v1/chat/:conversation_id/cancel", (c) => {
+    const conversationId = c.req.param("conversation_id");
+    if (!cancelClaudeConversation(conversationId)) {
+        return c.json({ error: conversationNotFound(conversationId) }, 404);
+    }
+    return c.json({ success: true });
+});
+export function cancelClaudeConversation(conversationId) {
+    return sessionManager.cancel(conversationId);
+}
+chat.get("/admin/status", (c) => {
+    const waits = listPendingClientTools().map((record) => ({
+        conversationId: record.conversationId,
+        toolCallId: record.toolCallId,
+        toolName: record.toolName,
+        kind: record.kind,
+        approveId: record.kind === "approval" ? record.approveId : undefined,
+        since: record.createdAt,
+        agentMode: record.agentMode,
+        model: record.model,
+    }));
+    const activity = claudeActivitySnapshot();
+    return c.json({
+        activeTaskCount: activity.active,
+        waitingClientToolCount: waits.length,
+        clientToolWaits: waits,
+    });
+});
+export async function prepareClaudeChatStream({ body, headers }) {
+    const requestedWorkdir = chatHeader(headers, "X-Matrix-Workdir");
+    const requestedWorkspaceId = chatHeader(headers, "X-Matrix-Workspace-ID");
+    const threadRef = matrixThreadRef(headers);
+    const matrixEvent = matrixEventRef(headers);
+    let workdir;
+    let workspaceRoot;
+    try {
+        workdir = resolveWorkdir(requestedWorkspaceId, requestedWorkdir);
+        workspaceRoot = resolveAgentWorkspaceRoot(appConfig, requestedWorkspaceId);
+    }
+    catch (err) {
+        throw new ChatRequestError(400, err instanceof Error ? err.message : "Invalid workspace");
+    }
+    if (requestedWorkdir && !existsSync(workdir)) {
+        throw new ChatRequestError(400, `Workdir not found: ${workdir}`);
+    }
+    mkdirSync(workdir, { recursive: true });
+    if (body.fork && !("sessionId" in body.fork)) {
+        throw new ChatRequestError(400, "Claude fork requires sessionId and messageId");
+    }
+    const claudeFork = body.fork && "sessionId" in body.fork ? body.fork : undefined;
+    const answerPart = clientToolAnswer(body.message.parts);
+    const pendingClientTool = answerPart && (isAskUserAnswerPart(answerPart) || isApprovalAnswerPart(answerPart))
+        ? loadPendingClientTool(answerPart.toolCallId)
+        : body.conversationId
+            ? findPendingClientToolByConversation(body.conversationId)
+            : undefined;
+    const liveTurn = pendingClientTool ? liveTurns.get(pendingClientTool.conversationId) : undefined;
+    const prompt = await promptFromClientToolAnswer(answerPart, body.message.parts);
+    const interruptedTextTool = answerPart ? undefined : pendingClientTool;
+    const requestedConversationId = pendingClientTool && !liveTurn ? pendingClientTool.conversationId : body.conversationId;
+    const requestedLlmProxyBinding = chatHeader(headers, "X-Elevo-LLM-Binding")?.trim() || undefined;
+    let existingSession = !claudeFork ? sessionManager.get(requestedConversationId) : undefined;
+    const storedLlmProxyBinding = existingSession?.llmProxyBinding ?? getLlmProxyBinding(requestedConversationId);
+    if (requestedLlmProxyBinding && storedLlmProxyBinding && requestedLlmProxyBinding !== storedLlmProxyBinding) {
+        throw new ChatRequestError(409, "LLM proxy binding does not match the existing conversation");
+    }
+    const llmProxyBinding = storedLlmProxyBinding ?? requestedLlmProxyBinding;
+    if (existingSession && llmProxyBinding && !existingSession.llmProxyBinding) {
+        if (existingSession.hasActiveOwner()) {
+            throw new ChatRequestError(409, "Cannot attach an LLM proxy binding while the conversation is active");
+        }
+        existingSession.abort();
+        existingSession = undefined;
+    }
+    const requestedModel = body.model || appConfig.claude.defaultModel;
+    const activeWorkdir = pendingClientTool && !liveTurn ? pendingClientTool.workdir : workdir;
+    const agentMode = pendingClientTool?.kind === "approval" && pendingApprovalLiveAnswer(pendingClientTool, answerPart, prompt).approved
+        ? "default"
+        : pendingClientTool?.agentMode
+            ? resolveAgentMode(pendingClientTool.agentMode)
+            : resolveAgentMode(chatHeader(headers, "X-Matrix-Agent-Mode"));
+    const activeModel = pendingClientTool && !liveTurn ? (pendingClientTool.model ?? requestedModel) : requestedModel;
+    return {
+        run: async (writer, signal) => {
+            if (pendingClientTool && liveTurn && !interruptedTextTool) {
+                const streamToken = {};
+                activeStreams.add(streamToken);
+                let downstreamClosed = false;
+                let heartbeatTimer;
+                const writeDone = async () => {
+                    if (downstreamClosed)
+                        return;
+                    downstreamClosed = true;
+                    if (heartbeatTimer) {
+                        clearTimeout(heartbeatTimer);
+                        heartbeatTimer = undefined;
+                    }
+                    await writer.writeDone();
+                };
+                const writeEnvelope = async (data) => {
+                    if (heartbeatTimer)
+                        clearTimeout(heartbeatTimer);
+                    await writer.writeData(data);
+                    if (!downstreamClosed) {
+                        heartbeatTimer = setTimeout(() => {
+                            writer.writeData({ type: "heartbeat" }).catch(() => { });
+                        }, 60_000);
+                    }
+                };
+                const writeData = async (data) => {
+                    if (downstreamClosed)
+                        return;
+                    await writeEnvelope(data);
+                };
+                try {
+                    await liveTurn.attach({ writeData, writeDone });
+                    if (pendingClientTool.kind === "ask_user") {
+                        answerPendingAsk(pendingClientTool.toolCallId, pendingAskLiveAnswer(pendingClientTool.input, answerPart, prompt));
+                    }
+                    else {
+                        const approval = pendingApprovalLiveAnswer(pendingClientTool, answerPart, prompt);
+                        if (approval.approved) {
+                            await sessionManager.get(pendingClientTool.conversationId)?.setPermissionMode("bypassPermissions");
+                        }
+                        answerPendingApproval(pendingClientTool.toolCallId, approval);
+                    }
+                    await liveTurn.done;
+                }
+                catch (err) {
+                    logger.error("Claude live ask continuation failed:", err);
+                    await writeData({
+                        type: "error",
+                        errorText: err instanceof Error ? err.message : String(err),
+                    });
+                    await writeDone();
+                }
+                finally {
+                    if (heartbeatTimer)
+                        clearTimeout(heartbeatTimer);
+                    activeStreams.delete(streamToken);
+                }
+                return;
+            }
+            const streamToken = {};
+            activeStreams.add(streamToken);
+            const localConversationId = requestedConversationId ?? randomUUID();
+            let activeConversationId = localConversationId;
+            let responseStarted = false;
+            let stepStarted = false;
+            let completed = false;
+            let textOpen = new Set();
+            let reasoningOpen = new Set();
+            const textBlockIds = new Map();
+            const reasoningBlockIds = new Map();
+            const toolNamesByCallId = new Map();
+            let partialTextSeen = false;
+            let partialReasoningSeen = false;
+            let currentMessageId;
+            let finishReason = "stop";
+            let pendingUsage;
+            let latestContext;
+            let activeCompact;
+            let backgroundTaskIds = new Set();
+            let awaitingBackgroundCompletionResult = false;
+            let heartbeatTimer;
+            const taskAggregator = createTaskAggregator();
+            // Task* tool calls are buffered: a run of consecutive Task* calls collapses
+            // into a single TodoWrite-shaped input+output pair, flushed lazily when any
+            // non-Task* message arrives or the stream ends. Each flush uses a fresh
+            // toolCallId so every emitted pair is a self-contained, completed tool call.
+            let pendingTodoFlush = false;
+            let todoFlushSeq = 0;
+            // When the model calls AskUserQuestion / ExitPlanMode, canUseTool returns
+            // deny+interrupt and we pause: emit the downstream tool event, then keep
+            // draining the SDK stream until the turn ends naturally. We must NOT close
+            // the async iterator early — tearing it down before the SDK's can_use_tool
+            // control request is answered rejects the pending permission request
+            // ("Tool permission stream closed before response received") and canUseTool
+            // never runs.
+            let paused = false;
+            const pendingAskToolCallIds = new Set();
+            // Once the downstream SSE is closed with [DONE], all further writes are
+            // suppressed. We close it immediately when pausing for a user-answered tool
+            // (AskUserQuestion / ExitPlanMode) while still draining the SDK stream, so
+            // any error the SDK throws afterwards (e.g. the interrupted-result
+            // diagnostic) is not forwarded downstream.
+            let downstreamClosed = false;
+            let activeSink;
+            let liveTurnRegistered = false;
+            let liveTurnTimeout;
+            let doneResolve;
+            const liveDone = new Promise((resolve) => {
+                doneResolve = resolve;
+            });
+            let pauseResolve;
+            const firstTurnPaused = new Promise((resolve) => {
+                pauseResolve = resolve;
+            });
+            const scheduleHeartbeat = () => {
+                heartbeatTimer = setTimeout(() => {
+                    writeData({ type: "heartbeat" }).catch(() => { });
+                }, 60_000);
+            };
+            const writeEnvelope = async (data) => {
+                if (heartbeatTimer)
+                    clearTimeout(heartbeatTimer);
+                await writer.writeData(data);
+                if (!downstreamClosed)
+                    scheduleHeartbeat();
+            };
+            const initialSink = {
+                writeData: async (data) => {
+                    if (downstreamClosed)
+                        return;
+                    await writeEnvelope(data);
+                },
+                writeDone: async () => {
+                    if (downstreamClosed)
+                        return;
+                    downstreamClosed = true;
+                    if (heartbeatTimer) {
+                        clearTimeout(heartbeatTimer);
+                        heartbeatTimer = undefined;
+                    }
+                    await writer.writeDone();
+                },
+            };
+            activeSink = initialSink;
+            const writeData = async (data) => {
+                if (downstreamClosed)
+                    return;
+                await activeSink.writeData(data);
+            };
+            const writeDone = async () => {
+                if (downstreamClosed)
+                    return;
+                await activeSink.writeDone();
+                downstreamClosed = true;
+            };
+            const writeCompactStart = async () => {
+                if (activeCompact)
+                    return;
+                activeCompact = { activityId: randomUUID() };
+                await writeData({
+                    type: "data",
+                    kind: "compact",
+                    data: { phase: "start", activityId: activeCompact.activityId },
+                });
+            };
+            const writeCompactEnd = async (status, metadata = {}) => {
+                if (!activeCompact)
+                    return;
+                const compact = activeCompact;
+                activeCompact = undefined;
+                await writeData({
+                    type: "data",
+                    kind: "compact",
+                    data: {
+                        phase: "end",
+                        activityId: compact.activityId,
+                        status,
+                        ...metadata,
+                    },
+                });
+            };
+            const writeFinish = async (finishReason) => {
+                if (completed || downstreamClosed)
+                    return;
+                completed = true;
+                for (const id of textOpen) {
+                    await writeData({ type: "text-end", id });
+                }
+                textOpen = new Set();
+                for (const id of reasoningOpen) {
+                    await writeData({ type: "reasoning-end", id });
+                }
+                reasoningOpen = new Set();
+                if (stepStarted) {
+                    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 closeOpenText = async () => {
+                for (const id of textOpen)
+                    await writeData({ type: "text-end", id });
+                textOpen = new Set();
+            };
+            const closeOpenReasoning = async () => {
+                for (const id of reasoningOpen)
+                    await writeData({ type: "reasoning-end", id });
+                reasoningOpen = new Set();
+            };
+            const closeOpenBlocks = async () => {
+                await closeOpenText();
+                await closeOpenReasoning();
+            };
+            const flushTodo = async () => {
+                if (!pendingTodoFlush)
+                    return;
+                pendingTodoFlush = false;
+                taskAggregator.clearDirty();
+                await closeOpenBlocks();
+                const toolCallId = `todo-${localConversationId}-${todoFlushSeq++}`;
+                await writeData({
+                    type: "tool-input-available",
+                    toolCallId,
+                    toolName: "TodoWrite",
+                    input: taskAggregator.snapshot(),
+                });
+                await writeData({
+                    type: "tool-output-available",
+                    toolCallId,
+                    output: "Task updated",
+                });
+            };
+            const pauseForClientTool = async (toolCallId, toolName, input, approval) => {
+                if (pendingAskToolCallIds.has(toolCallId))
+                    return;
+                pendingAskToolCallIds.add(toolCallId);
+                paused = true;
+                signal?.removeEventListener("abort", abortFromParent);
+                if (approval) {
+                    await writeData({
+                        type: "tool-approval-request",
+                        toolCallId,
+                        approveId: approval.approveId,
+                    });
+                }
+                await writeDone();
+                liveTurnTimeout = setTimeout(() => {
+                    logger.warn(`Claude ${toolName} timed out after ${appConfig.claude.askTimeoutMs}ms`, {
+                        conversationId: activeConversationId,
+                        toolCallId,
+                    });
+                    liveTurns.delete(activeConversationId);
+                    session.abort();
+                    doneResolve();
+                }, appConfig.claude.askTimeoutMs);
+                liveTurnTimeout.unref?.();
+                pauseResolve();
+            };
+            const ensureTextStarted = async (id) => {
+                if (textOpen.has(id))
+                    return;
+                textOpen.add(id);
+                await writeData({ type: "text-start", id });
+            };
+            const ensureReasoningStarted = async (id) => {
+                if (reasoningOpen.has(id))
+                    return;
+                reasoningOpen.add(id);
+                await writeData({ type: "reasoning-start", id });
+            };
+            const registerSession = (id) => {
+                if (id === activeConversationId)
+                    return;
+                const previousConversationId = activeConversationId;
+                activeConversationId = id;
+                sessionManager.bind(session, id);
+                moveLlmProxyBinding(previousConversationId, id, llmProxyBinding);
+                updatePendingAskConversation(previousConversationId, id);
+                const liveTurn = liveTurns.get(previousConversationId);
+                if (liveTurn) {
+                    liveTurns.delete(previousConversationId);
+                    liveTurns.set(id, liveTurn);
+                }
+            };
+            const writeStart = async (id) => {
+                if (responseStarted)
+                    return;
+                responseStarted = true;
+                registerSession(id);
+                if (!liveTurnRegistered) {
+                    liveTurnRegistered = true;
+                    liveTurns.set(id, {
+                        attach: async (sink) => {
+                            if (liveTurnTimeout) {
+                                clearTimeout(liveTurnTimeout);
+                                liveTurnTimeout = undefined;
+                            }
+                            activeSink = sink;
+                            downstreamClosed = false;
+                            paused = false;
+                        },
+                        done: liveDone,
+                        dispose: () => {
+                            if (liveTurnTimeout) {
+                                clearTimeout(liveTurnTimeout);
+                                liveTurnTimeout = undefined;
+                            }
+                        },
+                    });
+                }
+                await writeData({
+                    type: "start",
+                    messageMetadata: {
+                        conversationId: id,
+                        threadId: id,
+                    },
+                });
+                await writeData({ type: "start-step" });
+                stepStarted = true;
+            };
+            const cleanupCompletedTurn = () => {
+                if (liveTurnRegistered) {
+                    liveTurns.get(activeConversationId)?.dispose();
+                    liveTurns.delete(activeConversationId);
+                }
+                for (const toolCallId of pendingAskToolCallIds) {
+                    deletePendingClientTool(toolCallId, { rejectWait: true });
+                }
+            };
+            const finishCompletedTurn = async () => {
+                await writeFinish(finishReason);
+                cleanupCompletedTurn();
+                doneResolve();
+                return true;
+            };
+            scheduleHeartbeat();
+            const permissionHandler = async (toolName, input, options) => {
+                const { toolUseID } = options;
+                if (isAskUserQuestionTool(toolName)) {
+                    savePendingAsk({
+                        conversationId: activeConversationId,
+                        toolCallId: toolUseID,
+                        workdir: activeWorkdir,
+                        model: activeModel,
+                        agentMode,
+                        toolName: "AskUserQuestion",
+                        input,
+                    });
+                    await pauseForClientTool(toolUseID, "AskUserQuestion", input);
+                    const answer = await waitPendingAsk(toolUseID);
+                    if (!answer) {
+                        return {
+                            behavior: "deny",
+                            message: `${toolName} requires user input; session will resume after user responds.`,
+                            toolUseID,
+                        };
+                    }
+                    if ("interrupted" in answer) {
+                        return {
+                            behavior: "deny",
+                            message: "Question interrupted by text response",
+                            interrupt: true,
+                            toolUseID,
+                        };
+                    }
+                    return {
+                        behavior: "allow",
+                        updatedInput: {
+                            ...input,
+                            questions: questionsFromInput(input),
+                            answers: answer.answers,
+                        },
+                        toolUseID,
+                    };
+                }
+                if (isExitPlanModeTool(toolName)) {
+                    const pendingApproval = savePendingApproval({
+                        conversationId: activeConversationId,
+                        toolCallId: toolUseID,
+                        workdir: activeWorkdir,
+                        model: activeModel,
+                        agentMode,
+                        toolName: "ExitPlanMode",
+                        input,
+                    });
+                    await pauseForClientTool(toolUseID, "ExitPlanMode", input, pendingApproval);
+                    const approval = await waitPendingApproval(toolUseID);
+                    if (approval && "interrupted" in approval) {
+                        return {
+                            behavior: "deny",
+                            message: "Approval interrupted by text response",
+                            interrupt: true,
+                            toolUseID,
+                            decisionClassification: "user_reject",
+                        };
+                    }
+                    if (approval?.approved) {
+                        return {
+                            behavior: "allow",
+                            updatedInput: { ...input, approval },
+                            toolUseID,
+                        };
+                    }
+                    return {
+                        behavior: "deny",
+                        message: approval?.reason || "Denied by user",
+                        toolUseID,
+                        decisionClassification: "user_reject",
+                    };
+                }
+                return { behavior: "allow", toolUseID };
+            };
+            const handleMessage = async (message) => {
+                if (isSubagentMessage(message))
+                    return false;
+                const id = messageSessionId(message);
+                if (id) {
+                    await writeStart(id);
+                    taskAggregator.setSessionId(id);
+                }
+                if (paused)
+                    return false;
+                switch (message.type) {
+                    case "system": {
+                        if (message.subtype === "background_tasks_changed") {
+                            backgroundTaskIds = new Set(message.tasks.map((task) => task.task_id));
+                        }
+                        else if (message.subtype === "status") {
+                            if (message.status === "compacting") {
+                                await writeCompactStart();
+                            }
+                            if (message.compact_result === "success") {
+                                await writeCompactEnd("completed");
+                            }
+                            else if (message.compact_result === "failed") {
+                                await writeCompactEnd("failed", { error: message.compact_error });
+                            }
+                        }
+                        else if (message.subtype === "compact_boundary") {
+                            await writeCompactEnd("completed", {
+                                trigger: message.compact_metadata.trigger,
+                                preTokens: message.compact_metadata.pre_tokens,
+                                postTokens: message.compact_metadata.post_tokens,
+                                durationMs: message.compact_metadata.duration_ms,
+                            });
+                        }
+                        return false;
+                    }
+                    case "stream_event": {
+                        const event = message.event;
+                        switch (event.type) {
+                            case "message_start": {
+                                currentMessageId = event.message.id;
+                                partialTextSeen = false;
+                                partialReasoningSeen = false;
+                                break;
+                            }
+                            case "content_block_start": {
+                                const key = `${currentMessageId ?? message.session_id}:${event.index}`;
+                                if (event.content_block.type === "text") {
+                                    await flushTodo();
+                                    textBlockIds.set(key, message.uuid);
+                                    await ensureTextStarted(message.uuid);
+                                }
+                                else if (event.content_block.type === "thinking") {
+                                    await flushTodo();
+                                    reasoningBlockIds.set(key, message.uuid);
+                                    await ensureReasoningStarted(message.uuid);
+                                }
+                                break;
+                            }
+                            case "content_block_delta": {
+                                const delta = event.delta;
+                                const key = `${currentMessageId ?? message.session_id}:${event.index}`;
+                                if (delta.type === "text_delta") {
+                                    await flushTodo();
+                                    partialTextSeen = true;
+                                    const blockId = textBlockIds.get(key);
+                                    if (!blockId) {
+                                        logger.warn("Ignoring Claude text delta without content_block_start", {
+                                            conversationId: activeConversationId,
+                                            blockKey: key,
+                                        });
+                                        break;
+                                    }
+                                    await writeData({ type: "text-delta", id: blockId, delta: delta.text });
+                                }
+                                else if (delta.type === "thinking_delta") {
+                                    await flushTodo();
+                                    partialReasoningSeen = true;
+                                    const blockId = reasoningBlockIds.get(key);
+                                    if (!blockId) {
+                                        logger.warn("Ignoring Claude reasoning delta without content_block_start", {
+                                            conversationId: activeConversationId,
+                                            blockKey: key,
+                                        });
+                                        break;
+                                    }
+                                    await writeData({ type: "reasoning-delta", id: blockId, delta: delta.thinking });
+                                }
+                                break;
+                            }
+                            case "content_block_stop": {
+                                // The matching SDKAssistantMessage carries the transcript UUID
+                                // required for fork. Keep downstream blocks open until that
+                                // checkpoint has been published.
+                                break;
+                            }
+                        }
+                        return false;
+                    }
+                    case "assistant": {
+                        latestContext = claudeContextSnapshot(message.message) ?? latestContext;
+                        if (message.session_id && message.uuid) {
+                            await writeData({
+                                type: "data",
+                                kind: "agent_session",
+                                data: {
+                                    agentType: "claude",
+                                    sessionId: message.session_id,
+                                    messageId: message.uuid,
+                                },
+                            });
+                        }
+                        const content = message.message.content;
+                        if (typeof content === "string")
+                            break;
+                        for (const block of content) {
+                            switch (block.type) {
+                                case "thinking": {
+                                    // Fallback for non-streamed thinking blocks.
+                                    if (partialReasoningSeen || !block.thinking)
+                                        break;
+                                    await flushTodo();
+                                    await ensureReasoningStarted(message.uuid);
+                                    await writeData({ type: "reasoning-delta", id: message.uuid, delta: block.thinking });
+                                    break;
+                                }
+                                case "text": {
+                                    // Fallback for non-streamed text blocks.
+                                    if (partialTextSeen || !block.text)
+                                        break;
+                                    await flushTodo();
+                                    await ensureTextStarted(message.uuid);
+                                    await writeData({ type: "text-delta", id: message.uuid, delta: block.text });
+                                    break;
+                                }
+                                case "tool_use": {
+                                    await closeOpenBlocks();
+                                    toolNamesByCallId.set(block.id, block.name);
+                                    if (taskAggregator.isTaskTool(block.name)) {
+                                        // Buffer Task* tools: record the change and defer emission so a
+                                        // run of consecutive Task* calls collapses into a single
+                                        // TodoWrite input+output pair, flushed on the next non-Task*
+                                        // message or at stream end.
+                                        if (taskAggregator.applyToolUse(block.id, block.name, block.input)) {
+                                            pendingTodoFlush = true;
+                                        }
+                                        break;
+                                    }
+                                    await flushTodo();
+                                    await closeOpenBlocks();
+                                    await writeData({
+                                        type: "tool-input-available",
+                                        toolCallId: block.id,
+                                        toolName: block.name,
+                                        input: block.input,
+                                    });
+                                    break;
+                                }
+                            }
+                        }
+                        await closeOpenBlocks();
+                        textBlockIds.clear();
+                        reasoningBlockIds.clear();
+                        return false;
+                    }
+                    case "user": {
+                        const content = message.message.content;
+                        if (typeof content === "string")
+                            break;
+                        const toolResults = content.filter((block) => block.type === "tool_result");
+                        const structuredOutput = toolResults.length === 1 ? managedTaskStructuredOutput(message.tool_use_result) : undefined;
+                        for (const block of toolResults) {
+                            const toolCallId = block.tool_use_id;
+                            const output = block.content;
+                            // Re-read the task files after a Task* tool completes and buffer the
+                            // change; the raw Task* tool output is suppressed (it is represented
+                            // by the aggregated TodoWrite pair flushed later).
+                            if (taskAggregator.isTaskToolCall(toolCallId)) {
+                                if (taskAggregator.applyToolResult(toolCallId, output)) {
+                                    pendingTodoFlush = true;
+                                }
+                                continue;
+                            }
+                            await flushTodo();
+                            if (block.is_error === true) {
+                                await writeData({
+                                    type: "tool-output-error",
+                                    toolCallId,
+                                    errorText: toolResultText(output),
+                                });
+                            }
+                            else {
+                                const toolName = toolNamesByCallId.get(toolCallId);
+                                await writeData({
+                                    type: "tool-output-available",
+                                    toolCallId,
+                                    output: toolName && isManagedTaskTool(toolName) && structuredOutput !== undefined
+                                        ? structuredOutput
+                                        : output,
+                                });
+                            }
+                            toolNamesByCallId.delete(toolCallId);
+                        }
+                        return false;
+                    }
+                    case "result": {
+                        if (backgroundTaskIds.size > 0) {
+                            if (message.origin?.kind !== "task-notification") {
+                                awaitingBackgroundCompletionResult = true;
+                            }
+                            return false;
+                        }
+                        // A resumed session can replay a zero-turn task notification result
+                        // before it processes the newly queued human message.
+                        if (isNoopTaskNotificationResult(message) && !awaitingBackgroundCompletionResult) {
+                            return false;
+                        }
+                        finishReason = message.subtype === "success" || session.wasCancelled ? "stop" : "error";
+                        const usage = claudeTokenUsage(message, latestContext);
+                        pendingUsage = finishReason === "stop" ? usage : undefined;
+                        await flushTodo();
+                        if (message.subtype !== "success" && !session.wasCancelled) {
+                            await writeData({
+                                type: "error",
+                                errorText: message.errors?.filter((error) => error.trim()).join("\n") ||
+                                    `Claude Code failed: ${message.subtype}`,
+                            });
+                        }
+                        return finishCompletedTurn();
+                    }
+                }
+                return false;
+            };
+            const managedTaskContext = { threadRef, matrixEvent };
+            const session = existingSession ??
+                sessionManager.create({
+                    conversationId: localConversationId,
+                    workdir: activeWorkdir,
+                    model: activeModel,
+                    agentMode,
+                    managedTaskContext,
+                    llmProxyBinding,
+                    buildOptions: (abortController, canUseTool, context) => ({
+                        abortController,
+                        cwd: activeWorkdir,
+                        includePartialMessages: true,
+                        model: activeModel,
+                        maxTurns: appConfig.claude.maxTurns,
+                        systemPrompt: {
+                            type: "preset",
+                            preset: "claude_code",
+                            append: claudePlatformInstructions,
+                        },
+                        ...claudePermissionOptions(agentMode),
+                        tools: { type: "preset", preset: "claude_code" },
+                        mcpServers: {
+                            [MANAGED_TASK_MCP_SERVER_NAME]: createManagedTaskMcpServer({ workspaceRoot, context }),
+                        },
+                        disallowedTools: ["EnterWorktree", "ExitWorktree"],
+                        ...(claudeFork
+                            ? {
+                                resume: claudeFork.sessionId,
+                                resumeSessionAt: claudeFork.messageId,
+                                forkSession: true,
+                            }
+                            : requestedConversationId
+                                ? { resume: requestedConversationId }
+                                : null),
+                        canUseTool,
+                        env: {
+                            ...process.env,
+                            ...(appConfig.claude.apiKey ? { ANTHROPIC_API_KEY: appConfig.claude.apiKey } : null),
+                            ...(appConfig.claude.baseUrl ? { ANTHROPIC_BASE_URL: appConfig.claude.baseUrl } : null),
+                            ...(llmProxyBinding
+                                ? {
+                                    ANTHROPIC_CUSTOM_HEADERS: [
+                                        process.env.ANTHROPIC_CUSTOM_HEADERS,
+                                        `X-Elevo-LLM-Binding: ${llmProxyBinding}`,
+                                    ]
+                                        .filter(Boolean)
+                                        .join("\n"),
+                                }
+                                : null),
+                            CLAUDE_AGENT_SDK_CLIENT_APP: "coding-agent/claude-agent",
+                        },
+                    }),
+                });
+            setLlmProxyBinding(localConversationId, llmProxyBinding);
+            session.updateManagedTaskContext(managedTaskContext);
+            const abortFromParent = () => session.abort();
+            let ownerSignalAttached = false;
+            try {
+                if (interruptedTextTool && liveTurn) {
+                    await liveTurn.attach({
+                        writeData: async () => undefined,
+                        writeDone: async () => undefined,
+                    });
+                    if (interruptedTextTool.kind === "ask_user") {
+                        answerPendingAsk(interruptedTextTool.toolCallId, { interrupted: true });
+                    }
+                    else {
+                        answerPendingApproval(interruptedTextTool.toolCallId, { interrupted: true });
+                    }
+                    await liveTurn.done;
+                }
+                if (pendingClientTool && (!liveTurn || interruptedTextTool)) {
+                    if (pendingClientTool.kind === "ask_user") {
+                        await writeData(interruptedTextTool
+                            ? {
+                                type: "tool-output-error",
+                                toolCallId: pendingClientTool.toolCallId,
+                                toolName: pendingClientTool.toolName,
+                                errorText: "Question interrupted by text response",
+                            }
+                            : {
+                                type: "tool-output-available",
+                                toolCallId: pendingClientTool.toolCallId,
+                                output: pendingAskToolOutput(pendingClientTool, answerPart, prompt),
+                            });
+                    }
+                    else {
+                        await writeData(interruptedTextTool
+                            ? {
+                                type: "tool-output-error",
+                                toolCallId: pendingClientTool.toolCallId,
+                                toolName: pendingClientTool.toolName,
+                                errorText: "Approval interrupted by text response",
+                            }
+                            : {
+                                type: "tool-output-available",
+                                toolCallId: pendingClientTool.toolCallId,
+                                output: pendingApprovalToolOutput(pendingClientTool, answerPart, prompt),
+                            });
+                    }
+                    if (!interruptedTextTool || !liveTurn) {
+                        deletePendingClientTool(pendingClientTool.toolCallId);
+                    }
+                }
+                const turnPrompt = pendingClientTool && !liveTurn && !interruptedTextTool
+                    ? pendingClientTool.kind === "ask_user"
+                        ? pendingAskResumePrompt(answerPart, prompt)
+                        : pendingApprovalResumePrompt(pendingClientTool, answerPart, prompt)
+                    : prompt;
+                const reservation = await session.reserveTurn(turnPrompt, handleMessage, permissionHandler, {
+                    model: activeModel,
+                    agentMode,
+                    managedTaskContext,
+                });
+                if (reservation.kind === "interjection") {
+                    if (heartbeatTimer)
+                        clearTimeout(heartbeatTimer);
+                    await writer.writeDone();
+                    return;
+                }
+                ownerSignalAttached = true;
+                if (signal?.aborted)
+                    abortFromParent();
+                signal?.addEventListener("abort", abortFromParent, { once: true });
+                await Promise.race([reservation.done, firstTurnPaused]);
+                if (!paused && !completed && !downstreamClosed) {
+                    await writeFinish(session.wasCancelled || !session.isDead ? "stop" : "error");
+                }
+            }
+            catch (err) {
+                if (downstreamClosed) {
+                    logger.error("Claude stream failed after downstream closed:", err);
+                    doneResolve();
+                }
+                else {
+                    await writeStart(activeConversationId);
+                    if (signal?.aborted || session.wasCancelled) {
+                        await writeFinish("stop");
+                    }
+                    else if (session.isDead) {
+                        await writeFinish("error");
+                    }
+                    else {
+                        logger.error("Claude stream failed:", err);
+                        await writeData({
+                            type: "error",
+                            errorText: err instanceof Error ? err.message : String(err),
+                        });
+                        await writeFinish("error");
+                    }
+                }
+            }
+            finally {
+                if (ownerSignalAttached)
+                    signal?.removeEventListener("abort", abortFromParent);
+                if (heartbeatTimer)
+                    clearTimeout(heartbeatTimer);
+                activeStreams.delete(streamToken);
+                if (!paused) {
+                    cleanupCompletedTurn();
+                }
+                if (!paused)
+                    doneResolve();
+            }
+        },
+    };
+}
+export async function handleClaudeChatStream(request, writer) {
+    const prepared = await prepareClaudeChatStream(request);
+    await prepared.run(writer, request.signal);
+}
+chat.post("/v1/chat/stream", zValidator("json", ChatBodySchema), async (c) => {
+    let prepared;
+    try {
+        prepared = await prepareClaudeChatStream({
+            body: c.req.valid("json"),
+            headers: c.req.raw.headers,
+        });
+    }
+    catch (err) {
+        if (err instanceof ChatRequestError) {
+            return c.json({ error: err.message }, err.status);
+        }
+        throw err;
+    }
+    return streamSSE(c, async (sse) => {
+        await prepared.run({
+            writeData: async (data) => {
+                await sse.writeSSE({ data: JSON.stringify(data) });
+            },
+            writeDone: async () => {
+                await sse.writeSSE({ data: "[DONE]" });
+            },
+        }, c.req.raw.signal);
+    });
+});
+export default chat;