shennian 0.2.6 → 0.2.7

package/dist/src/relay/client.js

@@ -0,0 +1,311 @@
+// @arch docs/architecture/cli/daemon.md#关键数据流
+// @test src/__tests__/e2e-relay.ts
+import WebSocket from 'ws';
+import { generateTraceId } from '../log-reporter.js';
+const HEARTBEAT_TIMEOUT = 90_000;
+const MAX_RECONNECT_DELAY = 30_000;
+const BASE_RECONNECT_DELAY = 1_000;
+const JITTER_FACTOR = 0.2;
+const PING_INTERVAL = 20_000;
+const PONG_TIMEOUT = 10_000;
+const CONNECT_TIMEOUT = 15_000;
+const MAX_SEND_BUFFER = 1000;
+export class CliRelayClient {
+    options;
+    ws = null;
+    state = 'disconnected';
+    reconnectAttempts = 0;
+    heartbeatTimer = null;
+    reconnectTimer = null;
+    connectTimer = null;
+    pingTimer = null;
+    pongTimer = null;
+    disposed = false;
+    closeTrigger;
+    lastSocketError;
+    /** Buffered agent events awaiting server ack, keyed by event id */
+    sendBuffer = new Map();
+    pendingAcks = new Map();
+    constructor(options) {
+        this.options = options;
+    }
+    connect() {
+        if (this.disposed)
+            return;
+        // Always clean up stale connection before creating a new one
+        if (this.ws) {
+            this.cleanup(false);
+        }
+        this.state = 'connecting';
+        const sep = this.options.serverUrl.includes('?') ? '&' : '?';
+        const vParam = this.options.cliVersion ? `&v=${encodeURIComponent(this.options.cliVersion)}` : '';
+        const agentsParam = this.options.agentList?.length
+            ? `&agents=${encodeURIComponent(this.options.agentList.join(','))}`
+            : '';
+        const url = `${this.options.serverUrl}${sep}token=${encodeURIComponent(this.options.machineToken)}${vParam}${agentsParam}`;
+        const ws = new WebSocket(url);
+        this.ws = ws;
+        // Guard against connections that never open (DNS hang, TCP timeout, etc.)
+        this.connectTimer = setTimeout(() => {
+            if (this.ws === ws && this.state === 'connecting') {
+                this.closeTrigger = 'connect-timeout';
+                ws.terminate();
+            }
+        }, CONNECT_TIMEOUT);
+        ws.on('open', () => {
+            if (this.ws !== ws)
+                return;
+            this.clearConnectTimer();
+            this.state = 'connected';
+            this.reconnectAttempts = 0;
+            this.startHeartbeat();
+            this.startPing(ws);
+            this.flushSendBuffer();
+            this.options.onConnected?.();
+        });
+        ws.on('pong', () => {
+            if (this.ws !== ws)
+                return;
+            this.clearPongTimer();
+            this.resetHeartbeat();
+        });
+        ws.on('message', (data) => {
+            if (this.ws !== ws)
+                return;
+            let frame;
+            try {
+                frame = JSON.parse(data.toString());
+            }
+            catch {
+                return;
+            }
+            this.handleFrame(frame);
+        });
+        ws.on('close', (code, reason) => {
+            if (this.ws !== ws)
+                return;
+            const phase = this.state;
+            const info = {
+                code,
+                reason: reason.toString(),
+                error: this.lastSocketError,
+                phase,
+                trigger: this.closeTrigger ?? 'socket-close',
+                reconnectAttempt: this.reconnectAttempts + 1,
+            };
+            this.cleanup(false);
+            this.options.onDisconnected?.(info);
+            this.scheduleReconnect();
+        });
+        ws.on('error', (error) => {
+            this.lastSocketError = error.message;
+            this.closeTrigger = 'socket-error';
+            ws.close();
+        });
+    }
+    disconnect() {
+        this.disposed = true;
+        this.cleanup(true);
+    }
+    sendRes(res) {
+        if (this.state !== 'connected' || !this.ws)
+            return;
+        if (!res.traceId)
+            res.traceId = generateTraceId();
+        this.ws.send(JSON.stringify(res));
+    }
+    sendEvent(event) {
+        if (this.state !== 'connected' || !this.ws)
+            return;
+        if (!event.traceId)
+            event.traceId = generateTraceId();
+        this.ws.send(JSON.stringify(event));
+    }
+    sendBufferedEvent(event, timeoutMs = 120_000) {
+        if (!event.traceId)
+            event.traceId = generateTraceId();
+        if (!event.id) {
+            this.sendEvent(event);
+            return Promise.resolve();
+        }
+        const eventId = event.id;
+        return new Promise((resolve, reject) => {
+            const existing = this.pendingAcks.get(eventId);
+            if (existing) {
+                clearTimeout(existing.timer);
+                existing.reject(new Error('Superseded by a newer buffered event'));
+            }
+            const timer = setTimeout(() => {
+                this.pendingAcks.delete(eventId);
+                this.sendBuffer.delete(eventId);
+                reject(new Error('Relay event acknowledgement timed out'));
+            }, timeoutMs);
+            this.pendingAcks.set(eventId, { resolve, reject, timer });
+            this.bufferEvent(event);
+        });
+    }
+    /**
+     * Send an agent event with at-least-once delivery guarantee.
+     * The event is buffered until the server acknowledges it.
+     * On reconnect, all unacked events are resent in order.
+     */
+    sendAgentEvent(event) {
+        void this.sendBufferedEvent(event).catch(() => { });
+    }
+    getState() {
+        return this.state;
+    }
+    handleFrame(frame) {
+        if (frame.type === 'event' && frame.event === 'tick') {
+            this.resetHeartbeat();
+            return;
+        }
+        if (frame.type === 'res' && frame.id) {
+            // Server ack for a buffered agent event — remove from buffer
+            this.sendBuffer.delete(frame.id);
+            const pending = this.pendingAcks.get(frame.id);
+            if (pending) {
+                this.pendingAcks.delete(frame.id);
+                clearTimeout(pending.timer);
+                if (frame.ok)
+                    pending.resolve();
+                else
+                    pending.reject(new Error(frame.error ?? 'Relay event failed'));
+            }
+            return;
+        }
+        if (frame.type === 'req') {
+            this.options.onReq?.(frame);
+        }
+    }
+    /** Resend all buffered agent events after reconnect, in insertion order */
+    flushSendBuffer() {
+        if (this.sendBuffer.size === 0 || !this.ws)
+            return;
+        for (const event of this.sendBuffer.values()) {
+            if (this.state !== 'connected' || !this.ws)
+                break;
+            this.ws.send(JSON.stringify(event));
+        }
+    }
+    bufferEvent(event) {
+        if (!event.id) {
+            this.sendEvent(event);
+            return;
+        }
+        this.sendBuffer.set(event.id, event);
+        if (this.sendBuffer.size > MAX_SEND_BUFFER) {
+            const oldest = this.sendBuffer.keys().next().value;
+            if (oldest) {
+                this.sendBuffer.delete(oldest);
+                const pending = this.pendingAcks.get(oldest);
+                if (pending) {
+                    this.pendingAcks.delete(oldest);
+                    clearTimeout(pending.timer);
+                    pending.reject(new Error('Relay send buffer overflow'));
+                }
+            }
+        }
+        if (this.state === 'connected' && this.ws) {
+            this.ws.send(JSON.stringify(event));
+        }
+    }
+    clearConnectTimer() {
+        if (this.connectTimer !== null) {
+            clearTimeout(this.connectTimer);
+            this.connectTimer = null;
+        }
+    }
+    startPing(ws) {
+        this.clearPing();
+        this.pingTimer = setInterval(() => {
+            if (this.ws !== ws || this.state !== 'connected')
+                return;
+            // Set pong timeout before sending ping
+            this.pongTimer = setTimeout(() => {
+                // No pong received — connection is dead, force close
+                this.closeTrigger = 'pong-timeout';
+                ws.close();
+            }, PONG_TIMEOUT);
+            try {
+                ws.ping();
+            }
+            catch {
+                this.clearPongTimer();
+                this.closeTrigger = 'socket-error';
+                ws.close();
+            }
+        }, PING_INTERVAL);
+    }
+    clearPing() {
+        if (this.pingTimer !== null) {
+            clearInterval(this.pingTimer);
+            this.pingTimer = null;
+        }
+        this.clearPongTimer();
+    }
+    clearPongTimer() {
+        if (this.pongTimer !== null) {
+            clearTimeout(this.pongTimer);
+            this.pongTimer = null;
+        }
+    }
+    startHeartbeat() {
+        this.clearHeartbeat();
+        this.heartbeatTimer = setTimeout(() => {
+            this.closeTrigger = 'heartbeat-timeout';
+            this.ws?.close();
+        }, HEARTBEAT_TIMEOUT);
+    }
+    resetHeartbeat() {
+        this.startHeartbeat();
+    }
+    clearHeartbeat() {
+        if (this.heartbeatTimer !== null) {
+            clearTimeout(this.heartbeatTimer);
+            this.heartbeatTimer = null;
+        }
+    }
+    scheduleReconnect() {
+        if (this.disposed)
+            return;
+        const base = Math.min(BASE_RECONNECT_DELAY * Math.pow(2, this.reconnectAttempts), MAX_RECONNECT_DELAY);
+        const jitter = base * JITTER_FACTOR * (Math.random() * 2 - 1);
+        const delay = Math.round(base + jitter);
+        this.reconnectAttempts++;
+        this.reconnectTimer = setTimeout(() => {
+            this.reconnectTimer = null;
+            this.connect();
+        }, delay);
+    }
+    cleanup(rejectAll) {
+        this.state = 'disconnected';
+        this.closeTrigger = undefined;
+        this.lastSocketError = undefined;
+        this.clearConnectTimer();
+        this.clearHeartbeat();
+        this.clearPing();
+        if (this.reconnectTimer !== null) {
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = null;
+        }
+        if (this.ws) {
+            const ws = this.ws;
+            this.ws = null;
+            ws.removeAllListeners();
+            try {
+                ws.close();
+            }
+            catch {
+                // already closed
+            }
+        }
+        if (rejectAll) {
+            for (const [id, pending] of this.pendingAcks) {
+                clearTimeout(pending.timer);
+                pending.reject(new Error('Relay client disconnected'));
+                this.pendingAcks.delete(id);
+            }
+        }
+    }
+}

