@supen-ai/cli 0.1.6

package/daemon/dist/http/routes/sessions.js

@@ -0,0 +1,963 @@
+import fs from 'fs';
+import path from 'path';
+import { randomUUID } from 'crypto';
+import { logger } from '../../core/logger.js';
+import { ensureSession, getSessionForAgent, getSessionInteractionEvents, getSessionUiEvents, getSessionsForAgent, getArchivedSessionsForAgent, getAutomationRunById, getAutomationById, getAutomationState, listAutomationRuns, finalizeRunningAutomationRunForSession, finalizeAutomationRun, clearSessionSdkId, deleteSessionForAgent, archiveSessionForAgent, restoreSessionForAgent, updateAutomationState, updateSessionMetadata, updateSessionStatus, storeMessage, } from '../../core/store.js';
+import { ASSISTANT_NAME, SUPEN_HOME } from '../../core/config.js';
+import { writeJson, writeProtocolError, readJsonBody } from '../response.js';
+import { addClient, broadcastToChat, buildHttpSessionId, removeClient } from '../stream.js';
+import { deriveHttpSenderIdentity } from '../context.js';
+import { readCodexThreadTitleFromStateDb, readCodexThreadTitleFromSessionIndex, } from '../thread-title.js';
+import { buildWorkspaceAttachmentPrompt, extractUserMessageText, persistUserMessageFiles, } from './chat-input.js';
+import { listWebCommands, resolveWebCommandInput } from '../command-catalog.js';
+import { AgentCortex } from '../../core/cortex.js';
+import { runSessionAutonomyPrelude } from '../../autonomy/session-autonomy.js';
+import { recordSessionControlCommand } from '../../core/control-commands.js';
+import { listControlLogEntries } from '../../core/control-log.js';
+import { appendThreadEvent } from '../../core/thread-event-log.js';
+import { projectThreadRuntimeState } from '../../core/thread-runtime-state.js';
+const recentPrewarmAttempts = new Map();
+const PREWARM_COOLDOWN_MS = 15_000;
+function autonomyPreludeTimeoutMs() {
+    const raw = Number(process.env.SUPEN_AUTONOMY_PRELUDE_TIMEOUT_MS || 1500);
+    return Number.isFinite(raw) && raw >= 0 ? raw : 1500;
+}
+async function runSessionAutonomyPreludeBounded(input) {
+    const timeoutMs = autonomyPreludeTimeoutMs();
+    if (timeoutMs === 0)
+        return null;
+    let timeout;
+    try {
+        return await Promise.race([
+            runSessionAutonomyPrelude(input),
+            new Promise((resolve) => {
+                timeout = setTimeout(() => resolve(null), timeoutMs);
+                timeout.unref?.();
+            }),
+        ]);
+    }
+    finally {
+        if (timeout)
+            clearTimeout(timeout);
+    }
+}
+export function captureWebUserMessage(input) {
+    try {
+        appendThreadEvent({
+            threadId: input.threadId,
+            runtimeThreadId: input.runtimeThreadId || input.threadId,
+            source: 'web',
+            eventType: 'user_message',
+            rawPayload: input.userMessage,
+        });
+    }
+    catch (error) {
+        logger.warn({
+            err: error,
+            threadId: input.threadId,
+            runtimeThreadId: input.runtimeThreadId || input.threadId,
+        }, 'Failed to capture web user message');
+    }
+}
+function serializeTask(session) {
+    const { session_id: sessionId, ...rest } = session;
+    return {
+        ...rest,
+        task_id: sessionId,
+    };
+}
+function isNoOpAutomationRun(runId) {
+    if (!runId)
+        return false;
+    const run = getAutomationRunById(runId);
+    return Boolean(run?.status === 'succeeded' &&
+        run.no_op_detected &&
+        !run.notification_sent);
+}
+function getNoOpAutomationTaskIds(messages) {
+    const taskIds = new Set();
+    for (const message of messages) {
+        if (!message.task_id)
+            continue;
+        if (isNoOpAutomationRun(message.automation_run_id) ||
+            isNoOpAutomationRun(message.schedule_run_id)) {
+            taskIds.add(message.task_id);
+        }
+    }
+    return taskIds;
+}
+function runtimeStateForThread(threadId) {
+    return projectThreadRuntimeState(threadId);
+}
+function isRecord(value) {
+    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+function stringField(record, key) {
+    const value = record[key];
+    return typeof value === 'string' ? value : undefined;
+}
+function rawAppServerPayloadFromLoggedEvent(event) {
+    const rawPayload = event.raw_payload;
+    if (!isRecord(rawPayload))
+        return rawPayload;
+    const data = rawPayload.data;
+    if (isRecord(data) && data.raw)
+        return data.raw;
+    return rawPayload;
+}
+function runtimeThreadIdFromLoggedEvent(event) {
+    if (!isRecord(event))
+        return null;
+    const directRuntimeThreadId = stringField(event, 'runtime_thread_id');
+    const rawPayload = rawAppServerPayloadFromLoggedEvent(event);
+    const params = isRecord(rawPayload) && isRecord(rawPayload.params)
+        ? rawPayload.params
+        : null;
+    const payloadThreadId = params ? stringField(params, 'threadId') : undefined;
+    const threadId = payloadThreadId || directRuntimeThreadId;
+    return threadId || null;
+}
+function readRuntimeThreadIdsFromJsonl(filePath) {
+    if (!fs.existsSync(filePath))
+        return [];
+    const ids = [];
+    const lines = fs
+        .readFileSync(filePath, 'utf8')
+        .split('\n')
+        .filter((line) => line.trim().length > 0)
+        .reverse();
+    for (const line of lines) {
+        try {
+            const threadId = runtimeThreadIdFromLoggedEvent(JSON.parse(line));
+            if (threadId && !ids.includes(threadId))
+                ids.push(threadId);
+        }
+        catch {
+            // Ignore corrupt event lines; title refresh should be best-effort.
+        }
+    }
+    return ids;
+}
+function runtimeThreadIdCandidatesForThread(threadId) {
+    const projectionRuntimeThreadId = runtimeStateForThread(threadId).runtime.runtime_thread_id;
+    const candidates = [
+        projectionRuntimeThreadId,
+        ...readRuntimeThreadIdsFromJsonl(path.join(SUPEN_HOME, 'threads', threadId, 'event-log', 'raw-events.jsonl')),
+        ...readRuntimeThreadIdsFromJsonl(path.join(SUPEN_HOME, 'threads', threadId, 'event-mirror', 'raw-events.jsonl')),
+        threadId,
+    ].filter((value) => Boolean(value));
+    return candidates.filter((value, index) => candidates.indexOf(value) === index);
+}
+function readCodexTitleForThread(threadId) {
+    for (const candidate of runtimeThreadIdCandidatesForThread(threadId)) {
+        const title = readCodexThreadTitleFromSessionIndex(candidate) ||
+            readCodexThreadTitleFromStateDb(candidate);
+        if (title)
+            return title;
+    }
+    return null;
+}
+function shouldReplaceTitle(input) {
+    if (!input.currentTitle)
+        return true;
+    if (input.currentTitle === input.nextTitle)
+        return false;
+    if (input.force)
+        return true;
+    return false;
+}
+function refreshThreadTitleFromCodexIndex(agentId, threadId, options = {}) {
+    const session = getSessionForAgent(agentId, threadId);
+    if (!session)
+        return { updated: false, title: null, previousTitle: null, reason: 'thread_not_found' };
+    const title = readCodexTitleForThread(threadId);
+    if (!title) {
+        return {
+            updated: false,
+            title: null,
+            previousTitle: session.title || null,
+            reason: 'codex_title_not_found',
+        };
+    }
+    const previousTitle = session.title?.trim() || '';
+    if (!shouldReplaceTitle({
+        currentTitle: previousTitle,
+        nextTitle: title,
+        force: options.force === true,
+    })) {
+        return {
+            updated: false,
+            title,
+            previousTitle: previousTitle || null,
+            reason: 'title_preserved',
+        };
+    }
+    updateSessionMetadata(agentId, threadId, { title });
+    broadcastToChat(buildHttpSessionId(agentId, threadId), {
+        type: 'session_updated',
+        session: { task_id: threadId, title },
+    });
+    return {
+        updated: true,
+        title,
+        previousTitle: previousTitle || null,
+    };
+}
+function runtimeStateSummary(projection) {
+    return {
+        event_log_head: projection.event_log_head,
+        projection_version: projection.projection_version,
+        event_log: projection.event_log,
+        runtime: projection.runtime,
+    };
+}
+function prewarmSessionInBackground(agentId, sessionId, options) {
+    const key = [
+        agentId,
+        sessionId,
+        options?.model || '',
+        options?.permissionMode || '',
+        options?.networkAccess ? 'network' : '',
+    ].join(':');
+    const now = Date.now();
+    const lastAttemptAt = recentPrewarmAttempts.get(key) || 0;
+    if (now - lastAttemptAt < PREWARM_COOLDOWN_MS) {
+        return;
+    }
+    recentPrewarmAttempts.set(key, now);
+    const cortex = new AgentCortex(agentId, sessionId);
+    void cortex.prewarmNativeSession(options);
+}
+function readRuntimeOptions(body) {
+    const model = typeof body?.model === 'string' && body.model.trim()
+        ? body.model.trim()
+        : undefined;
+    const effortText = typeof body?.effort === 'string' && body.effort.trim()
+        ? body.effort.trim().toLowerCase()
+        : typeof body?.reasoningEffort === 'string' && body.reasoningEffort.trim()
+            ? body.reasoningEffort.trim().toLowerCase()
+            : undefined;
+    const effort = effortText === 'low' ||
+        effortText === 'medium' ||
+        effortText === 'high' ||
+        effortText === 'xhigh'
+        ? effortText
+        : effortText === 'extra-high' || effortText === 'extra_high' || effortText === 'extra high'
+            ? 'xhigh'
+            : undefined;
+    const permissionMode = body?.permissionMode === 'default' ||
+        body?.permissionMode === 'read-only' ||
+        body?.permissionMode === 'workspace-write' ||
+        body?.permissionMode === 'full-access' ||
+        body?.permissionMode === 'custom'
+        ? body.permissionMode
+        : undefined;
+    const networkAccess = body?.networkAccess === true;
+    return {
+        ...(model ? { model } : {}),
+        ...(effort ? { effort } : {}),
+        ...(permissionMode ? { permissionMode } : {}),
+        ...(networkAccess ? { networkAccess } : {}),
+    };
+}
+function resetAutomationRuntimeForSession(sessionId) {
+    const automationMatch = sessionId.match(/^sched-(.+)$/);
+    if (!automationMatch)
+        return null;
+    const automationId = automationMatch[1];
+    const automation = getAutomationById(automationId);
+    const state = getAutomationState(automationId);
+    if (!automation || !state) {
+        return { automation_id: automationId, status: 'not_found' };
+    }
+    if (state.execution_status !== 'running' && state.execution_status !== 'claimed') {
+        return { automation_id: automationId, status: 'not_running' };
+    }
+    const now = new Date().toISOString();
+    const resetError = 'Automation runtime reset by user';
+    const runningRun = listAutomationRuns({
+        automation_id: automationId,
+        status: 'running',
+        limit: 1,
+    })[0];
+    if (runningRun) {
+        const finalized = finalizeAutomationRun(runningRun.run_id, {
+            status: 'failed',
+            finished_at: now,
+            error: resetError,
+            notification_sent: false,
+        });
+        if (finalized) {
+            return {
+                automation_id: automationId,
+                status: 'finalized_run',
+                run_id: finalized.run_id,
+            };
+        }
+    }
+    updateAutomationState(automationId, {
+        execution_status: 'idle',
+        claimed_at: null,
+        started_at: null,
+        last_error: resetError,
+        last_run: now,
+        failure_count: state.failure_count + 1,
+    });
+    return { automation_id: automationId, status: 'reset_state' };
+}
+export async function handleSessionsRoutes(req, res, url, pathname, method, adminContext, onMessage, onSessionStop) {
+    const sseV1Match = pathname.match(/^\/api\/computer\/agents\/([^/]+)\/sessions\/([^/]+)\/stream$/);
+    if (sseV1Match && method === 'GET') {
+        const agentId = decodeURIComponent(sseV1Match[1]);
+        const sessionId = decodeURIComponent(sseV1Match[2]);
+        const session = getSessionForAgent(agentId, sessionId);
+        if (!session) {
+            writeProtocolError(res, 404, 'input_error', 'session_not_found', `Task "${sessionId}" was not found for agent "${agentId}"`);
+            return true;
+        }
+        const chatJid = buildHttpSessionId(agentId, sessionId);
+        let clientRegistered = false;
+        const cleanup = () => {
+            if (!clientRegistered)
+                return;
+            removeClient(chatJid, res);
+            clientRegistered = false;
+        };
+        res.writeHead(200, {
+            'Content-Type': 'text/event-stream; charset=utf-8',
+            'Cache-Control': 'no-cache',
+            'Connection': 'keep-alive',
+            'X-Accel-Buffering': 'no',
+            'x-vercel-ai-ui-message-stream': 'v1',
+        });
+        addClient(chatJid, res);
+        clientRegistered = true;
+        req.on('close', cleanup);
+        res.on('close', cleanup);
+        res.flushHeaders?.();
+        res.write(': connected\n\n');
+        res.flush?.();
+        return true;
+    }
+    const commandsV1Match = pathname.match(/^\/api\/computer\/agents\/([^/]+)\/sessions\/([^/]+)\/commands$/);
+    if (commandsV1Match && method === 'GET') {
+        const agentId = decodeURIComponent(commandsV1Match[1]);
+        const commands = await listWebCommands({ channel: 'web', agentId });
+        writeJson(res, 200, { commands });
+        return true;
+    }
+    const agentCommandsV1Match = pathname.match(/^\/api\/computer\/agents\/([^/]+)\/commands$/);
+    if (agentCommandsV1Match && method === 'GET') {
+        const agentId = decodeURIComponent(agentCommandsV1Match[1]);
+        const commands = await listWebCommands({ channel: 'web', agentId });
+        writeJson(res, 200, { commands });
+        return true;
+    }
+    const resolveCommandsV1Match = pathname.match(/^\/api\/computer\/agents\/([^/]+)\/sessions\/([^/]+)\/commands\/resolve$/);
+    if (resolveCommandsV1Match && method === 'POST') {
+        const agentId = decodeURIComponent(resolveCommandsV1Match[1]);
+        const parsed = await readJsonBody(req);
+        const input = typeof parsed?.input === 'string' ? parsed.input : '';
+        const channel = typeof parsed?.channel === 'string' ? parsed.channel : 'web';
+        if (!input.trim()) {
+            writeProtocolError(res, 400, 'input_error', 'content_required', 'input is required');
+            return true;
+        }
+        const resolved = await resolveWebCommandInput(input, { channel, agentId });
+        writeJson(res, 200, resolved);
+        return true;
+    }
+    const stopV1Match = pathname.match(/^\/api\/computer\/agents\/([^/]+)\/sessions\/([^/]+)\/stop$/);
+    if (stopV1Match && method === 'POST') {
+        const agentId = decodeURIComponent(stopV1Match[1]);
+        const sessionId = decodeURIComponent(stopV1Match[2]);
+        if (!onSessionStop) {
+            writeProtocolError(res, 501, 'input_error', 'stop_not_supported', 'Session stop is not supported by this daemon.');
+            return true;
+        }
+        const actor = adminContext?.actor || 'http';
+        recordSessionControlCommand({
+            agentId,
+            sessionId,
+            surface: 'web',
+            commandType: 'session.stop',
+            method: 'turn/interrupt',
+            actor,
+            status: 'received',
+            payload: { endpoint: 'stop' },
+        });
+        const result = onSessionStop(agentId, sessionId, actor);
+        if (!result.ok && result.code !== 'session_not_running') {
+            writeProtocolError(res, 404, 'input_error', result.code, result.message);
+            return true;
+        }
+        const finalizedAutomationRun = finalizeRunningAutomationRunForSession(agentId, sessionId, {
+            actor,
+        });
+        const automationReset = finalizedAutomationRun
+            ? {
+                automation_id: finalizedAutomationRun.automation_id,
+                status: 'finalized_run',
+                run_id: finalizedAutomationRun.run_id,
+            }
+            : resetAutomationRuntimeForSession(sessionId);
+        const automationRuntimeReleased = automationReset?.status === 'finalized_run' || automationReset?.status === 'reset_state';
+        if (automationRuntimeReleased) {
+            updateSessionStatus(agentId, sessionId, 'idle');
+            const refreshedSession = getSessionForAgent(agentId, sessionId);
+            if (refreshedSession) {
+                broadcastToChat(buildHttpSessionId(agentId, sessionId), {
+                    type: 'session_updated',
+                    session: refreshedSession,
+                });
+            }
+        }
+        writeJson(res, 200, {
+            ...result,
+            ok: result.ok || automationRuntimeReleased,
+            automation_reset: automationReset,
+        });
+        return true;
+    }
+    const resetRuntimeV1Match = pathname.match(/^\/api\/computer\/agents\/([^/]+)\/sessions\/([^/]+)\/reset-runtime$/);
+    if (resetRuntimeV1Match && method === 'POST') {
+        const agentId = decodeURIComponent(resetRuntimeV1Match[1]);
+        const sessionId = decodeURIComponent(resetRuntimeV1Match[2]);
+        const session = getSessionForAgent(agentId, sessionId);
+        if (!session) {
+            writeProtocolError(res, 404, 'input_error', 'session_not_found', `Task "${sessionId}" was not found for agent "${agentId}"`);
+            return true;
+        }
+        const clearedSdkSessionId = Boolean(session.sdk_session_id);
+        clearSessionSdkId(agentId, sessionId);
+        updateSessionStatus(agentId, sessionId, 'idle');
+        const automationReset = resetAutomationRuntimeForSession(sessionId);
+        const refreshedSession = getSessionForAgent(agentId, sessionId) || {
+            ...session,
+            status: 'idle',
+        };
+        broadcastToChat(buildHttpSessionId(agentId, sessionId), {
+            type: 'session_updated',
+            session: serializeTask(refreshedSession),
+        });
+        writeJson(res, 200, {
+            ok: true,
+            session: serializeTask(refreshedSession),
+            cleared_sdk_session_id: clearedSdkSessionId,
+            automation_reset: automationReset,
+        });
+        return true;
+    }
+    const prewarmV1Match = pathname.match(/^\/api\/computer\/agents\/([^/]+)\/sessions\/([^/]+)\/prewarm$/);
+    if (prewarmV1Match && method === 'POST') {
+        const agentId = decodeURIComponent(prewarmV1Match[1]);
+        const sessionId = decodeURIComponent(prewarmV1Match[2]);
+        const session = getSessionForAgent(agentId, sessionId);
+        if (!session) {
+            writeProtocolError(res, 404, 'input_error', 'session_not_found', `Task "${sessionId}" was not found for agent "${agentId}"`);
+            return true;
+        }
+        const parsed = await readJsonBody(req).catch(() => ({}));
+        const runtimeOptions = readRuntimeOptions(parsed);
+        prewarmSessionInBackground(agentId, sessionId, runtimeOptions);
+        writeJson(res, 202, { ok: true, task_id: sessionId, prewarming: true });
+        return true;
+    }
+    const chatV1Match = pathname.match(/^\/api\/computer\/agents\/([^/]+)\/sessions\/([^/]+)\/chat$/);
+    if (chatV1Match && method === 'POST') {
+        const agentId = decodeURIComponent(chatV1Match[1]);
+        const sessionId = decodeURIComponent(chatV1Match[2]);
+        const parsed = await readJsonBody(req);
+        const { messages } = parsed;
+        const runtimeOptions = readRuntimeOptions(parsed);
+        const model = runtimeOptions.model;
+        if (!messages || !Array.isArray(messages)) {
+            writeProtocolError(res, 400, 'input_error', 'content_required', 'messages array is required');
+            return true;
+        }
+        const chatJid = buildHttpSessionId(agentId, sessionId);
+        ensureSession({ agent_id: agentId, session_id: sessionId, channel: 'http', agent_name: agentId });
+        prewarmSessionInBackground(agentId, sessionId, runtimeOptions);
+        const senderIdentity = deriveHttpSenderIdentity(adminContext);
+        const rawLastUserMsg = messages[messages.length - 1];
+        const rawUserText = rawLastUserMsg?.role === 'user' ? extractUserMessageText(rawLastUserMsg) : '';
+        const resolvedUserInput = rawLastUserMsg?.role === 'user'
+            ? await resolveWebCommandInput(rawUserText, { channel: 'web', agentId })
+            : null;
+        const executionText = resolvedUserInput?.kind === 'chat' || resolvedUserInput?.kind === 'builtin'
+            ? resolvedUserInput.text
+            : rawUserText;
+        const displayUserText = resolvedUserInput?.kind === 'chat'
+            ? resolvedUserInput.rawInput
+            : executionText;
+        const taskId = randomUUID();
+        recordSessionControlCommand({
+            agentId,
+            sessionId,
+            turnId: taskId,
+            surface: 'web',
+            commandType: 'session.instruct',
+            method: 'turn/start',
+            actor: senderIdentity.sender,
+            status: 'received',
+            payload: {
+                endpoint: 'chat',
+                message_excerpt: (displayUserText || rawUserText || '').slice(0, 240),
+                model,
+                runtime_options: runtimeOptions,
+            },
+        });
+        const uploadedFiles = rawLastUserMsg?.role === 'user'
+            ? persistUserMessageFiles(agentId, rawLastUserMsg, { sessionId, taskId })
+            : [];
+        const attachmentPrompt = buildWorkspaceAttachmentPrompt(uploadedFiles);
+        const storedUserContent = [displayUserText, attachmentPrompt].filter(Boolean).join('\n\n').trim();
+        let autonomyMetadata = null;
+        try {
+            const prelude = await runSessionAutonomyPreludeBounded({
+                agentId,
+                sessionId,
+                taskId,
+                message: displayUserText || rawUserText || '',
+            });
+            if (prelude) {
+                autonomyMetadata = {
+                    decision: prelude.decision,
+                    proof: prelude.proof,
+                    memoryCandidates: prelude.memoryCandidates,
+                    activeMemorySignals: prelude.activeMemorySignals,
+                    executionContext: prelude.executionContext,
+                };
+            }
+            else {
+                logger.warn({ agentId, sessionId, timeoutMs: autonomyPreludeTimeoutMs() }, 'autonomy prelude timed out; dispatching chat without autonomy metadata');
+            }
+        }
+        catch (error) {
+            logger.warn({ err: error, agentId, sessionId }, 'autonomy prelude failed');
+        }
+        const userMessage = {
+            id: `http-${Date.now()}-${taskId.slice(0, 8)}`,
+            chat_jid: chatJid,
+            sender: senderIdentity.sender,
+            sender_name: senderIdentity.sender_name,
+            content: storedUserContent || '',
+            timestamp: new Date().toISOString(),
+            is_from_me: false,
+            agent_id: agentId,
+            session_id: sessionId,
+            task_id: taskId,
+            attachments: uploadedFiles,
+            model,
+            metadata: {
+                source: 'http-chat',
+                runtime_options: runtimeOptions,
+                ...(autonomyMetadata ? { autonomy: autonomyMetadata } : {}),
+            },
+        };
+        const userContentForTitle = attachmentPrompt || storedUserContent || rawUserText || '';
+        const waitMs = 100;
+        const timeoutMs = 180_000;
+        const waitUntil = Date.now() + timeoutMs;
+        let clientRegistered = false;
+        const cleanup = () => {
+            if (!clientRegistered)
+                return;
+            removeClient(chatJid, res);
+            clientRegistered = false;
+        };
+        try {
+            res.writeHead(200, {
+                'Content-Type': 'text/event-stream; charset=utf-8',
+                'Cache-Control': 'no-cache',
+                'Connection': 'keep-alive',
+                'X-Accel-Buffering': 'no',
+                'x-vercel-ai-ui-message-stream': 'v1',
+            });
+            addClient(chatJid, res);
+            clientRegistered = true;
+            req.on('close', cleanup);
+            res.on('close', cleanup);
+            res.flushHeaders?.();
+            res.write(': ping\n\n');
+            res.flush?.();
+            captureWebUserMessage({
+                threadId: sessionId,
+                runtimeThreadId: sessionId,
+                userMessage,
+            });
+            onMessage(chatJid, userMessage);
+            recordSessionControlCommand({
+                agentId,
+                sessionId,
+                turnId: taskId,
+                surface: 'web',
+                commandType: 'session.instruct',
+                method: 'turn/start',
+                actor: senderIdentity.sender,
+                status: 'dispatched',
+                payload: {
+                    endpoint: 'chat',
+                    message_excerpt: (displayUserText || rawUserText || '').slice(0, 240),
+                    model,
+                    runtime_options: runtimeOptions,
+                },
+            });
+            let completed = false;
+            let completedWithError = false;
+            while (Date.now() < waitUntil) {
+                const events = getSessionUiEvents(agentId, sessionId, 80);
+                completed = events.some((evt) => {
+                    return (evt.task_id === taskId &&
+                        evt.chunk &&
+                        evt.chunk?.type === 'stream-dispatched');
+                });
+                completedWithError = events.some((evt) => {
+                    return (evt.task_id === taskId &&
+                        evt.chunk &&
+                        evt.chunk?.type === 'error');
+                });
+                if (completed || completedWithError)
+                    break;
+                await new Promise((resolve) => setTimeout(resolve, waitMs));
+            }
+            const finalEvents = getSessionUiEvents(agentId, sessionId, 80);
+            const timedOut = !completed && !completedWithError;
+            const endedWithError = finalEvents.some((evt) => {
+                return (evt.task_id === taskId &&
+                    evt.chunk &&
+                    evt.chunk?.type === 'error');
+            });
+            if (timedOut && !completed && !completedWithError) {
+                res.write(`data: ${JSON.stringify({ type: 'error', errorText: 'Message stream timed out' })}\n\n`);
+            }
+            else if (endedWithError || completedWithError) {
+                const payload = JSON.stringify({
+                    type: 'error',
+                    errorText: 'Message stream ended with error',
+                });
+                res.write(`data: ${payload}\n\n`);
+            }
+            else if (rawLastUserMsg?.role === 'user' && userContentForTitle) {
+                await ensureThreadTitleFromBackend(agentId, sessionId);
+            }
+        }
+        catch (err) {
+            logger.error({ err, agentId, sessionId }, 'Chat stream failed');
+            if (res.headersSent) {
+                const payload = JSON.stringify({
+                    type: 'error',
+                    errorText: err?.message || 'Chat stream failed',
+                });
+                res.write(`data: ${payload}\n\n`);
+            }
+            else {
+                writeProtocolError(res, 500, 'internal_error', 'cortex_error', err.message);
+            }
+        }
+        finally {
+            cleanup();
+            res.end();
+        }
+        return true;
+    }
+    // ── List Sessions ──
+    const listSessionsMatch = pathname.match(/^\/api\/computer\/agents\/([^/]+)\/sessions$/);
+    if (listSessionsMatch && method === 'POST') {
+        const agentId = decodeURIComponent(listSessionsMatch[1]);
+        const parsed = await readJsonBody(req);
+        const requestedSessionId = typeof parsed?.task_id === 'string'
+            ? parsed.task_id.trim()
+            : typeof parsed?.session_id === 'string'
+                ? parsed.session_id.trim()
+                : '';
+        const requestedTitle = typeof parsed?.title === 'string' ? parsed.title.trim() : '';
+        const requestedKnowledgeId = typeof parsed?.knowledge_id === 'string' ? parsed.knowledge_id.trim() : '';
+        const requestedKnowledgeName = typeof parsed?.knowledge_name === 'string' ? parsed.knowledge_name.trim() : '';
+        if (requestedSessionId && getSessionForAgent(agentId, requestedSessionId)) {
+            writeProtocolError(res, 409, 'input_error', 'session_exists', `Task "${requestedSessionId}" already exists for agent "${agentId}"`);
+            return true;
+        }
+        let sessionId = requestedSessionId;
+        if (!sessionId) {
+            do {
+                sessionId = `session-${Date.now().toString(36)}-${randomUUID().slice(0, 8)}`;
+            } while (getSessionForAgent(agentId, sessionId));
+        }
+        const session = ensureSession({
+            agent_id: agentId,
+            session_id: sessionId,
+            channel: 'http',
+            agent_name: agentId,
+            source_ref: buildHttpSessionId(agentId, sessionId),
+            knowledge_id: requestedKnowledgeId || undefined,
+            knowledge_name: requestedKnowledgeName || undefined,
+            title: requestedTitle || undefined,
+        });
+        recordSessionControlCommand({
+            agentId,
+            sessionId,
+            surface: 'web',
+            commandType: 'session.start',
+            method: 'thread/start',
+            actor: adminContext?.actor || 'http',
+            status: 'completed',
+            payload: {
+                requested_task_id: requestedSessionId || null,
+                title: requestedTitle || null,
+                knowledge_id: requestedKnowledgeId || null,
+                knowledge_name: requestedKnowledgeName || null,
+            },
+        });
+        const refreshedSession = getSessionForAgent(agentId, sessionId) || session;
+        prewarmSessionInBackground(agentId, sessionId);
+        writeJson(res, 200, { session: serializeTask(refreshedSession) });
+        return true;
+    }
+    if (listSessionsMatch && method === 'GET') {
+        const agentId = decodeURIComponent(listSessionsMatch[1]);
+        const sessions = getSessionsForAgent(agentId).map(serializeTask);
+        writeJson(res, 200, { sessions });
+        return true;
+    }
+    const archivedSessionsMatch = pathname.match(/^\/api\/computer\/agents\/([^/]+)\/archived_sessions$/);
+    if (archivedSessionsMatch && method === 'GET') {
+        const agentId = decodeURIComponent(archivedSessionsMatch[1]);
+        const sessions = getArchivedSessionsForAgent(agentId).map(serializeTask);
+        writeJson(res, 200, { sessions });
+        return true;
+    }
+    const refreshTitlesMatch = pathname.match(/^\/api\/computer\/agents\/([^/]+)\/threads\/refresh-titles$/);
+    if (refreshTitlesMatch && method === 'POST') {
+        const agentId = decodeURIComponent(refreshTitlesMatch[1]);
+        const parsed = await readJsonBody(req).catch(() => ({}));
+        const force = parsed?.force === true;
+        const sessions = getSessionsForAgent(agentId);
+        const results = sessions.map((session) => {
+            const result = refreshThreadTitleFromCodexIndex(agentId, session.session_id, { force });
+            return {
+                thread_id: session.session_id,
+                updated: result.updated,
+                title: result.title,
+                previous_title: result.previousTitle,
+                reason: result.reason || null,
+            };
+        });
+        writeJson(res, 200, {
+            ok: true,
+            force,
+            total: results.length,
+            updated: results.filter((result) => result.updated).length,
+            results,
+        });
+        return true;
+    }
+    const refreshTitleMatch = pathname.match(/^\/api\/computer\/agents\/([^/]+)\/threads\/([^/]+)\/refresh-title$/);
+    if (refreshTitleMatch && method === 'POST') {
+        const agentId = decodeURIComponent(refreshTitleMatch[1]);
+        const threadId = decodeURIComponent(refreshTitleMatch[2]);
+        const parsed = await readJsonBody(req).catch(() => ({}));
+        const result = refreshThreadTitleFromCodexIndex(agentId, threadId, {
+            force: parsed?.force === true,
+        });
+        if (result.reason === 'thread_not_found') {
+            writeProtocolError(res, 404, 'input_error', 'thread_not_found', `Thread "${threadId}" was not found for agent "${agentId}"`);
+            return true;
+        }
+        writeJson(res, 200, {
+            ok: true,
+            thread_id: threadId,
+            updated: result.updated,
+            title: result.title,
+            previous_title: result.previousTitle,
+            reason: result.reason || null,
+        });
+        return true;
+    }
+    const sessionLifecycleMatch = pathname.match(/^\/api\/computer\/agents\/([^/]+)\/sessions\/([^/]+)$/);
+    if (sessionLifecycleMatch && method === 'PATCH') {
+        const agentId = decodeURIComponent(sessionLifecycleMatch[1]);
+        const sessionId = decodeURIComponent(sessionLifecycleMatch[2]);
+        const parsed = await readJsonBody(req);
+        if (parsed?.archived === true) {
+            const archived = archiveSessionForAgent(agentId, sessionId);
+            if (!archived) {
+                writeProtocolError(res, 404, 'input_error', 'session_not_found', `Task "${sessionId}" was not found for agent "${agentId}"`);
+                return true;
+            }
+            writeJson(res, 200, { ok: true, archived: true });
+            return true;
+        }
+        if (parsed?.archived === false) {
+            const restored = restoreSessionForAgent(agentId, sessionId);
+            if (!restored) {
+                writeProtocolError(res, 404, 'input_error', 'session_not_found', `Archived task "${sessionId}" was not found for agent "${agentId}"`);
+                return true;
+            }
+            writeJson(res, 200, {
+                ok: true,
+                archived: false,
+                session: serializeTask(getSessionForAgent(agentId, sessionId)),
+            });
+            return true;
+        }
+        if (typeof parsed?.title === 'string') {
+            const updated = updateSessionMetadata(agentId, sessionId, {
+                title: parsed.title.trim() || undefined,
+            });
+            if (!updated) {
+                writeProtocolError(res, 404, 'input_error', 'session_not_found', `Task "${sessionId}" was not found for agent "${agentId}"`);
+                return true;
+            }
+            const session = getSessionForAgent(agentId, sessionId);
+            writeJson(res, 200, { ok: true, session: session ? serializeTask(session) : null });
+            return true;
+        }
+        writeProtocolError(res, 400, 'input_error', 'invalid_session_update', 'Expected archived or title in request body.');
+        return true;
+    }
+    if (sessionLifecycleMatch && method === 'DELETE') {
+        const agentId = decodeURIComponent(sessionLifecycleMatch[1]);
+        const sessionId = decodeURIComponent(sessionLifecycleMatch[2]);
+        const deleted = deleteSessionForAgent(agentId, sessionId) ||
+            deleteSessionForAgent(agentId, sessionId, true);
+        if (!deleted) {
+            writeProtocolError(res, 404, 'input_error', 'session_not_found', `Task "${sessionId}" was not found for agent "${agentId}"`);
+            return true;
+        }
+        writeJson(res, 200, { ok: true });
+        return true;
+    }
+    const runtimeStateMatch = pathname.match(/^\/api\/computer\/agents\/([^/]+)\/sessions\/([^/]+)\/runtime-state$/);
+    if (runtimeStateMatch && method === 'GET') {
+        const agentId = decodeURIComponent(runtimeStateMatch[1]);
+        const sessionId = decodeURIComponent(runtimeStateMatch[2]);
+        const session = getSessionForAgent(agentId, sessionId);
+        if (!session) {
+            writeProtocolError(res, 404, 'input_error', 'session_not_found', `Session "${sessionId}" was not found for agent "${agentId}"`);
+            return true;
+        }
+        const projection = projectThreadRuntimeState(sessionId);
+        writeJson(res, 200, {
+            session,
+            runtimeState: runtimeStateSummary(projection),
+            projection,
+        });
+        return true;
+    }
+    const sessionMessagesMatch = pathname.match(/^\/api\/computer\/agents\/([^/]+)\/sessions\/([^/]+)\/messages$/);
+    if (sessionMessagesMatch && method === 'GET') {
+        const agentId = decodeURIComponent(sessionMessagesMatch[1]);
+        const sessionId = decodeURIComponent(sessionMessagesMatch[2]);
+        const session = getSessionForAgent(agentId, sessionId);
+        if (!session) {
+            writeProtocolError(res, 404, 'input_error', 'session_not_found', `Task "${sessionId}" was not found for agent "${agentId}"`);
+            return true;
+        }
+        const limit = Math.max(1, parseInt(url.searchParams.get('limit') || '100', 10) || 100);
+        const interactionEvents = getSessionInteractionEvents(agentId, sessionId, limit);
+        const controlLog = listControlLogEntries(sessionId, limit);
+        const runtimeState = runtimeStateForThread(sessionId);
+        const responseMessages = runtimeState.messages.slice(-limit);
+        const responseEvents = runtimeState.events.slice(-limit);
+        writeJson(res, 200, {
+            session,
+            messages: responseMessages,
+            events: responseEvents,
+            interaction_events: interactionEvents,
+            control_log: controlLog,
+            runtimeState: runtimeStateSummary(runtimeState),
+        });
+        return true;
+    }
+    if (sessionMessagesMatch && method === 'POST') {
+        const agentId = decodeURIComponent(sessionMessagesMatch[1]);
+        const sessionId = decodeURIComponent(sessionMessagesMatch[2]);
+        const session = getSessionForAgent(agentId, sessionId);
+        if (!session) {
+            writeProtocolError(res, 404, 'input_error', 'session_not_found', `Task "${sessionId}" was not found for agent "${agentId}"`);
+            return true;
+        }
+        const parsed = await readJsonBody(req);
+        const userText = typeof parsed?.user_text === 'string' ? parsed.user_text : '';
+        const assistantText = typeof parsed?.assistant_text === 'string' ? parsed.assistant_text : '';
+        if (!userText.trim() || !assistantText.trim()) {
+            writeProtocolError(res, 400, 'input_error', 'content_required', 'user_text and assistant_text are required non-empty strings');
+            return true;
+        }
+        const chatJid = buildHttpSessionId(agentId, sessionId);
+        const senderIdentity = deriveHttpSenderIdentity(adminContext);
+        const pairId = randomUUID();
+        recordSessionControlCommand({
+            agentId,
+            sessionId,
+            turnId: pairId,
+            surface: 'web',
+            commandType: 'session.instruct',
+            method: 'turn/start',
+            actor: senderIdentity.sender,
+            status: 'completed',
+            payload: {
+                endpoint: 'messages',
+                source: 'http-slash-command',
+                message_excerpt: userText.slice(0, 240),
+            },
+        });
+        const userTs = new Date().toISOString();
+        const assistantTs = new Date(Date.now() + 1).toISOString();
+        storeMessage({
+            id: `http-slash-${pairId}-user`,
+            chat_jid: chatJid,
+            agent_id: agentId,
+            session_id: sessionId,
+            sender: senderIdentity.sender,
+            sender_name: senderIdentity.sender_name,
+            content: userText,
+            timestamp: userTs,
+            is_from_me: false,
+            is_bot_message: false,
+            metadata: { source: 'http-slash-command' },
+        });
+        storeMessage({
+            id: `http-slash-${pairId}-assistant`,
+            chat_jid: chatJid,
+            agent_id: agentId,
+            session_id: sessionId,
+            sender: ASSISTANT_NAME,
+            sender_name: ASSISTANT_NAME,
+            content: assistantText,
+            timestamp: assistantTs,
+            is_from_me: true,
+            is_bot_message: true,
+            metadata: { source: 'http-slash-command' },
+        });
+        await ensureThreadTitleFromBackend(agentId, sessionId);
+        writeJson(res, 200, { ok: true });
+        return true;
+    }
+    return false;
+}
+async function ensureThreadTitleFromBackend(agentId, threadId) {
+    const existingTitle = getSessionForAgent(agentId, threadId)?.title?.trim();
+    if (existingTitle)
+        return;
+    let title = readCodexTitleForThread(threadId);
+    if (!title) {
+        for (const waitMs of [250, 750, 1500]) {
+            await new Promise((resolve) => setTimeout(resolve, waitMs));
+            title = readCodexTitleForThread(threadId);
+            if (title)
+                break;
+        }
+    }
+    if (!title)
+        return;
+    if (existingTitle === title)
+        return;
+    updateSessionMetadata(agentId, threadId, { title });
+    broadcastToChat(buildHttpSessionId(agentId, threadId), {
+        type: 'session_updated',
+        session: { task_id: threadId, title },
+    });
+}
+//# sourceMappingURL=sessions.js.map