wave-code 0.19.2 → 0.19.4

package/dist/stdio/agentBridge.js

@@ -0,0 +1,562 @@
+/**
+ * AgentBridge — wraps the SDK Agent and translates between the JSON-RPC-like
+ * stdio protocol and Agent method calls / callbacks.
+ *
+ * Multi-tenant: maintains a Map<sessionId, {agent, storedConfig}> so a single
+ * `wave --stdio` process can host multiple sessions. Session-scoped requests
+ * carry `sessionId` on the JSON-RPC envelope for routing; global requests
+ * (listSessions/searchFiles/auth/plugins) don't require it but may use it
+ * for workdir fallback.
+ *
+ * Responsibilities:
+ * - Route incoming requests to the appropriate Agent method (by sessionId)
+ * - Translate AgentCallbacks into outgoing notifications (with sessionId)
+ * - Implement the canUseTool permission flow over the stdio protocol
+ * - Handle config updates by destroying and recreating the Agent
+ */
+import { Agent, listSessions, searchFiles, PromptHistoryManager, AuthService, PluginCore, } from "wave-agent-sdk";
+import { INTERNAL_ERROR as PROTOCOL_INTERNAL_ERROR, METHOD_NOT_FOUND as PROTOCOL_METHOD_NOT_FOUND, } from "./protocol.js";
+import { readFileSync } from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const CLI_VERSION = (() => {
+    try {
+        const pkg = JSON.parse(readFileSync(path.resolve(__dirname, "../../package.json"), "utf-8"));
+        return pkg.version ?? "";
+    }
+    catch {
+        return "";
+    }
+})();
+export class AgentBridge {
+    constructor(options) {
+        this.sessions = new Map();
+        this.pendingPermissions = new Map();
+        this.permissionCounter = 0;
+        this.emit = options.emit;
+    }
+    // ── Public API ────────────────────────────────────────────────
+    async handleRequest(method, params, sessionId) {
+        const p = (params ?? {});
+        switch (method) {
+            // ── Lifecycle ──
+            case "initialize":
+                return this.initialize(p);
+            case "destroy":
+                return this.destroy(sessionId);
+            case "restoreSession":
+                return this.restoreSession(p.sessionId, sessionId);
+            case "listSessions":
+                return this.listSessions(p.workdir, sessionId);
+            case "getSessionInfo":
+                return this.getSessionInfo(sessionId);
+            case "updateConfig":
+                return this.updateConfig(p, sessionId);
+            // ── Messages ──
+            case "sendMessage":
+                return this.sendMessage(p, sessionId);
+            case "bang":
+                return this.bang(p.command, sessionId);
+            case "abortMessage":
+                return this.abortMessage(sessionId);
+            case "clearMessages":
+                return this.clearMessages(sessionId);
+            case "rewindToMessage":
+                return this.rewindToMessage(p.messageId, sessionId);
+            case "deleteQueuedMessage":
+                return this.deleteQueuedMessage(p.index, sessionId);
+            case "getMessages":
+                return this.getMessages(sessionId);
+            case "getFullMessageThread":
+                return this.getFullMessageThread(sessionId);
+            // ── Permissions ──
+            case "setPermissionMode":
+                return this.setPermissionMode(p.mode, sessionId);
+            case "getPermissionMode":
+                return this.getPermissionMode(sessionId);
+            // ── MCP ──
+            case "getMcpServers":
+                return this.getMcpServers(sessionId);
+            case "connectMcpServer":
+                return this.connectMcpServer(p.serverName, sessionId);
+            case "disconnectMcpServer":
+                return this.disconnectMcpServer(p.serverName, sessionId);
+            // ── Commands ──
+            case "getSlashCommands":
+                return this.getSlashCommands(sessionId);
+            // ── File / History (global — no session required) ──
+            case "searchFiles":
+                return this.searchFiles(p, sessionId);
+            case "getPromptHistory":
+                return this.getPromptHistory(p.workdir, sessionId);
+            case "searchPromptHistory":
+                return this.searchPromptHistory(p.query, p.workdir, sessionId);
+            // ── Auth (global — no session required) ──
+            case "getAuthStatus":
+                return this.getAuthStatus();
+            case "login":
+                return this.login(p.serverUrl);
+            case "logout":
+                return this.logout();
+            // ── Plugins (global — no session required) ──
+            case "listPlugins":
+                return this.listPlugins(p.workdir, sessionId);
+            case "installPlugin":
+                return this.installPlugin(p.pluginId, p.scope, p.workdir, sessionId);
+            case "uninstallPlugin":
+                return this.uninstallPlugin(p.pluginId, p.workdir, sessionId);
+            case "enablePlugin":
+                return this.enablePlugin(p.pluginId, p.scope, p.workdir, sessionId);
+            case "disablePlugin":
+                return this.disablePlugin(p.pluginId, p.scope, p.workdir, sessionId);
+            case "updatePlugin":
+                return this.updatePlugin(p.pluginId, p.workdir, sessionId);
+            case "listMarketplaces":
+                return this.listMarketplaces(p.workdir, sessionId);
+            case "addMarketplace":
+                return this.addMarketplace(p.input, p.scope, p.workdir, sessionId);
+            case "removeMarketplace":
+                return this.removeMarketplace(p.name, p.scope, p.workdir, sessionId);
+            case "updateMarketplace":
+                return this.updateMarketplace(p.name, p.workdir, sessionId);
+            default:
+                throw new RpcError(PROTOCOL_METHOD_NOT_FOUND, `Method not found: ${method}`);
+        }
+    }
+    handleNotification(method, params) {
+        if (method === "permissionResponse") {
+            const p = params;
+            // requestId is process-level unique; lookup doesn't need sessionId
+            const resolve = this.pendingPermissions.get(p.requestId);
+            if (resolve) {
+                this.pendingPermissions.delete(p.requestId);
+                resolve(p.decision);
+            }
+        }
+    }
+    // ── Lifecycle ─────────────────────────────────────────────────
+    async initialize(params) {
+        const ctx = {};
+        const callbacks = this.createCallbacks(ctx);
+        const options = {
+            callbacks,
+            workdir: params.workdir,
+            restoreSessionId: params.restoreSessionId,
+            apiKey: params.apiKey,
+            baseURL: params.baseURL,
+            defaultHeaders: params.defaultHeaders,
+            model: params.model,
+            fastModel: params.fastModel,
+            language: params.language,
+            permissionMode: params.permissionMode,
+            tools: params.tools,
+            allowedTools: params.allowedTools,
+            disallowedTools: params.disallowedTools,
+            plugins: params.pluginDirs?.map((path) => ({ type: "local", path })),
+            mcpServers: params.mcpServers,
+            canUseTool: (context) => this.canUseTool(context, ctx),
+        };
+        const agent = await Agent.create(options);
+        ctx.agent = agent;
+        ctx.registeredSessionId = agent.sessionId;
+        this.sessions.set(agent.sessionId, {
+            agent,
+            storedConfig: { ...params },
+        });
+        if (params.clientVersion) {
+            console.debug(`[agentBridge] clientVersion=${params.clientVersion} serverVersion=${CLI_VERSION}`);
+        }
+        return {
+            sessionId: agent.sessionId,
+            workingDirectory: agent.workingDirectory,
+            permissionMode: agent.getPermissionMode(),
+            latestTotalTokens: agent.latestTotalTokens,
+            serverVersion: CLI_VERSION,
+        };
+    }
+    async destroy(sessionId) {
+        if (sessionId) {
+            const entry = this.sessions.get(sessionId);
+            if (entry) {
+                await entry.agent.destroy();
+                this.sessions.delete(sessionId);
+            }
+        }
+        return null;
+    }
+    async restoreSession(restoreId, sessionId) {
+        const entry = this.requireSession(sessionId);
+        await entry.agent.restoreSession(restoreId);
+        return null;
+    }
+    async listSessions(workdir, sessionId) {
+        const sessions = await listSessions(workdir || this.getSessionWorkdir(sessionId) || process.cwd());
+        return { sessions };
+    }
+    getSessionInfo(sessionId) {
+        const entry = this.requireSession(sessionId);
+        return {
+            sessionId: entry.agent.sessionId,
+            workingDirectory: entry.agent.workingDirectory,
+            latestTotalTokens: entry.agent.latestTotalTokens,
+            permissionMode: entry.agent.getPermissionMode(),
+            availableTools: entry.agent.getAvailableToolNames(),
+        };
+    }
+    async updateConfig(params, sessionId) {
+        const entry = this.requireSession(sessionId);
+        const currentSessionId = entry.agent.sessionId;
+        // Merge new config into stored config
+        entry.storedConfig = { ...entry.storedConfig, ...params };
+        // Destroy and recreate within the same session slot
+        await entry.agent.destroy();
+        this.sessions.delete(currentSessionId);
+        const ctx = {};
+        const callbacks = this.createCallbacks(ctx);
+        const options = {
+            callbacks,
+            workdir: entry.storedConfig.workdir,
+            restoreSessionId: currentSessionId,
+            apiKey: entry.storedConfig.apiKey,
+            baseURL: entry.storedConfig.baseURL,
+            defaultHeaders: entry.storedConfig.defaultHeaders,
+            model: entry.storedConfig.model,
+            fastModel: entry.storedConfig.fastModel,
+            language: entry.storedConfig.language,
+            permissionMode: entry.storedConfig.permissionMode,
+            tools: entry.storedConfig.tools,
+            allowedTools: entry.storedConfig.allowedTools,
+            disallowedTools: entry.storedConfig.disallowedTools,
+            plugins: entry.storedConfig.pluginDirs?.map((p) => ({
+                type: "local",
+                path: p,
+            })),
+            mcpServers: entry.storedConfig.mcpServers,
+            canUseTool: (context) => this.canUseTool(context, ctx),
+        };
+        const agent = await Agent.create(options);
+        ctx.agent = agent;
+        ctx.registeredSessionId = agent.sessionId;
+        this.sessions.set(agent.sessionId, {
+            agent,
+            storedConfig: { ...entry.storedConfig },
+        });
+        return { sessionId: agent.sessionId };
+    }
+    // ── Messages ──────────────────────────────────────────────────
+    async sendMessage(params, sessionId) {
+        const entry = this.requireSession(sessionId);
+        if (params.force) {
+            entry.agent.abortMessage();
+        }
+        // Save prompt to history (mirrors VSCE chatSession.ts:236-242)
+        try {
+            await PromptHistoryManager.addEntry(params.text, entry.agent.sessionId, {}, entry.agent.workingDirectory);
+        }
+        catch {
+            // Best-effort; don't block message sending on history save failure
+        }
+        await entry.agent.sendMessage(params.text, params.images);
+        return null;
+    }
+    async bang(command, sessionId) {
+        const entry = this.requireSession(sessionId);
+        await entry.agent.bang(command);
+        return null;
+    }
+    async abortMessage(sessionId) {
+        const entry = this.requireSession(sessionId);
+        entry.agent.abortMessage();
+        return null;
+    }
+    async clearMessages(sessionId) {
+        const entry = this.requireSession(sessionId);
+        entry.agent.clearMessages();
+        return null;
+    }
+    async rewindToMessage(messageId, sessionId) {
+        const entry = this.requireSession(sessionId);
+        const { messages } = await entry.agent.getFullMessageThread();
+        const index = messages.findIndex((m) => m.id === messageId);
+        if (index === -1) {
+            throw new RpcError(PROTOCOL_INTERNAL_ERROR, `Message not found: ${messageId}`);
+        }
+        const message = messages[index];
+        const textBlock = message.blocks.find((b) => b.type === "text");
+        await entry.agent.truncateHistory(index);
+        return { inputContent: textBlock?.content || "" };
+    }
+    deleteQueuedMessage(index, sessionId) {
+        const entry = this.requireSession(sessionId);
+        entry.agent.removeQueuedMessage(index);
+        return null;
+    }
+    getMessages(sessionId) {
+        const entry = this.requireSession(sessionId);
+        return { messages: entry.agent.messages };
+    }
+    async getFullMessageThread(sessionId) {
+        const entry = this.requireSession(sessionId);
+        return entry.agent.getFullMessageThread();
+    }
+    // ── Permissions ───────────────────────────────────────────────
+    async setPermissionMode(mode, sessionId) {
+        const entry = this.requireSession(sessionId);
+        await entry.agent.setPermissionMode(mode);
+        return null;
+    }
+    getPermissionMode(sessionId) {
+        const entry = this.requireSession(sessionId);
+        return { mode: entry.agent.getPermissionMode() };
+    }
+    // ── MCP ───────────────────────────────────────────────────────
+    getMcpServers(sessionId) {
+        const entry = this.requireSession(sessionId);
+        return { servers: entry.agent.getMcpServers() };
+    }
+    async connectMcpServer(serverName, sessionId) {
+        const entry = this.requireSession(sessionId);
+        const success = await entry.agent.connectMcpServer(serverName);
+        return { success };
+    }
+    async disconnectMcpServer(serverName, sessionId) {
+        const entry = this.requireSession(sessionId);
+        const success = await entry.agent.disconnectMcpServer(serverName);
+        return { success };
+    }
+    // ── Commands ──────────────────────────────────────────────────
+    getSlashCommands(sessionId) {
+        const entry = this.requireSession(sessionId);
+        return { commands: entry.agent.getSlashCommands() };
+    }
+    // ── File / History (global) ───────────────────────────────────
+    async searchFiles(params, sessionId) {
+        const files = await searchFiles(params.query, {
+            maxResults: params.maxResults,
+            workingDirectory: params.workdir || this.getSessionWorkdir(sessionId) || process.cwd(),
+        });
+        return { files };
+    }
+    async getPromptHistory(workdir, sessionId) {
+        const history = await PromptHistoryManager.getHistory({
+            workdir: workdir || this.getSessionWorkdir(sessionId),
+        });
+        return { history };
+    }
+    async searchPromptHistory(query, workdir, sessionId) {
+        const history = await PromptHistoryManager.searchHistory(query, {
+            workdir: workdir || this.getSessionWorkdir(sessionId),
+        });
+        return { history };
+    }
+    // ── canUseTool flow ───────────────────────────────────────────
+    canUseTool(context, ctx) {
+        const requestId = `perm_${++this.permissionCounter}`;
+        return new Promise((resolve) => {
+            this.pendingPermissions.set(requestId, resolve);
+            this.emit("permissionRequest", { requestId, context }, ctx.registeredSessionId);
+            // 5-minute timeout → auto-deny
+            setTimeout(() => {
+                if (this.pendingPermissions.has(requestId)) {
+                    this.pendingPermissions.delete(requestId);
+                    resolve({
+                        behavior: "deny",
+                        message: "Permission request timed out",
+                    });
+                }
+            }, 5 * 60 * 1000);
+        });
+    }
+    // ── Auth (global) ────────────────────────────────────────────
+    async getAuthStatus() {
+        const authService = AuthService.getInstance();
+        return {
+            isAuthenticated: authService.isSSOAuthenticated(),
+            user: authService.getAuthUser(),
+        };
+    }
+    async login(serverUrl) {
+        const authService = AuthService.getInstance();
+        await authService.login({
+            onAuthUrl: (url) => {
+                this.emit("authUrl", { url });
+            },
+            serverUrl,
+        });
+        return { user: authService.getAuthUser() };
+    }
+    async logout() {
+        const authService = AuthService.getInstance();
+        await authService.clearAuth();
+        return null;
+    }
+    // ── Plugins (global) ─────────────────────────────────────────
+    getPluginCore(workdir, sessionId) {
+        const resolvedWorkdir = workdir || this.getSessionWorkdir(sessionId) || process.cwd();
+        if (!this.pluginCore || this.pluginCoreWorkdir !== resolvedWorkdir) {
+            this.pluginCore = new PluginCore(resolvedWorkdir);
+            this.pluginCoreWorkdir = resolvedWorkdir;
+        }
+        return this.pluginCore;
+    }
+    async listPlugins(workdir, sessionId) {
+        const core = this.getPluginCore(workdir, sessionId);
+        const { plugins, mergedEnabled } = await core.listPlugins();
+        return {
+            plugins: plugins.map((p) => {
+                const pluginId = `${p.name}@${p.marketplace}`;
+                return {
+                    id: pluginId,
+                    name: p.name,
+                    description: p.description,
+                    marketplace: p.marketplace,
+                    installed: p.installed,
+                    version: p.version,
+                    enabled: mergedEnabled[pluginId] !== false,
+                    scope: p.scope,
+                };
+            }),
+        };
+    }
+    async installPlugin(pluginId, scope, workdir, sessionId) {
+        return this.getPluginCore(workdir, sessionId).installPlugin(pluginId, scope);
+    }
+    async uninstallPlugin(pluginId, workdir, sessionId) {
+        await this.getPluginCore(workdir, sessionId).uninstallPlugin(pluginId);
+        return null;
+    }
+    async enablePlugin(pluginId, scope, workdir, sessionId) {
+        return this.getPluginCore(workdir, sessionId).enablePlugin(pluginId, scope);
+    }
+    async disablePlugin(pluginId, scope, workdir, sessionId) {
+        return this.getPluginCore(workdir, sessionId).disablePlugin(pluginId, scope);
+    }
+    async updatePlugin(pluginId, workdir, sessionId) {
+        return this.getPluginCore(workdir, sessionId).updatePlugin(pluginId);
+    }
+    async listMarketplaces(workdir, sessionId) {
+        return this.getPluginCore(workdir, sessionId).listMarketplaces();
+    }
+    async addMarketplace(input, scope, workdir, sessionId) {
+        return this.getPluginCore(workdir, sessionId).addMarketplace(input, scope);
+    }
+    async removeMarketplace(name, scope, workdir, sessionId) {
+        await this.getPluginCore(workdir, sessionId).removeMarketplace(name, scope);
+        return null;
+    }
+    async updateMarketplace(name, workdir, sessionId) {
+        await this.getPluginCore(workdir, sessionId).updateMarketplace(name);
+        return null;
+    }
+    // ── Callbacks → Notifications ─────────────────────────────────
+    createCallbacks(ctx) {
+        return {
+            onMessagesChange: (messages) => {
+                this.emit("messagesChange", { messages }, ctx.registeredSessionId);
+            },
+            onUserMessageAdded: () => {
+                const msg = this.findLastUserMessage(ctx.agent);
+                if (msg)
+                    this.emit("userMessageAdded", { message: msg }, ctx.registeredSessionId);
+            },
+            onAssistantMessageAdded: (messageId) => {
+                const msg = ctx.agent?.messages.find((m) => m.id === messageId);
+                if (msg)
+                    this.emit("assistantMessageAdded", { message: msg }, ctx.registeredSessionId);
+            },
+            onAssistantContentUpdated: (params) => {
+                this.emit("assistantContentUpdated", params, ctx.registeredSessionId);
+            },
+            onAssistantReasoningUpdated: (params) => {
+                this.emit("assistantReasoningUpdated", params, ctx.registeredSessionId);
+            },
+            onToolBlockUpdated: (params) => {
+                this.emit("toolBlockUpdated", params, ctx.registeredSessionId);
+            },
+            onErrorBlockAdded: (error) => {
+                this.emit("errorBlockAdded", { error }, ctx.registeredSessionId);
+            },
+            onLoadingChange: (loading) => {
+                this.emit("loadingChange", {
+                    loading,
+                    latestTotalTokens: ctx.agent?.latestTotalTokens,
+                }, ctx.registeredSessionId);
+            },
+            onCommandRunningChange: (running) => {
+                this.emit("commandRunningChange", { running }, ctx.registeredSessionId);
+            },
+            onQueuedMessagesChange: (messages) => {
+                this.emit("queuedMessagesChange", { messages }, ctx.registeredSessionId);
+            },
+            onTasksChange: (tasks) => {
+                this.emit("tasksChange", { tasks }, ctx.registeredSessionId);
+            },
+            onSessionIdChange: (newSessionId) => {
+                const oldSessionId = ctx.registeredSessionId;
+                // Emit with the OLD sessionId so the client's router can deliver it
+                this.emit("sessionIdChange", { sessionId: newSessionId }, oldSessionId);
+                // Update the sessions Map key atomically (single-threaded, no await)
+                if (oldSessionId && oldSessionId !== newSessionId) {
+                    const entry = this.sessions.get(oldSessionId);
+                    if (entry) {
+                        this.sessions.delete(oldSessionId);
+                        this.sessions.set(newSessionId, entry);
+                    }
+                }
+                ctx.registeredSessionId = newSessionId;
+            },
+            onPermissionModeChange: (mode) => {
+                this.emit("permissionModeChange", { mode }, ctx.registeredSessionId);
+            },
+            onMcpServersChange: (servers) => {
+                this.emit("mcpServersChange", { servers }, ctx.registeredSessionId);
+            },
+            onAddBangMessage: () => {
+                this.emit("bangMessageAdded", {}, ctx.registeredSessionId);
+            },
+            onUpdateBangMessage: () => {
+                this.emit("bangMessageUpdated", {}, ctx.registeredSessionId);
+            },
+            onCompleteBangMessage: () => {
+                this.emit("bangMessageCompleted", {}, ctx.registeredSessionId);
+            },
+            onNotificationMessageAdded: (params) => {
+                const msg = ctx.agent?.messages.find((m) => m.role === "user" &&
+                    m.blocks.some((b) => b.type === "task_notification" &&
+                        b.taskId === params.taskId));
+                this.emit("notificationMessageAdded", { ...params, message: msg }, ctx.registeredSessionId);
+            },
+        };
+    }
+    findLastUserMessage(agent) {
+        const userMessages = agent?.messages.filter((m) => m.role === "user") ?? [];
+        return userMessages[userMessages.length - 1];
+    }
+    // ── Utils ─────────────────────────────────────────────────────
+    requireSession(sessionId) {
+        if (!sessionId) {
+            throw new RpcError(PROTOCOL_INTERNAL_ERROR, "sessionId is required for this request");
+        }
+        const entry = this.sessions.get(sessionId);
+        if (!entry) {
+            throw new RpcError(PROTOCOL_INTERNAL_ERROR, `Session not found: ${sessionId}`);
+        }
+        return entry;
+    }
+    getSessionWorkdir(sessionId) {
+        if (!sessionId)
+            return undefined;
+        return this.sessions.get(sessionId)?.agent.workingDirectory;
+    }
+}
+// ── Error class for protocol errors ─────────────────────────────
+export class RpcError extends Error {
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+    }
+    toJsonRpcError() {
+        return { code: this.code, message: this.message };
+    }
+}