package/dist/src/session/handlers/agents.d.ts

@@ -0,0 +1,4 @@
+import type { ReqFrame } from '@shennian/wire';
+import type { SessionManagerRuntime } from '../types.js';
+export declare function handleModelsRefresh(runtime: SessionManagerRuntime, req: ReqFrame): Promise<void>;
+export declare function handleAgentsRefresh(runtime: SessionManagerRuntime, req: ReqFrame): Promise<void>;

package/dist/src/session/handlers/agents.js

@@ -0,0 +1,55 @@
+// @arch docs/architecture/cli/daemon.md#会话管理
+// @test src/__tests__/model-switching.test.ts
+import { SERVERS } from '../../region.js';
+import { loadConfig } from '../../config/index.js';
+import { detectAgents } from '../../agents/detect.js';
+import { refreshAgentInfos } from '../../agents/model-registry.js';
+import { resetCommandSpecCache } from '../../agents/command-spec.js';
+async function refreshMachineAgents(runtime, req) {
+    const config = loadConfig();
+    const serverUrl = config.serverUrl ?? SERVERS.global.url;
+    const detectedAgents = detectAgents();
+    const agentList = detectedAgents.map((agent) => agent.type);
+    if (detectedAgents.length === 0) {
+        runtime.client.sendRes({
+            type: 'res',
+            id: req.id,
+            ok: true,
+            payload: { agentList: [], agents: [] },
+        });
+        return;
+    }
+    try {
+        const agents = await refreshAgentInfos(detectedAgents, {
+            serverUrl,
+            authToken: config.machineToken ?? config.accessToken,
+        });
+        runtime.client.sendRes({
+            type: 'res',
+            id: req.id,
+            ok: true,
+            payload: { agentList, agents },
+        });
+        runtime.client.sendEvent({
+            type: 'event',
+            event: 'machine.agents',
+            payload: { agentList, agents },
+        });
+    }
+    catch (err) {
+        runtime.client.sendRes({
+            type: 'res',
+            id: req.id,
+            ok: false,
+            error: err instanceof Error ? err.message : String(err),
+        });
+    }
+}
+export async function handleModelsRefresh(runtime, req) {
+    await refreshMachineAgents(runtime, req);
+}
+export async function handleAgentsRefresh(runtime, req) {
+    resetCommandSpecCache();
+    runtime.reloadCustomAgents();
+    await refreshMachineAgents(runtime, req);
+}

