opencandle 0.11.1 → 0.13.0

package/dist/gui/server/session-entry-wait.js

@@ -0,0 +1,129 @@
+export async function waitForEntryCount(getCount, previousCount, options = {}) {
+    const timeoutMs = options.timeoutMs ?? 2_000;
+    const intervalMs = options.intervalMs ?? 25;
+    const deadline = Date.now() + timeoutMs;
+    while (getCount() <= previousCount && Date.now() < deadline) {
+        await delay(intervalMs);
+    }
+    if (getCount() <= previousCount) {
+        throw new Error("Timed out waiting for a new session entry");
+    }
+}
+export async function waitForNewEntryId(getIds, previousIds, options = {}) {
+    const timeoutMs = options.timeoutMs ?? 2_000;
+    const intervalMs = options.intervalMs ?? 25;
+    const deadline = Date.now() + timeoutMs;
+    while (!getIds().some((id) => !previousIds.has(id)) && Date.now() < deadline) {
+        await delay(intervalMs);
+    }
+    if (!getIds().some((id) => !previousIds.has(id))) {
+        throw new Error("Timed out waiting for a new session entry");
+    }
+}
+export async function waitForSessionTurnSettlement(getStatus, options = {}) {
+    const timeoutMs = options.timeoutMs ?? 120_000;
+    const intervalMs = options.intervalMs ?? 25;
+    const idleGraceMs = options.idleGraceMs ?? 250;
+    // timeoutMs bounds STALL, not total runtime: a live workflow run (e.g.
+    // /analyze) stays active for minutes while its status keeps changing, and
+    // capping total runtime failed those runs mid-workflow with
+    // "Timed out waiting for the session turn to settle". A hung session stops
+    // changing status entirely, which is what the deadline must catch.
+    let lastProgressAt = Date.now();
+    let lastSignature;
+    let idleSince;
+    while (true) {
+        const status = getStatus();
+        const signature = `${status.isStreaming}:${status.pendingMessageCount}:${status.progressToken ?? 0}`;
+        if (signature !== lastSignature) {
+            lastSignature = signature;
+            lastProgressAt = Date.now();
+        }
+        const active = status.isStreaming || status.pendingMessageCount > 0;
+        if (active) {
+            idleSince = undefined;
+            if (Date.now() - lastProgressAt >= timeoutMs) {
+                throw new Error("Timed out waiting for the session turn to settle");
+            }
+            await delay(intervalMs);
+            continue;
+        }
+        idleSince ??= Date.now();
+        if (Date.now() - idleSince >= idleGraceMs) {
+            return;
+        }
+        await delay(intervalMs);
+    }
+}
+export function findUnresolvedToolCalls(entries) {
+    const latestAssistantIndex = latestAssistantToolUseIndex(entries);
+    if (latestAssistantIndex === -1)
+        return [];
+    const assistant = asMessage(entries[latestAssistantIndex]);
+    const calls = toolCallsFromContent(assistant?.content);
+    if (calls.length === 0)
+        return [];
+    const resolved = new Set();
+    for (const entry of entries.slice(latestAssistantIndex + 1)) {
+        const message = asMessage(entry);
+        if (message?.role !== "toolResult")
+            continue;
+        const toolCallId = typeof message.toolCallId === "string" ? message.toolCallId : "";
+        if (toolCallId)
+            resolved.add(toolCallId);
+    }
+    return calls.filter((call) => !resolved.has(call.id));
+}
+export async function waitForResolvedToolCalls(getEntries, options = {}) {
+    const timeoutMs = options.timeoutMs ?? 120_000;
+    const intervalMs = options.intervalMs ?? 25;
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        if (findUnresolvedToolCalls(getEntries()).length === 0)
+            return;
+        await delay(intervalMs);
+    }
+    const unresolved = findUnresolvedToolCalls(getEntries());
+    if (unresolved.length > 0) {
+        throw new Error(`Timed out waiting for tool results: ${unresolved.map((call) => call.name).join(", ")}`);
+    }
+}
+function delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function latestAssistantToolUseIndex(entries) {
+    for (let index = entries.length - 1; index >= 0; index--) {
+        const message = asMessage(entries[index]);
+        if (message?.role === "assistant") {
+            if (toolCallsFromContent(message.content).length > 0)
+                return index;
+            if (message.stopReason === "stop")
+                return -1;
+        }
+        if (message?.role === "user")
+            return -1;
+    }
+    return -1;
+}
+function asMessage(entry) {
+    if (entry?.type !== "message")
+        return undefined;
+    const message = entry.message;
+    return typeof message === "object" && message !== null && !Array.isArray(message)
+        ? message
+        : undefined;
+}
+function toolCallsFromContent(content) {
+    if (!Array.isArray(content))
+        return [];
+    return content.flatMap((part) => {
+        if (typeof part !== "object" || part === null || Array.isArray(part))
+            return [];
+        const record = part;
+        if (record.type !== "toolCall")
+            return [];
+        const id = typeof record.id === "string" ? record.id : "";
+        const name = typeof record.name === "string" ? record.name : "tool";
+        return id ? [{ id, name }] : [];
+    });
+}

