connectonion 0.0.20 → 0.1.0

package/dist/connect/remote-agent.d.ts

@@ -1,12 +1,12 @@
 /**
  * @llm-note
- *   Dependencies: imports from [src/connect/types, src/connect/endpoint, src/connect/auth, src/connect/handlers, src/address]
- *   Data flow: input() → _connectAndSend() → creates WS + Promise → attachWsHandlers() dispatches events → resolve on OUTPUT
- *   State/Effects: owns WebSocket lifecycle + mutable _chatItems + _currentSession
+ *   Dependencies: imports from [src/connect/types, src/connect/endpoint, src/connect/auth, src/connect/chat-item-mapper, src/address]
+ *   Data flow: ensureConnected() opens persistent WS + INIT auth → input() sends INPUT on existing WS → handleMessage() dispatches events → resolves on OUTPUT
+ *   State/Effects: owns persistent WebSocket + mutable _chatItems + _currentSession
  *   Integration: public API consumed by connect() factory and React useAgentForHuman hook
  */
 import * as address from '../address';
-import { AgentStatus, ApprovalMode, ChatItem, ChatItemType, ConnectionState, ConnectOptions, ResolvedEndpoint, Response, SessionState, WebSocketCtor, WebSocketLike } from './types';
+import { AgentStatus, ApprovalMode, ChatItem, ChatItemType, ConnectionState, ConnectOptions, ResolvedEndpoint, Response, SessionState, WebSocketCtor } from './types';
 export declare class RemoteAgent {
     readonly address: string;
     _keys?: address.AddressData;
@@ -19,16 +19,19 @@ export declare class RemoteAgent {
     _connectionState: ConnectionState;
     _currentSession: SessionState | null;
     _chatItems: ChatItem[];
-    _activeWs: WebSocketLike | null;
-    _pendingPrompt: string | null;
-    _pendingInputId: string | null;
-    _pendingSessionId: string | null;
-    _lastPingTime: number;
-    _healthCheckInterval: ReturnType<typeof setInterval> | null;
-    _reconnectAttempts: number;
-    _maxReconnectAttempts: number;
-    _reconnectBaseDelay: number;
-    _shouldReconnect: boolean;
+    _error: Error | null;
+    private _ws;
+    private _authenticated;
+    private _inputResolve;
+    private _inputReject;
+    private _inputTimer;
+    private _pendingRetry;
+    private _lastPingTime;
+    private _pingTimer;
+    private _connectResolve;
+    private _connectReject;
+    _onMessage: (() => void) | null;
+    set onMessage(fn: (() => void) | null);
     constructor(agentAddress: string, options?: ConnectOptions);
     get agentAddress(): string;
     get status(): AgentStatus;
@@ -37,43 +40,37 @@ export declare class RemoteAgent {
     get ui(): ChatItem[];
     get mode(): ApprovalMode;
     get error(): Error | null;
-    _error: Error | null;
-    _onMessage: (() => void) | null;
-    set onMessage(fn: (() => void) | null);
     input(prompt: string, options?: {
         images?: string[];
         timeoutMs?: number;
     }): Promise<Response>;
-    /** Reconnect to an existing session to receive pending output without adding duplicate UI items */
     reconnect(sessionId?: string): Promise<Response>;
-    inputAsync(prompt: string, options?: {
-        images?: string[];
-        timeoutMs?: number;
-    }): Promise<Response>;
+    send(message: Record<string, unknown>): void;
     setMode(mode: ApprovalMode, options?: {
         turns?: number;
     }): void;
     reset(): void;
     resetConversation(): void;
-    send(message: Record<string, unknown>): void;
     signOnboard(options: {
         inviteCode?: string;
         payment?: number;
     }): Record<string, unknown>;
+    checkSessionStatus(sessionId: string): Promise<'executing' | 'suspended' | 'connected' | 'not_found'>;
     checkSession(sessionId?: string): Promise<'running' | 'done' | 'not_found'>;
-    checkSessionStatus(sessionId: string): Promise<'running' | 'suspended' | 'completed' | 'not_found'>;
+    toString(): string;
     _addChatItem(event: Partial<ChatItem> & {
         type: ChatItemType;
     }): void;
     _clearPlaceholder(): void;
-    _stopPingMonitor(): void;
-    _attemptReconnect(resolve: (value: Response) => void, reject: (reason?: any) => void): void;
-    _sendInput(ws: WebSocketLike, inputId: string, prompt: string, sessionId: string, isDirect: boolean, images?: string[]): void;
+    private _ensureConnected;
+    private _handleMessage;
+    private _handleConnectionLoss;
+    private _settleInput;
+    private _closeWs;
     private _startPingMonitor;
+    private _stopPingMonitor;
+    private _isDirect;
     private _resolveWsUrl;
     private _resolveEndpointOnce;
-    private _connectAndSend;
-    private _reconnect;
-    toString(): string;
 }
 //# sourceMappingURL=remote-agent.d.ts.map

package/dist/connect/remote-agent.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"remote-agent.d.ts","sourceRoot":"","sources":["../../src/connect/remote-agent.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"remote-agent.d.ts","sourceRoot":"","sources":["../../src/connect/remote-agent.ts"],"names":[],"mappings":"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"}

package/dist/connect/remote-agent.js

@@ -3,25 +3,32 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.RemoteAgent = void 0;
 const endpoint_1 = require("./endpoint");
 const auth_1 = require("./auth");
-const ws_handlers_1 = require("./ws-handlers");
+const chat_item_mapper_1 = require("./chat-item-mapper");
 class RemoteAgent {
+    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._lastPingTime = 0;
-        this._healthCheckInterval = null;
-        this._reconnectAttempts = 0;
-        this._maxReconnectAttempts = 3;
-        this._reconnectBaseDelay = 1000;
-        this._shouldReconnect = false;
         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._pingTimer = null;
+        // Callback + promise for ensureConnected
+        this._connectResolve = null;
+        this._connectReject = null;
         this._onMessage = null;
         this.address = agentAddress;
         this._relayUrl = (0, endpoint_1.normalizeRelayUrl)(options.relayUrl || 'wss://oo.openonion.ai');
@@ -30,6 +37,7 @@ class RemoteAgent {
         if (options.keys)
             this._keys = options.keys;
     }
+    // --- Public getters ---
     get agentAddress() { return this.address; }
     get status() { return this._status; }
     get connectionState() { return this._connectionState; }
@@ -37,52 +45,84 @@ class RemoteAgent {
     get ui() { return this._chatItems; }
     get mode() { return this._currentSession?.mode || 'safe'; }
     get error() { return this._error || null; }
-    set onMessage(fn) { this._onMessage = fn; }
     // --- Public API ---
     async input(prompt, options) {
-        return this._connectAndSend(prompt, options?.timeoutMs ?? 600000, options?.images);
+        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);
+        });
     }
-    /** Reconnect to an existing session to receive pending output without adding duplicate UI items */
     async reconnect(sessionId) {
         const sid = sessionId || this._currentSession?.session_id;
         if (!sid)
             throw new Error('No session to reconnect');
-        this._keys = (0, auth_1.ensureKeys)(this._keys);
-        await this._resolveEndpointOnce();
         if (!this._currentSession)
             this._currentSession = { session_id: sid };
         this._status = 'working';
-        const inputId = (0, endpoint_1.generateUUID)();
+        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._activeWs = ws;
-        this._shouldReconnect = true;
+        this._ws = ws;
+        this._connectionState = 'reconnecting';
+        this._onMessage?.();
         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('Reconnect timed out'));
-                    }
-                }, 60000),
-            };
+            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(ws, reject);
-                // Send INPUT with existing session to trigger server reconnect path
-                this._sendInput(ws, inputId, this._pendingPrompt || '', sid, isDirect);
+                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));
             };
