@astroanywhere/agent 0.2.4 → 0.2.5

package/dist/providers/openclaw-adapter.js

@@ -1,31 +1,20 @@
 /**
- * OpenClaw provider adapter — Gateway WebSocket mode
+ * OpenClaw provider adapter — Thin wrapper delegating to OpenClawBridge
  *
- * Connects to the local OpenClaw gateway via WebSocket and dispatches tasks
- * using `chat.send`. Each task gets its own session key for isolation.
+ * When a bridge is injected via setBridge(), task execution goes through
+ * the bridge's shared WebSocket connection (session-multiplexed).
+ * Falls back to standalone connections when no bridge is available.
  *
- * 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'
- *
- * Execution flow:
- *   chat.send({ sessionKey, message, idempotencyKey })
- *   → gateway streams `agent` + `chat` events over WebSocket
- *   → adapter translates to TaskOutputStream calls
- *   → returns TaskResult on session completion
+ * The HTTP llm-task path (runLlmTask) remains in the adapter since it
+ * uses a separate HTTP POST, not the WebSocket.
  */
-import { existsSync, readFileSync } from 'node:fs';
-import { join } from 'node:path';
-import { homedir } from 'node:os';
 import { randomUUID } from 'node:crypto';
-import WebSocket from 'ws';
 import { SUMMARY_PROMPT, SUMMARY_TIMEOUT_MS, parseSummaryResponse, createNoopStream } from './base-adapter.js';
+import { readGatewayConfig, probeGateway, parseGatewayFrame, makeSessionKey, matchesSessionKey, PROTOCOL_VERSION, CONNECT_TIMEOUT_MS, } from '../lib/openclaw-gateway.js';
+import WebSocket from 'ws';
 // ---------------------------------------------------------------------------
 // Constants
 // ---------------------------------------------------------------------------