package/dist/gui/server/session-list.d.ts

@@ -0,0 +1,2 @@
+import { type SessionInfo } from "@earendil-works/pi-coding-agent";
+export declare function listDisplaySessions(cwd: string, sessionDir: string): Promise<SessionInfo[]>;

package/dist/gui/server/session-list.js

@@ -0,0 +1,11 @@
+import { SessionManager } from "@earendil-works/pi-coding-agent";
+// Pi counts every `type: "message"` entry in messageCount (including tool-result
+// messages), and falls back to the literal "(no messages)" firstMessage when a
+// session has no user text. A session is worth listing only when the user named
+// it or it carries actual conversation text.
+const NO_MESSAGES_SENTINEL = "(no messages)";
+export async function listDisplaySessions(cwd, sessionDir) {
+    const sessions = await SessionManager.list(cwd, sessionDir);
+    return sessions.filter((session) => Boolean(session.name?.trim()) ||
+        (session.messageCount > 0 && session.firstMessage !== NO_MESSAGES_SENTINEL));
+}

package/dist/gui/server/shutdown.d.ts

@@ -0,0 +1,10 @@
+import type { Server } from "node:http";
+type Cleanup = () => void | Promise<void>;
+export interface GracefulShutdownOptions {
+    server: Server;
+    cleanup: Cleanup;
+    exit: (code: number) => void;
+    timeoutMs?: number;
+}
+export declare function createGracefulShutdown({ server, cleanup, exit, timeoutMs, }: GracefulShutdownOptions): () => void;
+export {};

package/dist/gui/server/shutdown.js

@@ -0,0 +1,29 @@
+export function createGracefulShutdown({ server, cleanup, exit, timeoutMs = 1000, }) {
+    let shuttingDown = false;
+    let exited = false;
+    const finish = () => {
+        if (exited)
+            return;
+        exited = true;
+        exit(0);
+    };
+    return () => {
+        if (shuttingDown)
+            return;
+        shuttingDown = true;
+        const timeout = setTimeout(() => {
+            server.closeAllConnections?.();
+            finish();
+        }, timeoutMs);
+        timeout.unref?.();
+        void Promise.resolve()
+            .then(cleanup)
+            .catch(() => undefined)
+            .finally(() => {
+            server.close(() => {
+                clearTimeout(timeout);
+                finish();
+            });
+        });
+    };
+}

package/dist/gui/server/tool-invoke-ack.d.ts

@@ -0,0 +1,17 @@
+import type { InvokeToolResult } from "./invoke-tool.js";
+export interface ToolInvokeAckMessage {
+    type: "tool.invoke.result";
+    requestId: string;
+    ok: boolean;
+    toolName: string;
+    result?: {
+        toolCallId: string;
+        content: InvokeToolResult["result"]["content"];
+        details: unknown;
+        isError: boolean;
+    };
+    error?: {
+        message: string;
+    };
+}
+export declare function buildToolInvokeAckMessage(requestId: string, toolName: string, invocation: InvokeToolResult): ToolInvokeAckMessage;

package/dist/gui/server/tool-invoke-ack.js