package/dist/src/session/handlers/chat.d.ts

@@ -0,0 +1,4 @@
+import type { ReqFrame } from '@shennian/wire';
+import type { SessionManagerRuntime } from '../types.js';
+export declare function handleChatSend(runtime: SessionManagerRuntime, req: ReqFrame): Promise<void>;
+export declare function handleChatAbort(runtime: SessionManagerRuntime, req: ReqFrame): Promise<void>;

package/dist/src/session/handlers/chat.js

@@ -0,0 +1,326 @@
+// @arch docs/architecture/cli/daemon.md#会话管理
+// @test src/__tests__/session-manager.test.ts
+import os from 'node:os';
+import { createAgent } from '../../agents/adapter.js';
+import { reportLog } from '../../log-reporter.js';
+import { lookupClaudeTranscriptCwd } from '../../native-fusion/parsers.js';
+function extractSummary(text) {
+    const newline = text.indexOf('\n');
+    const end = newline > 0 ? Math.min(newline, 80) : Math.min(text.length, 80);
+    return text.slice(0, end);
+}
+function maybeResolveClaudeImportedWorkDir(agentType, workDir, agentSessionId) {
+    if (agentType !== 'claude')
+        return workDir;
+    if (!agentSessionId)
+        return workDir;
+    const trimmed = workDir.trim();
+    const looksLikeTranscriptSlug = !!trimmed && trimmed.startsWith('-') && !trimmed.includes('/');
+    if (!looksLikeTranscriptSlug)
+        return workDir;
+    return lookupClaudeTranscriptCwd(agentSessionId) ?? workDir;
+}
+function bindAdapterEvents(runtime, sessionId, agentType, adapter) {
+    let emittedAgentSessionId = null;
+    function sendAgentEvent(event, extra = {}) {
+        runtime.client.sendAgentEvent({
+            type: 'event',
+            event: 'agent',
+            payload: { ...event, sessionId, ...extra },
+            seq: event.seq,
+            id: `agent-evt-${event.runId}-${event.seq}`,
+        });
+    }
+    function flushTextBuffer(activeSession) {
+        const textBuffer = activeSession?.pendingTextEvent;
+        if (!activeSession || !textBuffer || !textBuffer.text)
+            return;
+        sendAgentEvent({
+            state: 'delta',
+            runId: textBuffer.runId,
+            seq: textBuffer.seq,
+            text: textBuffer.text,
+            thinking: textBuffer.thinking || undefined,
+        });
+        activeSession.pendingTextEvent = null;
+    }
+    adapter.on('agentEvent', (event) => {
+        const activeSession = runtime.sessions.get(sessionId);
+        if (activeSession) {
+            activeSession.currentRunId = event.runId;
+            activeSession.nextEventSeq = event.seq + 1;
+            if (event.agentSessionId)
+                activeSession.agentSessionId = event.agentSessionId;
+        }
+        if (event.state !== 'delta') {
+            reportLog({
+                level: 'info',
+                sessionId,
+                wsEvent: `agent.${event.state}`,
+                wsDirection: 'out',
+                metadata: { runId: event.runId, seq: event.seq, agentType },
+            });
+        }
+        const runKey = `${sessionId}:${event.runId}`;
+        if (event.state === 'delta' && !event.thinking && event.text) {
+            runtime.runTextAcc.set(runKey, (runtime.runTextAcc.get(runKey) ?? '') + event.text);
+        }
+        if (event.agentSessionId && event.agentSessionId !== emittedAgentSessionId) {
+            emittedAgentSessionId = event.agentSessionId;
+            runtime.nativeFusion?.noteManagedSourceSession(sessionId, agentType, event.agentSessionId);
+            runtime.client.sendEvent({
+                type: 'event',
+                event: 'session.update',
+                payload: {
+                    session: {
+                        id: sessionId,
+                        agentType,
+                        agentSessionId: event.agentSessionId,
+                    },
+                },
+            });
+        }
+        if (event.state === 'delta') {
+            const text = event.text ?? '';
+            if (!text)
+                return;
+            const thinking = Boolean(event.thinking);
+            if (activeSession?.pendingTextEvent &&
+                (activeSession.pendingTextEvent.runId !== event.runId ||
+                    activeSession.pendingTextEvent.thinking !== thinking)) {
+                flushTextBuffer(activeSession);
+            }
+            if (activeSession && !activeSession.pendingTextEvent) {
+                activeSession.pendingTextEvent = { runId: event.runId, seq: event.seq, text: '', thinking };
+            }
+            if (activeSession?.pendingTextEvent) {
+                activeSession.pendingTextEvent.text += text;
+                activeSession.pendingTextEvent.seq = event.seq;
+            }
+            return;
+        }
+        let extra = {};
+        if (event.state === 'final') {
+            flushTextBuffer(activeSession);
+            const accumulated = runtime.runTextAcc.get(runKey) ?? '';
+            if (accumulated)
+                extra = { messageSummary: extractSummary(accumulated) };
+            runtime.runTextAcc.delete(runKey);
+        }
+        else if (event.state === 'error' || event.state === 'aborted') {
+            flushTextBuffer(activeSession);
+            runtime.runTextAcc.delete(runKey);
+        }
+        else if (event.state === 'tool-call' || event.state === 'tool-result') {
+            flushTextBuffer(activeSession);
+        }
+        if ((event.state === 'final' || event.state === 'error' || event.state === 'aborted') &&
+            activeSession?.currentRunId === event.runId) {
+            activeSession.currentRunId = null;
+            activeSession.nextEventSeq = 0;
+        }
+        sendAgentEvent(event, extra);
+    });
+    adapter.on('error', (error) => {
+        runtime.sessions.delete(sessionId);
+        runtime.client.sendEvent({
+            type: 'event',
+            event: 'agent',
+            payload: { state: 'error', sessionId, message: error.message, runId: '', seq: 0 },
+        });
+    });
+}
+function rememberProcessedReqId(runtime, reqId) {
+    runtime.processedReqIds.add(reqId);
+    if (runtime.processedReqIds.size > 1000) {
+        const first = runtime.processedReqIds.values().next().value;
+        runtime.processedReqIds.delete(first);
+    }
+}
+async function disposeSession(session) {
+    session.adapter.removeAllListeners();
+    await session.adapter.stop().catch(() => { });
+}
+async function createActiveSession(runtime, sessionId, agentType, resolvedWorkDir, incomingAgentSid) {
+    runtime.evictIdleSessions();
+    const adapter = createAgent(agentType);
+    if (!adapter)
+        throw new Error(`Unsupported agent: ${agentType}`);
+    await adapter.start(sessionId, resolvedWorkDir, incomingAgentSid);
+    const session = {
+        adapter,
+        workDir: resolvedWorkDir,
+        agentType,
+        agentSessionId: incomingAgentSid ?? null,
+        lastActiveAt: Date.now(),
+        currentRunId: null,
+        nextEventSeq: 0,
+        pendingTextEvent: null,
+    };
+    runtime.sessions.set(sessionId, session);
+    bindAdapterEvents(runtime, sessionId, agentType, adapter);
+    return session;
+}
+function emitSyntheticAbort(runtime, sessionId) {
+    const session = runtime.sessions.get(sessionId);
+    const runId = session?.currentRunId;
+    if (!session || !runId)
+        return;
+    const seq = session.nextEventSeq;
+    runtime.runTextAcc.delete(`${sessionId}:${runId}`);
+    session.pendingTextEvent = null;
+    session.currentRunId = null;
+    session.nextEventSeq = 0;
+    runtime.client.sendAgentEvent({
+        type: 'event',
+        event: 'agent',
+        payload: { state: 'aborted', sessionId, runId, seq },
+        seq,
+        id: `agent-evt-${runId}-${seq}`,
+    });
+}
+export async function handleChatSend(runtime, req) {
+    if (runtime.processedReqIds.has(req.id)) {
+        runtime.client.sendRes({ type: 'res', id: req.id, ok: true });
+        return;
+    }
+    rememberProcessedReqId(runtime, req.id);
+    const { sessionId, text, agentType, workDir, agentSessionId: incomingAgentSid, modelId, clientMessageId } = req.params;
+    if (!sessionId || !text) {
+        runtime.processedReqIds.delete(req.id);
+        runtime.client.sendRes({ type: 'res', id: req.id, ok: false, error: 'sessionId and text are required' });
+        return;
+    }
+    const requestedAgentType = agentType;
+    const resolvedWorkDir = runtime.resolvePath(maybeResolveClaudeImportedWorkDir(requestedAgentType, workDir || os.homedir(), incomingAgentSid) || os.homedir());
+    let session = runtime.sessions.get(sessionId);
+    if (session) {
+        session.lastActiveAt = Date.now();
+        const sessionDrifted = session.agentType !== requestedAgentType ||
+            session.workDir !== resolvedWorkDir;
+        if (sessionDrifted) {
+            runtime.sessions.delete(sessionId);
+            try {
+                await disposeSession(session);
+            }
+            catch {
+                runtime.processedReqIds.delete(req.id);
+            }
+            session = undefined;
+        }
+        else if (incomingAgentSid && session.agentSessionId !== incomingAgentSid) {
+            try {
+                await session.adapter.resume(incomingAgentSid);
+                session.agentSessionId = incomingAgentSid;
+            }
+            catch {
+                runtime.sessions.delete(sessionId);
+                try {
+                    await disposeSession(session);
+                }
+                catch {
+                    runtime.processedReqIds.delete(req.id);
+                }
+                session = undefined;
+            }
+        }
+    }
+    if (!session) {
+        try {
+            session = await createActiveSession(runtime, sessionId, requestedAgentType, resolvedWorkDir, incomingAgentSid);
+        }
+        catch (err) {
+            runtime.client.sendEvent({
+                type: 'event',
+                event: 'agent',
+                payload: {
+                    state: 'error',
+                    sessionId,
+                    message: err instanceof Error && err.message.startsWith('Unsupported agent:')
+                        ? err.message
+                        : `Failed to start ${agentType}: ${err instanceof Error ? err.message : String(err)}`,
+                    runId: '',
+                    seq: 0,
+                },
+            });
+            runtime.processedReqIds.delete(req.id);
+            runtime.client.sendRes({
+                type: 'res',
+                id: req.id,
+                ok: false,
+                error: err instanceof Error && err.message.startsWith('Unsupported agent:')
+                    ? err.message
+                    : `Failed to start ${agentType}: ${err instanceof Error ? err.message : String(err)}`,
+            });
+            return;
+        }
+    }
+    try {
+        session.currentRunId = null;
+        session.nextEventSeq = 0;
+        runtime.nativeFusion?.registerManagedSend({
+            sessionId,
+            agentType: requestedAgentType,
+            canonicalMessageId: clientMessageId ?? null,
+            sourceSessionKey: session.agentSessionId ?? incomingAgentSid ?? null,
+            text,
+        });
+        reportLog({
+            level: 'info',
+            sessionId,
+            wsEvent: 'chat.send.start',
+            metadata: { reqId: req.id, agentType: requestedAgentType, modelId },
+        });
+        await session.adapter.send(text, modelId);
+        reportLog({
+            level: 'info',
+            sessionId,
+            wsEvent: 'chat.send.done',
+            metadata: { reqId: req.id },
+        });
+        runtime.client.sendRes({ type: 'res', id: req.id, ok: true });
+        reportLog({
+            level: 'info',
+            sessionId,
+            wsEvent: 'chat.send.res',
+            metadata: { reqId: req.id, ok: true },
+        });
+    }
+    catch (err) {
+        runtime.sessions.delete(sessionId);
+        try {
+            await disposeSession(session);
+        }
+        catch { /* best-effort cleanup */ }
+        runtime.processedReqIds.delete(req.id);
+        runtime.client.sendEvent({
+            type: 'event',
+            event: 'agent',
+            payload: {
+                state: 'error',
+                sessionId,
+                message: `Agent send failed: ${err instanceof Error ? err.message : String(err)}`,
+                runId: '',
+                seq: 0,
+            },
+        });
+        runtime.client.sendRes({
+            type: 'res',
+            id: req.id,
+            ok: false,
+            error: `Agent send failed: ${err instanceof Error ? err.message : String(err)}`,
+        });
+    }
+}
+export async function handleChatAbort(runtime, req) {
+    const { sessionId } = req.params;
+    const session = runtime.sessions.get(sessionId);
+    if (session) {
+        try {
+            await session.adapter.stop();
+        }
+        catch { /* best-effort: still emit synthetic abort below */ }
+        emitSyntheticAbort(runtime, sessionId);
+    }
+    runtime.client.sendRes({ type: 'res', id: req.id, ok: true });
+}