connectonion 0.0.18 → 0.0.21

package/dist/connect/remote-agent.js

@@ -1,109 +1,129 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RemoteAgent = void 0;
-const address = __importStar(require("../address"));
 const endpoint_1 = require("./endpoint");
-/**
- * Proxy to a remote agent with streaming support.
- *
- * @example
- * ```typescript
- * const agent = connect("0x123abc");
- *
- * // Simple usage
- * const response = await agent.input("Search for Python docs");
- * console.log(response.text);  // Agent's response
- * console.log(response.done);  // true if complete
- *
- * // Access UI events for rendering
- * console.log(agent.ui);      // Array of UI events
- * console.log(agent.status);  // 'idle' | 'working' | 'waiting'
- * ```
- */
+const auth_1 = require("./auth");
+const chat_item_mapper_1 = require("./chat-item-mapper");
 class RemoteAgent {
-    /** Alias for address (backwards compatibility) */
-    get agentAddress() {
-        return this.address;
-    }
+    set onMessage(fn) { this._onMessage = fn; }
     constructor(agentAddress, options = {}) {
         this._endpointResolutionAttempted = false;
+        // Public reactive state
         this._status = 'idle';
         this._connectionState = 'disconnected';
         this._currentSession = null;
         this._chatItems = [];
-        this._activeWs = null;
-        this._pendingPrompt = null;
-        this._pendingInputId = null;
-        this._pendingSessionId = null;
+        this._error = null;
+        // Persistent WebSocket
+        this._ws = null;
+        this._authenticated = false;
+        // Promise resolution for current input() call
+        this._inputResolve = null;
+        this._inputReject = null;
+        this._inputTimer = null;
+        // Pending retry after onboard
+        this._pendingRetry = null;
+        // PING/PONG health check
         this._lastPingTime = 0;
-        this._healthCheckInterval = null;
-        // Reconnection state
-        this._reconnectAttempts = 0;
-        this._maxReconnectAttempts = 3;
-        this._reconnectBaseDelay = 1000;
-        this._shouldReconnect = false;
+        this._pingTimer = null;
+        // Callback + promise for ensureConnected
+        this._connectResolve = null;
+        this._connectReject = null;
+        this._onMessage = null;
         this.address = agentAddress;
-        this._relayUrl = (0, endpoint_1.normalizeRelayBase)(options.relayUrl || 'wss://oo.openonion.ai');
+        this._relayUrl = (0, endpoint_1.normalizeRelayUrl)(options.relayUrl || 'wss://oo.openonion.ai');
         this._directUrl = options.directUrl?.replace(/\/$/, '');
-        this._WS = options.wsCtor || (0, endpoint_1.defaultWebSocketCtor)();
-        if (options.keys) {
+        this._WS = options.wsCtor || (0, endpoint_1.getWebSocketCtor)();
+        if (options.keys)
             this._keys = options.keys;
-        }
-    }
-    // ==========================================================================
-    // Public Properties
-    // ==========================================================================
-    get status() {
-        return this._status;
     }
-    get connectionState() {
-        return this._connectionState;
-    }
-    get currentSession() {
-        return this._currentSession;
+    // --- Public getters ---
+    get agentAddress() { return this.address; }
+    get status() { return this._status; }
+    get connectionState() { return this._connectionState; }
+    get currentSession() { return this._currentSession; }
+    get ui() { return this._chatItems; }
+    get mode() { return this._currentSession?.mode || 'safe'; }
+    get error() { return this._error || null; }
+    // --- Public API ---
+    async input(prompt, options) {
+        const timeoutMs = options?.timeoutMs ?? 600000;
+        this._addChatItem({ type: 'user', content: prompt, images: options?.images });
+        this._addChatItem({ type: 'thinking', id: '__optimistic__', status: 'running' });
+        this._status = 'working';
+        this._onMessage?.();
+        await this._ensureConnected();
+        const inputId = (0, endpoint_1.generateUUID)();
+        const isDirect = this._isDirect();
+        const msg = { type: 'INPUT', input_id: inputId, prompt };
+        if (options?.images?.length)
+            msg.images = options.images;
+        if (!isDirect)
+            msg.to = this.address;
+        this._ws.send(JSON.stringify(msg));
+        return new Promise((resolve, reject) => {
+            this._inputResolve = resolve;
+            this._inputReject = reject;
+            this._inputTimer = setTimeout(() => {
+                this._settleInput();
+                this._status = 'idle';
+                this._onMessage?.();
+                reject(new Error('Request timed out'));
+            }, timeoutMs);
+        });
     }
-    get ui() {
-        return this._chatItems;
+    async reconnect(sessionId) {
+        const sid = sessionId || this._currentSession?.session_id;
+        if (!sid)
+            throw new Error('No session to reconnect');
+        if (!this._currentSession)
+            this._currentSession = { session_id: sid };
+        this._status = 'working';
+        this._onMessage?.();
+        // Force new connection for reconnect
+        this._closeWs();
+        this._keys = (0, auth_1.ensureKeys)(this._keys);
+        await this._resolveEndpointOnce();
+        const { wsUrl, isDirect } = this._resolveWsUrl();
+        const ws = new this._WS(wsUrl);
+        this._ws = ws;
+        this._connectionState = 'reconnecting';
+        this._onMessage?.();
+        return new Promise((resolve, reject) => {
+            this._inputResolve = resolve;
+            this._inputReject = reject;
+            this._inputTimer = setTimeout(() => {
+                this._settleInput();
+                this._status = 'idle';
+                this._connectionState = 'disconnected';
+                this._onMessage?.();
+                reject(new Error('Reconnect timed out'));
+            }, 60000);
+            ws.onopen = () => {
+                this._connectionState = 'connected';
+                this._lastPingTime = Date.now();
+                this._startPingMonitor();
+                // Send CONNECT with session_id + session data
+                const payload = { timestamp: Math.floor(Date.now() / 1000) };
+                payload.to = this.address;
+                const signed = (0, auth_1.signPayload)(this._keys, payload);
+                const msg = { type: 'CONNECT', session_id: sid, ...signed };
+                if (!isDirect)
+                    msg.to = this.address;
+                if (this._currentSession)
+                    msg.session = { ...this._currentSession };
+                ws.send(JSON.stringify(msg));
+            };
+            ws.onmessage = (evt) => this._handleMessage(evt);
+            ws.onerror = () => this._handleConnectionLoss();
+            ws.onclose = () => this._handleConnectionLoss();
+        });
     }
-    get mode() {
-        return this._currentSession?.mode || 'safe';
+    send(message) {
+        if (!this._ws)
+            throw new Error('No active connection');
+        this._ws.send(JSON.stringify(message));
     }
-    // ==========================================================================
-    // Public Methods
-    // ==========================================================================
     setMode(mode, options) {
         if (!this._currentSession) {
             this._currentSession = { mode };
@@ -115,708 +135,428 @@ class RemoteAgent {
             this._currentSession.ulw_turns = options?.turns || 100;
             this._currentSession.ulw_turns_used = 0;
         }
-        if (this._activeWs) {
+        if (this._ws) {
             const msg = { type: 'mode_change', mode };
-            if (mode === 'ulw' && options?.turns) {
+            if (mode === 'ulw' && options?.turns)
                 msg.turns = options.turns;
-            }
-            this._activeWs.send(JSON.stringify(msg));
-        }
-    }
-    setPrompt(prompt) {
-        if (this._activeWs) {
-            this._activeWs.send(JSON.stringify({ type: 'prompt_update', prompt }));
+            this._ws.send(JSON.stringify(msg));
         }
     }
     reset() {
-        if (this._activeWs) {
-            this._activeWs.close();
-            this._activeWs = null;
-        }
+        this._closeWs();
         this._currentSession = null;
         this._chatItems = [];
         this._status = 'idle';
         this._connectionState = 'disconnected';
-        this._shouldReconnect = false;
-        this._reconnectAttempts = 0;
-    }
-    resetConversation() {
-        this.reset();
+        this._error = null;
+        this._settleInput();
+        this._pendingRetry = null;
     }
-    async input(prompt, options) {
-        const timeoutMs = options?.timeoutMs ?? 600000;
-        const images = options?.images;
-        return this._streamInput(prompt, timeoutMs, images);
-    }
-    async inputAsync(prompt, options) {
-        return this.input(prompt, options);
-    }
-    respond(answer) {
-        if (!this._activeWs) {
-            throw new Error('No active connection to respond to');
-        }
-        const answerStr = Array.isArray(answer) ? answer.join(', ') : answer;
-        this._activeWs.send(JSON.stringify({
-            type: 'ASK_USER_RESPONSE',
-            answer: answerStr,
-        }));
-    }
-    respondToApproval(approved, scope = 'once', mode, feedback) {
-        if (!this._activeWs) {
-            throw new Error('No active connection to respond to');
-        }
-        this._activeWs.send(JSON.stringify({
-            type: 'APPROVAL_RESPONSE',
-            approved,
-            scope,
-            ...(mode && { mode }),
-            ...(feedback && { feedback }),
-        }));
-    }
-    submitOnboard(options) {
-        if (!this._activeWs) {
-            throw new Error('No active connection to submit onboard');
-        }
-        const payload = {
-            timestamp: Math.floor(Date.now() / 1000),
-        };
+    resetConversation() { this.reset(); }
+    signOnboard(options) {
+        const payload = { timestamp: Math.floor(Date.now() / 1000) };
         if (options.inviteCode)
             payload.invite_code = options.inviteCode;
         if (options.payment)
             payload.payment = options.payment;
-        const signed = this._signPayload(payload);
-        this._activeWs.send(JSON.stringify({
-            type: 'ONBOARD_SUBMIT',
-            ...signed,
-        }));
-    }
-    respondToPlanReview(message) {
-        if (!this._activeWs) {
-            throw new Error('No active connection to respond to');
-        }
-        this._activeWs.send(JSON.stringify({
-            type: 'PLAN_REVIEW_RESPONSE',
-            message,
-        }));
-    }
-    respondToUlwTurnsReached(action, options) {
-        if (!this._activeWs) {
-            throw new Error('No active connection to respond to ULW');
-        }
-        this._activeWs.send(JSON.stringify({
-            type: 'ULW_RESPONSE',
-            action,
-            ...(action === 'continue' && options?.turns && { turns: options.turns }),
-            ...(action === 'switch_mode' && options?.mode && { mode: options.mode }),
-        }));
-    }
-    // ==========================================================================
-    // Private Methods - Streaming
-    // ==========================================================================
-    _ensureKeys() {
-        if (this._keys)
-            return;
-        const isBrowser = (0, endpoint_1.isBrowserEnv)();
-        const existingKeys = isBrowser ? address.loadBrowser() : address.load();
-        if (existingKeys) {
-            this._keys = existingKeys;
-            return;
-        }
-        if (isBrowser) {
-            this._keys = address.generateBrowser();
-            address.saveBrowser(this._keys);
-        }
-        else {
-            this._keys = address.generate();
-        }
-    }
-    _deriveWsUrl() {
-        if (this._directUrl) {
-            const base = this._directUrl.replace(/^https?:\/\//, '');
-            const protocol = this._directUrl.startsWith('https') ? 'wss' : 'ws';
-            return { wsUrl: `${protocol}://${base}/ws`, isDirect: true };
-        }
-        if (this._resolvedEndpoint) {
-            return { wsUrl: this._resolvedEndpoint.wsUrl, isDirect: true };
+        return { type: 'ONBOARD_SUBMIT', ...(0, auth_1.signPayload)(this._keys, payload) };
+    }
+    async checkSessionStatus(sessionId) {
+        // If we have a live WS, send SESSION_STATUS over it (no new connection needed)
+        if (this._ws && this._authenticated) {
+            return new Promise((resolve) => {
+                const timeout = setTimeout(() => resolve('not_found'), 5000);
+                // Temporarily intercept the next SESSION_STATUS response
+                const origHandler = this._ws.onmessage;
+                this._ws.onmessage = (evt) => {
+                    const raw = typeof evt.data === 'string' ? evt.data : String(evt.data);
+                    const data = JSON.parse(raw);
+                    if (data?.type === 'SESSION_STATUS') {
+                        clearTimeout(timeout);
+                        this._ws.onmessage = origHandler;
+                        resolve(data.status || 'not_found');
+                    }
+                    else {
+                        // Not our response — pass to normal handler
+                        this._handleMessage(evt);
+                    }
+                };
+                this._ws.send(JSON.stringify({
+                    type: 'SESSION_STATUS',
+                    session: { session_id: sessionId },
+                }));
+            });
         }
-        return { wsUrl: `${this._relayUrl}/ws/input`, isDirect: false };
+        // No active connection — open a short-lived WS just for the check
+        this._keys = (0, auth_1.ensureKeys)(this._keys);
+        await this._resolveEndpointOnce();
+        const { wsUrl, isDirect } = this._resolveWsUrl();
+        return new Promise((resolve) => {
+            const ws = new this._WS(wsUrl);
+            const timeout = setTimeout(() => { ws.close(); resolve('not_found'); }, 5000);
+            ws.onopen = () => {
+                ws.send(JSON.stringify({
+                    type: 'SESSION_STATUS',
+                    session: { session_id: sessionId },
+                    ...(!isDirect && { to: this.address }),
+                }));
+            };
+            ws.onmessage = (evt) => {
+                const data = JSON.parse(typeof evt.data === 'string' ? evt.data : String(evt.data));
+                if (data?.type === 'SESSION_STATUS') {
+                    clearTimeout(timeout);
+                    ws.close();
+                    resolve(data.status || 'not_found');
+                }
+            };
+            ws.onerror = () => { clearTimeout(timeout); ws.close(); resolve('not_found'); };
+        });
     }
-    _startHealthCheck(ws, reject) {
-        this._stopHealthCheck();
-        this._healthCheckInterval = setInterval(() => {
-            const timeSinceLastPing = Date.now() - this._lastPingTime;
-            if (timeSinceLastPing > 60000) {
-                this._stopHealthCheck();
-                ws.close();
-                reject(new Error('Connection health check failed: No PING received for 60 seconds'));
-            }
-        }, 10000);
+    async checkSession(sessionId) {
+        const sid = sessionId || this._currentSession?.session_id;
+        if (!sid)
+            return 'not_found';
+        await this._resolveEndpointOnce();
+        const httpUrl = this._directUrl || this._resolvedEndpoint?.httpUrl;
+        if (!httpUrl)
+            return 'not_found';
+        const res = await fetch(`${httpUrl}/sessions/${sid}`).catch(() => null);
+        if (!res || !res.ok)
+            return 'not_found';
+        const data = await res.json().catch(() => null);
+        return data?.status === 'running' ? 'running' : 'done';
     }
-    _stopHealthCheck() {
-        if (this._healthCheckInterval) {
-            clearInterval(this._healthCheckInterval);
-            this._healthCheckInterval = null;
-        }
+    toString() {
+        const short = this.address.length > 12 ? this.address.slice(0, 12) + '...' : this.address;
+        return `RemoteAgent(${short})`;
     }
-    _attemptReconnect(resolve, reject) {
-        if (!this._currentSession?.session_id) {
-            reject(new Error('No session to reconnect'));
-            return;
-        }
-        if (this._reconnectAttempts >= this._maxReconnectAttempts) {
-            this._reconnectAttempts = 0;
-            this._shouldReconnect = false;
-            this._connectionState = 'disconnected';
-            reject(new Error('Max reconnection attempts reached'));
-            return;
-        }
-        this._connectionState = 'reconnecting';
-        this._reconnectAttempts++;
-        const delay = Math.min(this._reconnectBaseDelay * Math.pow(2, this._reconnectAttempts - 1), 30000);
-        console.log(`[ConnectOnion] Connection lost. Reconnecting in ${delay}ms (attempt ${this._reconnectAttempts}/${this._maxReconnectAttempts})...`);
-        setTimeout(() => {
-            this._reconnect(resolve, reject);
-        }, delay);
+    // --- Internal helpers (used by useAgentForHuman) ---
+    _addChatItem(event) {
+        const id = event.id || (0, endpoint_1.generateUUID)();
+        this._chatItems.push({ ...event, id });
     }
-    _reconnect(resolve, reject) {
-        const sessionId = this._currentSession?.session_id;
-        if (!sessionId) {
-            reject(new Error('No session to reconnect'));
-            return;
-        }
-        const { wsUrl, isDirect } = this._deriveWsUrl();
-        const ws = new this._WS(wsUrl);
-        this._activeWs = ws;
-        this._status = 'working';
-        const state = {
-            settled: false,
-            timer: setTimeout(() => {
-                if (!state.settled) {
-                    state.settled = true;
-                    this._status = 'idle';
-                    ws.close();
-                    this._attemptReconnect(resolve, reject);
-                }
-            }, 600000),
-        };
-        ws.onopen = () => {
-            console.log('[ConnectOnion] Reconnected successfully');
-            this._connectionState = 'connected';
-            this._reconnectAttempts = 0;
-            this._lastPingTime = Date.now();
-            this._startHealthCheck(ws, reject);
-            // Send full session for server-side merge (iteration count comparison)
-            const payload = {
-                prompt: '',
-                timestamp: Math.floor(Date.now() / 1000),
-            };
-            if (!isDirect)
-                payload.to = this.address;
-            const signed = this._signPayload(payload);
-            ws.send(JSON.stringify({
-                type: 'INPUT',
-                input_id: (0, endpoint_1.generateUUID)(),
-                prompt: '',
-                ...signed,
-                ...(!isDirect && { to: this.address }),
-                session: { ...this._currentSession, session_id: sessionId },
-            }));
-        };
-        this._attachMessageHandlers(ws, (0, endpoint_1.generateUUID)(), isDirect, state, resolve, reject);
+    _clearPlaceholder() {
+        const idx = this._chatItems.findIndex(item => item.id === '__optimistic__');
+        if (idx !== -1)
+            this._chatItems.splice(idx, 1);
     }
-    async _tryResolveEndpoint() {
-        if (this._endpointResolutionAttempted || this._directUrl)
+    // --- Private: connection lifecycle ---
+    async _ensureConnected() {
+        if (this._ws && this._authenticated)
             return;
-        this._endpointResolutionAttempted = true;
-        if (!this.address.startsWith('0x') || this.address.length !== 66)
-            return;
-        const resolved = await (0, endpoint_1.resolveEndpoint)(this.address, this._relayUrl);
-        if (resolved) {
-            this._resolvedEndpoint = resolved;
-        }
-    }
-    async _streamInput(prompt, timeoutMs, images) {
-        this._ensureKeys();
-        await this._tryResolveEndpoint();
-        this._addChatItem({ type: 'user', content: prompt, images });
-        this._addChatItem({ type: 'thinking', id: '__optimistic__', status: 'running' });
-        this._status = 'working';
-        const inputId = (0, endpoint_1.generateUUID)();
-        const sessionId = this._currentSession?.session_id || (0, endpoint_1.generateUUID)();
-        const { wsUrl, isDirect } = this._deriveWsUrl();
+        this._keys = (0, auth_1.ensureKeys)(this._keys);
+        await this._resolveEndpointOnce();
+        const { wsUrl, isDirect } = this._resolveWsUrl();
         const ws = new this._WS(wsUrl);
-        this._activeWs = ws;
-        this._shouldReconnect = true;
-        return new Promise((resolve, reject) => {
-            const state = {
-                settled: false,
-                timer: setTimeout(() => {
-                    if (!state.settled) {
-                        state.settled = true;
-                        this._status = 'idle';
-                        this._shouldReconnect = false;
-                        this._connectionState = 'disconnected';
-                        ws.close();
-                        reject(new Error('Connection timed out'));
-                    }
-                }, timeoutMs),
-            };
+        this._ws = ws;
+        // Wait for open
+        await new Promise((resolve, reject) => {
             ws.onopen = () => {
                 this._connectionState = 'connected';
                 this._lastPingTime = Date.now();
-                this._startHealthCheck(ws, reject);
-                const payload = {
-                    prompt,
-                    timestamp: Math.floor(Date.now() / 1000),
-                };
-                if (!isDirect) {
-                    payload.to = this.address;
-                }
-                const signed = this._signPayload(payload);
-                const inputMessage = {
-                    type: 'INPUT',
-                    input_id: inputId,
-                    prompt,
-                    ...signed,
-                };
-                if (images && images.length > 0) {
-                    inputMessage.images = images;
-                }
-                if (!isDirect) {
-                    inputMessage.to = this.address;
-                }
-                if (this._currentSession) {
-                    inputMessage.session = { ...this._currentSession, session_id: sessionId };
-                }
-                else {
-                    inputMessage.session = { session_id: sessionId };
-                }
-                ws.send(JSON.stringify(inputMessage));
+                this._startPingMonitor();
+                resolve();
             };
-            this._attachMessageHandlers(ws, inputId, isDirect, state, resolve, reject);
+            ws.onerror = (err) => reject(new Error(`WebSocket connection failed: ${String(err)}`));
         });
-    }
-    /**
-     * Attach onmessage/onerror/onclose to a WebSocket.
-     * Shared by _streamInput (initial connection) and _reconnect.
-     */
-    _attachMessageHandlers(ws, inputId, isDirect, state, resolve, reject) {
-        ws.onmessage = (evt) => {
-            if (state.settled)
-                return;
-            const raw = typeof evt.data === 'string' ? evt.data : String(evt.data);
-            const data = JSON.parse(raw);
-            if (data?.type === 'PING') {
-                this._lastPingTime = Date.now();
-                ws.send(JSON.stringify({ type: 'PONG' }));
-                return;
-            }
-            if (data?.type === 'session_sync' && data.session) {
-                this._currentSession = data.session;
-            }
-            if (data?.type === 'RECONNECTED') {
-                console.log('[RemoteAgent] Reconnected to session:', data.session_id);
-            }
-            if (data?.type === 'SESSION_MERGED' && data.server_newer) {
-                console.log('[RemoteAgent] Server had newer session, merged');
-            }
-            if (data?.type === 'mode_changed' && data.mode) {
-                if (!this._currentSession) {
-                    this._currentSession = { mode: data.mode };
-                }
-                else {
-                    this._currentSession.mode = data.mode;
-                }
-            }
-            if (data?.type === 'ulw_turns_reached') {
-                this._status = 'waiting';
-                if (this._currentSession) {
-                    this._currentSession.ulw_turns_used = data.turns_used;
-                }
-                this._addChatItem({
-                    type: 'ulw_turns_reached',
-                    turns_used: data.turns_used,
-                    max_turns: data.max_turns,
-                });
-            }
-            if (data?.type === 'llm_call' || data?.type === 'llm_result' ||
-                data?.type === 'tool_call' || data?.type === 'tool_result' ||
-                data?.type === 'thinking' || data?.type === 'assistant' ||
-                data?.type === 'intent' || data?.type === 'eval' || data?.type === 'compact' ||
-                data?.type === 'tool_blocked') {
-                this._handleStreamEvent(data);
-                if (data.session) {
-                    this._currentSession = data.session;
+        // Wire up persistent message handler
+        ws.onmessage = (evt) => this._handleMessage(evt);
+        ws.onerror = () => this._handleConnectionLoss();
+        ws.onclose = () => this._handleConnectionLoss();
+        // Send CONNECT with session (conversation history)
+        const payload = { timestamp: Math.floor(Date.now() / 1000) };
+        payload.to = this.address;
+        const signed = (0, auth_1.signPayload)(this._keys, payload);
+        const connectMsg = { type: 'CONNECT', ...signed };
+        if (!isDirect)
+            connectMsg.to = this.address;
+        if (this._currentSession?.session_id)
+            connectMsg.session_id = this._currentSession.session_id;
+        if (this._currentSession)
+            connectMsg.session = { ...this._currentSession };
+        ws.send(JSON.stringify(connectMsg));
+        // Wait for CONNECTED response
+        const connected = await new Promise((resolve, reject) => {
+            this._connectResolve = resolve;
+            this._connectReject = reject;
+            setTimeout(() => {
+                if (this._connectResolve) {
+                    this._connectResolve = null;
+                    this._connectReject = null;
+                    reject(new Error('Authentication timed out'));
                 }
+            }, 30000);
+        });
+        this._authenticated = true;
+        // Update session from server (may include merged data)
+        const sid = connected.session_id;
+        if (sid) {
+            if (!this._currentSession) {
+                this._currentSession = { session_id: sid };
             }
-            if (data?.type === 'ask_user') {
-                this._status = 'waiting';
-                this._addChatItem({ type: 'ask_user', text: data.text || '', options: data.options || [], multi_select: data.multi_select || false });
+            else {
+                this._currentSession.session_id = sid;
             }
-            if (data?.type === 'approval_needed') {
-                this._status = 'waiting';
-                this._addChatItem({
-                    type: 'approval_needed',
-                    tool: data.tool,
-                    arguments: data.arguments,
-                    ...(data.description && { description: data.description }),
-                    ...(data.batch_remaining && { batch_remaining: data.batch_remaining }),
-                });
+        }
+        if (connected.server_newer && connected.session) {
+            this._currentSession = connected.session;
+        }
+        if (connected.server_newer && connected.chat_items && Array.isArray(connected.chat_items)) {
+            const userItems = this._chatItems.filter(item => item.type === 'user');
+            const serverNonUserItems = connected.chat_items.filter(item => item.type !== 'user');
+            this._chatItems = [...userItems, ...serverNonUserItems];
+            this._onMessage?.();
+        }
+    }
+    _handleMessage(evt) {
+        const raw = typeof evt.data === 'string' ? evt.data : String(evt.data);
+        const data = JSON.parse(raw);
+        // PING/PONG keepalive
+        if (data?.type === 'PING') {
+            this._lastPingTime = Date.now();
+            this._ws?.send(JSON.stringify({ type: 'PONG' }));
+            return;
+        }
+        // CONNECTED — resolve ensureConnected() promise
+        if (data?.type === 'CONNECTED') {
+            if (this._connectResolve) {
+                const resolve = this._connectResolve;
+                this._connectResolve = null;
+                this._connectReject = null;
+                resolve(data);
+                this._onMessage?.();
+                return;
             }
-            if (data?.type === 'plan_review') {
-                this._status = 'waiting';
-                this._addChatItem({
-                    type: 'plan_review',
-                    plan_content: data.plan_content,
-                });
+            // CONNECTED during reconnect — update session and UI if server has newer data
+            if (data.server_newer && data.session) {
+                this._currentSession = data.session;
             }
-            if (data?.type === 'ONBOARD_REQUIRED') {
-                this._status = 'waiting';
-                this._pendingPrompt = data.prompt || '';
-                this._pendingInputId = inputId;
-                this._pendingSessionId = this._currentSession?.session_id || null;
-                this._addChatItem({
-                    type: 'onboard_required',
-                    methods: (data.methods || []),
-                    paymentAmount: data.payment_amount,
-                });
+            if (data.server_newer && data.chat_items && Array.isArray(data.chat_items)) {
+                // Server has newer chat items (e.g., agent finished while client was away)
+                // Keep user items from client, take everything else from server
+                const userItems = this._chatItems.filter(item => item.type === 'user');
+                const serverNonUserItems = data.chat_items.filter(item => item.type !== 'user');
+                this._chatItems = [...userItems, ...serverNonUserItems];
             }
-            if (data?.type === 'ONBOARD_SUCCESS') {
-                this._addChatItem({
-                    type: 'onboard_success',
-                    level: data.level,
-                    message: data.message,
-                });
-                if (this._pendingPrompt && this._activeWs) {
-                    this._status = 'working';
-                    const retryPrompt = this._pendingPrompt;
-                    const retryInputId = this._pendingInputId || (0, endpoint_1.generateUUID)();
-                    this._pendingPrompt = null;
-                    this._pendingInputId = null;
-                    const retryPayload = {
-                        prompt: retryPrompt,
-                        timestamp: Math.floor(Date.now() / 1000),
-                    };
-                    if (!isDirect)
-                        retryPayload.to = this.address;
-                    const retrySigned = this._signPayload(retryPayload);
-                    const retryMessage = {
-                        type: 'INPUT',
-                        input_id: retryInputId,
-                        prompt: retryPrompt,
-                        ...retrySigned,
-                    };
-                    if (!isDirect)
-                        retryMessage.to = this.address;
-                    if (this._currentSession) {
-                        retryMessage.session = { ...this._currentSession, session_id: this._pendingSessionId };
-                    }
-                    else {
-                        retryMessage.session = { session_id: this._pendingSessionId };
-                    }
-                    this._activeWs.send(JSON.stringify(retryMessage));
-                    this._pendingSessionId = null;
-                }
+            const reconnectSid = data.session_id;
+            if (reconnectSid && this._currentSession) {
+                this._currentSession.session_id = reconnectSid;
             }
-            const isOutputForUs = isDirect
-                ? data?.type === 'OUTPUT'
-                : data?.type === 'OUTPUT' && data?.input_id === inputId;
-            if (isOutputForUs) {
-                state.settled = true;
-                clearTimeout(state.timer);
-                this._stopHealthCheck();
-                this._removeOptimisticThinking();
+            this._authenticated = true;
+            // If status is "connected" (idle), resolve immediately — session is alive, no events to wait for
+            if (data.status === 'connected' || data.status === 'new') {
                 this._status = 'idle';
-                this._shouldReconnect = false;
-                this._connectionState = 'disconnected';
-                this._reconnectAttempts = 0;
-                if (data.session) {
-                    this._currentSession = data.session;
-                }
-                if (data.chat_items && Array.isArray(data.chat_items)) {
-                    const userItems = this._chatItems.filter(item => item.type === 'user');
-                    const serverNonUserItems = data.chat_items.filter(item => item.type !== 'user');
-                    this._chatItems = [...userItems, ...serverNonUserItems];
-                }
-                if (data.server_newer) {
-                    console.log('[RemoteAgent] Session was merged with newer server state');
-                }
-                const result = data.result || '';
-                if (result) {
-                    const lastAgent = this._chatItems.filter((e) => e.type === 'agent').pop();
-                    if (!lastAgent || lastAgent.content !== result) {
-                        this._addChatItem({ type: 'agent', content: result });
-                    }
-                }
-                this._activeWs = null;
-                ws.close();
-                resolve({ text: result, done: true });
-            }
-            if (data?.type === 'ERROR') {
-                state.settled = true;
-                clearTimeout(state.timer);
-                this._stopHealthCheck();
-                this._status = 'idle';
-                this._shouldReconnect = false;
-                this._connectionState = 'disconnected';
-                this._activeWs = null;
-                ws.close();
-                reject(new Error(`Agent error: ${String(data.message || data.error || 'Unknown error')}`));
-            }
-        };
-        ws.onerror = async (err) => {
-            if (state.settled)
-                return;
-            this._stopHealthCheck();
-            clearTimeout(state.timer);
-            ws.close();
-            if (isDirect && !this._directUrl) {
-                this._resolvedEndpoint = undefined;
-                this._endpointResolutionAttempted = false;
+                const resolve = this._inputResolve;
+                this._settleInput();
+                resolve?.({ text: '', done: true });
             }
-            if (this._shouldReconnect && this._reconnectAttempts < this._maxReconnectAttempts) {
-                this._attemptReconnect(resolve, reject);
+            // If status is "executing", events will stream in via _handleMessage — don't resolve yet
+            this._onMessage?.();
+            return;
+        }
+        // Session sync
+        if (data?.type === 'session_sync' && data.session) {
+            this._currentSession = data.session;
+        }
+        if (data?.type === 'RECONNECTED') {
+            // Server confirmed reconnect — events will follow
+        }
+        if (data?.type === 'SESSION_MERGED' && data.server_newer) {
+            // Server had newer session
+        }
+        if (data?.type === 'mode_changed' && data.mode) {
+            if (!this._currentSession) {
+                this._currentSession = { mode: data.mode };
             }
             else {
-                state.settled = true;
-                this._status = 'idle';
-                this._shouldReconnect = false;
-                this._connectionState = 'disconnected';
-                reject(new Error(`WebSocket error: ${String(err)}`));
+                this._currentSession.mode = data.mode;
             }
-        };
-        ws.onclose = async () => {
-            this._activeWs = null;
-            this._stopHealthCheck();
-            if (!state.settled) {
-                clearTimeout(state.timer);
-                if (isDirect && !this._directUrl) {
-                    this._resolvedEndpoint = undefined;
-                    this._endpointResolutionAttempted = false;
-                }
-                if (this._shouldReconnect && this._reconnectAttempts < this._maxReconnectAttempts) {
-                    this._attemptReconnect(resolve, reject);
-                }
-                else {
-                    state.settled = true;
-                    this._status = 'idle';
-                    this._shouldReconnect = false;
-                    this._connectionState = 'disconnected';
-                    reject(new Error('Connection closed before response'));
-                }
-            }
-        };
-    }
-    // ==========================================================================
-    // Private Methods - UI Helpers
-    // ==========================================================================
-    _removeOptimisticThinking() {
-        const idx = this._chatItems.findIndex(item => item.id === '__optimistic__');
-        if (idx !== -1) {
-            this._chatItems.splice(idx, 1);
         }
-    }
-    _handleStreamEvent(event) {
-        const eventType = event.type;
-        this._removeOptimisticThinking();
-        switch (eventType) {
-            case 'tool_call': {
-                const toolId = (event.tool_id || event.id);
-                this._addChatItem({
-                    type: 'tool_call',
-                    id: toolId,
-                    name: event.name,
-                    args: event.args,
-                    status: 'running',
-                });
-                break;
-            }
-            case 'tool_result': {
-                const toolId = (event.tool_id || event.id);
-                const existing = this._chatItems.find((e) => e.type === 'tool_call' && e.id === toolId);
-                if (existing) {
-                    existing.status = event.status === 'error' ? 'error' : 'done';
-                    existing.result = event.result;
-                    if (typeof event.timing_ms === 'number') {
-                        existing.timing_ms = event.timing_ms;
-                    }
-                }
-                break;
-            }
-            case 'llm_call': {
-                const llmId = event.id;
-                this._addChatItem({
-                    type: 'thinking',
-                    id: llmId,
-                    status: 'running',
-                    model: event.model,
-                });
-                break;
-            }
-            case 'llm_result': {
-                const llmId = event.id;
-                const existingThinking = this._chatItems.find((e) => e.type === 'thinking' && e.id === llmId);
-                if (existingThinking) {
-                    existingThinking.status = event.status === 'error' ? 'error' : 'done';
-                    if (typeof event.duration_ms === 'number') {
-                        existingThinking.duration_ms = event.duration_ms;
-                    }
-                    if (event.model) {
-                        existingThinking.model = event.model;
-                    }
-                    if (event.usage) {
-                        existingThinking.usage = event.usage;
-                    }
-                    if (typeof event.context_percent === 'number') {
-                        existingThinking.context_percent = event.context_percent;
-                    }
-                }
-                break;
-            }
-            case 'thinking': {
-                this._addChatItem({
-                    type: 'thinking',
-                    id: event.id != null ? String(event.id) : undefined,
-                    status: 'done',
-                    content: event.content,
-                    kind: event.kind,
-                });
-                break;
+        // ULW turns reached
+        if (data?.type === 'ulw_turns_reached') {
+            this._status = 'waiting';
+            if (this._currentSession) {
+                this._currentSession.ulw_turns_used = data.turns_used;
             }
-            case 'assistant': {
-                if (event.content) {
-                    this._addChatItem({
-                        type: 'agent',
-                        id: event.id != null ? String(event.id) : undefined,
-                        content: event.content,
-                    });
-                }
-                break;
+            this._addChatItem({
+                type: 'ulw_turns_reached',
+                turns_used: data.turns_used,
+                max_turns: data.max_turns,
+            });
+        }
+        // Stream events → ChatItem mapping
+        if (data?.type === 'llm_call' || data?.type === 'llm_result' ||
+            data?.type === 'tool_call' || data?.type === 'tool_result' ||
+            data?.type === 'thinking' || data?.type === 'assistant' ||
+            data?.type === 'intent' || data?.type === 'eval' || data?.type === 'compact' ||
+            data?.type === 'tool_blocked') {
+            this._clearPlaceholder();
+            (0, chat_item_mapper_1.mapEventToChatItem)(this._chatItems, data, (item) => this._addChatItem(item));
+            if (data.session) {
+                this._currentSession = data.session;
             }
-            case 'agent_image': {
-                const imageData = event.image;
-                if (imageData) {
-                    const lastAgent = this._chatItems.filter((e) => e.type === 'agent').pop();
-                    if (lastAgent) {
-                        if (!lastAgent.images) {
-                            lastAgent.images = [];
-                        }
-                        lastAgent.images.push(imageData);
-                    }
-                    else {
-                        this._addChatItem({
-                            type: 'agent',
-                            id: event.id != null ? String(event.id) : undefined,
-                            content: '',
-                            images: [imageData],
-                        });
-                    }
-                }
-                break;
+        }
+        // Interactive events
+        if (data?.type === 'ask_user') {
+            this._status = 'waiting';
+            this._addChatItem({ type: 'ask_user', text: data.text || '', options: data.options || [], multi_select: data.multi_select || false });
+        }
+        if (data?.type === 'approval_needed') {
+            this._status = 'waiting';
+            this._addChatItem({
+                type: 'approval_needed',
+                tool: data.tool,
+                arguments: data.arguments,
+                ...(data.description && { description: data.description }),
+                ...(data.batch_remaining && { batch_remaining: data.batch_remaining }),
+            });
+        }
+        if (data?.type === 'plan_review') {
+            this._status = 'waiting';
+            this._addChatItem({ type: 'plan_review', plan_content: data.plan_content });
+        }
+        // Onboard flow
+        if (data?.type === 'ONBOARD_REQUIRED') {
+            this._status = 'waiting';
+            this._pendingRetry = { prompt: data.prompt || '', inputId: (0, endpoint_1.generateUUID)() };
+            this._addChatItem({
+                type: 'onboard_required',
+                methods: (data.methods || []),
+                paymentAmount: data.payment_amount,
+            });
+        }
+        if (data?.type === 'ONBOARD_SUCCESS') {
+            this._addChatItem({
+                type: 'onboard_success',
+                level: data.level,
+                message: data.message,
+            });
+            if (this._pendingRetry && this._ws) {
+                this._status = 'working';
+                const retry = this._pendingRetry;
+                this._pendingRetry = null;
+                const isDirect = this._isDirect();
+                const msg = { type: 'INPUT', input_id: retry.inputId, prompt: retry.prompt };
+                if (!isDirect)
+                    msg.to = this.address;
+                this._ws.send(JSON.stringify(msg));
             }
-            case 'intent': {
-                const intentId = event.id;
-                const status = event.status;
-                if (status === 'analyzing') {
-                    this._addChatItem({
-                        type: 'intent',
-                        id: intentId,
-                        status: 'analyzing',
-                    });
-                }
-                else if (status === 'understood') {
-                    const existing = this._chatItems.find((e) => e.type === 'intent' && e.id === intentId);
-                    if (existing) {
-                        existing.status = 'understood';
-                        existing.ack = event.ack;
-                        existing.is_build = event.is_build;
-                    }
-                }
-                break;
+        }
+        // OUTPUT — resolve input() promise
+        if (data?.type === 'OUTPUT') {
+            this._clearPlaceholder();
+            this._status = 'idle';
+            if (data.session) {
+                this._currentSession = data.session;
             }
-            case 'eval': {
-                const evalId = event.id;
-                const status = event.status;
-                if (status === 'evaluating') {
-                    this._addChatItem({
-                        type: 'eval',
-                        id: evalId,
-                        status: 'evaluating',
-                        expected: event.expected,
-                        eval_path: event.eval_path,
-                    });
-                }
-                else if (status === 'done') {
-                    const existing = this._chatItems.find((e) => e.type === 'eval' && e.id === evalId);
-                    if (existing) {
-                        existing.status = 'done';
-                        existing.passed = event.passed;
-                        existing.summary = event.summary;
-                        existing.expected = event.expected;
-                        existing.eval_path = event.eval_path;
-                    }
-                }
-                break;
+            if (data.server_newer && data.chat_items && Array.isArray(data.chat_items)) {
+                const userItems = this._chatItems.filter(item => item.type === 'user');
+                const serverNonUserItems = data.chat_items.filter(item => item.type !== 'user');
+                this._chatItems = [...userItems, ...serverNonUserItems];
             }
-            case 'compact': {
-                const compactId = event.id;
-                const status = event.status;
-                if (status === 'compacting') {
-                    this._addChatItem({
-                        type: 'compact',
-                        id: compactId,
-                        status: 'compacting',
-                        context_percent: event.context_percent,
-                    });
-                }
-                else {
-                    const existing = this._chatItems.find((e) => e.type === 'compact' && e.id === compactId);
-                    if (existing) {
-                        existing.status = status;
-                        existing.context_before = event.context_before;
-                        existing.context_after = event.context_after;
-                        existing.message = event.message;
-                        existing.error = event.error;
-                    }
+            const result = data.result || '';
+            if (result) {
+                const lastAgent = this._chatItems.filter((e) => e.type === 'agent').pop();
+                if (!lastAgent || lastAgent.content !== result) {
+                    this._addChatItem({ type: 'agent', content: result });
                 }
-                break;
             }
-            case 'tool_blocked': {
-                this._addChatItem({
-                    type: 'tool_blocked',
-                    tool: event.tool,
-                    reason: event.reason,
-                    message: event.message,
-                    command: event.command,
-                });
-                break;
+            // Don't close WS — keep it for next input()
+            const resolve = this._inputResolve;
+            this._settleInput();
+            resolve?.({ text: result, done: true });
+        }
+        // ERROR — reject input() promise
+        if (data?.type === 'ERROR') {
+            this._status = 'idle';
+            this._connectionState = 'disconnected';
+            this._closeWs();
+            const reject = this._inputReject;
+            this._settleInput();
+            reject?.(new Error(`Agent error: ${String(data.message || data.error || 'Unknown error')}`));
+        }
+        this._onMessage?.();
+    }
+    _handleConnectionLoss() {
+        this._ws = null;
+        this._authenticated = false;
+        this._stopPingMonitor();
+        // Reject pending connect
+        if (this._connectReject) {
+            const reject = this._connectReject;
+            this._connectResolve = null;
+            this._connectReject = null;
+            reject(new Error('Connection lost during authentication'));
+            return;
+        }
+        // Reject pending input only if there is one
+        if (this._inputReject) {
+            this._status = 'idle';
+            this._connectionState = 'disconnected';
+            const reject = this._inputReject;
+            this._settleInput();
+            reject(new Error('Connection closed before response'));
+            this._onMessage?.();
+        }
+    }
+    _settleInput() {
+        if (this._inputTimer) {
+            clearTimeout(this._inputTimer);
+            this._inputTimer = null;
+        }
+        this._inputResolve = null;
+        this._inputReject = null;
+    }
+    _closeWs() {
+        this._stopPingMonitor();
+        if (this._ws) {
+            // Prevent close handler from firing during intentional close
+            this._ws.onerror = null;
+            this._ws.onclose = null;
+            this._ws.onmessage = null;
+            this._ws.close();
+            this._ws = null;
+        }
+        this._authenticated = false;
+        this._connectionState = 'disconnected';
+    }
+    _startPingMonitor() {
+        this._stopPingMonitor();
+        this._pingTimer = setInterval(() => {
+            if (Date.now() - this._lastPingTime > 60000) {
+                this._stopPingMonitor();
+                this._ws?.close();
             }
+        }, 10000);
+    }
+    _stopPingMonitor() {
+        if (this._pingTimer) {
+            clearInterval(this._pingTimer);
+            this._pingTimer = null;
         }
     }
-    _addChatItem(event) {
-        const id = event.id || (0, endpoint_1.generateUUID)();
-        this._chatItems.push({ ...event, id });
+    _isDirect() {
+        return !!this._directUrl || !!this._resolvedEndpoint;
     }
-    // ==========================================================================
-    // Private Methods - Signing
-    // ==========================================================================
-    _signPayload(payload) {
-        if (!this._keys) {
-            return { prompt: payload.prompt };
+    _resolveWsUrl() {
+        if (this._directUrl) {
+            const base = this._directUrl.replace(/^https?:\/\//, '');
+            const protocol = this._directUrl.startsWith('https') ? 'wss' : 'ws';
+            return { wsUrl: `${protocol}://${base}/ws`, isDirect: true };
         }
-        const canonicalMessage = (0, endpoint_1.canonicalJSON)(payload);
-        const signer = (0, endpoint_1.isBrowserEnv)() ? address.signBrowser : address.sign;
-        const signature = signer(this._keys, canonicalMessage);
-        return {
-            payload,
-            from: this._keys.address,
-            signature,
-            timestamp: payload.timestamp,
-        };
+        if (this._resolvedEndpoint)
+            return { wsUrl: this._resolvedEndpoint.wsUrl, isDirect: true };
+        return { wsUrl: `${this._relayUrl}/ws/input`, isDirect: false };
     }
-    toString() {
-        const short = this.address.length > 12 ? this.address.slice(0, 12) + '...' : this.address;
-        return `RemoteAgent(${short})`;
+    async _resolveEndpointOnce() {
+        if (this._endpointResolutionAttempted || this._directUrl)
+            return;
+        this._endpointResolutionAttempted = true;
+        if (!this.address.startsWith('0x') || this.address.length !== 66)
+            return;
+        const resolved = await (0, endpoint_1.resolveEndpoint)(this.address, this._relayUrl);
+        if (resolved)
+            this._resolvedEndpoint = resolved;
     }
 }
 exports.RemoteAgent = RemoteAgent;