@@ -0,0 +1,26 @@
+export function buildToolInvokeAckMessage(requestId, toolName, invocation) {
+    const message = {
+        type: "tool.invoke.result",
+        requestId,
+        ok: !invocation.isError,
+        toolName,
+        result: {
+            toolCallId: invocation.toolCallId,
+            content: invocation.result.content,
+            details: invocation.result.details,
+            isError: invocation.isError,
+        },
+    };
+    if (invocation.isError) {
+        message.error = { message: toolResultMessage(invocation) };
+    }
+    return message;
+}
+function toolResultMessage(invocation) {
+    for (const item of invocation.result.content) {
+        if (item?.type === "text" && typeof item.text === "string" && item.text.trim()) {
+            return item.text.trim();
+        }
+    }
+    return `${invocation.toolCallId} failed`;
+}

package/dist/gui/server/tool-metadata.d.ts

@@ -0,0 +1,93 @@
+export declare function buildCatalog(): {
+    tools: {
+        name: string;
+        label: string;
+        description: string;
+        parameters: import("@earendil-works/pi-ai").TSchema;
+        domain: string;
+        enabled: boolean;
+        defaults: import("../../memory/tool-defaults.js").ToolDefaults;
+    }[];
+    workflows: {
+        id: string;
+        name: string;
+        description: string;
+        prompt: string;
+        slots: {
+            name: string;
+            label: string;
+            type: string;
+        }[];
+    }[];
+    providers: ({
+        id: import("../../onboarding/providers.js").ApiKeyProviderId | import("../../onboarding/providers.js").ExternalToolProviderId | import("../../onboarding/providers.js").PublicHttpProviderId;
+        kind: "api-key" | "external-tool" | "public-http";
+        displayName: string;
+        category: import("../../onboarding/providers.js").ProviderCategory;
+        tier: import("../../onboarding/providers.js").ProviderTier;
+        aliases: readonly string[];
+        unlocks: readonly string[];
+        fallbackDescription: string | null;
+        instructionsHint: string;
+        source: "absent" | "env" | "file";
+        configured: boolean;
+        maskedKeyHint: string | undefined;
+        status: "absent" | "env" | "file";
+        signupUrl: string;
+        freeTier: boolean;
+        envVar: string;
+    } | {
+        id: import("../../onboarding/providers.js").ApiKeyProviderId | import("../../onboarding/providers.js").ExternalToolProviderId | import("../../onboarding/providers.js").PublicHttpProviderId;
+        kind: "api-key" | "external-tool" | "public-http";
+        displayName: string;
+        category: import("../../onboarding/providers.js").ProviderCategory;
+        tier: import("../../onboarding/providers.js").ProviderTier;
+        aliases: readonly string[];
+        unlocks: readonly string[];
+        fallbackDescription: string | null;
+        instructionsHint: string;
+        status: string;
+        statusDetail: {
+            providerId: import("../../onboarding/providers.js").ExternalToolProviderId;
+            kind: string;
+            mode: string;
+            state: string;
+            installCmd: string;
+            message: string;
+            checkedAt: string;
+            cacheHit: boolean;
+        };
+        binary: string;
+        installCmd: string;
+        sessionSource: "browser-cookies";
+        supportedBrowsers: readonly string[] | undefined;
+    } | {
+        id: import("../../onboarding/providers.js").ApiKeyProviderId | import("../../onboarding/providers.js").ExternalToolProviderId | import("../../onboarding/providers.js").PublicHttpProviderId;
+        kind: "api-key" | "external-tool" | "public-http";
+        displayName: string;
+        category: import("../../onboarding/providers.js").ProviderCategory;
+        tier: import("../../onboarding/providers.js").ProviderTier;
+        aliases: readonly string[];
+        unlocks: readonly string[];
+        fallbackDescription: string | null;
+        instructionsHint: string;
+        status: string;
+        binary: string;
+        installCmd: string;
+        sessionSource: "browser-cookies";
+        supportedBrowsers: readonly string[] | undefined;
+    } | {
+        id: import("../../onboarding/providers.js").ApiKeyProviderId | import("../../onboarding/providers.js").ExternalToolProviderId | import("../../onboarding/providers.js").PublicHttpProviderId;
+        kind: "api-key" | "external-tool" | "public-http";
+        displayName: string;
+        category: import("../../onboarding/providers.js").ProviderCategory;
+        tier: import("../../onboarding/providers.js").ProviderTier;
+        aliases: readonly string[];
+        unlocks: readonly string[];
+        fallbackDescription: string | null;
+        instructionsHint: string;
+        status: string;
+        probeUrl: string;
+    })[];
+};
+export declare function setToolEnabled(toolName: string, enabled: boolean): void;

