@contextual-io/cli 0.7.1 → 0.8.0

package/dist/mcp/socket-bridge.js

@@ -0,0 +1,357 @@
+import { randomUUID } from "node:crypto";
+import { io } from "socket.io-client";
+import { McpBindSessionFailure, McpBindSessionResponse, McpCommandStatus, McpListSessionsResponse, McpManifestResponse, McpToolError, McpToolRegistrySync, McpToolResult } from "../models/mcp.js";
+import { McpDetachedPayload, McpSessionAvailablePayload, McpSessionUnavailablePayload, } from "./contracts.js";
+const mcpNamespace = "/mcp";
+const toSocketIoUrl = (routeUrl) => `${routeUrl.protocol}//${routeUrl.host}`;
+const getConnectErrorMessage = (error) => {
+    const message = error.message || "Socket.IO connection failed";
+    const type = error.type ? ` (${error.type})` : "";
+    return `${message}${type}`;
+};
+export const getMcpSocketRoute = ({ url }) => {
+    let routeUrl;
+    try {
+        routeUrl = new URL(url);
+    }
+    catch {
+        throw new McpSocketBridgeError(`Invalid route URL '${url}'`, "INVALID_CONNECT_ROUTE");
+    }
+    if (routeUrl.protocol !== "http:" && routeUrl.protocol !== "https:") {
+        throw new McpSocketBridgeError(`Route URL must use http:// or https:// (received '${url}')`, "INVALID_CONNECT_ROUTE");
+    }
+    if (routeUrl.search || routeUrl.hash) {
+        throw new McpSocketBridgeError(`Websocket URL cannot include query string or hash (received '${url}')`, "INVALID_CONNECT_ROUTE");
+    }
+    const normalizedPathname = (routeUrl.pathname.length > 1 && routeUrl.pathname.endsWith("/")
+        ? routeUrl.pathname.slice(0, -1)
+        : routeUrl.pathname) || "/";
+    const path = normalizedPathname.endsWith(mcpNamespace)
+        ? normalizedPathname.slice(0, -mcpNamespace.length) || "/"
+        : normalizedPathname;
+    const connectUrl = toSocketIoUrl(routeUrl);
+    const namespaceUrl = new URL(mcpNamespace, `${connectUrl}/`).toString();
+    return {
+        connectUrl,
+        namespace: mcpNamespace,
+        namespaceUrl,
+        path,
+        url: routeUrl.toString(),
+    };
+};
+export class McpSocketBridgeError extends Error {
+    code;
+    constructor(message, code) {
+        super(message);
+        this.code = code;
+        this.name = "McpSocketBridgeError";
+    }
+}
+export class McpSocketBridge {
+    boundFlowId;
+    commandQueue = Promise.resolve();
+    handlers;
+    pendingCommands = new Map();
+    socket;
+    constructor(handlers = {}) {
+        this.handlers = handlers;
+    }
+    get isConnected() {
+        return this.socket?.connected ?? false;
+    }
+    async bindSession({ flowId }) {
+        const socket = this.requireSocket();
+        return new Promise((resolve, reject) => {
+            let settled = false;
+            const timer = setTimeout(() => {
+                if (settled)
+                    return;
+                settled = true;
+                reject(new McpSocketBridgeError("Timed out waiting for bind response", "BIND_TIMEOUT"));
+            }, 60_000);
+            socket.emit("mcp-bind-session", { flowId }, (response) => {
+                if (settled)
+                    return;
+                settled = true;
+                clearTimeout(timer);
+                const failure = McpBindSessionFailure.safeParse(response);
+                if (failure.success && failure.data.code) {
+                    reject(new McpSocketBridgeError(failure.data.message, "BIND_FAILED"));
+                    return;
+                }
+                const parsed = McpBindSessionResponse.safeParse(response);
+                if (!parsed.success) {
+                    reject(new McpSocketBridgeError("Invalid bind-session response payload", "BIND_FAILED"));
+                    return;
+                }
+                this.boundFlowId = parsed.data.flowId;
+                resolve(parsed.data);
+            });
+        });
+    }
+    async connect({ interfaceType, orgId, token, url }) {
+        if (this.socket) {
+            throw new McpSocketBridgeError("An MCP socket is already active", "ALREADY_CONNECTED");
+        }
+        const route = getMcpSocketRoute({ url });
+        const socket = io(route.namespaceUrl, {
+            auth: { token },
+            path: route.path,
+            query: { interfaceType, orgId },
+            reconnection: false,
+            transports: ["websocket", "polling"],
+            tryAllTransports: true,
+        });
+        return new Promise((resolve, reject) => {
+            let settled = false;
+            const cleanup = () => {
+                socket.off("connect", onConnect);
+                socket.off("connect_error", onConnectError);
+            };
+            const fail = (error) => {
+                if (settled)
+                    return;
+                settled = true;
+                cleanup();
+                socket.removeAllListeners();
+                socket.disconnect();
+                reject(error);
+            };
+            const onConnect = () => {
+                if (settled)
+                    return;
+                settled = true;
+                cleanup();
+                this.socket = socket;
+                this.bindPersistentListeners(socket);
+                resolve({ connectedAt: Date.now() });
+            };
+            const onConnectError = (error) => {
+                fail(new McpSocketBridgeError(getConnectErrorMessage(error), "CONNECT_ERROR"));
+            };
+            socket.on("connect", onConnect);
+            socket.on("connect_error", onConnectError);
+        });
+    }
+    async disconnect() {
+        if (!this.socket) {
+            return;
+        }
+        const { boundFlowId, socket } = this;
+        this.socket = undefined;
+        this.boundFlowId = undefined;
+        const disconnectInfo = boundFlowId ? await this.notifyRemoteDisconnect(socket) : undefined;
+        socket.removeAllListeners();
+        socket.disconnect();
+        this.rejectAllPendingCommands(new McpSocketBridgeError("Disconnected before command completion", "DISCONNECTED_DURING_COMMAND"));
+        return {
+            detachedAt: disconnectInfo?.detachedAt ?? Date.now(),
+        };
+    }
+    hasActiveSocket() {
+        return Boolean(this.socket);
+    }
+    async listSessions({ flowId, interfaceType }) {
+        const socket = this.requireSocket();
+        return new Promise((resolve, reject) => {
+            let settled = false;
+            const timer = setTimeout(() => {
+                if (settled)
+                    return;
+                settled = true;
+                reject(new McpSocketBridgeError("Timed out waiting for session list", "LIST_SESSIONS_FAILED"));
+            }, 15_000);
+            socket.emit("mcp-list-sessions", {
+                interfaceType,
+                ...(flowId !== undefined && { flowId }),
+            }, (response) => {
+                if (settled)
+                    return;
+                settled = true;
+                clearTimeout(timer);
+                const parsed = McpListSessionsResponse.safeParse(response);
+                if (!parsed.success) {
+                    reject(new McpSocketBridgeError("Invalid list-sessions response payload", "LIST_SESSIONS_FAILED"));
+                    return;
+                }
+                resolve(parsed.data);
+            });
+        });
+    }
+    async requestManifest(interfaceType) {
+        const socket = this.requireSocket();
+        return new Promise((resolve, reject) => {
+            let settled = false;
+            const timer = setTimeout(() => {
+                if (settled)
+                    return;
+                settled = true;
+                reject(new McpSocketBridgeError("Timed out waiting for manifest response", "MANIFEST_TIMEOUT"));
+            }, 15_000);
+            socket.emit("mcp-request-manifest", { interfaceType }, (response) => {
+                if (settled)
+                    return;
+                settled = true;
+                clearTimeout(timer);
+                const parsed = McpManifestResponse.safeParse(response);
+                if (!parsed.success) {
+                    reject(new McpSocketBridgeError("Invalid manifest response payload", "MANIFEST_FETCH_FAILED"));
+                    return;
+                }
+                resolve(parsed.data);
+            });
+        });
+    }
+    async runTool(params) {
+        return new Promise((resolve, reject) => {
+            this.commandQueue = this.commandQueue.then(() => this.executeToolCommand(params).then(resolve, reject));
+        });
+    }
+    async unbindSession() {
+        if (!this.boundFlowId) {
+            return;
+        }
+        const socket = this.requireSocket();
+        this.boundFlowId = undefined;
+        return new Promise((resolve) => {
+            let settled = false;
+            const timer = setTimeout(() => {
+                if (settled)
+                    return;
+                settled = true;
+                resolve();
+            }, 5000);
+            socket.emit("mcp-unbind-session", {}, () => {
+                if (settled)
+                    return;
+                settled = true;
+                clearTimeout(timer);
+                resolve();
+            });
+        });
+    }
+    bindPersistentListeners(socket) {
+        socket.on("mcp-tool-registry", (payload) => {
+            const parsed = McpToolRegistrySync.safeParse(payload);
+            if (!parsed.success) {
+                return;
+            }
+            this.handlers.onToolRegistrySync?.(parsed.data);
+        });
+        socket.on("mcp-command-status", (payload) => {
+            const parsed = McpCommandStatus.safeParse(payload);
+            if (!parsed.success) {
+                return;
+            }
+            this.handlers.onCommandStatus?.(parsed.data);
+            const pendingCommand = this.pendingCommands.get(parsed.data.commandId);
+            if (!pendingCommand) {
+                return;
+            }
+            if (parsed.data.status === "failed" || parsed.data.status === "timeout") {
+                this.pendingCommands.delete(parsed.data.commandId);
+                pendingCommand.reject(new McpSocketBridgeError(parsed.data.error?.message ?? parsed.data.progress?.message ?? `Tool command ${parsed.data.status}`, "MCP_ERROR"));
+            }
+        });
+        socket.on("mcp-tool-result", (payload) => {
+            const parsed = McpToolResult.safeParse(payload);
+            if (!parsed.success) {
+                return;
+            }
+            const pendingCommand = this.pendingCommands.get(parsed.data.commandId);
+            if (!pendingCommand) {
+                return;
+            }
+            this.pendingCommands.delete(parsed.data.commandId);
+            pendingCommand.resolve(parsed.data.result);
+        });
+        socket.on("mcp-tool-error", (payload) => {
+            const parsed = McpToolError.safeParse(payload);
+            if (!parsed.success) {
+                return;
+            }
+            this.rejectAllPendingCommands(new McpSocketBridgeError(parsed.data.message, "MCP_ERROR"));
+        });
+        socket.on("mcp-session-available", (payload) => {
+            const parsed = McpSessionAvailablePayload.safeParse(payload);
+            if (!parsed.success) {
+                return;
+            }
+            this.handlers.onSessionAvailable?.(parsed.data);
+        });
+        socket.on("mcp-session-unavailable", (payload) => {
+            const parsed = McpSessionUnavailablePayload.safeParse(payload);
+            if (!parsed.success) {
+                return;
+            }
+            this.handlers.onSessionUnavailable?.(parsed.data);
+        });
+        socket.on("mcp-detached", (payload) => {
+            const parsed = McpDetachedPayload.safeParse(payload);
+            if (parsed.success) {
+                this.handlers.onDetached?.(parsed.data);
+            }
+            this.boundFlowId = undefined;
+            this.rejectAllPendingCommands(new McpSocketBridgeError("Remote session detached", "DISCONNECTED_DURING_COMMAND"));
+        });
+        socket.on("disconnect", (reason) => {
+            if (this.socket?.id === socket.id) {
+                this.socket = undefined;
+            }
+            this.boundFlowId = undefined;
+            this.rejectAllPendingCommands(new McpSocketBridgeError(`Socket disconnected (${reason})`, "DISCONNECTED_DURING_COMMAND"));
+            this.handlers.onDisconnected?.(reason);
+        });
+    }
+    async executeToolCommand({ args, name, timeoutMs }) {
+        const socket = this.requireSocket();
+        const commandId = randomUUID();
+        return new Promise((resolve, reject) => {
+            this.pendingCommands.set(commandId, {
+                commandId,
+                reject,
+                resolve,
+            });
+            socket.emit("mcp-run-tool", {
+                commandId,
+                toolCall: {
+                    args,
+                    name,
+                    ...(timeoutMs !== undefined && { timeoutMs }),
+                    type: "mcp-tool",
+                },
+            });
+        });
+    }
+    notifyRemoteDisconnect(socket) {
+        return new Promise((resolve) => {
+            let settled = false;
+            const timer = setTimeout(() => {
+                if (settled)
+                    return;
+                settled = true;
+                resolve({ detachedAt: Date.now() });
+            }, 1000);
+            socket.emit("mcp-disconnect-session", {}, (payload) => {
+                if (settled)
+                    return;
+                settled = true;
+                clearTimeout(timer);
+                resolve(payload);
+            });
+        });
+    }
+    rejectAllPendingCommands(error) {
+        const pending = [...this.pendingCommands.values()];
+        this.pendingCommands.clear();
+        for (const command of pending) {
+            command.reject(error);
+        }
+    }
+    requireSocket() {
+        if (!this.socket) {
+            throw new McpSocketBridgeError("Cannot perform action without an active MCP socket", "NOT_CONNECTED");
+        }
+        return this.socket;
+    }
+}

