@astroanywhere/agent 0.1.35 → 0.1.37

package/dist/providers/openclaw-adapter.js

@@ -1,61 +1,66 @@
 /**
- * OpenClaw provider adapter
+ * OpenClaw provider adapter — Gateway WebSocket mode
  *
- * Executes tasks using the OpenClaw CLI in RPC/JSON streaming mode.
+ * Connects to the local OpenClaw gateway via WebSocket and dispatches tasks
+ * using `chat.send`. Each task gets its own session key for isolation.
  *
- * CLI invocation:
- *   openclaw agent --mode rpc --json --prompt "<task>"
+ * Gateway discovery:
+ *   1. Read ~/.openclaw/openclaw.json for gateway port + auth token
+ *   2. Probe ws://127.0.0.1:{port} for connect.challenge
+ *   3. Handshake with client.id='gateway-client', mode='backend'
  *
- * Output: JSONL streaming to stdout with event types:
- *   session.start, content.text, tool_use.start, tool_use.end,
- *   file.change, message.start, message.end, session.end
+ * Execution flow:
+ *   chat.send({ sessionKey, message, idempotencyKey })
+ *   → gateway streams `agent` + `chat` events over WebSocket
+ *   → adapter translates to TaskOutputStream calls
+ *   → returns TaskResult on session completion
  */