package/dist/gui/server/tool-metadata.js

@@ -0,0 +1,148 @@
+import { getOpenCandleToolDefinitions } from "../../index.js";
+import { getAllDefaults, setDefault } from "../../memory/tool-defaults.js";
+import { getCredential, isApiKeyProvider, isExternalToolProvider, isPublicHttpProvider, PROVIDERS, } from "../../onboarding/providers.js";
+import { loadOnboardingState } from "../../onboarding/state.js";
+const WORKFLOWS = [
+    {
+        id: "comprehensive_analysis",
+        name: "Comprehensive Analysis",
+        description: "Run the multi-analyst stock analysis workflow.",
+        prompt: "/analyze {symbol}",
+        slots: [{ name: "symbol", label: "Symbol", type: "text" }],
+    },
+    {
+        id: "portfolio_builder",
+        name: "Portfolio Builder",
+        description: "Build a diversified portfolio from goals and constraints.",
+        prompt: "Build me a portfolio for {objective}",
+        slots: [{ name: "objective", label: "Objective", type: "text" }],
+    },
+    {
+        id: "options_screener",
+        name: "Options Screener",
+        description: "Screen option chains for a target symbol.",
+        prompt: "Screen options for {symbol}",
+        slots: [{ name: "symbol", label: "Symbol", type: "text" }],
+    },
+    {
+        id: "compare_assets",
+        name: "Compare Assets",
+        description: "Compare two or more assets side by side.",
+        prompt: "Compare {symbols}",
+        slots: [{ name: "symbols", label: "Symbols", type: "text" }],
+    },
+];
+export function buildCatalog() {
+    const defaults = getAllDefaults();
+    const onboardingState = loadOnboardingState();
+    const tools = getOpenCandleToolDefinitions().map((tool) => ({
+        name: tool.name,
+        label: tool.label,
+        description: tool.description,
+        parameters: tool.parameters,
+        domain: inferDomain(tool.name),
+        enabled: defaults.get(tool.name)?.__enabled !== false,
+        defaults: defaults.get(tool.name) ?? {},
+    }));
+    return {
+        tools,
+        workflows: WORKFLOWS,
+        providers: PROVIDERS.map((provider) => serializeProvider(provider, onboardingState)),
+    };
+}
+function serializeProvider(provider, onboardingState) {
+    const common = {
+        id: provider.id,
+        kind: provider.kind,
+        displayName: provider.displayName,
+        category: provider.category,
+        tier: provider.tier,
+        aliases: provider.aliases,
+        unlocks: provider.unlocks,
+        fallbackDescription: provider.fallbackDescription,
+        instructionsHint: provider.instructionsHint,
+    };
+    if (isApiKeyProvider(provider)) {
+        // Never serialize the credential value: this payload reaches the browser DOM.
+        const credential = getCredential(provider.id);
+        const source = credential.source;
+        return {
+            ...common,
+            source,
+            configured: source !== "absent",
+            maskedKeyHint: credential.value ? `…${credential.value.slice(-4)}` : undefined,
+            status: source,
+            signupUrl: provider.signupUrl,
+            freeTier: provider.freeTier,
+            envVar: provider.envVar,
+        };
+    }
+    if (isExternalToolProvider(provider)) {
+        if (onboardingState.providers[provider.id]?.status === "never_ask") {
+            return {
+                ...common,
+                status: "skipped",
+                statusDetail: {
+                    providerId: provider.id,
+                    kind: "external-tool",
+                    mode: "install",
+                    state: "skipped",
+                    installCmd: provider.installCmd,
+                    message: `Skipped by user preference; run opencandle doctor --enable ${provider.id} to re-enable.`,
+                    checkedAt: new Date().toISOString(),
+                    cacheHit: false,
+                },
+                binary: provider.binary,
+                installCmd: provider.installCmd,
+                sessionSource: provider.sessionSource,
+                supportedBrowsers: provider.supportedBrowsers,
+            };
+        }
+        return {
+            ...common,
+            status: "unknown",
+            binary: provider.binary,
+            installCmd: provider.installCmd,
+            sessionSource: provider.sessionSource,
+            supportedBrowsers: provider.supportedBrowsers,
+        };
+    }
+    if (isPublicHttpProvider(provider)) {
+        return {
+            ...common,
+            status: "unknown",
+            probeUrl: provider.probeUrl,
+        };
+    }
+    const exhaustive = provider;
+    return exhaustive;
+}
+export function setToolEnabled(toolName, enabled) {
+    setDefault(toolName, "__enabled", enabled);
+}
+function inferDomain(toolName) {
+    if (toolName.includes("option"))
+        return "options";
+    if (toolName.includes("portfolio") ||
+        toolName.includes("risk") ||
+        toolName.includes("correlation"))
+        return "portfolio";
+    if (toolName.includes("sentiment") ||
+        toolName.includes("reddit") ||
+        toolName.includes("twitter") ||
+        toolName.includes("web"))
+        return "sentiment";
+    if (toolName.includes("economic") || toolName.includes("fear"))
+        return "macro";
+    if (toolName.includes("technical") || toolName.includes("backtest"))
+        return "technical";
+    if (toolName.includes("company") ||
+        toolName.includes("financial") ||
+        toolName.includes("earnings") ||
+        toolName.includes("dcf") ||
+        toolName.includes("sec"))
+        return "fundamentals";
+    if (toolName.includes("ask_user") || toolName.includes("login"))
+        return "interaction";
+    return "market";
+}