package/dist/models/mcp.d.ts

@@ -0,0 +1,288 @@
+import { z } from "zod";
+export declare const McpSessionId: z.ZodString;
+export type McpSessionId = z.infer<typeof McpSessionId>;
+export declare const McpDetachReason: z.ZodEnum<{
+    "target-disconnected": "target-disconnected";
+    "mcp-disconnected": "mcp-disconnected";
+    "manual-detach": "manual-detach";
+}>;
+export type McpDetachReason = z.infer<typeof McpDetachReason>;
+export declare const McpBindFailureCode: z.ZodEnum<{
+    MCP_DISABLED: "MCP_DISABLED";
+    NO_ACTIVE_BROWSER: "NO_ACTIVE_BROWSER";
+    BIND_DENIED: "BIND_DENIED";
+    INTERNAL_ERROR: "INTERNAL_ERROR";
+}>;
+export type McpBindFailureCode = z.infer<typeof McpBindFailureCode>;
+export declare const McpToolErrorCode: z.ZodEnum<{
+    INTERNAL_ERROR: "INTERNAL_ERROR";
+    NOT_ATTACHED: "NOT_ATTACHED";
+    UNKNOWN_TOOL: "UNKNOWN_TOOL";
+    COMMAND_IN_FLIGHT: "COMMAND_IN_FLIGHT";
+    TIMEOUT: "TIMEOUT";
+    UNAUTHORIZED: "UNAUTHORIZED";
+}>;
+export type McpToolErrorCode = z.infer<typeof McpToolErrorCode>;
+export declare const JsonSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+export type JsonSchema = z.infer<typeof JsonSchema>;
+export declare const McpToolDefinition: z.ZodObject<{
+    annotations: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    description: z.ZodString;
+    inputSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    name: z.ZodString;
+    outputSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    title: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type McpToolDefinition = z.infer<typeof McpToolDefinition>;
+export declare const McpClientPackageInfo: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    version: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type McpClientPackageInfo = z.infer<typeof McpClientPackageInfo>;
+export declare const McpManifestRequest: z.ZodObject<{
+    interfaceType: z.ZodString;
+}, z.core.$strip>;
+export type McpManifestRequest = z.infer<typeof McpManifestRequest>;
+export declare const McpManifestResponse: z.ZodObject<{
+    definitions: z.ZodArray<z.ZodObject<{
+        annotations: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        description: z.ZodString;
+        inputSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        name: z.ZodString;
+        outputSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        title: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    interfaceType: z.ZodString;
+    resolvedAt: z.ZodNumber;
+    tools: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export type McpManifestResponse = z.infer<typeof McpManifestResponse>;
+export declare const McpFlowSession: z.ZodObject<{
+    flowId: z.ZodString;
+    flowName: z.ZodString;
+}, z.core.$strip>;
+export type McpFlowSession = z.infer<typeof McpFlowSession>;
+export declare const McpListSessionsRequest: z.ZodObject<{
+    flowId: z.ZodOptional<z.ZodString>;
+    interfaceType: z.ZodString;
+}, z.core.$strip>;
+export type McpListSessionsRequest = z.infer<typeof McpListSessionsRequest>;
+export declare const McpListSessionsResponse: z.ZodObject<{
+    sessions: z.ZodArray<z.ZodObject<{
+        flowId: z.ZodString;
+        flowName: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type McpListSessionsResponse = z.infer<typeof McpListSessionsResponse>;
+export declare const McpBindSessionRequest: z.ZodObject<{
+    flowId: z.ZodString;
+}, z.core.$strip>;
+export type McpBindSessionRequest = z.infer<typeof McpBindSessionRequest>;
+export declare const McpBindSessionResponse: z.ZodObject<{
+    boundAt: z.ZodNumber;
+    flowId: z.ZodString;
+    flowName: z.ZodString;
+}, z.core.$strip>;
+export type McpBindSessionResponse = z.infer<typeof McpBindSessionResponse>;
+export declare const McpBindSessionFailure: z.ZodObject<{
+    code: z.ZodEnum<{
+        MCP_DISABLED: "MCP_DISABLED";
+        NO_ACTIVE_BROWSER: "NO_ACTIVE_BROWSER";
+        BIND_DENIED: "BIND_DENIED";
+        INTERNAL_ERROR: "INTERNAL_ERROR";
+    }>;
+    message: z.ZodString;
+    sessions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        flowId: z.ZodString;
+        flowName: z.ZodString;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type McpBindSessionFailure = z.infer<typeof McpBindSessionFailure>;
+export declare const McpSessionControlRequest: z.ZodObject<{
+    mcpSessionId: z.ZodString;
+}, z.core.$strip>;
+export type McpSessionControlRequest = z.infer<typeof McpSessionControlRequest>;
+export declare const McpSessionDisconnectAck: z.ZodObject<{
+    detachedAt: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type McpSessionDisconnectAck = z.infer<typeof McpSessionDisconnectAck>;
+export declare const McpToolRegistrySync: z.ZodObject<{
+    action: z.ZodEnum<{
+        clear: "clear";
+        register: "register";
+    }>;
+    clientPackage: z.ZodOptional<z.ZodObject<{
+        name: z.ZodOptional<z.ZodString>;
+        version: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    definitions: z.ZodArray<z.ZodObject<{
+        annotations: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        description: z.ZodString;
+        inputSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        name: z.ZodString;
+        outputSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        title: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    expertId: z.ZodOptional<z.ZodString>;
+    expertName: z.ZodOptional<z.ZodString>;
+    mcpSessionId: z.ZodString;
+    replace: z.ZodOptional<z.ZodBoolean>;
+    tools: z.ZodArray<z.ZodString>;
+    updatedAt: z.ZodNumber;
+}, z.core.$strip>;
+export type McpToolRegistrySync = z.infer<typeof McpToolRegistrySync>;
+export declare const McpToolCall: z.ZodObject<{
+    args: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    name: z.ZodString;
+    timeoutMs: z.ZodOptional<z.ZodNumber>;
+    type: z.ZodLiteral<"mcp-tool">;
+}, z.core.$strip>;
+export type McpToolCall = z.infer<typeof McpToolCall>;
+export declare const McpToolProgress: z.ZodObject<{
+    data: z.ZodOptional<z.ZodUnknown>;
+    message: z.ZodOptional<z.ZodString>;
+    percent: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type McpToolProgress = z.infer<typeof McpToolProgress>;
+export declare const McpToolResult: z.ZodObject<{
+    commandId: z.ZodString;
+    result: z.ZodUnknown;
+}, z.core.$strip>;
+export type McpToolResult = z.infer<typeof McpToolResult>;
+export declare const McpToolError: z.ZodObject<{
+    code: z.ZodOptional<z.ZodEnum<{
+        INTERNAL_ERROR: "INTERNAL_ERROR";
+        NOT_ATTACHED: "NOT_ATTACHED";
+        UNKNOWN_TOOL: "UNKNOWN_TOOL";
+        COMMAND_IN_FLIGHT: "COMMAND_IN_FLIGHT";
+        TIMEOUT: "TIMEOUT";
+        UNAUTHORIZED: "UNAUTHORIZED";
+    }>>;
+    data: z.ZodOptional<z.ZodUnknown>;
+    message: z.ZodString;
+}, z.core.$strip>;
+export type McpToolError = z.infer<typeof McpToolError>;
+export declare const McpCommandStatusType: z.ZodEnum<{
+    failed: "failed";
+    progress: "progress";
+    accepted: "accepted";
+    dispatched: "dispatched";
+    completed: "completed";
+    timeout: "timeout";
+}>;
+export type McpCommandStatusType = z.infer<typeof McpCommandStatusType>;
+export declare const McpCommandStatus: z.ZodObject<{
+    commandId: z.ZodString;
+    error: z.ZodOptional<z.ZodObject<{
+        code: z.ZodOptional<z.ZodEnum<{
+            INTERNAL_ERROR: "INTERNAL_ERROR";
+            NOT_ATTACHED: "NOT_ATTACHED";
+            UNKNOWN_TOOL: "UNKNOWN_TOOL";
+            COMMAND_IN_FLIGHT: "COMMAND_IN_FLIGHT";
+            TIMEOUT: "TIMEOUT";
+            UNAUTHORIZED: "UNAUTHORIZED";
+        }>>;
+        data: z.ZodOptional<z.ZodUnknown>;
+        message: z.ZodString;
+    }, z.core.$strip>>;
+    mcpSessionId: z.ZodString;
+    progress: z.ZodOptional<z.ZodObject<{
+        data: z.ZodOptional<z.ZodUnknown>;
+        message: z.ZodOptional<z.ZodString>;
+        percent: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    status: z.ZodEnum<{
+        failed: "failed";
+        progress: "progress";
+        accepted: "accepted";
+        dispatched: "dispatched";
+        completed: "completed";
+        timeout: "timeout";
+    }>;
+    timestamp: z.ZodNumber;
+    toolName: z.ZodString;
+}, z.core.$strip>;
+export type McpCommandStatus = z.infer<typeof McpCommandStatus>;
+export declare const McpCommandHistoryEntry: z.ZodObject<{
+    commandId: z.ZodString;
+    completedAt: z.ZodOptional<z.ZodNumber>;
+    createdAt: z.ZodNumber;
+    error: z.ZodOptional<z.ZodObject<{
+        code: z.ZodOptional<z.ZodEnum<{
+            INTERNAL_ERROR: "INTERNAL_ERROR";
+            NOT_ATTACHED: "NOT_ATTACHED";
+            UNKNOWN_TOOL: "UNKNOWN_TOOL";
+            COMMAND_IN_FLIGHT: "COMMAND_IN_FLIGHT";
+            TIMEOUT: "TIMEOUT";
+            UNAUTHORIZED: "UNAUTHORIZED";
+        }>>;
+        data: z.ZodOptional<z.ZodUnknown>;
+        message: z.ZodString;
+    }, z.core.$strip>>;
+    mcpSessionId: z.ZodString;
+    progress: z.ZodOptional<z.ZodObject<{
+        data: z.ZodOptional<z.ZodUnknown>;
+        message: z.ZodOptional<z.ZodString>;
+        percent: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    result: z.ZodOptional<z.ZodUnknown>;
+    status: z.ZodEnum<{
+        failed: "failed";
+        progress: "progress";
+        accepted: "accepted";
+        dispatched: "dispatched";
+        completed: "completed";
+        timeout: "timeout";
+    }>;
+    toolCall: z.ZodOptional<z.ZodObject<{
+        args: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        name: z.ZodString;
+        timeoutMs: z.ZodOptional<z.ZodNumber>;
+        type: z.ZodLiteral<"mcp-tool">;
+    }, z.core.$strip>>;
+    toolName: z.ZodString;
+    updatedAt: z.ZodNumber;
+}, z.core.$strip>;
+export type McpCommandHistoryEntry = z.infer<typeof McpCommandHistoryEntry>;
+export type McpToSolutionAiSocketMap = {
+    "mcp-bind-session": (messageParams: McpBindSessionRequest, callback: (messageParams: McpBindSessionFailure | McpBindSessionResponse) => void) => void;
+    "mcp-disconnect-session": (messageParams: Partial<McpSessionControlRequest>, callback: (messageParams: McpSessionDisconnectAck) => void) => void;
+    "mcp-list-sessions": (messageParams: McpListSessionsRequest, callback: (messageParams: McpListSessionsResponse) => void) => void;
+    "mcp-request-manifest": (messageParams: McpManifestRequest, callback: (messageParams: McpManifestResponse) => void) => void;
+    "mcp-run-tool": (messageParams: {
+        commandId?: string;
+        toolCall: McpToolCall;
+    }) => void;
+    "mcp-unbind-session": (messageParams: Partial<McpSessionControlRequest>, callback: (messageParams: McpSessionDisconnectAck) => void) => void;
+};
+export type SolutionAiToMcpSocketMap = {
+    "mcp-command-status": (messageParams: McpCommandStatus) => void;
+    "mcp-detached": (messageParams: {
+        detachedAt: number;
+        mcpSessionId: string;
+        reason: McpDetachReason;
+    }) => void;
+    "mcp-error": (messageParams: {
+        error: string;
+    }) => void;
+    "mcp-session-available": (messageParams: {
+        flowId: string;
+        flowName: string;
+    }) => void;
+    "mcp-session-unavailable": (messageParams: {
+        flowId: string;
+        reason: string;
+    }) => void;
+    "mcp-tool-accepted": (messageParams: {
+        commandId: string;
+        toolName: string;
+    }) => void;
+    "mcp-tool-error": (messageParams: {
+        commandId?: string;
+        error: Omit<McpToolError, "code"> & {
+            code: NonNullable<McpToolError["code"]>;
+        };
+    }) => void;
+    "mcp-tool-registry": (messageParams: McpToolRegistrySync) => void;
+    "mcp-tool-result": (messageParams: McpToolResult) => void;
+};