-const PROTOCOL_VERSION = 3;
-const CONNECT_TIMEOUT_MS = 10_000;
 /** TTL for preserved sessions (10 minutes) */
 const SESSION_TTL_MS = 10 * 60 * 1000;
 export class OpenClawAdapter {
@@ -36,16 +25,31 @@ export class OpenClawAdapter {
     lastError;
     gatewayConfig = null;
     lastAvailableCheck = null;
+    bridge = null;
     /** Preserved sessions for multi-turn resume, keyed by taskId */
     preservedSessions = new Map();
+    // ─── Bridge Injection ───────────────────────────────────────────
+    /**
+     * Inject the shared bridge for task execution.
+     * Called by task-executor when the bridge becomes available.
+     */
+    setBridge(bridge) {
+        this.bridge = bridge;
+    }
+    // ─── Availability ───────────────────────────────────────────────
     async isAvailable() {
-        const config = this.readGatewayConfig();
+        // If bridge is connected, we're available
+        if (this.bridge?.isConnected) {
+            this.lastAvailableCheck = { available: true, at: Date.now() };
+            return true;
+        }
+        const config = readGatewayConfig();
         if (!config)
             return false;
         this.gatewayConfig = config;
         // Probe the gateway with a quick connect
         try {
-            const ok = await this.probeGateway(config);
+            const ok = await probeGateway(config.url);
             this.lastAvailableCheck = { available: ok, at: Date.now() };
             return ok;
         }
@@ -54,8 +58,10 @@ export class OpenClawAdapter {
             return false;
         }
     }
+    // ─── Task Execution ─────────────────────────────────────────────
     async execute(task, stream, signal) {
-        if (!this.gatewayConfig) {
+        // Ensure we have config or bridge
+        if (!this.bridge?.isConnected && !this.gatewayConfig) {
             const available = await this.isAvailable();
             if (!available) {
                 return {
@@ -85,13 +91,33 @@ export class OpenClawAdapter {
                     };
                 }
                 catch (err) {
-                    // Fall through to runViaGateway() agent mode
+                    // Fall through to agent mode
                     console.warn('[openclaw] llm-task failed, falling back to agent mode:', err);
                 }
             }
             stream.status('running', 0, 'Connecting to OpenClaw gateway');
-            const sessionKey = `astro:task:${task.id}`;
-            const result = await this.runViaGateway(task, stream, signal);
+            const sessionKey = makeSessionKey(task.id);
+            // Build the prompt
+            let effectivePrompt = task.systemPrompt
+                ? `${task.systemPrompt}\n\n---\n\n${task.prompt}`
+                : task.prompt;
+            // Prepend conversation history if available
+            if (task.messages && task.messages.length > 0) {
+                const conversationContext = task.messages
+                    .map(m => `${m.role === 'user' ? 'Human' : 'Assistant'}: ${m.content}`)
+                    .join('\n\n');
+                effectivePrompt = `${conversationContext}\n\nHuman: ${effectivePrompt}`;
+            }
+            let result;
+            if (this.bridge?.isConnected) {
+                // Bridge-backed execution (shared WebSocket)
+                stream.status('running', 5, 'Connected to gateway');
+                result = await this.bridge.executeTask(sessionKey, effectivePrompt, stream, signal, task.timeout);
+            }
+            else {
+                // Fallback: standalone connection
+                result = await this.runViaStandaloneConnection(sessionKey, effectivePrompt, stream, signal, task.timeout);
+            }
             const isCancelled = signal.aborted || result.error === 'Task cancelled';
             // Preserve session for multi-turn resume (unless cancelled/failed)
             if (!isCancelled && !result.error) {
@@ -159,8 +185,7 @@ export class OpenClawAdapter {
         }
     }
     async getStatus() {
-        // Use cached availability if checked within the last 30 seconds to avoid
-        // opening a new WebSocket probe on every status poll
+        // Use cached availability if checked within the last 30 seconds
         let available;
         if (this.lastAvailableCheck && Date.now() - this.lastAvailableCheck.at < 30_000) {
             available = this.lastAvailableCheck.available;
@@ -179,30 +204,29 @@ export class OpenClawAdapter {
     // ─── 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' };
-            }
-        }
-        // Use the preserved session key, or resolve from the provider sessionId.
-        // The sessionId may already be a valid session key (e.g. 'astro:task:...' or
-        // 'agent:main:astro:task:...'), so don't blindly wrap it in 'astro:task:'.
+        // Use the preserved session key, or resolve from the provider sessionId
         const session = this.preservedSessions.get(taskId);
         const sessionKey = session?.sessionKey || this.resolveSessionKey(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;
+            let result;
+            if (this.bridge?.isConnected) {
+                stream.status('running', 5, 'Resuming OpenClaw session');
+                result = await this.bridge.sendChatMessage(sessionKey, message, stream, signal);
+            }
+            else {
+                // Fallback: standalone connection for resume
+                if (!this.gatewayConfig) {
+                    const available = await this.isAvailable();
+                    if (!available || !this.gatewayConfig) {
+                        return { success: false, output: '', error: 'OpenClaw gateway not available' };
+                    }
+                }
+                stream.status('running', 5, 'Resuming OpenClaw session');
+                result = await this.runViaStandaloneConnection(sessionKey, message, stream, signal);
+            }
             // Update preserved session timestamp
             if (session) {
                 session.createdAt = Date.now();
@@ -214,7 +238,6 @@ export class OpenClawAdapter {
             };
         }
         catch (error) {
-            ws?.close();
             const errorMsg = error instanceof Error ? error.message : String(error);
             this.lastError = errorMsg;
             return { success: false, output: '', error: errorMsg };
@@ -225,7 +248,6 @@ export class OpenClawAdapter {
     }
     /**
      * 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;
@@ -256,7 +278,6 @@ export class OpenClawAdapter {
     // ─── Summary Generation ──────────────────────────────────────
     /**
      * Generate a structured execution summary by resuming the completed OpenClaw session.
-     * Sends the summary prompt to the same session key via chat.send.
      */
     async generateSummary(taskId, workingDirectory) {
         const session = this.preservedSessions.get(taskId);
@@ -264,9 +285,9 @@ export class OpenClawAdapter {
             console.log(`[openclaw] No session to resume for summary (task ${taskId})`);
             return undefined;
         }
-        if (!this.gatewayConfig) {
+        if (!this.bridge?.isConnected && !this.gatewayConfig) {
             const available = await this.isAvailable();
-            if (!available || !this.gatewayConfig) {
+            if (!available) {
                 console.warn(`[openclaw] Gateway not available for summary generation (task ${taskId})`);
                 return undefined;
             }
@@ -287,10 +308,6 @@ export class OpenClawAdapter {
     }
     /**
      * Resolve a provider session ID to a valid OpenClaw session key.
-     * The sessionId from the frontend may be:
-     *   - 'astro:task:{taskId}' (direct)
-     *   - 'agent:main:astro:task:{taskId}' (gateway-prefixed)
-     * Avoid double-wrapping by checking for existing prefixes.
      */
     resolveSessionKey(sessionId) {
         if (sessionId.startsWith('astro:task:'))
@@ -300,137 +317,19 @@ export class OpenClawAdapter {
             return stripped;
         return `astro:task:${sessionId}`;
     }
-    // ─── 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}`,
-            };
-        }
-        catch {
-            return null;
+    // ─── Standalone Connection (Fallback) ──────────────────────────
+    /**
+     * Execute via a standalone WebSocket connection when no bridge is available.
+     * This preserves backward compatibility for cases where the bridge isn't wired.
+     */
+    async runViaStandaloneConnection(sessionKey, message, stream, signal, timeout) {
+        const config = this.gatewayConfig;
+        if (!config) {
+            throw new Error('Gateway config not available');
         }
-    }
-    // ─── 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
-                }
-            });
-            ws.on('error', () => {
-                clearTimeout(timeout);
-                ws?.removeAllListeners();
-                done(false);
-            });
-            ws.on('close', () => {
-                clearTimeout(timeout);
-                done(false);
-            });
-        });
-    }
-    // ─── 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);
+        const ws = await this.connectToGateway(config);
         stream.status('running', 5, 'Connected to gateway');
         return new Promise((resolve) => {
-            const sessionKey = `astro:task:${task.id}`;
             const idempotencyKey = randomUUID();
             const artifacts = [];
             let outputText = '';
@@ -458,22 +357,17 @@ export class OpenClawAdapter {
                     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',
@@ -482,32 +376,21 @@ export class OpenClawAdapter {
                             params: { sessionKey },
                         }));
                     }
-                    catch {
-                        // ignore
-                    }
+                    catch { /* ignore */ }
                 }
                 finish('Task cancelled');
             };
             signal.addEventListener('abort', abortHandler);
-            // Handle timeout
             let taskTimeout;
-            if (task.timeout) {
-                taskTimeout = setTimeout(() => {
-                    finish('Task timed out');
-                }, task.timeout);
+            if (timeout) {
+                taskTimeout = setTimeout(() => { finish('Task timed out'); }, timeout);
             }
-            // Handle incoming events
             ws.on('message', (data) => {
                 if (finished)
                     return;
-                let frame;
-                try {
-                    frame = JSON.parse(String(data));
-                }
-                catch {
+                const frame = parseGatewayFrame(data);
+                if (!frame)
                     return;
-                }
-                // Handle chat.send response
                 if (frame.type === 'res' && frame.id === 'chat-send-1') {
                     if (frame.ok) {
                         runId = frame.payload?.runId;
@@ -518,13 +401,10 @@ export class OpenClawAdapter {
                     }
                     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) {
+                    if (!matchesSessionKey(p.sessionKey, sessionKey))
                         return;
-                    }
                     const streamType = p.stream;
                     const eventData = p.data;
                     if (streamType === 'lifecycle') {
@@ -533,7 +413,6 @@ export class OpenClawAdapter {
                             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;
@@ -582,36 +461,27 @@ export class OpenClawAdapter {
                     }
                     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) {
+                    if (!matchesSessionKey(p.sessionKey, sessionKey))
                         return;
-                    }
-                    const state = p.state;
-                    if (state === 'final') {
+                    if (p.state === 'final') {
                         chatFinalReceived = true;
-                        // Extract final message content
-                        const message = p.message;
-                        if (message) {
-                            const content = message.content;
+                        const chatMessage = p.message;
+                        if (chatMessage) {
+                            const content = chatMessage.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;
-                                        }
+                                    if (block.type === 'text' && block.text && !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);
+                            const model = (p.model ?? p.message?.model);
                             if (usage || cost !== undefined || model) {
                                 lastMetrics = {
                                     inputTokens: usage?.input_tokens,
@@ -621,202 +491,94 @@ export class OpenClawAdapter {
                                 };
                             }
                         }
-                        // 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
-            let effectivePrompt = task.systemPrompt
-                ? `${task.systemPrompt}\n\n---\n\n${task.prompt}`
-                : task.prompt;
-            // Prepend conversation history if available (fallback for multi-turn when
-            // session resume isn't used or preservedSessions lookup failed)
-            if (task.messages && task.messages.length > 0) {
-                const conversationContext = task.messages
-                    .map(m => `${m.role === 'user' ? 'Human' : 'Assistant'}: ${m.content}`)
-                    .join('\n\n');
-                effectivePrompt = `${conversationContext}\n\nHuman: ${effectivePrompt}`;
-            }
-            // Send chat.send
+            ws.on('close', () => { if (!finished)
+                finish('Gateway connection closed unexpectedly'); });
+            ws.on('error', (err) => { if (!finished)
+                finish(`Gateway WebSocket error: ${err.message}`); });
             try {
                 ws.send(JSON.stringify({
                     type: 'req',
                     id: 'chat-send-1',
                     method: 'chat.send',
-                    params: {
-                        sessionKey,
-                        message: effectivePrompt,
-                        idempotencyKey,
-                    },
+                    params: { sessionKey, message, 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) ────────────────────
     /**
-     * Send a chat message to an already-connected gateway WebSocket.
-     * Used by resumeTask() to continue a conversation on the same sessionKey.
+     * Connect to gateway with full handshake (standalone fallback).
      */
-    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);
+    connectToGateway(config) {
+        return new Promise((resolve, reject) => {
+            const ws = new WebSocket(config.url);
+            const timeout = setTimeout(() => {
                 ws.removeAllListeners();
                 ws.close();
-                resolve({ output: outputText, error });
-            };
-            const tryFinishAfterLifecycle = () => {
-                if (chatFinalReceived) {
-                    finish();
-                }
-                else {
-                    gracePeriodTimeout = setTimeout(() => { if (!finished)
-                        finish(); }, 500);
-                }
-            };
-            const abortHandler = () => {
-                try {
+                reject(new Error('Gateway connection timeout'));
+            }, CONNECT_TIMEOUT_MS);
+            const handshakeHandler = (data) => {
+                const frame = parseGatewayFrame(data);
+                if (!frame)
+                    return;
+                if (frame.type === 'event' && frame.event === 'connect.challenge') {
                     ws.send(JSON.stringify({
                         type: 'req',
-                        id: 'abort-resume',
-                        method: 'chat.abort',
-                        params: { sessionKey },
+                        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'],
+                        },
                     }));
                 }
-                catch { /* ignore */ }
-                finish('Task cancelled');
-            };
-            signal.addEventListener('abort', abortHandler);
-            ws.on('message', (data) => {
-                if (finished)
-                    return;
-                let frame;
-                try {
-                    frame = JSON.parse(String(data));
-                }
-                catch {
-                    return;
-                }
-                if (frame.type === 'res' && frame.id === 'chat-resume-1') {
-                    if (!frame.ok) {
-                        finish(`Gateway rejected resume: ${frame.error?.message || 'unknown'}`);
-                    }
-                    return;
-                }
-                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 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);
-                        }
+                if (frame.type === 'res' && frame.id === 'connect-1') {
+                    clearTimeout(timeout);
+                    ws.removeListener('message', handshakeHandler);
+                    ws.removeListener('error', errorHandler);
+                    if (frame.ok) {
+                        resolve(ws);
                     }
-                    return;
-                }
-                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();
+                    else {
+                        ws.close();
+                        reject(new Error(`Gateway handshake failed: ${frame.error?.message || 'unknown'}`));
                     }
-                    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 (err) {
-                finish(`Failed to send chat.send: ${err instanceof Error ? err.message : String(err)}`);
-            }
+            };
+            const errorHandler = (err) => {
+                clearTimeout(timeout);
+                ws?.removeListener('message', handshakeHandler);
+                reject(err);
+            };
+            ws.on('message', handshakeHandler);
+            ws.on('error', errorHandler);
         });
     }
     // ─── LLM Task (Structured JSON via HTTP) ──────────────────────────
     /**
      * Use the Gateway's HTTP `POST /tools/invoke` endpoint for structured JSON
-     * plan generation. The `llm-task` tool supports JSON Schema validation,
-     * guaranteeing well-formed output without prompt engineering.
+     * plan generation.
      */
     async runLlmTask(task, stream, signal) {
-        const config = this.gatewayConfig;
+        const config = this.gatewayConfig || readGatewayConfig();
         if (!config) {
             throw new Error('Gateway config not available');
         }