package/dist/gui/server/websocket.d.ts

@@ -0,0 +1,9 @@
+import type { IncomingMessage } from "node:http";
+import type { Duplex } from "node:stream";
+export interface WsClient {
+    send(data: unknown): void;
+    close(): void;
+    onMessage(handler: (data: unknown) => void): void;
+    onClose(handler: () => void): void;
+}
+export declare function acceptWebSocket(req: IncomingMessage, socket: Duplex): WsClient;

package/dist/gui/server/websocket.js

@@ -0,0 +1,124 @@
+import { createHash } from "node:crypto";
+export function acceptWebSocket(req, socket) {
+    const key = req.headers["sec-websocket-key"];
+    if (typeof key !== "string") {
+        socket.destroy();
+        throw new Error("Missing Sec-WebSocket-Key");
+    }
+    const accept = createHash("sha1")
+        .update(`${key}258EAFA5-E914-47DA-95CA-C5AB0DC85B11`)
+        .digest("base64");
+    socket.write([
+        "HTTP/1.1 101 Switching Protocols",
+        "Upgrade: websocket",
+        "Connection: Upgrade",
+        `Sec-WebSocket-Accept: ${accept}`,
+        "",
+        "",
+    ].join("\r\n"));
+    const messageHandlers = [];
+    const closeHandlers = [];
+    let buffer = Buffer.alloc(0);
+    socket.on("data", (chunk) => {
+        buffer = Buffer.concat([buffer, chunk]);
+        while (true) {
+            const frame = readFrame(buffer);
+            if (!frame)
+                break;
+            buffer = buffer.subarray(frame.bytesRead);
+            if (frame.opcode === 8) {
+                socket.end();
+                break;
+            }
+            if (frame.opcode !== 1)
+                continue;
+            try {
+                const parsed = JSON.parse(frame.payload.toString("utf8"));
+                for (const handler of messageHandlers) {
+                    handler(parsed);
+                }
+            }
+            catch {
+                // Ignore malformed client frames; the GUI reconnects on protocol errors.
+            }
+        }
+    });
+    socket.on("close", () => {
+        for (const handler of closeHandlers) {
+            handler();
+        }
+    });
+    socket.on("error", () => {
+        for (const handler of closeHandlers) {
+            handler();
+        }
+    });
+    return {
+        send(data) {
+            if (socket.destroyed)
+                return;
+            socket.write(writeFrame(Buffer.from(JSON.stringify(data), "utf8")));
+        },
+        close() {
+            socket.end();
+        },
+        onMessage(handler) {
+            messageHandlers.push(handler);
+        },
+        onClose(handler) {
+            closeHandlers.push(handler);
+        },
+    };
+}
+function readFrame(buffer) {
+    if (buffer.length < 2)
+        return null;
+    const opcode = buffer[0] & 0x0f;
+    let length = buffer[1] & 0x7f;
+    let offset = 2;
+    if (length === 126) {
+        if (buffer.length < offset + 2)
+            return null;
+        length = buffer.readUInt16BE(offset);
+        offset += 2;
+    }
+    else if (length === 127) {
+        if (buffer.length < offset + 8)
+            return null;
+        const big = buffer.readBigUInt64BE(offset);
+        if (big > BigInt(Number.MAX_SAFE_INTEGER))
+            throw new Error("Frame too large");
+        length = Number(big);
+        offset += 8;
+    }
+    const masked = (buffer[1] & 0x80) !== 0;
+    const mask = masked ? buffer.subarray(offset, offset + 4) : null;
+    if (masked)
+        offset += 4;
+    if (buffer.length < offset + length)
+        return null;
+    const payload = Buffer.from(buffer.subarray(offset, offset + length));
+    if (mask) {
+        for (let i = 0; i < payload.length; i++) {
+            payload[i] ^= mask[i % 4];
+        }
+    }
+    return { opcode, payload, bytesRead: offset + length };
+}
+function writeFrame(payload) {
+    if (payload.length < 126) {
+        return Buffer.concat([Buffer.from([0x81, payload.length]), payload]);
+    }
+    if (payload.length <= 65535) {
+        const header = Buffer.alloc(4);
+        header[0] = 0x81;
+        header[1] = 126;
+        header.writeUInt16BE(payload.length, 2);
+        return Buffer.concat([header, payload]);
+    }
+    const header = Buffer.alloc(10);
+    header[0] = 0x81;
+    header[1] = 127;
+    header.writeBigUInt64BE(BigInt(payload.length), 2);
+    return Buffer.concat([header, payload]);
+}