-import { spawn } from 'node:child_process';
 import { existsSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { homedir } from 'node:os';
-import { getProvider } from '../lib/providers.js';
+import { randomUUID } from 'node:crypto';
+import WebSocket from 'ws';
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+const PROTOCOL_VERSION = 3;
+const CONNECT_TIMEOUT_MS = 10_000;
+/** TTL for preserved sessions (30 minutes) */
+const SESSION_TTL_MS = 30 * 60 * 1000;
 export class OpenClawAdapter {
     type = 'openclaw';
     name = 'OpenClaw';
     activeTasks = 0;
-    maxTasks = 1;
+    maxTasks = 10;
     lastError;
-    openclawPath = null;
-    configModel = null;
+    gatewayConfig = null;
+    lastAvailableCheck = null;
+    /** Preserved sessions for multi-turn resume, keyed by taskId */
+    preservedSessions = new Map();
     async isAvailable() {
-        const provider = await getProvider('openclaw');
-        if (provider?.available) {
-            this.openclawPath = provider.path;
-            this.configModel = this.readConfigModel();
-            return true;
-        }
-        return false;
-    }
-    /**
-     * Read the default model from ~/.openclaw/config.json
-     */
-    readConfigModel() {
+        const config = this.readGatewayConfig();
+        if (!config)
+            return false;
+        this.gatewayConfig = config;
+        // Probe the gateway with a quick connect
         try {
-            const configPath = join(homedir(), '.openclaw', 'config.json');
-            if (!existsSync(configPath))
-                return null;
-            const content = readFileSync(configPath, 'utf-8');
-            const config = JSON.parse(content);
-            return config.model ?? null;
+            const ok = await this.probeGateway(config);
+            this.lastAvailableCheck = { available: ok, at: Date.now() };
+            return ok;
         }
         catch {
-            return null;
+            this.lastAvailableCheck = { available: false, at: Date.now() };
+            return false;
         }
     }
     async execute(task, stream, signal) {
-        if (!this.openclawPath) {
+        if (!this.gatewayConfig) {
             const available = await this.isAvailable();
             if (!available) {
                 return {
                     taskId: task.id,
                     status: 'failed',
-                    error: 'OpenClaw not available',
+                    error: 'OpenClaw gateway not available',
                     startedAt: new Date().toISOString(),
                     completedAt: new Date().toISOString(),
                 };
@@ -64,12 +69,23 @@ export class OpenClawAdapter {
         this.activeTasks++;
         const startedAt = new Date().toISOString();
         try {
-            stream.status('running', 0, 'Starting OpenClaw');
-            const result = await this.runOpenClaw(task, stream, signal);
+            stream.status('running', 0, 'Connecting to OpenClaw gateway');
+            const sessionKey = `astro:task:${task.id}`;
+            const result = await this.runViaGateway(task, stream, signal);
+            const isCancelled = signal.aborted || result.error === 'Task cancelled';
+            // Preserve session for multi-turn resume (unless cancelled/failed)
+            if (!isCancelled && !result.error) {
+                this.cleanupExpiredSessions();
+                this.preservedSessions.set(task.id, {
+                    sessionKey,
+                    taskId: task.id,
+                    workingDirectory: task.workingDirectory,
+                    createdAt: Date.now(),
+                });
+            }
             return {
                 taskId: task.id,
-                status: result.exitCode === 0 ? 'completed' : 'failed',
-                exitCode: result.exitCode,
+                status: isCancelled ? 'cancelled' : result.error ? 'failed' : 'completed',
                 output: result.output,
                 error: result.error,
                 startedAt,
@@ -103,226 +119,598 @@ export class OpenClawAdapter {
         }
     }
     async getStatus() {
-        const available = await this.isAvailable();
-        const provider = await getProvider('openclaw');
+        // Use cached availability if checked within the last 30 seconds to avoid
+        // opening a new WebSocket probe on every status poll
+        let available;
+        if (this.lastAvailableCheck && Date.now() - this.lastAvailableCheck.at < 30_000) {
+            available = this.lastAvailableCheck.available;
+        }
+        else {
+            available = await this.isAvailable();
+        }
         return {
             available,
-            version: provider?.version ?? null,
+            version: null,
             activeTasks: this.activeTasks,
             maxTasks: this.maxTasks,
             lastError: this.lastError,
         };
     }
-    runOpenClaw(task, stream, signal) {
-        return new Promise((resolve, reject) => {
-            // OpenClaw CLI: agent --mode rpc --json
-            // --mode rpc: Non-interactive RPC mode (no TUI)
-            // --json: JSONL streaming output to stdout
-            const model = task.model || this.configModel;
-            // Combine systemPrompt with prompt when provided (e.g., interactive plan sessions)
-            const effectivePrompt = task.systemPrompt
-                ? `${task.systemPrompt}\n\n---\n\n${task.prompt}`
-                : task.prompt;
-            const args = [
-                'agent',
-                '--mode', 'rpc',
-                '--json',
-                ...(model ? ['--model', model] : []),
-                '--prompt', effectivePrompt,
-            ];
-            const env = {
-                ...process.env,
-                ...task.environment,
-            };
-            // Validate working directory exists before spawning
-            if (task.workingDirectory && !existsSync(task.workingDirectory)) {
-                reject(new Error(`Working directory does not exist: ${task.workingDirectory}. ` +
-                    `Ensure the directory exists on this machine before dispatching.`));
-                return;
+    // ─── Multi-Turn Resume ─────────────────────────────────────────
+    /**
+     * Resume a completed session by sending another chat.send to the same sessionKey.
+     * The OpenClaw gateway preserves session history per sessionKey.
+     */
+    async resumeTask(taskId, message, _workingDirectory, sessionId, stream, signal) {
+        if (!this.gatewayConfig) {
+            // Attempt availability check as fallback (mirrors execute() pattern)
+            const available = await this.isAvailable();
+            if (!available || !this.gatewayConfig) {
+                return { success: false, output: '', error: 'OpenClaw gateway not available' };
             }
-            let proc;
-            try {
-                proc = spawn(this.openclawPath, args, {
-                    cwd: task.workingDirectory || undefined,
-                    env,
-                    stdio: ['pipe', 'pipe', 'pipe'],
-                });
+        }
+        // Use the preserved session key, or construct one from the original taskId (keyed by taskId)
+        const session = this.preservedSessions.get(taskId);
+        const sessionKey = session?.sessionKey || `astro:task:${sessionId}`;
+        this.activeTasks++;
+        let ws;
+        try {
+            ws = await this.connectToGateway(this.gatewayConfig);
+            stream.status('running', 5, 'Resuming OpenClaw session');
+            // sendChatMessage() registers ws error/close handlers before sending,
+            // so it owns cleanup (calls ws.close() in its finish() helper)
+            const result = await this.sendChatMessage(ws, sessionKey, message, stream, signal);
+            ws = undefined;
+            // Update preserved session timestamp
+            if (session) {
+                session.createdAt = Date.now();
             }
-            catch (error) {
-                reject(error);
-                return;
+            return {
+                success: !result.error,
+                output: result.output,
+                error: result.error,
+            };
+        }
+        catch (error) {
+            ws?.close();
+            const errorMsg = error instanceof Error ? error.message : String(error);
+            this.lastError = errorMsg;
+            return { success: false, output: '', error: errorMsg };
+        }
+        finally {
+            this.activeTasks--;
+        }
+    }
+    /**
+     * Mid-execution message injection is not supported for OpenClaw gateway.
+     * The gateway processes one chat.send at a time per session.
+     */
+    async injectMessage(_taskId, _content, _interrupt) {
+        return false;
+    }
+    /**
+     * Get preserved session context for a task (used by task executor for resume routing).
+     */
+    getTaskContext(taskId) {
+        this.cleanupExpiredSessions();
+        const session = this.preservedSessions.get(taskId);
+        if (!session || Date.now() - session.createdAt > SESSION_TTL_MS) {
+            this.preservedSessions.delete(taskId);
+            return null;
+        }
+        return {
+            sessionId: session.sessionKey,
+            workingDirectory: session.workingDirectory || '',
+        };
+    }
+    cleanupExpiredSessions() {
+        const now = Date.now();
+        for (const [key, session] of this.preservedSessions) {
+            if (now - session.createdAt > SESSION_TTL_MS) {
+                this.preservedSessions.delete(key);
             }
-            let stdout = '';
-            let stderr = '';
-            let lastMetrics;
-            const artifacts = [];
-            const abortHandler = () => {
-                proc.kill('SIGTERM');
-                setTimeout(() => {
-                    if (!proc.killed) {
-                        proc.kill('SIGKILL');
-                    }
-                }, 5000);
+        }
+    }
+    // ─── Gateway Config Discovery ────────────────────────────────────
+    readGatewayConfig() {
+        try {
+            const configPath = join(homedir(), '.openclaw', 'openclaw.json');
+            if (!existsSync(configPath))
+                return null;
+            const raw = JSON.parse(readFileSync(configPath, 'utf-8'));
+            const port = raw?.gateway?.port;
+            if (!port)
+                return null;
+            const token = raw?.gateway?.auth?.token || '';
+            const bind = raw?.gateway?.bind || '127.0.0.1';
+            const host = bind === 'loopback' || bind === '127.0.0.1' ? '127.0.0.1' : bind;
+            return {
+                port,
+                token,
+                url: `ws://${host}:${port}`,
             };
-            signal.addEventListener('abort', abortHandler);
-            // Line buffer for incomplete JSONL lines
-            let lineBuf = '';
-            proc.stdout?.on('data', (data) => {
-                const text = data.toString();
-                stdout += text;
-                lineBuf += text;
-                const lines = lineBuf.split('\n');
-                lineBuf = lines.pop() || '';
-                for (const line of lines) {
-                    if (line.trim()) {
-                        const metrics = this.handleStreamLine(line, stream, artifacts);
-                        if (metrics) {
-                            lastMetrics = metrics;
-                        }
+        }
+        catch {
+            return null;
+        }
+    }
+    // ─── Gateway Probe ───────────────────────────────────────────────
+    probeGateway(config) {
+        return new Promise((resolve) => {
+            let resolved = false;
+            const done = (val) => { if (!resolved) {
+                resolved = true;
+                resolve(val);
+            } };
+            let ws;
+            const timeout = setTimeout(() => {
+                ws?.removeAllListeners();
+                ws?.close();
+                done(false);
+            }, 5000);
+            ws = new WebSocket(config.url);
+            ws.on('message', (data) => {
+                try {
+                    const frame = JSON.parse(String(data));
+                    if (frame.type === 'event' && frame.event === 'connect.challenge') {
+                        clearTimeout(timeout);
+                        ws.removeAllListeners();
+                        ws.close();
+                        done(true);
                     }
                 }
+                catch {
+                    // ignore
+                }
             });
-            proc.stderr?.on('data', (data) => {
-                const text = data.toString();
-                stderr += text;
-                stream.stderr(text);
+            ws.on('error', () => {
+                clearTimeout(timeout);
+                ws?.removeAllListeners();
+                done(false);
             });
-            proc.on('error', (error) => {
-                signal.removeEventListener('abort', abortHandler);
-                reject(error);
+            ws.on('close', () => {
+                clearTimeout(timeout);
+                done(false);
             });
-            proc.on('close', (code) => {
-                // Flush remaining buffer
-                if (lineBuf.trim()) {
-                    const metrics = this.handleStreamLine(lineBuf, stream, artifacts);
-                    if (metrics) {
-                        lastMetrics = metrics;
+        });
+    }
+    // ─── Gateway Connection ──────────────────────────────────────────
+    connectToGateway(config) {
+        return new Promise((resolve, reject) => {
+            let ws;
+            const timeout = setTimeout(() => {
+                ws?.removeAllListeners();
+                ws?.close();
+                reject(new Error('Gateway connection timeout'));
+            }, CONNECT_TIMEOUT_MS);
+            ws = new WebSocket(config.url);
+            const handshakeHandler = (data) => {
+                try {
+                    const frame = JSON.parse(String(data));
+                    // Step 1: Receive challenge, send connect
+                    if (frame.type === 'event' && frame.event === 'connect.challenge') {
+                        ws.send(JSON.stringify({
+                            type: 'req',
+                            id: 'connect-1',
+                            method: 'connect',
+                            params: {
+                                minProtocol: PROTOCOL_VERSION,
+                                maxProtocol: PROTOCOL_VERSION,
+                                client: {
+                                    id: 'gateway-client',
+                                    version: 'dev',
+                                    platform: process.platform,
+                                    mode: 'backend',
+                                },
+                                caps: ['tool-events'],
+                                auth: { token: config.token },
+                                role: 'operator',
+                                scopes: ['operator.read', 'operator.write'],
+                            },
+                        }));
                     }
+                    // Step 2: Receive connect response
+                    if (frame.type === 'res' && frame.id === 'connect-1') {
+                        clearTimeout(timeout);
+                        ws.removeListener('message', handshakeHandler);
+                        ws.removeListener('error', errorHandler);
+                        if (frame.ok) {
+                            resolve(ws);
+                        }
+                        else {
+                            ws.close();
+                            reject(new Error(`Gateway handshake failed: ${frame.error?.message || 'unknown'}`));
+                        }
+                    }
+                }
+                catch {
+                    // ignore parse errors during handshake
                 }
+            };
+            const errorHandler = (err) => {
+                clearTimeout(timeout);
+                ws?.removeListener('message', handshakeHandler);
+                reject(err);
+            };
+            ws.on('message', handshakeHandler);
+            ws.on('error', errorHandler);
+        });
+    }
+    // ─── Task Execution via Gateway ──────────────────────────────────
+    async runViaGateway(task, stream, signal) {
+        const ws = await this.connectToGateway(this.gatewayConfig);
+        stream.status('running', 5, 'Connected to gateway');
+        return new Promise((resolve) => {
+            const sessionKey = `astro:task:${task.id}`;
+            const idempotencyKey = randomUUID();
+            const artifacts = [];
+            let outputText = '';
+            let lastMetrics;
+            let runId;
+            let finished = false;
+            let lifecycleEnded = false;
+            let chatFinalReceived = false;
+            let gracePeriodTimeout;
+            const finish = (error) => {
+                if (finished)
+                    return;
+                finished = true;
                 signal.removeEventListener('abort', abortHandler);
+                if (taskTimeout)
+                    clearTimeout(taskTimeout);
+                if (gracePeriodTimeout)
+                    clearTimeout(gracePeriodTimeout);
+                ws.removeAllListeners();
+                ws.close();
                 resolve({
-                    exitCode: code ?? 1,
-                    output: stdout,
-                    error: stderr || undefined,
+                    output: outputText,
+                    error,
                     artifacts: artifacts.length > 0 ? artifacts : undefined,
                     metrics: lastMetrics,
                 });
-            });
+            };
+            /** Finish when both lifecycle.end and chat.final have been seen, or
+             *  after a short grace period if only lifecycle.end arrived. */
+            const tryFinishAfterLifecycle = () => {
+                if (chatFinalReceived) {
+                    finish();
+                }
+                else {
+                    // Grace period: if chat.final doesn't arrive within 500ms, finish anyway
+                    gracePeriodTimeout = setTimeout(() => { if (!finished)
+                        finish(); }, 500);
+                }
+            };
+            // Handle abort
+            const abortHandler = () => {
+                if (runId) {
+                    // Try to abort the chat
+                    try {
+                        ws.send(JSON.stringify({
+                            type: 'req',
+                            id: 'abort-1',
+                            method: 'chat.abort',
+                            params: { sessionKey },
+                        }));
+                    }
+                    catch {
+                        // ignore
+                    }
+                }
+                finish('Task cancelled');
+            };
+            signal.addEventListener('abort', abortHandler);
+            // Handle timeout
+            let taskTimeout;
             if (task.timeout) {
-                setTimeout(() => {
-                    if (!proc.killed) {
-                        proc.kill('SIGTERM');
-                        setTimeout(() => {
-                            if (!proc.killed) {
-                                proc.kill('SIGKILL');
+                taskTimeout = setTimeout(() => {
+                    finish('Task timed out');
+                }, task.timeout);
+            }
+            // Handle incoming events
+            ws.on('message', (data) => {
+                if (finished)
+                    return;
+                let frame;
+                try {
+                    frame = JSON.parse(String(data));
+                }
+                catch {
+                    return;
+                }
+                // Handle chat.send response
+                if (frame.type === 'res' && frame.id === 'chat-send-1') {
+                    if (frame.ok) {
+                        runId = frame.payload?.runId;
+                        stream.status('running', 10, 'Task dispatched to agent');
+                    }
+                    else {
+                        finish(`Gateway rejected task: ${frame.error?.message || 'unknown'}`);
+                    }
+                    return;
+                }
+                // Handle agent events
+                if (frame.type === 'event' && frame.event === 'agent') {
+                    const p = frame.payload || {};
+                    // Filter to our session — gateway prepends 'agent:main:' to sessionKey
+                    if (p.sessionKey !== `agent:main:${sessionKey}` && p.sessionKey !== sessionKey) {
+                        return;
+                    }
+                    const streamType = p.stream;
+                    const eventData = p.data;
+                    if (streamType === 'lifecycle') {
+                        const phase = eventData?.phase;
+                        if (phase === 'start') {
+                            stream.sessionInit(p.sessionKey || sessionKey, eventData?.model || undefined);
+                        }
+                        else if (phase === 'end') {
+                            // Extract usage metrics from lifecycle.end if available
+                            const usage = eventData?.usage;
+                            const cost = (eventData?.total_cost_usd ?? eventData?.cost_usd);
+                            const numTurns = eventData?.num_turns;
+                            const durationMs = eventData?.duration_ms;
+                            const model = eventData?.model;
+                            if (usage || cost !== undefined) {
+                                lastMetrics = {
+                                    inputTokens: usage?.input_tokens,
+                                    outputTokens: usage?.output_tokens,
+                                    totalCost: cost,
+                                    numTurns,
+                                    durationMs,
+                                    model,
+                                };
                             }
-                        }, 5000);
+                            lifecycleEnded = true;
+                            tryFinishAfterLifecycle();
+                        }
                     }
-                }, task.timeout);
+                    else if (streamType === 'assistant') {
+                        const delta = eventData?.delta || eventData?.text;
+                        if (delta) {
+                            outputText += delta;
+                            stream.text(delta);
+                        }
+                    }
+                    else if (streamType === 'tool_use') {
+                        const toolName = eventData?.name || eventData?.toolName || 'unknown';
+                        const toolInput = eventData?.input || eventData?.toolInput || {};
+                        stream.toolUse(toolName, toolInput);
+                    }
+                    else if (streamType === 'tool_result') {
+                        const toolName = eventData?.name || eventData?.toolName || 'unknown';
+                        const result = eventData?.result || eventData?.output || '';
+                        const success = eventData?.success !== false;
+                        stream.toolResult(toolName, result, success);
+                    }
+                    else if (streamType === 'file_change') {
+                        const filePath = eventData?.path || eventData?.file;
+                        const rawAction = eventData?.type || eventData?.action || 'modified';
+                        const action = (['created', 'modified', 'deleted'].includes(rawAction) ? rawAction : 'modified');
+                        if (filePath) {
+                            artifacts.push({ type: 'file', name: filePath, path: filePath, metadata: { action } });
+                            stream.fileChange(filePath, action);
+                        }
+                    }
+                    return;
+                }
+                // Handle chat events (for final state + model info)
+                if (frame.type === 'event' && frame.event === 'chat') {
+                    const p = frame.payload || {};
+                    // Filter to our session — gateway prepends 'agent:main:' to sessionKey
+                    if (p.sessionKey !== `agent:main:${sessionKey}` && p.sessionKey !== sessionKey) {
+                        return;
+                    }
+                    const state = p.state;
+                    if (state === 'final') {
+                        chatFinalReceived = true;
+                        // Extract final message content
+                        const message = p.message;
+                        if (message) {
+                            const content = message.content;
+                            if (content) {
+                                for (const block of content) {
+                                    if (block.type === 'text' && block.text) {
+                                        // Only add if not already captured via agent delta events
+                                        if (!outputText.includes(block.text)) {
+                                            outputText += block.text;
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                        // Extract model/usage from chat.final if not yet captured
+                        if (!lastMetrics) {
+                            const usage = p.usage;
+                            const cost = (p.total_cost_usd ?? p.cost_usd);
+                            const model = (p.model ?? message?.model);
+                            if (usage || cost !== undefined || model) {
+                                lastMetrics = {
+                                    inputTokens: usage?.input_tokens,
+                                    outputTokens: usage?.output_tokens,
+                                    totalCost: cost,
+                                    model,
+                                };
+                            }
+                        }
+                        // If lifecycle already ended, finish immediately
+                        if (lifecycleEnded)
+                            finish();
+                    }
+                    return;
+                }
+                // Handle tick/health/presence (ignore)
+                if (frame.type === 'event') {
+                    const ignoredEvents = ['tick', 'health', 'presence', 'heartbeat'];
+                    if (frame.event && ignoredEvents.includes(frame.event))
+                        return;
+                }
+            });
+            ws.on('close', () => {
+                if (!finished) {
+                    finish('Gateway connection closed unexpectedly');
+                }
+            });
+            ws.on('error', (err) => {
+                if (!finished) {
+                    finish(`Gateway WebSocket error: ${err.message}`);
+                }
+            });
+            // Build the prompt
+            const effectivePrompt = task.systemPrompt
+                ? `${task.systemPrompt}\n\n---\n\n${task.prompt}`
+                : task.prompt;
+            // Send chat.send
+            try {
+                ws.send(JSON.stringify({
+                    type: 'req',
+                    id: 'chat-send-1',
+                    method: 'chat.send',
+                    params: {
+                        sessionKey,
+                        message: effectivePrompt,
+                        idempotencyKey,
+                    },
+                }));
+            }
+            catch (err) {
+                finish(`Failed to send chat.send: ${err instanceof Error ? err.message : String(err)}`);
             }
+            // Note: signal listener and timeout cleanup is handled in finish()
         });
     }
+    // ─── Reusable Chat Message Sender (for resume) ────────────────────
     /**
-     * Handle a single JSONL line from OpenClaw's RPC output.
-     *
-     * OpenClaw JSONL event types:
-     * - session.start     → sessionInit
-     * - content.text      → text output
-     * - tool_use.start    → toolUse
-     * - tool_use.end      → toolResult
-     * - file.change       → fileChange
-     * - message.start     → status update (agent thinking)
-     * - message.end       → status update (turn complete)
-     * - session.end       → metrics extraction
-     *
-     * Returns metrics if a session.end event is processed.
+     * Send a chat message to an already-connected gateway WebSocket.
+     * Used by resumeTask() to continue a conversation on the same sessionKey.
      */
-    handleStreamLine(line, stream, artifacts) {
-        try {
-            const event = JSON.parse(line);
-            const type = event.type;
-            switch (type) {
-                case 'session.start': {
-                    const sessionId = event.session_id;
-                    const model = event.model;
-                    if (sessionId) {
-                        stream.sessionInit(sessionId, model);
-                    }
-                    break;
+    sendChatMessage(ws, sessionKey, message, stream, signal) {
+        return new Promise((resolve) => {
+            const idempotencyKey = randomUUID();
+            let outputText = '';
+            let finished = false;
+            let lifecycleEnded = false;
+            let chatFinalReceived = false;
+            let gracePeriodTimeout;
+            const finish = (error) => {
+                if (finished)
+                    return;
+                finished = true;
+                signal.removeEventListener('abort', abortHandler);
+                if (gracePeriodTimeout)
+                    clearTimeout(gracePeriodTimeout);
+                ws.removeAllListeners();
+                ws.close();
+                resolve({ output: outputText, error });
+            };
+            const tryFinishAfterLifecycle = () => {
+                if (chatFinalReceived) {
+                    finish();
                 }
-                case 'message.start': {
-                    stream.status('running', undefined, 'Agent thinking...');
-                    break;
+                else {
+                    gracePeriodTimeout = setTimeout(() => { if (!finished)
+                        finish(); }, 500);
                 }
-                case 'content.text': {
-                    const text = event.text;
-                    if (text) {
-                        stream.text(text);
-                    }
-                    break;
+            };
+            const abortHandler = () => {
+                try {
+                    ws.send(JSON.stringify({
+                        type: 'req',
+                        id: 'abort-resume',
+                        method: 'chat.abort',
+                        params: { sessionKey },
+                    }));
                 }
-                case 'tool_use.start': {
-                    const toolName = event.tool_name || 'unknown';
-                    const toolInput = event.tool_input ?? {};
-                    stream.toolUse(toolName, toolInput);
-                    break;
+                catch { /* ignore */ }
+                finish('Task cancelled');
+            };
+            signal.addEventListener('abort', abortHandler);
+            ws.on('message', (data) => {
+                if (finished)
+                    return;
+                let frame;
+                try {
+                    frame = JSON.parse(String(data));
                 }
-                case 'tool_use.end': {
-                    const toolName = event.tool_name || 'unknown';
-                    const result = event.result;
-                    const success = event.success !== false;
-                    stream.toolResult(toolName, result, success);
-                    break;
+                catch {
+                    return;
                 }
-                case 'file.change': {
-                    const path = event.path;
-                    const action = event.action || 'modified';
-                    const linesAdded = event.lines_added;
-                    const linesRemoved = event.lines_removed;
-                    if (path) {
-                        stream.fileChange(path, action, linesAdded, linesRemoved);
-                        if (!artifacts.some((a) => a.path === path)) {
-                            artifacts.push({ type: 'file', name: path, path });
-                        }
+                if (frame.type === 'res' && frame.id === 'chat-resume-1') {
+                    if (!frame.ok) {
+                        finish(`Gateway rejected resume: ${frame.error?.message || 'unknown'}`);
                     }
-                    break;
-                }
-                case 'message.end': {
-                    stream.status('running', undefined, 'Turn complete');
-                    break;
+                    return;
                 }
-                case 'session.end': {
-                    const cost = event.cost;
-                    const inputTokens = event.input_tokens;
-                    const outputTokens = event.output_tokens;
-                    const turns = event.turns;
-                    const model = event.model;
-                    const durationMs = event.duration_ms;
-                    if (cost !== undefined) {
-                        stream.status('running', 100, `Completed (${turns ?? 0} turns, $${cost.toFixed(4)})`);
+                if (frame.type === 'event' && frame.event === 'agent') {
+                    const p = frame.payload || {};
+                    if (p.sessionKey !== `agent:main:${sessionKey}` && p.sessionKey !== sessionKey)
+                        return;
+                    const streamType = p.stream;
+                    const eventData = p.data;
+                    if (streamType === 'lifecycle') {
+                        const phase = eventData?.phase;
+                        if (phase === 'end') {
+                            lifecycleEnded = true;
+                            tryFinishAfterLifecycle();
+                        }
                     }
-                    else {
-                        stream.status('running', 100, 'Completed');
+                    else if (streamType === 'assistant') {
+                        const delta = eventData?.delta || eventData?.text;
+                        if (delta) {
+                            outputText += delta;
+                            stream.text(delta);
+                        }
+                    }
+                    else if (streamType === 'tool_use') {
+                        const toolName = eventData?.name || 'unknown';
+                        stream.toolUse(toolName, eventData?.input || {});
+                    }
+                    else if (streamType === 'tool_result') {
+                        const toolName = eventData?.name || 'unknown';
+                        stream.toolResult(toolName, eventData?.result || '', eventData?.success !== false);
+                    }
+                    else if (streamType === 'file_change') {
+                        const filePath = eventData?.path || eventData?.file;
+                        if (filePath) {
+                            const rawAction = eventData?.type || 'modified';
+                            const action = (['created', 'modified', 'deleted'].includes(rawAction) ? rawAction : 'modified');
+                            stream.fileChange(filePath, action);
+                        }
                     }
-                    return {
-                        totalCost: cost,
-                        inputTokens,
-                        outputTokens,
-                        numTurns: turns,
-                        model,
-                        durationMs,
-                    };
+                    return;
                 }
-                default:
-                    // Unknown event type — skip silently
-                    break;
+                if (frame.type === 'event' && frame.event === 'chat') {
+                    const p = frame.payload || {};
+                    if (p.sessionKey !== `agent:main:${sessionKey}` && p.sessionKey !== sessionKey)
+                        return;
+                    if (p.state === 'final') {
+                        chatFinalReceived = true;
+                        if (lifecycleEnded)
+                            finish();
+                    }
+                    return;
+                }
+            });
+            ws.on('close', () => { if (!finished)
+                finish('Gateway connection closed'); });
+            ws.on('error', (err) => { if (!finished)
+                finish(`Gateway error: ${err.message}`); });
+            // Send the resume message
+            try {
+                ws.send(JSON.stringify({
+                    type: 'req',
+                    id: 'chat-resume-1',
+                    method: 'chat.send',
+                    params: {
+                        sessionKey,
+                        message,
+                        idempotencyKey,
+                    },
+                }));
             }
-        }
-        catch {
-            // Not valid JSON — send as raw stdout
-            stream.stdout(line + '\n');
-        }
-        return undefined;
+            catch (err) {
+                finish(`Failed to send chat.send: ${err instanceof Error ? err.message : String(err)}`);
+            }
+        });
     }
 }
 //# sourceMappingURL=openclaw-adapter.js.map