package/dist/stdio/index.d.ts

@@ -0,0 +1,4 @@
+export { StdioServer, type StdioServerOptions } from "./stdioServer.js";
+export { AgentBridge, type AgentBridgeOptions, RpcError, } from "./agentBridge.js";
+export * from "./protocol.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/stdio/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/stdio/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,KAAK,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AACxE,OAAO,EACL,WAAW,EACX,KAAK,kBAAkB,EACvB,QAAQ,GACT,MAAM,kBAAkB,CAAC;AAC1B,cAAc,eAAe,CAAC"}

package/dist/stdio/index.js

@@ -0,0 +1,3 @@
+export { StdioServer } from "./stdioServer.js";
+export { AgentBridge, RpcError, } from "./agentBridge.js";
+export * from "./protocol.js";

package/dist/stdio/protocol.d.ts

@@ -0,0 +1,42 @@
+/**
+ * JSON-RPC 2.0-compatible protocol types for stdio communication.
+ *
+ * Each line on stdin/stdout is one JSON object.
+ * - Requests have `id` (number|string) and expect a response.
+ * - Responses match the request `id` with either `result` or `error`.
+ * - Notifications have no `id` and expect no response.
+ */
+export interface JsonRpcRequest {
+    id: number | string;
+    method: string;
+    params?: unknown;
+    /** Session-scoped requests carry sessionId for routing to the right Agent. */
+    sessionId?: string;
+}
+export interface JsonRpcResponse {
+    id: number | string | null;
+    result?: unknown;
+    error?: JsonRpcError;
+}
+export interface JsonRpcError {
+    code: number;
+    message: string;
+    data?: unknown;
+}
+export interface JsonRpcNotification {
+    method: string;
+    params?: unknown;
+    /** Session-scoped notifications carry sessionId for demultiplexing on the client. */
+    sessionId?: string;
+}
+export declare const PARSE_ERROR = -32700;
+export declare const INVALID_REQUEST = -32600;
+export declare const METHOD_NOT_FOUND = -32601;
+export declare const INVALID_PARAMS = -32602;
+export declare const INTERNAL_ERROR = -32603;
+export type RequestMethod = "initialize" | "destroy" | "restoreSession" | "listSessions" | "getSessionInfo" | "sendMessage" | "bang" | "abortMessage" | "clearMessages" | "rewindToMessage" | "deleteQueuedMessage" | "getMessages" | "getFullMessageThread" | "setPermissionMode" | "getPermissionMode" | "getMcpServers" | "connectMcpServer" | "disconnectMcpServer" | "getSlashCommands" | "searchFiles" | "getPromptHistory" | "searchPromptHistory" | "updateConfig" | "getAuthStatus" | "login" | "logout" | "listPlugins" | "installPlugin" | "uninstallPlugin" | "enablePlugin" | "disablePlugin" | "updatePlugin" | "listMarketplaces" | "addMarketplace" | "removeMarketplace" | "updateMarketplace";
+export type ClientNotificationMethod = "permissionResponse";
+export type ServerNotificationMethod = "messagesChange" | "userMessageAdded" | "assistantMessageAdded" | "assistantContentUpdated" | "assistantReasoningUpdated" | "toolBlockUpdated" | "errorBlockAdded" | "loadingChange" | "commandRunningChange" | "queuedMessagesChange" | "tasksChange" | "sessionIdChange" | "permissionModeChange" | "mcpServersChange" | "bangMessageAdded" | "bangMessageUpdated" | "bangMessageCompleted" | "notificationMessageAdded" | "permissionRequest" | "authUrl";
+export declare function isRequest(msg: unknown): msg is JsonRpcRequest;
+export declare function isNotification(msg: unknown): msg is JsonRpcNotification;
+//# sourceMappingURL=protocol.d.ts.map

