@downcity/agent 1.1.43 → 1.1.62

package/bin/agent/RemoteAgent.js

@@ -1,28 +1,29 @@
 /**
- * RemoteAgent：远程 SDK 客户端。
+ * RemoteAgent：统一远程 SDK 客户端。
  *
  * 关键点（中文）
- * - 面向已通过 `agent.start({ http: { ... } })` 暴露出来的远程/本地 HTTP 服务。
- * - 与本地 `Session` 保持同一套 Session actor 使用面：`prompt()` + `subscribe()`。
- * - `RemoteAgent` 只负责 transport 与本地 turn handle 合成，不重复实现第二套会话编排器。
+ * - 对外只暴露一个 `url` 入口，不向用户暴露 transport 细节。
+ * - 当前内部支持 `http/https` 与 `rpc` 两种访问方式。
+ * - `RemoteAgent` 只负责远程访问与 turn handle 合成，不重复实现第二套会话编排器。
  */
 import { SessionEventHub } from "../session/runtime/SessionEventHub.js";
+import { RpcClient, parse_rpc_url } from "../rpc/Client.js";
 /**
  * 远程 Session 客户端。
  */
 class RemoteSession {
     id;
-    baseUrl;
-    eventHub = new SessionEventHub();
-    turnsById = new Map();
-    completedTurnIds = [];
-    eventPumpConnectPromise = null;
-    eventPumpAbortController = null;
-    eventPumpRunning = false;
-    eventSubscriberCount = 0;
-    constructor(baseUrl, sessionId) {
-        this.baseUrl = baseUrl;
-        this.id = sessionId;
+    transport;
+    event_hub = new SessionEventHub();
+    turns_by_id = new Map();
+    completed_turn_ids = [];
+    event_pump_connect_promise = null;
+    event_pump_running = false;
+    event_subscriber_count = 0;
+    event_subscription = null;
+    constructor(transport, session_id) {
+        this.transport = transport;
+        this.id = session_id;
     }
     /**
      * 远程 session 当前不支持直接注入本地模型实例。
@@ -34,12 +35,7 @@ class RemoteSession {
      * 读取当前远程 session 详情。
      */
     async getInfo() {
-        const response = await fetch(`${this.baseUrl}/api/sdk/sessions/${encodeURIComponent(this.id)}`);
-        const payload = (await response.json());
-        if (!response.ok || !payload.success || !payload.session?.sessionId) {
-            throw new Error(String(payload.error || "Remote session info failed"));
-        }
-        return payload.session;
+        return await this.transport.get_info(this.id);
     }
     /**
      * 向当前远程 session 追加一条新的 prompt。
@@ -49,207 +45,88 @@ class RemoteSession {
         if (!query) {
             throw new Error("remote session.prompt requires a non-empty query");
         }
-        await this.ensureEventPump();
-        const response = await fetch(`${this.baseUrl}/api/sdk/sessions/${encodeURIComponent(this.id)}/prompt`, {
-            method: "POST",
-            headers: {
-                "Content-Type": "application/json",
-            },
-            body: JSON.stringify({
-                query,
-            }),
-        });
-        const payload = (await response.json());
-        if (!response.ok || !payload.success || !payload.turn?.id) {
-            throw new Error(String(payload.error || "Remote session prompt failed"));
-        }
-        const lifecycle = this.ensureTurnLifecycle(payload.turn.id);
-        return createTurnHandle(lifecycle);
+        await this.ensure_event_pump();
+        const turn = await this.transport.prompt(this.id, input);
+        const lifecycle = this.ensure_turn_lifecycle(turn.id);
+        return create_turn_handle(lifecycle);
     }
     /**
      * 订阅当前远程 session 的 future 事件。
      */
     subscribe(subscriber) {
-        this.eventSubscriberCount += 1;
-        void this.ensureEventPump().catch((error) => {
-            this.eventHub.publish({
+        this.event_subscriber_count += 1;
+        void this.ensure_event_pump().catch((error) => {
+            this.event_hub.publish({
                 type: "error",
                 message: error instanceof Error ? error.message : String(error),
             });
         });
-        const unsubscribe = this.eventHub.subscribe(subscriber);
+        const unsubscribe = this.event_hub.subscribe(subscriber);
         return () => {
             unsubscribe();
-            this.eventSubscriberCount = Math.max(0, this.eventSubscriberCount - 1);
-            this.maybeStopEventPump();
+            this.event_subscriber_count = Math.max(0, this.event_subscriber_count - 1);
+            void this.maybe_stop_event_pump();
         };
     }
     /**
      * 读取远程消息历史。
      */
     async history(input) {
-        const query = new URLSearchParams();
-        if (input?.limit !== undefined)
-            query.set("limit", String(input.limit));
-        if (input?.cursor)
-            query.set("cursor", input.cursor);
-        if (input?.order)
-            query.set("order", input.order);
-        if (input?.view)
-            query.set("view", input.view);
-        const response = await fetch(`${this.baseUrl}/api/sdk/sessions/${encodeURIComponent(this.id)}/history${query.size > 0 ? `?${query.toString()}` : ""}`);
-        const payload = (await response.json());
-        if (!response.ok ||
-            !payload.success ||
-            !payload.history ||
-            !Array.isArray(payload.history.items)) {
-            throw new Error(String(payload.error || "Remote session history failed"));
-        }
-        return payload.history;
+        return await this.transport.history(this.id, input);
     }
     /**
      * 读取远程 session 当前生效的 system prompt 快照。
      */
     async system() {
-        const response = await fetch(`${this.baseUrl}/api/sdk/sessions/${encodeURIComponent(this.id)}/system`);
-        const payload = (await response.json());
-        if (!response.ok ||
-            !payload.success ||
-            !payload.system ||
-            !Array.isArray(payload.system.blocks)) {
-            throw new Error(String(payload.error || "Remote session system failed"));
-        }
-        return payload.system;
+        return await this.transport.system(this.id);
     }
     /**
      * 分叉远程 session。
      */
     async fork(input) {
-        const messageId = typeof input === "string"
-            ? String(input || "").trim() || undefined
-            : String(input?.messageId || "").trim() || undefined;
-        const response = await fetch(`${this.baseUrl}/api/sdk/sessions/${encodeURIComponent(this.id)}/fork`, {
-            method: "POST",
-            headers: {
-                "Content-Type": "application/json",
-            },
-            body: JSON.stringify({
-                ...(messageId ? { messageId } : {}),
-            }),
-        });
-        const payload = (await response.json());
-        if (!response.ok || !payload.success || !payload.session?.sessionId) {
-            throw new Error(String(payload.error || "Remote session fork failed"));
-        }
-        return new RemoteSession(this.baseUrl, payload.session.sessionId);
+        const info = await this.transport.fork(this.id, input);
+        return new RemoteSession(this.transport, info.sessionId);
     }
-    async ensureEventPump() {
-        if (this.eventPumpConnectPromise) {
-            await this.eventPumpConnectPromise;
+    async ensure_event_pump() {
+        if (this.event_pump_connect_promise) {
+            await this.event_pump_connect_promise;
             return;
         }
-        if (this.eventPumpRunning)
+        if (this.event_pump_running)
             return;
-        this.eventPumpConnectPromise = (async () => {
-            const abortController = new AbortController();
-            this.eventPumpAbortController = abortController;
-            const response = await fetch(`${this.baseUrl}/api/sdk/sessions/${encodeURIComponent(this.id)}/events`, {
-                signal: abortController.signal,
+        this.event_pump_connect_promise = (async () => {
+            let resolved_ready = false;
+            this.event_subscription = await this.transport.subscribe({
+                session_id: this.id,
+                on_ready: () => {
+                    resolved_ready = true;
+                },
+                on_event: (event) => {
+                    this.handle_event(event);
+                },
             });
-            if (!response.ok || !response.body) {
-                const text = await response.text().catch(() => "");
-                throw new Error(text || `Remote session events failed (${response.status})`);
+            this.event_pump_running = true;
+            if (!resolved_ready) {
+                throw new Error("Remote session events connection closed before ready");
             }
-            this.eventPumpRunning = true;
-            const ready = createEventConnectionReady();
-            void this.consumeEventConnection(response.body, abortController, ready)
-                .finally(() => {
-                const wasAborted = abortController.signal.aborted;
-                this.eventPumpRunning = false;
-                if (this.eventPumpAbortController === abortController) {
-                    this.eventPumpAbortController = null;
-                }
-                if (!wasAborted) {
-                    this.failPendingTurns("Remote session events connection closed");
-                    this.eventHub.publish({
-                        type: "error",
-                        message: "Remote session events connection closed",
-                    });
-                }
-            });
-            await ready.promise;
         })();
         try {
-            await this.eventPumpConnectPromise;
-        }
-        catch (error) {
-            this.eventPumpAbortController = null;
-            throw error;
-        }
-        finally {
-            this.eventPumpConnectPromise = null;
-        }
-    }
-    async consumeEventConnection(body, abortController, ready) {
-        const decoder = new TextDecoder();
-        const reader = body.getReader();
-        let buffered = "";
-        try {
-            while (true) {
-                const { done, value } = await reader.read();
-                if (done)
-                    break;
-                buffered += decoder.decode(value, { stream: true });
-                let newlineIndex = buffered.indexOf("\n");
-                while (newlineIndex >= 0) {
-                    const line = buffered.slice(0, newlineIndex).trim();
-                    buffered = buffered.slice(newlineIndex + 1);
-                    if (line) {
-                        this.handleEventLine(JSON.parse(line), ready);
-                    }
-                    newlineIndex = buffered.indexOf("\n");
-                }
-            }
-            const tail = buffered.trim();
-            if (tail) {
-                this.handleEventLine(JSON.parse(tail), ready);
-            }
-            rejectEventConnectionReady(ready, "Remote session events connection closed before ready");
-        }
-        catch (error) {
-            if (!abortController.signal.aborted) {
-                const message = error instanceof Error ? error.message : String(error);
-                rejectEventConnectionReady(ready, message);
-                this.failPendingTurns(message);
-                this.eventHub.publish({
-                    type: "error",
-                    message,
-                });
-            }
+            await this.event_pump_connect_promise;
         }
         finally {
-            try {
-                reader.releaseLock();
-            }
-            catch {
-                // ignore
-            }
+            this.event_pump_connect_promise = null;
         }
     }
-    handleEventLine(value, ready) {
-        if (isSdkEventsReadyFrame(value)) {
-            resolveEventConnectionReady(ready);
-            return;
+    handle_event(event) {
+        if (event.type === "error") {
+            this.fail_pending_turns(event.message);
         }
-        this.handleEvent(value);
-    }
-    handleEvent(event) {
-        const turnId = extractTurnId(event);
-        if (turnId) {
-            this.ensureTurnLifecycle(turnId);
+        const turn_id = extract_turn_id(event);
+        if (turn_id) {
+            this.ensure_turn_lifecycle(turn_id);
         }
         if (event.type === "turn-finish") {
-            const lifecycle = this.ensureTurnLifecycle(event.turnId);
+            const lifecycle = this.ensure_turn_lifecycle(event.turnId);
             const result = {
                 turnId: event.turnId,
                 text: event.text,
@@ -257,26 +134,26 @@ class RemoteSession {
                 ...(event.error ? { error: event.error } : {}),
             };
             lifecycle.result = result;
-            lifecycle.deferredFinished.resolve(result);
-            this.rememberCompletedTurn(event.turnId);
-            this.maybeStopEventPump();
+            lifecycle.deferred_finished.resolve(result);
+            this.remember_completed_turn(event.turnId);
+            void this.maybe_stop_event_pump();
         }
-        this.eventHub.publish(event);
+        this.event_hub.publish(event);
     }
-    ensureTurnLifecycle(turnId) {
-        const cached = this.turnsById.get(turnId);
+    ensure_turn_lifecycle(turn_id) {
+        const cached = this.turns_by_id.get(turn_id);
         if (cached)
             return cached;
         const created = {
-            turnId,
+            turnId: turn_id,
             result: null,
-            deferredFinished: createDeferred(),
+            deferred_finished: create_deferred(),
         };
-        this.turnsById.set(turnId, created);
+        this.turns_by_id.set(turn_id, created);
         return created;
     }
-    failPendingTurns(message) {
-        for (const lifecycle of this.turnsById.values()) {
+    fail_pending_turns(message) {
+        for (const lifecycle of this.turns_by_id.values()) {
             if (lifecycle.result)
                 continue;
             const result = {
@@ -286,48 +163,78 @@ class RemoteSession {
                 error: message,
             };
             lifecycle.result = result;
-            lifecycle.deferredFinished.resolve(result);
-            this.rememberCompletedTurn(lifecycle.turnId);
+            lifecycle.deferred_finished.resolve(result);
+            this.remember_completed_turn(lifecycle.turnId);
         }
-        this.maybeStopEventPump();
-    }
-    rememberCompletedTurn(turnId) {
-        this.completedTurnIds.push(turnId);
-        while (this.completedTurnIds.length > 200) {
-            const oldestTurnId = this.completedTurnIds.shift();
-            if (oldestTurnId) {
-                this.turnsById.delete(oldestTurnId);
+    }
+    remember_completed_turn(turn_id) {
+        this.completed_turn_ids.push(turn_id);
+        while (this.completed_turn_ids.length > 200) {
+            const oldest_turn_id = this.completed_turn_ids.shift();
+            if (oldest_turn_id) {
+                this.turns_by_id.delete(oldest_turn_id);
             }
         }
     }
-    maybeStopEventPump() {
-        if (this.eventSubscriberCount > 0)
+    async maybe_stop_event_pump() {
+        if (this.event_subscriber_count > 0)
             return;
-        if ([...this.turnsById.values()].some((item) => item.result === null))
+        if ([...this.turns_by_id.values()].some((item) => item.result === null))
             return;
-        if (!this.eventPumpAbortController)
+        const current = this.event_subscription;
+        this.event_subscription = null;
+        this.event_pump_running = false;
+        if (!current)
             return;
-        this.eventPumpAbortController.abort();
-        this.eventPumpAbortController = null;
+        await current.close().catch((error) => {
+            this.fail_pending_turns(error instanceof Error ? error.message : String(error));
+        });
     }
 }
 /**
  * RemoteAgent：远程 Agent 客户端。
  */
 export class RemoteAgent {
-    baseUrl;
+    transport;
     constructor(options) {
-        const baseUrl = String(options.baseUrl || "").trim().replace(/\/+$/, "");
-        if (!baseUrl) {
-            throw new Error("RemoteAgent requires a non-empty baseUrl");
+        const url = String(options.url || "").trim();
+        if (!url) {
+            throw new Error("RemoteAgent requires a non-empty url");
         }
-        this.baseUrl = baseUrl;
+        this.transport = create_remote_agent_transport(url);
     }
     /**
      * 新建一个远程 session。
      */
     async createSession(input) {
-        const response = await fetch(`${this.baseUrl}/api/sdk/sessions`, {
+        const info = await this.transport.create_session(input);
+        return new RemoteSession(this.transport, info.sessionId);
+    }
+    /**
+     * 获取一个已存在的远程 session。
+     */
+    async getSession(sessionId) {
+        const resolved_session_id = String(sessionId || "").trim();
+        if (!resolved_session_id) {
+            throw new Error("getSession requires a non-empty sessionId");
+        }
+        const info = await this.transport.get_info(resolved_session_id);
+        return new RemoteSession(this.transport, info.sessionId);
+    }
+    /**
+     * 列出远程 agent 的 session 摘要页。
+     */
+    async listSessions(input) {
+        return await this.transport.list_sessions(input);
+    }
+}
+class HttpRemoteAgentTransport {
+    base_url;
+    constructor(url) {
+        this.base_url = url.replace(/\/+$/, "");
+    }
+    async create_session(input) {
+        const payload = await read_http_json(`${this.base_url}/api/sdk/sessions`, {
             method: "POST",
             headers: {
                 "Content-Type": "application/json",
@@ -336,31 +243,110 @@ export class RemoteAgent {
                 ...(input?.sessionId ? { sessionId: input.sessionId } : {}),
             }),
         });
-        const payload = (await response.json());
-        if (!response.ok || !payload.success || !payload.session?.sessionId) {
+        if (!payload.success || !payload.session?.sessionId) {
             throw new Error(String(payload.error || "Remote session create failed"));
         }
-        return new RemoteSession(this.baseUrl, payload.session.sessionId);
+        return payload.session;
     }
-    /**
-     * 获取一个已存在的远程 session。
-     */
-    async getSession(sessionId) {
-        const resolvedSessionId = String(sessionId || "").trim();
-        if (!resolvedSessionId) {
-            throw new Error("getSession requires a non-empty sessionId");
+    async get_info(session_id) {
+        const payload = await read_http_json(`${this.base_url}/api/sdk/sessions/${encodeURIComponent(session_id)}`);
+        if (!payload.success || !payload.session?.sessionId) {
+            throw new Error(String(payload.error || "Remote session info failed"));
         }
-        const response = await fetch(`${this.baseUrl}/api/sdk/sessions/${encodeURIComponent(resolvedSessionId)}`);
-        const payload = (await response.json());
-        if (!response.ok || !payload.success || !payload.session?.sessionId) {
-            throw new Error(String(payload.error || "Remote session get failed"));
+        return payload.session;
+    }
+    async prompt(session_id, input) {
+        const payload = await read_http_json(`${this.base_url}/api/sdk/sessions/${encodeURIComponent(session_id)}/prompt`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify({
+                query: input.query,
+            }),
+        });
+        const id = String(payload.turn?.id || "").trim();
+        if (!payload.success || !id) {
+            throw new Error(String(payload.error || "Remote session prompt failed"));
         }
-        return new RemoteSession(this.baseUrl, payload.session.sessionId);
+        return { id };
     }
-    /**
-     * 列出远程 agent 的 session 摘要页。
-     */
-    async listSessions(input) {
+    async subscribe(params) {
+        const abort_controller = new AbortController();
+        let resolve_ready;
+        let reject_ready;
+        const ready_promise = new Promise((resolve, reject) => {
+            resolve_ready = resolve;
+            reject_ready = reject;
+        });
+        const response = await fetch(`${this.base_url}/api/sdk/sessions/${encodeURIComponent(params.session_id)}/events`, {
+            signal: abort_controller.signal,
+        });
+        if (!response.ok || !response.body) {
+            const text = await response.text().catch(() => "");
+            throw new Error(text || `Remote session events failed (${response.status})`);
+        }
+        void consume_http_event_stream({
+            body: response.body,
+            abort_controller,
+            on_ready: () => {
+                params.on_ready();
+                resolve_ready();
+            },
+            on_ready_error: (error) => {
+                reject_ready(error);
+            },
+            on_event: params.on_event,
+        });
+        await ready_promise;
+        return {
+            close: async () => {
+                abort_controller.abort();
+            },
+        };
+    }
+    async history(session_id, input) {
+        const query = new URLSearchParams();
+        if (input?.limit !== undefined)
+            query.set("limit", String(input.limit));
+        if (input?.cursor)
+            query.set("cursor", input.cursor);
+        if (input?.order)
+            query.set("order", input.order);
+        if (input?.view)
+            query.set("view", input.view);
+        const payload = await read_http_json(`${this.base_url}/api/sdk/sessions/${encodeURIComponent(session_id)}/history${query.size > 0 ? `?${query.toString()}` : ""}`);
+        if (!payload.success || !payload.history || !Array.isArray(payload.history.items)) {
+            throw new Error(String(payload.error || "Remote session history failed"));
+        }
+        return payload.history;
+    }
+    async system(session_id) {
+        const payload = await read_http_json(`${this.base_url}/api/sdk/sessions/${encodeURIComponent(session_id)}/system`);
+        if (!payload.success || !payload.system || !Array.isArray(payload.system.blocks)) {
+            throw new Error(String(payload.error || "Remote session system failed"));
+        }
+        return payload.system;
+    }
+    async fork(session_id, input) {
+        const message_id = typeof input === "string"
+            ? String(input || "").trim() || undefined
+            : String(input?.messageId || "").trim() || undefined;
+        const payload = await read_http_json(`${this.base_url}/api/sdk/sessions/${encodeURIComponent(session_id)}/fork`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify({
+                ...(message_id ? { messageId: message_id } : {}),
+            }),
+        });
+        if (!payload.success || !payload.session?.sessionId) {
+            throw new Error(String(payload.error || "Remote session fork failed"));
+        }
+        return payload.session;
+    }
+    async list_sessions(input) {
         const query = new URLSearchParams();
         if (input?.limit !== undefined)
             query.set("limit", String(input.limit));
@@ -368,66 +354,190 @@ export class RemoteAgent {
             query.set("cursor", input.cursor);
         if (input?.query)
             query.set("query", input.query);
-        const response = await fetch(`${this.baseUrl}/api/sdk/sessions${query.size > 0 ? `?${query.toString()}` : ""}`);
-        const payload = (await response.json());
-        if (!response.ok || !payload.success || !payload.page) {
+        const payload = await read_http_json(`${this.base_url}/api/sdk/sessions${query.size > 0 ? `?${query.toString()}` : ""}`);
+        if (!payload.success || !payload.page) {
             throw new Error(String(payload.error || "Remote sessions list failed"));
         }
         return payload.page;
     }
 }
-function createDeferred() {
-    let resolve;
-    const promise = new Promise((innerResolve) => {
-        resolve = innerResolve;
-    });
-    return {
-        promise,
-        resolve,
-    };
+class RpcRemoteAgentTransport {
+    client;
+    constructor(url) {
+        this.client = new RpcClient(parse_rpc_url(url));
+    }
+    async create_session(input) {
+        return await this.client.create_session(input);
+    }
+    async get_info(session_id) {
+        return await this.client.get_session(session_id);
+    }
+    async prompt(session_id, input) {
+        return await this.client.prompt_session({
+            session_id,
+            input,
+        });
+    }
+    async subscribe(params) {
+        const subscription = await this.client.subscribe_session({
+            session_id: params.session_id,
+            on_ready: params.on_ready,
+            on_event: params.on_event,
+        });
+        return {
+            close: async () => {
+                await subscription.unsubscribe();
+            },
+        };
+    }
+    async history(session_id, input) {
+        return await this.client.get_session_history({
+            session_id,
+            input,
+        });
+    }
+    async system(session_id) {
+        return await this.client.get_session_system(session_id);
+    }
+    async fork(session_id, input) {
+        const message_id = typeof input === "string"
+            ? String(input || "").trim() || undefined
+            : String(input?.messageId || "").trim() || undefined;
+        return await this.client.fork_session({
+            session_id,
+            ...(message_id ? { message_id } : {}),
+        });
+    }
+    async list_sessions(input) {
+        return await this.client.list_sessions(input);
+    }
+}
+function create_remote_agent_transport(url) {
+    if (/^https?:\/\//i.test(url)) {
+        return new HttpRemoteAgentTransport(url);
+    }
+    if (/^rpc:\/\//i.test(url)) {
+        return new RpcRemoteAgentTransport(url);
+    }
+    throw new Error(`Unsupported RemoteAgent url protocol: ${url}. Expected http://, https://, or rpc://`);
+}
+async function read_http_json(input, init) {
+    const response = await fetch(input, init);
+    const payload = (await response.json().catch(() => ({})));
+    if (!response.ok) {
+        const message = extract_error_message(payload);
+        throw new Error(message || `HTTP ${response.status}`);
+    }
+    return payload;
 }
-function createEventConnectionReady() {
+async function consume_http_event_stream(params) {
+    const decoder = new TextDecoder();
+    const reader = params.body.getReader();
+    let buffered = "";
+    let ready_resolved = false;
+    try {
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            buffered += decoder.decode(value, { stream: true });
+            let newline_index = buffered.indexOf("\n");
+            while (newline_index >= 0) {
+                const line = buffered.slice(0, newline_index).trim();
+                buffered = buffered.slice(newline_index + 1);
+                if (line) {
+                    const value = JSON.parse(line);
+                    if (is_sdk_events_ready_frame(value)) {
+                        ready_resolved = true;
+                        params.on_ready();
+                    }
+                    else {
+                        params.on_event(value);
+                    }
+                }
+                newline_index = buffered.indexOf("\n");
+            }
+        }
+        const tail = buffered.trim();
+        if (tail) {
+            const value = JSON.parse(tail);
+            if (is_sdk_events_ready_frame(value)) {
+                ready_resolved = true;
+                params.on_ready();
+            }
+            else {
+                params.on_event(value);
+            }
+        }
+        if (!params.abort_controller.signal.aborted) {
+            if (!ready_resolved) {
+                const error = new Error("Remote session events connection closed before ready");
+                params.on_ready_error(error);
+                throw error;
+            }
+            params.on_event({
+                type: "error",
+                message: "Remote session events connection closed",
+            });
+        }
+    }
+    catch (error) {
+        if (!params.abort_controller.signal.aborted) {
+            if (!ready_resolved) {
+                params.on_ready_error(error);
+            }
+            params.on_event({
+                type: "error",
+                message: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    finally {
+        try {
+            reader.releaseLock();
+        }
+        catch {
+            // ignore
+        }
+    }
+}
+function extract_error_message(payload) {
+    if (!payload || typeof payload !== "object")
+        return "";
+    if ("error" in payload && typeof payload.error === "string") {
+        return payload.error;
+    }
+    if ("message" in payload && typeof payload.message === "string") {
+        return payload.message;
+    }
+    return "";
+}
+function create_deferred() {
     let resolve;
-    let reject;
-    const promise = new Promise((innerResolve, innerReject) => {
-        resolve = innerResolve;
-        reject = innerReject;
+    const promise = new Promise((inner_resolve) => {
+        resolve = inner_resolve;
     });
     return {
         promise,
-        settled: false,
         resolve,
-        reject,
     };
 }
-function resolveEventConnectionReady(ready) {
-    if (ready.settled)
-        return;
-    ready.settled = true;
-    ready.resolve();
-}
-function rejectEventConnectionReady(ready, error) {
-    if (ready.settled)
-        return;
-    ready.settled = true;
-    ready.reject(error);
-}
-function isSdkEventsReadyFrame(value) {
+function is_sdk_events_ready_frame(value) {
     return (typeof value === "object" &&
         value !== null &&
         "type" in value &&
         value.type === "sdk-events-ready");
 }
-function createTurnHandle(lifecycle) {
+function create_turn_handle(lifecycle) {
     return {
         id: lifecycle.turnId,
         get result() {
             return lifecycle.result;
         },
-        finished: lifecycle.deferredFinished.promise,
+        finished: lifecycle.deferred_finished.promise,
     };
 }
-function extractTurnId(event) {
+function extract_turn_id(event) {
     switch (event.type) {
         case "turn-start":
         case "text-delta":