-            (0, ws_handlers_1.attachWsHandlers)(this, ws, inputId, isDirect, state, resolve, reject);
+            ws.onmessage = (evt) => this._handleMessage(evt);
+            ws.onerror = () => this._handleConnectionLoss();
+            ws.onclose = () => this._handleConnectionLoss();
         });
     }
-    async inputAsync(prompt, options) {
-        return this.input(prompt, options);
+    send(message) {
+        if (!this._ws)
+            throw new Error('No active connection');
+        this._ws.send(JSON.stringify(message));
     }
     setMode(mode, options) {
         if (!this._currentSession) {
@@ -95,31 +135,24 @@ 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)
                 msg.turns = options.turns;
-            this._activeWs.send(JSON.stringify(msg));
+            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;
+        this._error = null;
+        this._settleInput();
+        this._pendingRetry = null;
     }
     resetConversation() { this.reset(); }
-    send(message) {
-        if (!this._activeWs)
-            throw new Error('No active connection');
-        this._activeWs.send(JSON.stringify(message));
-    }
     signOnboard(options) {
         const payload = { timestamp: Math.floor(Date.now() / 1000) };
         if (options.inviteCode)
@@ -128,21 +161,33 @@ class RemoteAgent {
             payload.payment = options.payment;
         return { type: 'ONBOARD_SUBMIT', ...(0, auth_1.signPayload)(this._keys, payload) };
     }
-    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}`);
-        if (!res.ok)
-            return 'not_found';
-        const data = await res.json();
-        return data?.status === 'running' ? 'running' : 'done';
-    }
     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 },
+                }));
+            });
+        }
+        // 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();
@@ -167,7 +212,25 @@ class RemoteAgent {
             ws.onerror = () => { clearTimeout(timeout); ws.close(); resolve('not_found'); };
         });
     }
-    // --- Module-internal helpers (used by handlers.ts) ---
+    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';
+    }
+    toString() {
+        const short = this.address.length > 12 ? this.address.slice(0, 12) + '...' : this.address;
+        return `RemoteAgent(${short})`;
+    }
+    // --- Internal helpers (used by useAgentForHuman) ---
     _addChatItem(event) {
         const id = event.id || (0, endpoint_1.generateUUID)();
         this._chatItems.push({ ...event, id });
@@ -177,56 +240,304 @@ class RemoteAgent {
         if (idx !== -1)
             this._chatItems.splice(idx, 1);
     }
-    _stopPingMonitor() {
-        if (this._healthCheckInterval) {
-            clearInterval(this._healthCheckInterval);
-            this._healthCheckInterval = null;
+    // --- Private: connection lifecycle ---
+    async _ensureConnected() {
+        if (this._ws && this._authenticated)
+            return;
+        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;
+        // Wait for open
+        await new Promise((resolve, reject) => {
+            ws.onopen = () => {
+                this._connectionState = 'connected';
+                this._lastPingTime = Date.now();
+                this._startPingMonitor();
+                resolve();
+            };
+            ws.onerror = (err) => reject(new Error(`WebSocket connection failed: ${String(err)}`));
+        });
+        // 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 };
+            }
+            else {
+                this._currentSession.session_id = sid;
+            }
+        }
+        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?.();
         }
     }
-    _attemptReconnect(resolve, reject) {
-        if (!this._currentSession?.session_id) {
-            reject(new Error('No session to reconnect'));
+    _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;
+            }
+            // CONNECTED during reconnect — update session and UI if server has newer data
+            if (data.server_newer && data.session) {
+                this._currentSession = data.session;
+            }
+            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];
+            }
+            const reconnectSid = data.session_id;
+            if (reconnectSid && this._currentSession) {
+                this._currentSession.session_id = reconnectSid;
+            }
+            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';
+                const resolve = this._inputResolve;
+                this._settleInput();
+                resolve?.({ text: '', done: true });
+            }
+            // If status is "executing", events will stream in via _handleMessage — don't resolve yet
+            this._onMessage?.();
             return;
         }
-        if (this._reconnectAttempts >= this._maxReconnectAttempts) {
-            this._reconnectAttempts = 0;
-            this._shouldReconnect = false;
+        // 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 {
+                this._currentSession.mode = data.mode;
+            }
+        }
+        // ULW turns reached
+        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,
+            });
+        }
+        // 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;
+            }
+        }
+        // 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));
+            }
+        }
+        // OUTPUT — resolve input() promise
+        if (data?.type === 'OUTPUT') {
+            this._clearPlaceholder();
+            this._status = 'idle';
+            if (data.session) {
+                this._currentSession = data.session;
+            }
+            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];
+            }
+            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 });
+                }
+            }
+            // 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';
-            reject(new Error('Max reconnection attempts reached'));
+            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;
         }
-        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);
+        // 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?.();
+        }
     }
-    _sendInput(ws, inputId, prompt, sessionId, isDirect, images) {
-        const payload = { prompt, timestamp: Math.floor(Date.now() / 1000) };
-        payload.to = this.address;
-        const signed = (0, auth_1.signPayload)(this._keys, payload);
-        const msg = { type: 'INPUT', input_id: inputId, prompt, ...signed };
-        if (images?.length)
-            msg.images = images;
-        if (!isDirect)
-            msg.to = this.address;
-        msg.session = this._currentSession
-            ? { ...this._currentSession, session_id: sessionId }
-            : { session_id: sessionId };
-        console.log(`[ConnectOnion] Sending INPUT via ${isDirect ? 'direct' : 'relay'}, from: ${signed.from?.slice(0, 12)}...`);
-        ws.send(JSON.stringify(msg));
+    _settleInput() {
+        if (this._inputTimer) {
+            clearTimeout(this._inputTimer);
+            this._inputTimer = null;
+        }
+        this._inputResolve = null;
+        this._inputReject = null;
     }
-    // --- Private: connection lifecycle ---
-    _startPingMonitor(ws, reject) {
+    _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._healthCheckInterval = setInterval(() => {
+        this._pingTimer = setInterval(() => {
             if (Date.now() - this._lastPingTime > 60000) {
                 this._stopPingMonitor();
-                ws.close();
-                reject(new Error('Connection health check failed: No PING received for 60 seconds'));
+                this._ws?.close();
             }
         }, 10000);
     }
+    _stopPingMonitor() {
+        if (this._pingTimer) {
+            clearInterval(this._pingTimer);
+            this._pingTimer = null;
+        }
+    }
+    _isDirect() {
+        return !!this._directUrl || !!this._resolvedEndpoint;
+    }
     _resolveWsUrl() {
         if (this._directUrl) {
             const base = this._directUrl.replace(/^https?:\/\//, '');
@@ -247,75 +558,5 @@ class RemoteAgent {
         if (resolved)
             this._resolvedEndpoint = resolved;
     }
-    async _connectAndSend(prompt, timeoutMs, images) {
-        this._keys = (0, auth_1.ensureKeys)(this._keys);
-        await this._resolveEndpointOnce();
-        this._pendingPrompt = prompt;
-        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._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),
-            };
-            ws.onopen = () => {
-                this._connectionState = 'connected';
-                this._lastPingTime = Date.now();
-                this._startPingMonitor(ws, reject);
-                this._sendInput(ws, inputId, prompt, sessionId, isDirect, images);
-            };
-            (0, ws_handlers_1.attachWsHandlers)(this, ws, inputId, isDirect, state, resolve, reject);
-        });
-    }
-    _reconnect(resolve, reject) {
-        const sessionId = this._currentSession?.session_id;
-        if (!sessionId) {
-            reject(new Error('No session to reconnect'));
-            return;
-        }
-        const { wsUrl, isDirect } = this._resolveWsUrl();
-        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._lastPingTime = Date.now();
-            this._startPingMonitor(ws, reject);
-            this._sendInput(ws, (0, endpoint_1.generateUUID)(), this._pendingPrompt || '', sessionId, isDirect);
-        };
-        (0, ws_handlers_1.attachWsHandlers)(this, ws, '', isDirect, state, resolve, reject);
-    }
-    toString() {
-        const short = this.address.length > 12 ? this.address.slice(0, 12) + '...' : this.address;
-        return `RemoteAgent(${short})`;
-    }
 }
 exports.RemoteAgent = RemoteAgent;

package/dist/react/use-agent-for-human.d.ts

@@ -35,16 +35,9 @@ export interface UseAgentForHumanReturn {
      * The caller decides when and how often to invoke this — no built-in interval.
      *
      * @param sessionId - Session UUID to probe
-     * @returns 'running' | 'suspended' | 'completed' | 'not_found'
+     * @returns 'executing' | 'suspended' | 'connected' | 'not_found'
      */
-    checkSessionStatus: (sessionId: string) => Promise<'running' | 'suspended' | 'completed' | 'not_found'>;
-    /**
-     * Lightweight HTTP check for the current session (no WebSocket relay required).
-     * Prefer this over `checkSessionStatus` when you only need a quick alive/dead signal.
-     *
-     * @returns 'running' | 'done' | 'not_found'
-     */
-    checkSession: () => Promise<'running' | 'done' | 'not_found'>;
+    checkSessionStatus: (sessionId: string) => Promise<'executing' | 'suspended' | 'connected' | 'not_found'>;
     /** Current approval mode. Defaults to 'safe' when no session exists yet. */
     mode: ApprovalMode;
     /** Maximum turns before ULW mode pauses. null when mode is not 'ulw'. */

package/dist/react/use-agent-for-human.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"use-agent-for-human.d.ts","sourceRoot":"","sources":["../../src/react/use-agent-for-human.ts"],"names":[],"mappings":"AACA,OAAO,EAGL,QAAQ,EACR,WAAW,EACX,eAAe,EAEf,YAAY,EACZ,eAAe,EAChB,MAAM,YAAY,CAAC;AAGpB;;;;;;;;;;GAUG;AACH,MAAM,WAAW,sBAAsB;IACrC,oEAAoE;IACpE,MAAM,EAAE,WAAW,CAAC;IAEpB;;;OAGG;IACH,eAAe,EAAE,eAAe,CAAC;IAEjC;;;;OAIG;IACH,EAAE,EAAE,QAAQ,EAAE,CAAC;IAEf,2FAA2F;IAC3F,SAAS,EAAE,MAAM,CAAC;IAElB,4EAA4E;IAC5E,YAAY,EAAE,OAAO,CAAC;IAEtB,+FAA+F;IAC/F,KAAK,EAAE,KAAK,GAAG,IAAI,CAAC;IAEpB;;;;;;OAMG;IACH,kBAAkB,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,OAAO,CAAC,SAAS,GAAG,WAAW,GAAG,WAAW,GAAG,WAAW,CAAC,CAAC;IAExG;;;;;OAKG;IACH,YAAY,EAAE,MAAM,OAAO,CAAC,SAAS,GAAG,MAAM,GAAG,WAAW,CAAC,CAAC;IAE9D,4EAA4E;IAC5E,IAAI,EAAE,YAAY,CAAC;IAEnB,yEAAyE;IACzE,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IAExB,oFAAoF;IACpF,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;IAE5B;;;;;;;OAOG;IACH,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE;QAAE,MAAM,CAAC,EAAE,MAAM,EAAE,CAAA;KAAE,KAAK,IAAI,CAAC;IAEjE;;;;OAIG;IACH,WAAW,EAAE,CAAC,OAAO,EAAE,eAAe,KAAK,IAAI,CAAC;IAEhD,qFAAqF;IACrF,WAAW,EAAE,CAAC,OAAO,EAAE;QAAE,UAAU,CAAC,EAAE,MAAM,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,CAAA;KAAE,KAAK,eAAe,CAAC;IAErF;;;;;;;OAOG;IACH,OAAO,EAAE,CAAC,IAAI,EAAE,YAAY,EAAE,OAAO,CAAC,EAAE;QAAE,KAAK,CAAC,EAAE,MAAM,CAAA;KAAE,KAAK,IAAI,CAAC;IAEpE,8DAA8D;IAC9D,SAAS,EAAE,MAAM,IAAI,CAAC;IAEtB,gFAAgF;IAChF,KAAK,EAAE,MAAM,IAAI,CAAC;CACnB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH,wBAAgB,gBAAgB,CAC9B,OAAO,EAAE,MAAM,EACf,SAAS,EAAE,MAAM,GAChB,sBAAsB,CAwJxB;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,cAAc,CAAC,CAAC,SAAS,QAAQ,CAAC,MAAM,CAAC,EACvD,IAAI,EAAE,QAAQ,EACd,IAAI,EAAE,CAAC,GACN,IAAI,IAAI,OAAO,CAAC,QAAQ,EAAE;IAAE,IAAI,EAAE,CAAC,CAAA;CAAE,CAAC,CAExC;AAED,6CAA6C;AAC7C,eAAO,MAAM,WAAW,uBAAiB,CAAC"}
+{"version":3,"file":"use-agent-for-human.d.ts","sourceRoot":"","sources":["../../src/react/use-agent-for-human.ts"],"names":[],"mappings":"AACA,OAAO,EAGL,QAAQ,EACR,WAAW,EACX,eAAe,EAEf,YAAY,EACZ,eAAe,EAChB,MAAM,YAAY,CAAC;AAGpB;;;;;;;;;;GAUG;AACH,MAAM,WAAW,sBAAsB;IACrC,oEAAoE;IACpE,MAAM,EAAE,WAAW,CAAC;IAEpB;;;OAGG;IACH,eAAe,EAAE,eAAe,CAAC;IAEjC;;;;OAIG;IACH,EAAE,EAAE,QAAQ,EAAE,CAAC;IAEf,2FAA2F;IAC3F,SAAS,EAAE,MAAM,CAAC;IAElB,4EAA4E;IAC5E,YAAY,EAAE,OAAO,CAAC;IAEtB,+FAA+F;IAC/F,KAAK,EAAE,KAAK,GAAG,IAAI,CAAC;IAEpB;;;;;;OAMG;IACH,kBAAkB,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,OAAO,CAAC,WAAW,GAAG,WAAW,GAAG,WAAW,GAAG,WAAW,CAAC,CAAC;IAG1G,4EAA4E;IAC5E,IAAI,EAAE,YAAY,CAAC;IAEnB,yEAAyE;IACzE,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IAExB,oFAAoF;IACpF,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;IAE5B;;;;;;;OAOG;IACH,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE;QAAE,MAAM,CAAC,EAAE,MAAM,EAAE,CAAA;KAAE,KAAK,IAAI,CAAC;IAEjE;;;;OAIG;IACH,WAAW,EAAE,CAAC,OAAO,EAAE,eAAe,KAAK,IAAI,CAAC;IAEhD,qFAAqF;IACrF,WAAW,EAAE,CAAC,OAAO,EAAE;QAAE,UAAU,CAAC,EAAE,MAAM,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,CAAA;KAAE,KAAK,eAAe,CAAC;IAErF;;;;;;;OAOG;IACH,OAAO,EAAE,CAAC,IAAI,EAAE,YAAY,EAAE,OAAO,CAAC,EAAE;QAAE,KAAK,CAAC,EAAE,MAAM,CAAA;KAAE,KAAK,IAAI,CAAC;IAEpE,8DAA8D;IAC9D,SAAS,EAAE,MAAM,IAAI,CAAC;IAEtB,gFAAgF;IAChF,KAAK,EAAE,MAAM,IAAI,CAAC;CACnB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH,wBAAgB,gBAAgB,CAC9B,OAAO,EAAE,MAAM,EACf,SAAS,EAAE,MAAM,GAChB,sBAAsB,CAwJxB;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,cAAc,CAAC,CAAC,SAAS,QAAQ,CAAC,MAAM,CAAC,EACvD,IAAI,EAAE,QAAQ,EACd,IAAI,EAAE,CAAC,GACN,IAAI,IAAI,OAAO,CAAC,QAAQ,EAAE;IAAE,IAAI,EAAE,CAAC,CAAA;CAAE,CAAC,CAExC;AAED,6CAA6C;AAC7C,eAAO,MAAM,WAAW,uBAAiB,CAAC"}

package/dist/react/use-agent-for-human.js

@@ -98,19 +98,19 @@ function useAgentForHuman(address, sessionId) {
         // eslint-disable-next-line react-hooks/exhaustive-deps
     }, [agent]);
     // Restore persisted session into the RemoteAgent on mount or when sessionId changes.
-    // The agent holds session state in memory only; without this restore the server would
-    // receive a sessionless request and start a brand-new conversation instead of resuming.
+    // Then auto-reconnect to sync with server (get newer data, resume executing agent, etc.)
     (0, react_1.useEffect)(() => {
         if (session) {
             agent._currentSession = { ...session, session_id: sessionId };
             agent._chatItems = [...ui];
         }
         else if (messages.length > 0) {
-            // No full session snapshot yet, but we have raw messages — build a minimal session
-            // so the server can reconstruct conversation history.
             agent._currentSession = { session_id: sessionId, messages };
             agent._chatItems = [...ui];
         }
+        // No auto-reconnect on mount. Show cached conversation from localStorage.
+        // When user sends next message, input() → _ensureConnected() → CONNECT
+        // will sync with server (session merge, server_newer, etc.).
     }, [sessionId]);
     const input = (prompt, options) => {
         setError(null);
@@ -172,7 +172,6 @@ function useAgentForHuman(address, sessionId) {
         isProcessing: status !== 'idle',
         error,
         checkSessionStatus: (sid) => agent.checkSessionStatus(sid),
-        checkSession: () => agent.checkSession(sessionId),
         mode: session?.mode || 'safe',
         ulwTurns: session?.ulw_turns ?? null,
         ulwTurnsUsed: session?.ulw_turns_used ?? null,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "connectonion",
-  "version": "0.0.20",
+  "version": "0.1.0",
   "description": "Connect to Python AI agents from TypeScript apps - Use powerful Python agents in your React, Next.js, Node.js, and Electron applications",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/dist/connect/ws-handlers.d.ts

@@ -1,14 +0,0 @@
-/**
- * @llm-note
- *   Dependencies: imports from [src/connect/types, src/connect/stream-events, src/connect/endpoint, src/connect/remote-agent (type-only)]
- *   Data flow: onmessage parses JSON → dispatches by type → mutates agent fields → resolves/rejects the input() Promise
- *   State/Effects: mutates RemoteAgent fields (session, status, chatItems, connection state) via _ prefix access
- *   Integration: attachWsHandlers() wires onmessage/onerror/onclose; called by RemoteAgent._connectAndSend and _reconnect
- */
-import type { RemoteAgent } from './remote-agent';
-import { Response, WebSocketLike } from './types';
-export declare function attachWsHandlers(agent: RemoteAgent, ws: WebSocketLike, inputId: string, isDirect: boolean, state: {
-    settled: boolean;
-    timer: ReturnType<typeof setTimeout>;
-}, resolve: (value: Response) => void, reject: (reason?: unknown) => void): void;
-//# sourceMappingURL=ws-handlers.d.ts.map

package/dist/connect/ws-handlers.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ws-handlers.d.ts","sourceRoot":"","sources":["../../src/connect/ws-handlers.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAGlD,OAAO,EAAY,QAAQ,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAE5D,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,WAAW,EAClB,EAAE,EAAE,aAAa,EACjB,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,OAAO,EACjB,KAAK,EAAE;IAAE,OAAO,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,UAAU,CAAC,OAAO,UAAU,CAAC,CAAA;CAAE,EACjE,OAAO,EAAE,CAAC,KAAK,EAAE,QAAQ,KAAK,IAAI,EAClC,MAAM,EAAE,CAAC,MAAM,CAAC,EAAE,OAAO,KAAK,IAAI,GACjC,IAAI,CA+MN"}

package/dist/connect/ws-handlers.js

@@ -1,188 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.attachWsHandlers = attachWsHandlers;
-const chat_item_mapper_1 = require("./chat-item-mapper");
-const endpoint_1 = require("./endpoint");
-function attachWsHandlers(agent, 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') {
-            agent._lastPingTime = Date.now();
-            ws.send(JSON.stringify({ type: 'PONG' }));
-            return;
-        }
-        if (data?.type === 'session_sync' && data.session) {
-            agent._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 (!agent._currentSession) {
-                agent._currentSession = { mode: data.mode };
-            }
-            else {
-                agent._currentSession.mode = data.mode;
-            }
-        }
-        if (data?.type === 'ulw_turns_reached') {
-            agent._status = 'waiting';
-            if (agent._currentSession) {
-                agent._currentSession.ulw_turns_used = data.turns_used;
-            }
-            agent._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') {
-            agent._clearPlaceholder();
-            (0, chat_item_mapper_1.mapEventToChatItem)(agent._chatItems, data, (item) => agent._addChatItem(item));
-            if (data.session) {
-                agent._currentSession = data.session;
-            }
-        }
-        if (data?.type === 'ask_user') {
-            agent._status = 'waiting';
-            agent._addChatItem({ type: 'ask_user', text: data.text || '', options: data.options || [], multi_select: data.multi_select || false });
-        }
-        if (data?.type === 'approval_needed') {
-            agent._status = 'waiting';
-            agent._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') {
-            agent._status = 'waiting';
-            agent._addChatItem({
-                type: 'plan_review',
-                plan_content: data.plan_content,
-            });
-        }
-        if (data?.type === 'ONBOARD_REQUIRED') {
-            agent._status = 'waiting';
-            agent._pendingPrompt = data.prompt || '';
-            agent._pendingInputId = inputId;
-            agent._pendingSessionId = agent._currentSession?.session_id || null;
-            agent._addChatItem({
-                type: 'onboard_required',
-                methods: (data.methods || []),
-                paymentAmount: data.payment_amount,
-            });
-        }
-        if (data?.type === 'ONBOARD_SUCCESS') {
-            agent._addChatItem({
-                type: 'onboard_success',
-                level: data.level,
-                message: data.message,
-            });
-            if (agent._pendingPrompt && agent._activeWs) {
-                agent._status = 'working';
-                const retryPrompt = agent._pendingPrompt;
-                const retryInputId = agent._pendingInputId || (0, endpoint_1.generateUUID)();
-                agent._pendingPrompt = null;
-                agent._pendingInputId = null;
-                agent._sendInput(agent._activeWs, retryInputId, retryPrompt, agent._pendingSessionId || (0, endpoint_1.generateUUID)(), isDirect);
-                agent._pendingSessionId = null;
-            }
-        }
-        if (data?.type === 'OUTPUT') {
-            state.settled = true;
-            clearTimeout(state.timer);
-            agent._stopPingMonitor();
-            agent._clearPlaceholder();
-            agent._status = 'idle';
-            agent._shouldReconnect = false;
-            agent._connectionState = 'disconnected';
-            agent._reconnectAttempts = 0;
-            if (data.session) {
-                agent._currentSession = data.session;
-            }
-            if (data.server_newer && data.chat_items && Array.isArray(data.chat_items)) {
-                console.log('[RemoteAgent] Session was merged with newer server state');
-                const userItems = agent._chatItems.filter(item => item.type === 'user');
-                const serverNonUserItems = data.chat_items.filter(item => item.type !== 'user');
-                agent._chatItems = [...userItems, ...serverNonUserItems];
-            }
-            const result = data.result || '';
-            if (result) {
-                const lastAgent = agent._chatItems.filter((e) => e.type === 'agent').pop();
-                if (!lastAgent || lastAgent.content !== result) {
-                    agent._addChatItem({ type: 'agent', content: result });
-                }
-            }
-            agent._activeWs = null;
-            ws.close();
-            resolve({ text: result, done: true });
-        }
-        if (data?.type === 'ERROR') {
-            state.settled = true;
-            clearTimeout(state.timer);
-            agent._stopPingMonitor();
-            agent._status = 'idle';
-            agent._shouldReconnect = false;
-            agent._connectionState = 'disconnected';
-            agent._activeWs = null;
-            ws.close();
-            reject(new Error(`Agent error: ${String(data.message || data.error || 'Unknown error')}`));
-        }
-        agent._onMessage?.();
-    };
-    ws.onerror = async (err) => {
-        if (state.settled)
-            return;
-        agent._stopPingMonitor();
-        clearTimeout(state.timer);
-        ws.close();
-        if (isDirect && !agent._directUrl) {
-            agent._resolvedEndpoint = undefined;
-            agent._endpointResolutionAttempted = false;
-        }
-        if (agent._shouldReconnect && agent._reconnectAttempts < agent._maxReconnectAttempts) {
-            agent._attemptReconnect(resolve, reject);
-        }
-        else {
-            state.settled = true;
-            agent._status = 'idle';
-            agent._shouldReconnect = false;
-            agent._connectionState = 'disconnected';
-            reject(new Error(`WebSocket error: ${String(err)}`));
-        }
-    };
-    ws.onclose = async () => {
-        agent._activeWs = null;
-        agent._stopPingMonitor();
-        if (!state.settled) {
-            clearTimeout(state.timer);
-            if (isDirect && !agent._directUrl) {
-                agent._resolvedEndpoint = undefined;
-                agent._endpointResolutionAttempted = false;
-            }
-            if (agent._shouldReconnect && agent._reconnectAttempts < agent._maxReconnectAttempts) {
-                agent._attemptReconnect(resolve, reject);
-            }
-            else {
-                state.settled = true;
-                agent._status = 'idle';
-                agent._shouldReconnect = false;
-                agent._connectionState = 'disconnected';
-                reject(new Error('Connection closed before response'));
-            }
-        }
-    };
-}