@nodetool-ai/cli 0.7.0-rc.23 → 0.8.2

package/dist/websocket-client.js

@@ -4,9 +4,214 @@
  * and workflow commands (run_job, cancel_job, get_status).
  */
 import WebSocket from "ws";
+import { processingMessageSchema } from "@nodetool-ai/protocol";
+import { isNumber, isRecord, isString } from "./predicates.js";
+/** Read `key` as a string, or report it absent when the wire says otherwise. */
+function wireString(frame, key) {
+    const value = frame[key];
+    return isString(value) ? value : undefined;
+}
+/** Read `key` as a number, or report it absent when the wire says otherwise. */
+function wireNumber(frame, key) {
+    const value = frame[key];
+    return isNumber(value) ? value : undefined;
+}
+function toolCallArgs(frame) {
+    const args = frame["args"];
+    return isRecord(args) ? args : {};
+}
+/** Read a `message` frame's `tool_calls`; anything else reads as none. */
+function parseToolCalls(frame) {
+    const raw = frame["tool_calls"];
+    if (!Array.isArray(raw))
+        return [];
+    const calls = [];
+    for (const entry of raw) {
+        if (!isRecord(entry))
+            continue;
+        const call = entry;
+        calls.push({
+            id: wireString(call, "id") ?? "",
+            name: wireString(call, "name") ?? "",
+            args: toolCallArgs(call)
+        });
+    }
+    return calls;
+}
+function parsePlan(value) {
+    if (!isRecord(value) ||
+        !isString(value["title"]) ||
+        !Array.isArray(value["tasks"]))
+        return null;
+    const tasks = [];
+    for (const task of value["tasks"]) {
+        if (!isRecord(task) ||
+            !isString(task["id"]) ||
+            !isString(task["title"]) ||
+            !Array.isArray(task["steps"]))
+            return null;
+        const steps = [];
+        for (const step of task["steps"]) {
+            if (!isRecord(step) ||
+                !isString(step["id"]) ||
+                !isString(step["instructions"]))
+                return null;
+            steps.push({ id: step["id"], instructions: step["instructions"] });
+        }
+        const dependencies = task["depends_on"];
+        tasks.push({
+            id: task["id"],
+            title: task["title"],
+            depends_on: Array.isArray(dependencies)
+                ? dependencies.filter(isString)
+                : [],
+            steps
+        });
+    }
+    return { title: value["title"], tasks };
+}
+function assistantText(content) {
+    if (isString(content))
+        return content;
+    if (!Array.isArray(content))
+        return "";
+    return content
+        .flatMap((block) => isRecord(block) && block["type"] === "text" && isString(block["text"])
+        ? [block["text"]]
+        : [])
+        .join("");
+}
+/**
+ * Turn one decoded frame into the domain value it stands for, or null when the
+ * client has nothing to do with it. Fields the wire gets wrong read as absent
+ * and fall back to the same defaults the generators used to apply inline.
+ */
+function parseServerFrame(frame) {
+    const type = wireString(frame, "type");
+    // A command-level failure has no `type`, only `error`.
+    if (type === undefined) {
+        const error = wireString(frame, "error");
+        return error === undefined ? null : { type: "error", message: error };
+    }
+    switch (type) {
+        case "chunk":
+            return {
+                type: "chunk",
+                content: wireString(frame, "content") ?? "",
+                done: frame["done"] === true
+            };
+        case "message": {
+            const role = wireString(frame, "role");
+            if (role === "tool") {
+                return {
+                    type: "tool_result",
+                    toolCallId: wireString(frame, "tool_call_id") ?? "",
+                    name: wireString(frame, "name") ?? "",
+                    content: wireString(frame, "content") ?? ""
+                };
+            }
+            if (role === "assistant") {
+                return {
+                    type: "assistant_message",
+                    toolCalls: parseToolCalls(frame),
+                    content: frame["content"]
+                };
+            }
+            return null;
+        }
+        case "tool_call":
+            return {
+                type: "tool_call",
+                id: wireString(frame, "tool_call_id") ?? wireString(frame, "id") ?? "",
+                name: wireString(frame, "name") ?? "",
+                args: toolCallArgs(frame)
+            };
+        case "tool_approval_request":
+            return {
+                type,
+                approvalId: wireString(frame, "approval_id") ?? "",
+                threadId: wireString(frame, "thread_id") ?? "",
+                toolName: wireString(frame, "tool_name") ?? "",
+                category: wireString(frame, "category") ?? "",
+                message: wireString(frame, "message") ?? "",
+                description: wireString(frame, "description") ?? "",
+                args: toolCallArgs(frame)
+            };
+        case "plan_approval_request": {
+            const plan = parsePlan(frame["plan"]);
+            if (!plan)
+                return {
+                    type: "error",
+                    message: "The server sent an invalid approval plan."
+                };
+            return {
+                type,
+                approvalId: wireString(frame, "approval_id") ?? "",
+                threadId: wireString(frame, "thread_id") ?? null,
+                plan
+            };
+        }
+        case "secret_request":
+            return {
+                type,
+                approvalId: wireString(frame, "approval_id") ?? "",
+                threadId: wireString(frame, "thread_id") ?? "",
+                key: wireString(frame, "key") ?? "",
+                description: wireString(frame, "description") ?? null,
+                reason: wireString(frame, "reason") ?? null,
+                helpUrl: wireString(frame, "help_url") ?? null
+            };
+        case "job_update":
+            return {
+                type: "job_update",
+                status: wireString(frame, "status") ?? "unknown",
+                jobId: wireString(frame, "job_id"),
+                workflowId: wireString(frame, "workflow_id"),
+                error: wireString(frame, "error"),
+                result: frame["result"]
+            };
+        case "node_update":
+            return {
+                type: "node_update",
+                nodeId: wireString(frame, "node_id") ?? "",
+                status: wireString(frame, "status") ?? "unknown",
+                error: wireString(frame, "error")
+            };
+        case "output_update":
+            return {
+                type: "output_update",
+                nodeId: wireString(frame, "node_id") ?? "",
+                value: frame["value"],
+                outputType: wireString(frame, "output_type")
+            };
+        case "node_progress":
+            return {
+                type: "node_progress",
+                nodeId: wireString(frame, "node_id") ?? "",
+                progress: wireNumber(frame, "progress") ?? 0,
+                total: wireNumber(frame, "total")
+            };
+        case "error":
+            return {
+                type: "error",
+                message: wireString(frame, "message") ?? "Unknown error"
+            };
+        case "inference_done":
+            return { type: "inference_done" };
+        case "generation_stopped":
+            return { type: "generation_stopped" };
+        default: {
+            const parsed = processingMessageSchema.safeParse(frame);
+            return parsed.success
+                ? { type: "processing", message: parsed.data }
+                : null;
+        }
+    }
+}
 export class WebSocketChatClient {
     wsUrl;
     ws = null;
+    disconnectedMessage = "Not connected to the NodeTool server.";
     contentQueue = [];
     contentWaiters = [];
     constructor(wsUrl) {
@@ -15,94 +220,133 @@ export class WebSocketChatClient {
     async connect() {
         return new Promise((resolve, reject) => {
             const ws = new WebSocket(this.wsUrl);
+            this.ws = ws;
+            this.disconnectedMessage =
+                "Connection to the NodeTool server closed before the response completed.";
+            // Guard so the connect promise settles exactly once: the "error" listener
+            // stays attached for the socket's lifetime, so without this a post-connect
+            // error would call reject() on an already-resolved promise and be silently
+            // swallowed (and an unhandled "error" event would otherwise crash Node).
+            let settled = false;
             ws.on("open", () => {
-                this.ws = ws;
+                if (this.ws !== ws) {
+                    ws.close();
+                    return;
+                }
                 // Switch server to text/JSON mode
                 ws.send(JSON.stringify({ command: "set_mode", data: { mode: "text" } }));
-                resolve();
+                if (!settled) {
+                    settled = true;
+                    resolve();
+                }
+            });
+            ws.on("error", (err) => {
+                this.disconnectedMessage = `NodeTool connection failed: ${err.message}`;
+                if (this.ws === ws)
+                    this.ws = null;
+                if (!settled) {
+                    settled = true;
+                    reject(err);
+                    this.drainWaiters();
+                    return;
+                }
+                // Error after a successful connect: tear down and unblock any waiting
+                // generators so they terminate instead of hanging forever.
+                this.ws = null;
+                this.drainWaiters();
             });
-            ws.on("error", (err) => reject(err));
             ws.on("message", (data) => {
                 try {
-                    const msg = JSON.parse(typeof data === "string" ? data : data.toString("utf8"));
-                    this.handleMessage(msg);
+                    const msg = JSON.parse(isString(data) ? data : data.toString("utf8"));
+                    if (isRecord(msg))
+                        this.handleMessage(msg);
                 }
                 catch {
                     // ignore malformed messages
                 }
             });
             ws.on("close", () => {
-                this.ws = null;
-                // Unblock all pending waiters
-                for (const waiter of this.contentWaiters)
-                    waiter(null);
-                this.contentWaiters = [];
+                if (this.ws === ws)
+                    this.ws = null;
+                if (!settled) {
+                    settled = true;
+                    reject(new Error(this.disconnectedMessage));
+                }
+                this.drainWaiters();
             });
         });
     }
+    /** A dropped connection is a failed response, never a successful completion. */
+    drainWaiters() {
+        const waiters = this.contentWaiters;
+        this.contentWaiters = [];
+        for (const waiter of waiters)
+            waiter({ type: "error", message: this.disconnectedMessage });
+    }
     handleMessage(msg) {
-        const type = typeof msg.type === "string" ? msg.type : null;
         // Auto-respond to server pings
-        if (type === "ping") {
+        if (msg["type"] === "ping") {
             this.send({ type: "pong", ts: Date.now() / 1000 });
             return;
         }
-        // Treat command-level errors (no type field but has error field) as error content events
-        if (!type && typeof msg.error === "string") {
-            const errorEvent = {
-                type: "error",
-                message: msg.error
-            };
-            const waiter = this.contentWaiters.shift();
-            if (waiter) {
-                waiter(errorEvent);
-            }
-            else {
-                this.contentQueue.push(errorEvent);
-            }
+        // Route content events to waiting generators
+        const parsed = parseServerFrame(msg);
+        if (!parsed)
             return;
+        const processing = processingMessageSchema.safeParse(msg);
+        const frame = {
+            ...parsed,
+            scopeThreadId: wireString(msg, "thread_id"),
+            parentToolCallId: wireString(msg, "parent_tool_call_id"),
+            ...(processing.success && { processing: processing.data })
+        };
+        const waiter = this.contentWaiters.shift();
+        if (waiter) {
+            waiter(frame);
         }
-        // Route content events to waiting generators
-        if (this.isContentEvent(type)) {
-            const waiter = this.contentWaiters.shift();
-            if (waiter) {
-                waiter(msg);
-            }
-            else {
-                this.contentQueue.push(msg);
-            }
+        else {
+            this.contentQueue.push(frame);
         }
-        // Ignore: system_stats, command acks (no type field), etc.
-    }
-    isContentEvent(type) {
-        return (type === "chunk" ||
-            type === "message" ||
-            type === "tool_call" ||
-            type === "job_update" ||
-            type === "node_update" ||
-            type === "output_update" ||
-            type === "node_progress" ||
-            type === "error" ||
-            type === "inference_done" ||
-            type === "generation_stopped");
     }
     send(data) {
-        if (this.ws && this.ws.readyState === WebSocket.OPEN) {
-            this.ws.send(JSON.stringify(data));
+        if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+            throw new Error(this.disconnectedMessage);
         }
+        this.ws.send(JSON.stringify(data));
     }
-    nextContent() {
-        if (this.contentQueue.length > 0) {
-            return Promise.resolve(this.contentQueue.shift());
+    nextContent(signal) {
+        if (signal?.aborted)
+            return Promise.resolve(null);
+        const queued = this.contentQueue.shift();
+        if (queued)
+            return Promise.resolve(queued);
+        if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+            return Promise.resolve({
+                type: "error",
+                message: this.disconnectedMessage
+            });
         }
         return new Promise((resolve) => {
-            this.contentWaiters.push(resolve);
+            const receive = (event) => {
+                signal?.removeEventListener("abort", cancel);
+                resolve(event);
+            };
+            const cancel = () => {
+                const index = this.contentWaiters.indexOf(receive);
+                if (index !== -1)
+                    this.contentWaiters.splice(index, 1);
+                receive(null);
+            };
+            this.contentWaiters.push(receive);
+            signal?.addEventListener("abort", cancel, { once: true });
         });
     }
     /** Stateful chat — messages are saved to DB, thread history is loaded. */
-    async *chat(content, threadId, model, provider, tools) {
-        // Drain stale events from previous responses (extra done chunks, final messages, etc.)
-        // that arrived between the previous chat completing and this one starting.
+    async *chat(content, threadId, model, provider, tools, options = {}) {
+        if (options.signal?.aborted) {
+            yield { type: "done" };
+            return;
+        }
         this.contentQueue.length = 0;
         this.send({
             command: "chat_message",
@@ -112,75 +356,142 @@ export class WebSocketChatClient {
                 thread_id: threadId,
                 model,
                 provider,
-                tools: tools ?? []
+                tools: tools ?? [],
+                ...(options.permissionMode && {
+                    permission_mode: options.permissionMode
+                })
             }
         });
-        while (true) {
-            const event = await this.nextContent();
-            if (!event) {
-                yield { type: "done" };
-                return;
-            }
-            const type = event.type;
-            if (type === "chunk") {
-                // Yield content from every chunk — including the done chunk which may carry the last piece
-                const chunkContent = typeof event.content === "string" ? event.content : "";
-                if (chunkContent) {
-                    yield { type: "chunk", content: chunkContent };
+        const cancel = () => {
+            if (this.ws?.readyState === WebSocket.OPEN)
+                this.stop(threadId);
+        };
+        options.signal?.addEventListener("abort", cancel, { once: true });
+        let streamedText = "";
+        const announcedCalls = new Set();
+        const completedCalls = new Set();
+        try {
+            while (true) {
+                const event = await this.nextContent(options.signal);
+                if (!event) {
+                    yield { type: "done" };
+                    return;
                 }
-                // Done chunk signals completion — matches Python's {"type": "chunk", "done": true}
-                if (event.done === true) {
+                if (event.scopeThreadId && event.scopeThreadId !== threadId)
+                    continue;
+                if (event.type === "chunk") {
+                    if (event.processing?.type === "chunk" &&
+                        (event.processing.thinking ||
+                            event.parentToolCallId ||
+                            event.processing.subtask_depth)) {
+                        yield { type: "processing", message: event.processing };
+                        continue;
+                    }
+                    if (event.content) {
+                        if (!event.parentToolCallId)
+                            streamedText += event.content;
+                        yield { type: "chunk", content: event.content };
+                    }
+                    // A delegated loop finishing does not finish its parent turn.
+                    if (event.done && !event.parentToolCallId) {
+                        yield { type: "done" };
+                        return;
+                    }
+                }
+                else if (event.type === "assistant_message") {
+                    if (event.content != null) {
+                        const fullText = assistantText(event.content);
+                        const text = fullText.startsWith(streamedText)
+                            ? fullText.slice(streamedText.length)
+                            : fullText;
+                        if (!event.parentToolCallId)
+                            streamedText = "";
+                        if (text || Array.isArray(event.content)) {
+                            yield { type: "assistant_message", content: event.content, text };
+                        }
+                    }
+                    for (const call of event.toolCalls) {
+                        if (announcedCalls.has(call.id))
+                            continue;
+                        announcedCalls.add(call.id);
+                        yield { type: "tool_call", ...call };
+                    }
+                }
+                else if (event.type === "tool_call") {
+                    yield {
+                        type: "client_tool_call",
+                        id: event.id,
+                        name: event.name,
+                        args: event.args,
+                        threadId: event.scopeThreadId ?? threadId
+                    };
+                }
+                else if (event.type === "tool_result") {
+                    if (completedCalls.has(event.toolCallId))
+                        continue;
+                    completedCalls.add(event.toolCallId);
+                    yield {
+                        type: "tool_result",
+                        id: event.toolCallId,
+                        name: event.name,
+                        content: event.content
+                    };
+                }
+                else if (event.type === "output_update") {
+                    yield {
+                        type: "output_update",
+                        node_id: event.nodeId,
+                        value: event.value,
+                        output_type: event.outputType
+                    };
+                }
+                else if (event.type === "generation_stopped") {
                     yield { type: "done" };
                     return;
                 }
-            }
-            else if (type === "message") {
-                const role = event.role;
-                if (role === "assistant" && Array.isArray(event.tool_calls)) {
-                    // Assistant decided to call tool(s) — yield each one
-                    for (const tc of event.tool_calls) {
+                else if (event.type === "error") {
+                    yield { type: "error", message: event.message };
+                    return;
+                }
+                else if (event.type === "tool_approval_request" ||
+                    event.type === "plan_approval_request" ||
+                    event.type === "secret_request") {
+                    yield event;
+                }
+                else if (event.type === "processing") {
+                    const message = event.message;
+                    if (message.type === "tool_call_update" &&
+                        message.tool_call_id &&
+                        !announcedCalls.has(message.tool_call_id)) {
+                        announcedCalls.add(message.tool_call_id);
                         yield {
                             type: "tool_call",
-                            id: typeof tc.id === "string" ? tc.id : "",
-                            name: typeof tc.name === "string" ? tc.name : "",
-                            args: (tc.args ?? {})
+                            id: message.tool_call_id,
+                            name: message.name,
+                            args: message.args
                         };
                     }
+                    else if (message.type === "tool_result_update" &&
+                        message.tool_call_id &&
+                        !completedCalls.has(message.tool_call_id)) {
+                        completedCalls.add(message.tool_call_id);
+                        yield {
+                            type: "tool_result",
+                            id: message.tool_call_id,
+                            name: message.name ?? "",
+                            content: JSON.stringify(message.result)
+                        };
+                    }
+                    yield { type: "processing", message };
                 }
-                else if (role === "tool") {
-                    // Tool result — yield for display
-                    yield {
-                        type: "tool_result",
-                        id: typeof event.tool_call_id === "string" ? event.tool_call_id : "",
-                        name: typeof event.name === "string" ? event.name : "",
-                        content: typeof event.content === "string" ? event.content : ""
-                    };
+                else if (event.processing) {
+                    yield { type: "processing", message: event.processing };
                 }
-                // Final assistant message (no tool_calls) is ignored — content already streamed via chunks
-                continue;
-            }
-            else if (type === "output_update") {
-                yield {
-                    type: "output_update",
-                    node_id: typeof event.node_id === "string" ? event.node_id : "",
-                    value: event.value,
-                    output_type: typeof event.output_type === "string"
-                        ? event.output_type
-                        : undefined
-                };
-            }
-            else if (type === "job_update" || type === "generation_stopped") {
-                yield { type: "done" };
-                return;
-            }
-            else if (type === "error") {
-                yield {
-                    type: "error",
-                    message: typeof event.message === "string" ? event.message : "Unknown error"
-                };
-                return;
             }
         }
+        finally {
+            options.signal?.removeEventListener("abort", cancel);
+        }
     }
     /** Stateless inference — takes full messages array, streams back, no DB. Used by agent mode. */
     async *inference(messages, model, provider, tools) {
@@ -194,34 +505,30 @@ export class WebSocketChatClient {
                 yield { type: "done" };
                 return;
             }
-            const type = event.type;
-            if (type === "chunk") {
-                const chunkContent = typeof event.content === "string" ? event.content : "";
-                if (chunkContent) {
-                    yield { type: "chunk", content: chunkContent };
+            if (event.type === "chunk") {
+                if (event.content) {
+                    yield { type: "chunk", content: event.content };
                 }
-                if (event.done === true) {
+                if (event.done) {
                     yield { type: "done" };
                     return;
                 }
             }
-            else if (type === "tool_call") {
+            else if (event.type === "tool_call") {
                 yield {
                     type: "tool_call",
-                    id: typeof event.id === "string" ? event.id : "",
-                    name: typeof event.name === "string" ? event.name : "",
-                    args: (event.args ?? {})
+                    id: event.id,
+                    name: event.name,
+                    args: event.args
                 };
             }
-            else if (type === "inference_done" || type === "generation_stopped") {
+            else if (event.type === "inference_done" ||
+                event.type === "generation_stopped") {
                 yield { type: "done" };
                 return;
             }
-            else if (type === "error") {
-                yield {
-                    type: "error",
-                    message: typeof event.message === "string" ? event.message : "Unknown error"
-                };
+            else if (event.type === "error") {
+                yield { type: "error", message: event.message };
                 return;
             }
         }
@@ -252,16 +559,7 @@ export class WebSocketChatClient {
         });
         yield* this.consumeJobEvents();
     }
-    /** Resume a paused/interrupted job. */
-    async *resumeJob(jobId, workflowId) {
-        this.contentQueue.length = 0;
-        this.send({
-            command: "resume_job",
-            data: { job_id: jobId, workflow_id: workflowId }
-        });
-        yield* this.consumeJobEvents();
-    }
-    /** Shared job event consumer used by runJob, reconnectJob, resumeJob. */
+    /** Shared job event consumer used by runJob and reconnectJob. */
     async *consumeJobEvents() {
         while (true) {
             const event = await this.nextContent();
@@ -269,58 +567,49 @@ export class WebSocketChatClient {
                 yield { type: "done" };
                 return;
             }
-            const type = event.type;
-            if (type === "job_update") {
-                const status = typeof event.status === "string" ? event.status : "unknown";
+            if (event.type === "job_update") {
                 yield {
                     type: "job_update",
-                    status,
-                    job_id: typeof event.job_id === "string" ? event.job_id : undefined,
-                    workflow_id: typeof event.workflow_id === "string"
-                        ? event.workflow_id
-                        : undefined,
-                    error: typeof event.error === "string" ? event.error : undefined,
+                    status: event.status,
+                    job_id: event.jobId,
+                    workflow_id: event.workflowId,
+                    error: event.error,
                     result: event.result
                 };
-                if (["completed", "failed", "cancelled", "error"].includes(status)) {
+                if (["completed", "failed", "cancelled", "error"].includes(event.status)) {
                     yield { type: "done" };
                     return;
                 }
             }
-            else if (type === "node_update") {
+            else if (event.type === "node_update") {
                 yield {
                     type: "node_update",
-                    node_id: typeof event.node_id === "string" ? event.node_id : "",
-                    status: typeof event.status === "string" ? event.status : "unknown",
-                    error: typeof event.error === "string" ? event.error : undefined
+                    node_id: event.nodeId,
+                    status: event.status,
+                    error: event.error
                 };
             }
-            else if (type === "output_update") {
+            else if (event.type === "output_update") {
                 yield {
                     type: "output_update",
-                    node_id: typeof event.node_id === "string" ? event.node_id : "",
+                    node_id: event.nodeId,
                     value: event.value,
-                    output_type: typeof event.output_type === "string"
-                        ? event.output_type
-                        : undefined
+                    output_type: event.outputType
                 };
             }
-            else if (type === "node_progress") {
+            else if (event.type === "node_progress") {
                 yield {
                     type: "node_progress",
-                    node_id: typeof event.node_id === "string" ? event.node_id : "",
-                    progress: typeof event.progress === "number" ? event.progress : 0,
-                    total: typeof event.total === "number" ? event.total : undefined
+                    node_id: event.nodeId,
+                    progress: event.progress,
+                    total: event.total
                 };
             }
-            else if (type === "error") {
-                yield {
-                    type: "error",
-                    message: typeof event.message === "string" ? event.message : "Unknown error"
-                };
+            else if (event.type === "error") {
+                yield { type: "error", message: event.message };
                 return;
             }
-            else if (type === "generation_stopped") {
+            else if (event.type === "generation_stopped") {
                 yield { type: "done" };
                 return;
             }
@@ -338,14 +627,51 @@ export class WebSocketChatClient {
     stop(threadId) {
         const data = {};
         if (threadId)
-            data["thread_id"] = threadId;
+            data.thread_id = threadId;
         this.send({ command: "stop", data });
     }
+    respondToolApproval(approvalId, decision) {
+        this.send({
+            type: "tool_approval_response",
+            approval_id: approvalId,
+            decision
+        });
+    }
+    respondPlanApproval(approvalId, decision, feedback) {
+        this.send({
+            type: "plan_approval_response",
+            approval_id: approvalId,
+            decision,
+            ...(feedback && { feedback })
+        });
+    }
+    respondSecretRequest(approvalId, status) {
+        this.send({
+            type: "secret_request_response",
+            approval_id: approvalId,
+            status
+        });
+    }
+    respondToolResult(id, threadId, result, ok = true) {
+        this.send({
+            type: "tool_result",
+            tool_call_id: id,
+            thread_id: threadId,
+            result,
+            ok
+        });
+    }
+    setPermissionMode(threadId, mode) {
+        this.send({
+            command: "set_permission_mode",
+            data: { thread_id: threadId, permission_mode: mode }
+        });
+    }
     disconnect() {
-        if (this.ws) {
-            this.ws.close();
-            this.ws = null;
-        }
+        const ws = this.ws;
+        this.ws = null;
+        ws?.close();
+        this.drainWaiters();
     }
 }
 //# sourceMappingURL=websocket-client.js.map