@supen-ai/cli 0.1.6

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

@@ -0,0 +1,790 @@
+import { randomUUID } from 'crypto';
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { ensureSession, getAllSessions, getSessionForAgent, getSessionUiEvents, getSessionsForAgent, } from '../../core/store.js';
+import { recordSessionControlCommand } from '../../core/control-commands.js';
+import { listControlLogEntries } from '../../core/control-log.js';
+import { resolveLocalWorkspaceFolder } from '../../core/task-artifacts.js';
+import { projectThreadRuntimeState } from '../../core/thread-runtime-state.js';
+import { respondAppServerApproval } from '../../agent-sdk/app-server-approvals.js';
+import { writeJson, readJsonBody } from '../response.js';
+import { buildHttpSessionId } from '../stream.js';
+import { readCodexThreadHistory } from './system.js';
+function success(id, result) {
+    return { jsonrpc: '2.0', id, result };
+}
+function rpcError(id, code, message, data) {
+    return {
+        jsonrpc: '2.0',
+        id,
+        error: {
+            code,
+            message,
+            ...(data ? { data } : {}),
+        },
+    };
+}
+function readString(value) {
+    return typeof value === 'string' ? value.trim() : '';
+}
+function readBoolean(value) {
+    return value === true;
+}
+function readRuntimeEffort(value) {
+    const text = readString(value).toLowerCase();
+    if (text === 'low' || text === 'medium' || text === 'high' || text === 'xhigh')
+        return text;
+    if (text === 'extra-high' || text === 'extra_high' || text === 'extra high')
+        return 'xhigh';
+    return undefined;
+}
+function readRuntimePermissionMode(value) {
+    const text = readString(value);
+    if (text === 'default' ||
+        text === 'read-only' ||
+        text === 'workspace-write' ||
+        text === 'full-access' ||
+        text === 'custom') {
+        return text;
+    }
+    return undefined;
+}
+function optionalAgentIdFromParams(params) {
+    return readString(params?.agentId) || readString(params?.agent_id) || null;
+}
+function threadIdFromParams(params) {
+    return (readString(params?.taskId) ||
+        readString(params?.task_id) ||
+        readString(params?.threadId) ||
+        readString(params?.thread_id) ||
+        readString(params?.sessionId));
+}
+function actorFromContext(context) {
+    return context?.actor || 'http';
+}
+function hasPendingApproval(session) {
+    const pendingToolCallIds = new Set();
+    for (const event of getSessionUiEvents(session.agent_id, session.session_id, 200)) {
+        const chunk = event.chunk && typeof event.chunk === 'object'
+            ? event.chunk
+            : {};
+        const type = typeof chunk.type === 'string' ? chunk.type : '';
+        const toolCallId = typeof chunk.toolCallId === 'string' ? chunk.toolCallId : '';
+        if (!toolCallId)
+            continue;
+        if (type === 'tool-approval-request') {
+            pendingToolCallIds.add(toolCallId);
+        }
+        else if (type === 'tool-output-available' ||
+            type === 'tool-output-error' ||
+            type === 'tool-output-denied') {
+            pendingToolCallIds.delete(toolCallId);
+        }
+    }
+    return pendingToolCallIds.size > 0;
+}
+function serializeThread(session) {
+    return {
+        id: session.session_id,
+        taskId: session.session_id,
+        agentId: session.agent_id,
+        status: session.status,
+        pendingApproval: hasPendingApproval(session),
+        title: session.title,
+        createdAt: session.created_at,
+        updatedAt: session.updated_at,
+        supen: {
+            spaceId: session.space_id,
+            channel: session.channel,
+            sourceRef: session.source_ref,
+            knowledgeId: session.knowledge_id,
+            knowledgeName: session.knowledge_name,
+            environmentId: session.environment_id,
+            environmentSnapshot: session.environment_snapshot,
+            taskWorkspaceFolder: session.task_workspace_folder,
+        },
+    };
+}
+function readStringRecord(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return {};
+    return Object.fromEntries(Object.entries(value).map(([key, entry]) => [
+        key,
+        entry == null ? '' : String(entry),
+    ]));
+}
+function readStringArray(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value.map((entry) => String(entry).trim()).filter(Boolean);
+}
+function normalizeEnvironmentSnapshot(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        return {
+            id: 'default',
+            name: 'Default Environment',
+            github_repo: null,
+            environment_variables: {},
+            secret_names: [],
+            task_network_access: false,
+        };
+    }
+    const record = value;
+    const githubRepo = readString(record.github_repo ?? record.githubRepo);
+    return {
+        id: readString(record.id) || 'default',
+        name: readString(record.name) || 'Default Environment',
+        description: readString(record.description),
+        github_repo: githubRepo || null,
+        environment_variables: readStringRecord(record.environment_variables ?? record.environmentVariables),
+        secret_names: readStringArray(record.secret_names ?? record.secretNames),
+        task_network_access: readBoolean(record.task_network_access ?? record.taskNetworkAccess),
+    };
+}
+function normalizeTaskWorkspaceFolder(value) {
+    const folder = readString(value);
+    return folder || null;
+}
+function validateTaskWorkspaceFolder(folder) {
+    if (!folder)
+        return null;
+    const resolved = resolveLocalWorkspaceFolder(folder);
+    try {
+        const stat = fs.statSync(resolved);
+        if (!stat.isDirectory()) {
+            return `Task local folder is not a directory: ${resolved}`;
+        }
+    }
+    catch {
+        return `Task local folder is not accessible: ${resolved}`;
+    }
+    return null;
+}
+function displayLocalPath(absolutePath) {
+    const resolved = path.resolve(absolutePath);
+    const home = path.resolve(os.homedir());
+    if (resolved === home)
+        return '~';
+    if (resolved.startsWith(`${home}${path.sep}`)) {
+        return `~/${path.relative(home, resolved).replace(/\\/g, '/')}`;
+    }
+    return resolved;
+}
+function listHostDirectories(folder) {
+    const resolved = resolveLocalWorkspaceFolder(folder || '~');
+    const stat = fs.statSync(resolved);
+    if (!stat.isDirectory()) {
+        throw new Error(`Not a directory: ${resolved}`);
+    }
+    const entries = fs
+        .readdirSync(resolved, { withFileTypes: true })
+        .filter((entry) => entry.isDirectory())
+        .map((entry) => {
+        const entryPath = path.join(resolved, entry.name);
+        return {
+            name: entry.name,
+            path: entryPath,
+            displayPath: displayLocalPath(entryPath),
+        };
+    })
+        .sort((a, b) => {
+        const aHidden = a.name.startsWith('.');
+        const bHidden = b.name.startsWith('.');
+        if (aHidden !== bHidden)
+            return aHidden ? 1 : -1;
+        return a.name.localeCompare(b.name);
+    });
+    const parent = path.dirname(resolved);
+    return {
+        path: resolved,
+        displayPath: displayLocalPath(resolved),
+        parentPath: parent === resolved ? null : parent,
+        parentDisplayPath: parent === resolved ? null : displayLocalPath(parent),
+        entries,
+    };
+}
+function contentPartToText(part) {
+    if (typeof part === 'string')
+        return part;
+    if (!part || typeof part !== 'object')
+        return '';
+    const record = part;
+    return readString(record.text) || readString(record.content);
+}
+function inputItemToText(item) {
+    if (typeof item === 'string')
+        return item;
+    if (!item || typeof item !== 'object')
+        return '';
+    const record = item;
+    if (typeof record.content === 'string')
+        return record.content;
+    if (Array.isArray(record.content)) {
+        return record.content.map(contentPartToText).filter(Boolean).join('\n');
+    }
+    return readString(record.text);
+}
+function extractInputText(params) {
+    if (!params)
+        return '';
+    if (typeof params.input === 'string')
+        return params.input.trim();
+    if (Array.isArray(params.input)) {
+        return params.input.map(inputItemToText).filter(Boolean).join('\n').trim();
+    }
+    if (typeof params.message === 'string')
+        return params.message.trim();
+    if (Array.isArray(params.messages)) {
+        return params.messages.map(inputItemToText).filter(Boolean).join('\n').trim();
+    }
+    return '';
+}
+const THREAD_READ_MESSAGE_TEXT_LIMIT = 8_000;
+const THREAD_READ_PAYLOAD_TEXT_LIMIT = 2_000;
+const THREAD_READ_ARRAY_LIMIT = 100;
+const THREAD_READ_OBJECT_ENTRY_LIMIT = 100;
+const THREAD_READ_DEPTH_LIMIT = 8;
+const THREAD_READ_ATTACHMENT_LIMIT = 20;
+function truncateThreadReadText(value, limit = THREAD_READ_MESSAGE_TEXT_LIMIT) {
+    if (value.length <= limit)
+        return value;
+    const omitted = value.length - limit;
+    return `${value.slice(0, limit)}\n\n[Truncated ${omitted} characters for chat history.]`;
+}
+function sanitizeThreadReadValue(value, depth = 0, textLimit = THREAD_READ_PAYLOAD_TEXT_LIMIT) {
+    if (typeof value === 'string')
+        return truncateThreadReadText(value, textLimit);
+    if (value == null || typeof value === 'number' || typeof value === 'boolean')
+        return value;
+    if (Array.isArray(value)) {
+        return value
+            .slice(0, THREAD_READ_ARRAY_LIMIT)
+            .map((entry) => sanitizeThreadReadValue(entry, depth + 1, textLimit));
+    }
+    if (typeof value !== 'object')
+        return undefined;
+    if (depth >= THREAD_READ_DEPTH_LIMIT)
+        return '[Omitted nested data for chat history.]';
+    const record = value;
+    const compact = {};
+    for (const [key, entry] of Object.entries(record).slice(0, THREAD_READ_OBJECT_ENTRY_LIMIT)) {
+        const normalizedKey = key.trim().toLowerCase();
+        if (normalizedKey === 'metadata' ||
+            normalizedKey === 'base64' ||
+            normalizedKey === 'binary' ||
+            normalizedKey === 'bytes') {
+            continue;
+        }
+        const compactEntry = sanitizeThreadReadValue(entry, depth + 1, textLimit);
+        if (compactEntry !== undefined)
+            compact[key] = compactEntry;
+    }
+    return compact;
+}
+function sanitizeThreadReadAttachments(attachments) {
+    if (!attachments?.length)
+        return undefined;
+    const compact = attachments.slice(0, THREAD_READ_ATTACHMENT_LIMIT).map((attachment) => {
+        const next = { type: attachment.type };
+        if (attachment.url)
+            next.url = truncateThreadReadText(attachment.url, THREAD_READ_PAYLOAD_TEXT_LIMIT);
+        if (attachment.mime_type)
+            next.mime_type = truncateThreadReadText(attachment.mime_type, THREAD_READ_PAYLOAD_TEXT_LIMIT);
+        if (attachment.filename)
+            next.filename = truncateThreadReadText(attachment.filename, THREAD_READ_PAYLOAD_TEXT_LIMIT);
+        if (typeof attachment.size === 'number')
+            next.size = attachment.size;
+        return next;
+    });
+    return compact.length > 0 ? compact : undefined;
+}
+function sanitizeThreadReadMessage(message) {
+    const { metadata: _metadata, attachments, content, ...rest } = message;
+    const compactAttachments = sanitizeThreadReadAttachments(attachments);
+    return {
+        ...rest,
+        content: truncateThreadReadText(content),
+        ...(compactAttachments ? { attachments: compactAttachments } : {}),
+    };
+}
+function sanitizeProjectedThreadMessage(message) {
+    return sanitizeThreadReadMessage(message);
+}
+function sanitizeThreadReadEvent(event) {
+    return {
+        ...event,
+        chunk: sanitizeThreadReadValue(event.chunk),
+    };
+}
+function messagesToItems(messages) {
+    return messages.map((message) => ({
+        id: message.id,
+        type: 'message',
+        role: message.role === 'bot' ? 'assistant' : message.role,
+        content: message.content,
+        createdAt: message.timestamp,
+        supen: {
+            taskId: message.task_id,
+        },
+    }));
+}
+function projectedMessagesToItems(messages) {
+    return messages.map((message) => ({
+        id: message.id,
+        type: 'message',
+        role: message.role === 'bot' ? 'assistant' : message.role,
+        content: message.content,
+        createdAt: message.timestamp,
+        supen: {
+            taskId: message.task_id,
+        },
+    }));
+}
+function runtimeStateForThread(threadId, session) {
+    const projection = projectThreadRuntimeState(threadId);
+    if (session &&
+        (session.channel === 'automation' || session.source_ref?.startsWith('automation:')) &&
+        session.status !== 'running' &&
+        projection.runtime.status === 'running' &&
+        projection.runtime.pending_approvals.length === 0) {
+        return {
+            ...projection,
+            runtime: {
+                ...projection.runtime,
+                status: session.status === 'error' ? 'failed' : 'idle',
+                updated_at: session.updated_at || projection.runtime.updated_at,
+            },
+        };
+    }
+    return projection;
+}
+function resolveThreadSession(agentId, threadId) {
+    if (agentId) {
+        const session = getSessionForAgent(agentId, threadId);
+        if (session)
+            return session;
+    }
+    return getAllSessions().find((candidate) => candidate.session_id === threadId) ?? 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 compactRuntimeStateSummary(projection) {
+    return sanitizeThreadReadValue(runtimeStateSummary(projection));
+}
+function compactCodexRuntimeStateSummary(runtimeState) {
+    const summary = {
+        event_log_head: runtimeState.event_log_head,
+        projection_version: runtimeState.projection_version,
+        event_log: runtimeState.event_log,
+        runtime: runtimeState.runtime,
+    };
+    return sanitizeThreadReadValue(summary);
+}
+function serializeCodexTaskThread(threadId, runtimeState, session) {
+    const runtimeStatus = runtimeState.runtime.status;
+    const pendingApprovals = Array.isArray(runtimeState.runtime.pending_approvals)
+        ? runtimeState.runtime.pending_approvals
+        : [];
+    return {
+        id: threadId,
+        taskId: threadId,
+        agentId: 'automation-task',
+        status: runtimeStatus === 'running' || runtimeStatus === 'blocked' || runtimeStatus === 'failed'
+            ? runtimeStatus
+            : 'idle',
+        pendingApproval: pendingApprovals.length > 0,
+        title: session?.title || threadId,
+        updatedAt: runtimeState.runtime.updated_at,
+        workspaceFolder: session?.task_workspace_folder || undefined,
+        supen: {
+            channel: 'automation',
+            sourceRef: `codex:${threadId}`,
+        },
+    };
+}
+async function handleRpcRequest(request, context) {
+    const id = request.id ?? null;
+    const method = readString(request.method);
+    const params = request.params && typeof request.params === 'object' && !Array.isArray(request.params)
+        ? request.params
+        : {};
+    if (request.jsonrpc && request.jsonrpc !== '2.0') {
+        return rpcError(id, -32600, 'Invalid JSON-RPC version');
+    }
+    if (!method) {
+        return rpcError(id, -32600, 'JSON-RPC method is required');
+    }
+    if (method === 'initialize') {
+        return success(id, {
+            protocolVersion: 'supen-jsonrpc',
+            serverInfo: {
+                name: 'supen-rpc',
+                version: '0.1.0',
+            },
+            capabilities: {
+                threads: true,
+                turns: true,
+                longConnection: true,
+                transparentProxy: true,
+                supenExtensions: true,
+            },
+        });
+    }
+    if (method === 'taskWorkspace/listDirectories') {
+        try {
+            return success(id, listHostDirectories(normalizeTaskWorkspaceFolder(params.path)));
+        }
+        catch (error) {
+            return rpcError(id, -32602, error instanceof Error ? error.message : 'Failed to list directories.');
+        }
+    }
+    if (method === 'thread/start') {
+        const agentId = optionalAgentIdFromParams(params);
+        if (!agentId)
+            return rpcError(id, -32602, 'agentId is required');
+        let threadId = threadIdFromParams(params);
+        if (!threadId) {
+            do {
+                threadId = `thread-${Date.now().toString(36)}-${randomUUID().slice(0, 8)}`;
+            } while (getSessionForAgent(agentId, threadId));
+        }
+        const environmentSnapshot = normalizeEnvironmentSnapshot(params.environmentSnapshot ?? params.environment_snapshot);
+        const taskWorkspaceFolder = normalizeTaskWorkspaceFolder(params.taskWorkspaceFolder ?? params.task_workspace_folder);
+        const taskWorkspaceError = validateTaskWorkspaceFolder(taskWorkspaceFolder);
+        if (taskWorkspaceError)
+            return rpcError(id, -32602, taskWorkspaceError);
+        const environmentId = readString(params.environmentId) ||
+            readString(params.environment_id) ||
+            environmentSnapshot.id ||
+            'default';
+        const session = ensureSession({
+            agent_id: agentId,
+            session_id: threadId,
+            channel: 'http',
+            agent_name: agentId,
+            source_ref: buildHttpSessionId(agentId, threadId),
+            knowledge_id: readString(params.knowledgeId) || readString(params.knowledge_id) || undefined,
+            knowledge_name: readString(params.knowledgeName) || readString(params.knowledge_name) || undefined,
+            environment_id: environmentId,
+            environment_snapshot: environmentSnapshot,
+            task_workspace_folder: taskWorkspaceFolder,
+            title: readString(params.title) || undefined,
+        });
+        recordSessionControlCommand({
+            agentId,
+            sessionId: threadId,
+            surface: context.surface || 'web',
+            commandType: 'session.start',
+            method,
+            actor: actorFromContext(context.adminContext),
+            status: 'completed',
+            params,
+            payload: {
+                requested_thread_id: threadId,
+                title: readString(params.title) || null,
+            },
+        });
+        return success(id, { thread: serializeThread(session) });
+    }
+    if (method === 'thread/resume') {
+        const agentId = optionalAgentIdFromParams(params);
+        const threadId = threadIdFromParams(params);
+        const session = threadId ? resolveThreadSession(agentId, threadId) : null;
+        if (!session)
+            return rpcError(id, -32004, 'Thread not found', { agentId, threadId });
+        recordSessionControlCommand({
+            agentId: session.agent_id,
+            sessionId: threadId,
+            surface: context.surface || 'web',
+            commandType: 'session.resume',
+            method,
+            actor: actorFromContext(context.adminContext),
+            status: 'completed',
+            params,
+            payload: {},
+        });
+        return success(id, { thread: serializeThread(session) });
+    }
+    if (method === 'thread/list') {
+        const agentId = optionalAgentIdFromParams(params);
+        if (!agentId)
+            return rpcError(id, -32602, 'agentId is required');
+        return success(id, {
+            threads: getSessionsForAgent(agentId).map(serializeThread),
+        });
+    }
+    if (method === 'thread/read') {
+        const agentId = optionalAgentIdFromParams(params);
+        const threadId = threadIdFromParams(params);
+        if (!threadId)
+            return rpcError(id, -32004, 'Thread not found', { agentId, threadId });
+        const rawLimit = Number(params.limit);
+        const limit = Number.isFinite(rawLimit) && rawLimit > 0 ? Math.min(Math.floor(rawLimit), 500) : 100;
+        const rawEventLimit = Number(params.eventLimit ?? params.event_limit);
+        const eventLimit = Number.isFinite(rawEventLimit) && rawEventLimit > 0
+            ? Math.min(Math.floor(rawEventLimit), 500)
+            : limit;
+        const includeEvents = params.includeEvents !== false && params.include_events !== false;
+        const controlLog = listControlLogEntries(threadId, limit);
+        const taskSession = resolveThreadSession(agentId, threadId);
+        const codexThreadId = taskSession && typeof taskSession.sdk_session_id === 'string' && taskSession.sdk_session_id.trim()
+            ? taskSession.sdk_session_id.trim()
+            : threadId;
+        const codexHistory = readCodexThreadHistory(codexThreadId, limit, {
+            eventLogThreadId: threadId,
+        });
+        if (codexHistory) {
+            const history = codexHistory;
+            const responseMessages = history.messages
+                .slice(-limit)
+                .map((message) => sanitizeProjectedThreadMessage({ ...message, task_id: threadId }));
+            const runtimeState = history.runtimeState;
+            const responseEvents = includeEvents
+                ? history.events.slice(-eventLimit).map(sanitizeThreadReadEvent)
+                : [];
+            const responseRuntimeState = {
+                ...runtimeState,
+                runtime: sanitizeThreadReadValue(runtimeState.runtime),
+                messages: responseMessages,
+                events: responseEvents,
+            };
+            return success(id, {
+                thread: serializeCodexTaskThread(threadId, runtimeState, {
+                    title: history.session?.title || taskSession?.title,
+                    task_workspace_folder: history.session?.task_workspace_folder || taskSession?.task_workspace_folder,
+                }),
+                messages: responseMessages,
+                events: responseEvents,
+                goal_context: history.goal_context,
+                control_log: controlLog,
+                items: messagesToItems(responseMessages),
+                runtimeState: compactCodexRuntimeStateSummary(runtimeState),
+                supen: {
+                    events: responseEvents,
+                    controlLog,
+                    runtimeState: responseRuntimeState,
+                },
+            });
+        }
+        const session = taskSession;
+        if (!session)
+            return rpcError(id, -32004, 'Thread not found', { agentId, threadId });
+        const runtimeState = runtimeStateForThread(threadId, session);
+        const responseMessages = runtimeState.messages.slice(-limit).map(sanitizeProjectedThreadMessage);
+        const responseEvents = includeEvents
+            ? runtimeState.events.slice(-eventLimit).map(sanitizeThreadReadEvent)
+            : [];
+        const responseRuntimeState = {
+            ...runtimeState,
+            runtime: sanitizeThreadReadValue(runtimeState.runtime),
+            messages: responseMessages,
+            events: responseEvents,
+        };
+        return success(id, {
+            thread: serializeThread(session),
+            session,
+            messages: responseMessages,
+            events: responseEvents,
+            control_log: controlLog,
+            items: projectedMessagesToItems(responseMessages),
+            runtimeState: compactRuntimeStateSummary(runtimeState),
+            supen: {
+                events: responseEvents,
+                controlLog,
+                runtimeState: responseRuntimeState,
+            },
+        });
+    }
+    if (method === 'thread/approval/respond') {
+        const approvalId = readString(params.approvalId) || readString(params.approval_id);
+        if (!approvalId)
+            return rpcError(id, -32602, 'approvalId is required');
+        try {
+            const approval = respondAppServerApproval({
+                approvalId,
+                approved: params.approved === true,
+            });
+            const threadId = threadIdFromParams(params);
+            const requestedAgentId = optionalAgentIdFromParams(params);
+            const session = threadId ? resolveThreadSession(requestedAgentId, threadId) : null;
+            const agentId = session?.agent_id || requestedAgentId;
+            if (agentId && threadId) {
+                recordSessionControlCommand({
+                    agentId,
+                    sessionId: threadId,
+                    surface: context.surface || 'web',
+                    commandType: 'approval.respond',
+                    method,
+                    actor: actorFromContext(context.adminContext),
+                    status: 'completed',
+                    params,
+                    payload: {
+                        approval_id: approvalId,
+                        approved: params.approved === true,
+                        tool_call_id: approval.toolCallId,
+                        tool_name: approval.toolName,
+                    },
+                });
+            }
+            return success(id, {
+                ok: true,
+                approvalId,
+                approved: params.approved === true,
+            });
+        }
+        catch (error) {
+            return rpcError(id, -32004, error instanceof Error ? error.message : 'Approval request not found');
+        }
+    }
+    if (method === 'turn/start' || method === 'turn/steer') {
+        const agentId = optionalAgentIdFromParams(params);
+        if (!agentId)
+            return rpcError(id, -32602, 'agentId is required');
+        const threadId = threadIdFromParams(params);
+        if (!threadId)
+            return rpcError(id, -32602, 'threadId is required');
+        const text = extractInputText(params);
+        if (!text)
+            return rpcError(id, -32602, 'turn input is required');
+        const model = readString(params.model);
+        const effort = readRuntimeEffort(params.effort ?? params.reasoningEffort ?? params.reasoning_effort);
+        const permissionMode = readRuntimePermissionMode(params.permissionMode ?? params.permission_mode);
+        const speedMode = readString(params.speedMode ?? params.speed_mode);
+        const runtimeOptions = {
+            ...(model ? { model } : {}),
+            ...(effort ? { effort } : {}),
+            ...(permissionMode ? { permissionMode } : {}),
+            ...(speedMode === 'standard' || speedMode === 'fast' ? { speedMode } : {}),
+        };
+        ensureSession({
+            agent_id: agentId,
+            session_id: threadId,
+            channel: 'http',
+            agent_name: agentId,
+            source_ref: buildHttpSessionId(agentId, threadId),
+        });
+        const turnId = readString(params.turnId) || readString(params.turn_id) || randomUUID();
+        const actor = actorFromContext(context.adminContext);
+        const msg = {
+            id: `supen-rpc-${turnId}`,
+            chat_jid: buildHttpSessionId(agentId, threadId),
+            sender: actor,
+            sender_name: actor,
+            content: text,
+            timestamp: new Date().toISOString(),
+            is_from_me: false,
+            agent_id: agentId,
+            session_id: threadId,
+            task_id: turnId,
+            ...(model ? { model } : {}),
+            metadata: {
+                source: 'rpc-turn',
+                runtime_options: runtimeOptions,
+            },
+        };
+        context.onMessage(msg.chat_jid, msg);
+        recordSessionControlCommand({
+            agentId,
+            sessionId: threadId,
+            turnId,
+            surface: context.surface || 'web',
+            commandType: 'session.instruct',
+            method,
+            actor,
+            status: 'dispatched',
+            params,
+            payload: {
+                message_excerpt: text.slice(0, 240),
+                runtime_options: runtimeOptions,
+            },
+        });
+        return success(id, {
+            turn: {
+                id: turnId,
+                threadId,
+                status: 'accepted',
+            },
+        });
+    }
+    if (method === 'turn/interrupt') {
+        const requestedAgentId = optionalAgentIdFromParams(params);
+        const threadId = threadIdFromParams(params);
+        if (!threadId)
+            return rpcError(id, -32602, 'threadId is required');
+        if (!context.onSessionStop)
+            return rpcError(id, -32001, 'Turn interruption is not supported');
+        const session = resolveThreadSession(requestedAgentId, threadId);
+        const agentId = session?.agent_id || requestedAgentId;
+        if (!agentId)
+            return rpcError(id, -32004, 'Thread not found', { agentId: requestedAgentId, threadId });
+        const actor = actorFromContext(context.adminContext);
+        const result = context.onSessionStop(agentId, threadId, actor);
+        recordSessionControlCommand({
+            agentId,
+            sessionId: threadId,
+            surface: context.surface || 'web',
+            commandType: 'session.interrupt',
+            method,
+            actor,
+            status: result.ok || result.code === 'session_not_running' ? 'completed' : 'failed',
+            params,
+            payload: {
+                code: result.code,
+                message: result.message,
+            },
+        });
+        if (!result.ok && result.code !== 'session_not_running') {
+            return rpcError(id, -32002, result.message, { code: result.code });
+        }
+        return success(id, { ok: true, ...result });
+    }
+    return rpcError(id, -32601, `Method not found: ${method}`);
+}
+export async function executeSupenRpc(request, context) {
+    if (!request || typeof request !== 'object' || Array.isArray(request)) {
+        return rpcError(null, -32600, 'Invalid JSON-RPC request');
+    }
+    const rpcRequest = request;
+    try {
+        return await handleRpcRequest(rpcRequest, context);
+    }
+    catch (error) {
+        return rpcError(rpcRequest.id ?? null, -32603, error instanceof Error ? error.message : 'Internal error');
+    }
+}
+export async function handleRpcRoutes(req, res, pathname, method, adminContext, onMessage, onSessionStop) {
+    if (pathname !== '/api/rpc' && pathname !== '/api/computer/rpc') {
+        return false;
+    }
+    if (method !== 'POST') {
+        writeJson(res, 405, rpcError(null, -32600, 'JSON-RPC endpoint requires POST'));
+        return true;
+    }
+    const body = await readJsonBody(req);
+    if (Array.isArray(body)) {
+        const batch = await Promise.all(body.map((entry) => executeSupenRpc(entry, {
+            adminContext,
+            onMessage,
+            onSessionStop,
+            surface: 'web',
+        })));
+        writeJson(res, 200, batch);
+        return true;
+    }
+    const response = await executeSupenRpc(body, {
+        adminContext,
+        onMessage,
+        onSessionStop,
+        surface: 'web',
+    });
+    writeJson(res, 200, response);
+    return true;
+}
+//# sourceMappingURL=rpc.js.map