package/dist/gui/server/writer-lock.d.ts

@@ -0,0 +1 @@
+export * from "../../pi/session-writer-lock.js";

package/dist/gui/server/writer-lock.js

@@ -0,0 +1 @@
+export * from "../../pi/session-writer-lock.js";

package/dist/gui/server/ws-hub.d.ts

@@ -0,0 +1,50 @@
+import type { IncomingMessage } from "node:http";
+import type { Duplex } from "node:stream";
+import type { AgentSession, SessionEntry } from "@earendil-works/pi-coding-agent";
+import type { ChatEvent } from "../shared/chat-events.js";
+import type { BackgroundQuoteRefreshes } from "./background-quotes.js";
+import type { ToolInvokeController } from "./invoke-tool.js";
+import type { ModelSetupController } from "./model-setup.js";
+import type { SessionActionsController } from "./session-actions.js";
+import { acceptWebSocket, type WsClient } from "./websocket.js";
+interface AskUserBridge {
+    getPrompts(): unknown[];
+}
+export interface WsHub {
+    handleUpgrade(req: IncomingMessage, socket: Duplex): void;
+    getClientCount(): number;
+    closeClients(): void;
+    sendBoot(client: WsClient): void;
+    buildBootstrapPayload(): Promise<Record<string, unknown>>;
+    broadcast(message: unknown): void;
+    broadcastModelSetup(): void;
+    broadcastState(): void;
+    broadcastSessionSnapshot(sessionManager: SessionManager): void;
+    broadcastSessions(): void;
+    buildStateSnapshot(): {
+        sessionId: string;
+        state: unknown;
+        entries: SessionEntry[];
+        events: ChatEvent[];
+    };
+    currentChatEvents(entries?: SessionEntry[]): ChatEvent[];
+    subscribeToSessionEvents(): () => void;
+}
+export interface WsHubOptions {
+    role: string;
+    lock: unknown;
+    cwd: string;
+    sessionDir: string;
+    getSession: () => AgentSession;
+    getSessionManager: () => SessionManager;
+    backgroundQuoteRefreshes: BackgroundQuoteRefreshes;
+    askUserBridge: AskUserBridge;
+    modelSetupController: ModelSetupController;
+    toolInvokeController: ToolInvokeController;
+    sessionActionsController: SessionActionsController;
+    onClientCountChanged: () => void;
+    isTrustedRequest?: (req: IncomingMessage) => boolean;
+    acceptWebSocketFn?: typeof acceptWebSocket;
+}
+export declare function createWsHub({ role, lock, cwd, sessionDir, getSession, getSessionManager, backgroundQuoteRefreshes, askUserBridge, modelSetupController, toolInvokeController, sessionActionsController, onClientCountChanged, isTrustedRequest, acceptWebSocketFn, }: WsHubOptions): WsHub;
+export {};