package/dist/stdio/protocol.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"protocol.d.ts","sourceRoot":"","sources":["../../src/stdio/protocol.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAIH,MAAM,WAAW,cAAc;IAC7B,EAAE,EAAE,MAAM,GAAG,MAAM,CAAC;IACpB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,8EAA8E;IAC9E,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,eAAe;IAC9B,EAAE,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAAC;IAC3B,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,KAAK,CAAC,EAAE,YAAY,CAAC;CACtB;AAED,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,OAAO,CAAC;CAChB;AAED,MAAM,WAAW,mBAAmB;IAClC,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,qFAAqF;IACrF,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAID,eAAO,MAAM,WAAW,SAAS,CAAC;AAClC,eAAO,MAAM,eAAe,SAAS,CAAC;AACtC,eAAO,MAAM,gBAAgB,SAAS,CAAC;AACvC,eAAO,MAAM,cAAc,SAAS,CAAC;AACrC,eAAO,MAAM,cAAc,SAAS,CAAC;AAIrC,MAAM,MAAM,aAAa,GACrB,YAAY,GACZ,SAAS,GACT,gBAAgB,GAChB,cAAc,GACd,gBAAgB,GAChB,aAAa,GACb,MAAM,GACN,cAAc,GACd,eAAe,GACf,iBAAiB,GACjB,qBAAqB,GACrB,aAAa,GACb,sBAAsB,GACtB,mBAAmB,GACnB,mBAAmB,GACnB,eAAe,GACf,kBAAkB,GAClB,qBAAqB,GACrB,kBAAkB,GAClB,aAAa,GACb,kBAAkB,GAClB,qBAAqB,GACrB,cAAc,GAEd,eAAe,GACf,OAAO,GACP,QAAQ,GAER,aAAa,GACb,eAAe,GACf,iBAAiB,GACjB,cAAc,GACd,eAAe,GACf,cAAc,GACd,kBAAkB,GAClB,gBAAgB,GAChB,mBAAmB,GACnB,mBAAmB,CAAC;AAIxB,MAAM,MAAM,wBAAwB,GAAG,oBAAoB,CAAC;AAI5D,MAAM,MAAM,wBAAwB,GAChC,gBAAgB,GAChB,kBAAkB,GAClB,uBAAuB,GACvB,yBAAyB,GACzB,2BAA2B,GAC3B,kBAAkB,GAClB,iBAAiB,GACjB,eAAe,GACf,sBAAsB,GACtB,sBAAsB,GACtB,aAAa,GACb,iBAAiB,GACjB,sBAAsB,GACtB,kBAAkB,GAClB,kBAAkB,GAClB,oBAAoB,GACpB,sBAAsB,GACtB,0BAA0B,GAC1B,mBAAmB,GACnB,SAAS,CAAC;AAId,wBAAgB,SAAS,CAAC,GAAG,EAAE,OAAO,GAAG,GAAG,IAAI,cAAc,CAS7D;AAED,wBAAgB,cAAc,CAAC,GAAG,EAAE,OAAO,GAAG,GAAG,IAAI,mBAAmB,CAIvE"}

package/dist/stdio/protocol.js

@@ -0,0 +1,26 @@
+/**
+ * JSON-RPC 2.0-compatible protocol types for stdio communication.
+ *
+ * Each line on stdin/stdout is one JSON object.
+ * - Requests have `id` (number|string) and expect a response.
+ * - Responses match the request `id` with either `result` or `error`.
+ * - Notifications have no `id` and expect no response.
+ */
+// ── Error codes (JSON-RPC 2.0 standard) ────────────────────────
+export const PARSE_ERROR = -32700;
+export const INVALID_REQUEST = -32600;
+export const METHOD_NOT_FOUND = -32601;
+export const INVALID_PARAMS = -32602;
+export const INTERNAL_ERROR = -32603;
+// ── Helper: is this a request (has id)? ─────────────────────────
+export function isRequest(msg) {
+    return (typeof msg === "object" &&
+        msg !== null &&
+        "method" in msg &&
+        "id" in msg &&
+        (typeof msg.id === "number" ||
+            typeof msg.id === "string"));
+}
+export function isNotification(msg) {
+    return (typeof msg === "object" && msg !== null && "method" in msg && !("id" in msg));
+}