wave-agent-sdk 1.1.4 → 1.2.0

package/dist/stdio/notificationRouter.d.ts

@@ -0,0 +1,38 @@
+/**
+ * NotificationRouter — demultiplexes server→client notifications by sessionId.
+ *
+ * In the single-shared-process architecture, all sessions share one StdioClient.
+ * The server tags each session-scoped notification with `sessionId` on the
+ * JSON-RPC envelope. The router inspects that field and dispatches to the
+ * matching StdioAgent; notifications without sessionId (e.g. `authUrl`) go to
+ * a global handler.
+ *
+ * Lifecycle:
+ * 1. `attach()` once — subscribes to every notification method on the shared client
+ * 2. Per session: `register(sessionId, agent)` after `initialize` response
+ * 3. On `sessionIdChange`: router auto-rekeys the agent (old → new)
+ * 4. On `destroy`: `unregister(sessionId)` removes the agent
+ */
+import type { RpcClient } from "./rpcClient.js";
+type GlobalHandler = (params: unknown) => void;
+import type { StdioAgent } from "./stdioAgent.js";
+export declare class NotificationRouter {
+    private client;
+    private sessions;
+    private globalHandlers;
+    private attached;
+    constructor(client: RpcClient);
+    /**
+     * Subscribe to all notification methods on the shared client.
+     * Must be called once after construction. Idempotent.
+     */
+    attach(): void;
+    /** Register a session-scoped agent. Call after `initialize` response. */
+    register(sessionId: string, agent: StdioAgent): void;
+    /** Unregister a session. Call on destroy. */
+    unregister(sessionId: string): void;
+    /** Register a global (non-session-scoped) notification handler. */
+    registerGlobal(method: string, handler: GlobalHandler): void;
+    private dispatch;
+}
+export {};

package/dist/stdio/notificationRouter.js

@@ -0,0 +1,96 @@
+/**
+ * NotificationRouter — demultiplexes server→client notifications by sessionId.
+ *
+ * In the single-shared-process architecture, all sessions share one StdioClient.
+ * The server tags each session-scoped notification with `sessionId` on the
+ * JSON-RPC envelope. The router inspects that field and dispatches to the
+ * matching StdioAgent; notifications without sessionId (e.g. `authUrl`) go to
+ * a global handler.
+ *
+ * Lifecycle:
+ * 1. `attach()` once — subscribes to every notification method on the shared client
+ * 2. Per session: `register(sessionId, agent)` after `initialize` response
+ * 3. On `sessionIdChange`: router auto-rekeys the agent (old → new)
+ * 4. On `destroy`: `unregister(sessionId)` removes the agent
+ */
+const ALL_NOTIFICATION_METHODS = [
+    "userMessageAdded",
+    "assistantMessageAdded",
+    "assistantContentUpdated",
+    "assistantReasoningUpdated",
+    "toolBlockUpdated",
+    "errorBlockAdded",
+    "loadingChange",
+    "contextUsage",
+    "commandRunningChange",
+    "queuedMessagesChange",
+    "tasksChange",
+    "sessionIdChange",
+    "permissionModeChange",
+    "mcpServersChange",
+    "workdirChange",
+    "notificationMessageAdded",
+    "permissionRequest",
+    "authUrl",
+    "btwContent",
+    "compactBlockAdded",
+    "compactionStateChange",
+    "compactionContentUpdate",
+    "backgroundTasksChange",
+];
+export class NotificationRouter {
+    constructor(client) {
+        this.client = client;
+        this.sessions = new Map();
+        this.globalHandlers = new Map();
+        this.attached = false;
+    }
+    /**
+     * Subscribe to all notification methods on the shared client.
+     * Must be called once after construction. Idempotent.
+     */
+    attach() {
+        if (this.attached)
+            return;
+        this.attached = true;
+        for (const method of ALL_NOTIFICATION_METHODS) {
+            this.client.onNotification(method, (params, sessionId) => {
+                this.dispatch(method, params, sessionId);
+            });
+        }
+    }
+    /** Register a session-scoped agent. Call after `initialize` response. */
+    register(sessionId, agent) {
+        this.sessions.set(sessionId, agent);
+    }
+    /** Unregister a session. Call on destroy. */
+    unregister(sessionId) {
+        this.sessions.delete(sessionId);
+    }
+    /** Register a global (non-session-scoped) notification handler. */
+    registerGlobal(method, handler) {
+        this.globalHandlers.set(method, handler);
+    }
+    dispatch(method, params, sessionId) {
+        if (sessionId) {
+            const agent = this.sessions.get(sessionId);
+            if (!agent)
+                return; // early notification before register — drop (v1)
+            // sessionIdChange requires rekeying the agent in the map
+            if (method === "sessionIdChange") {
+                const newId = params.sessionId;
+                if (newId && newId !== sessionId) {
+                    this.sessions.delete(sessionId);
+                    this.sessions.set(newId, agent);
+                }
+            }
+            agent.handleNotification(method, params);
+        }
+        else {
+            // Global notification (e.g. authUrl)
+            const handler = this.globalHandlers.get(method);
+            if (handler)
+                handler(params);
+        }
+    }
+}

package/dist/stdio/rpcClient.d.ts

@@ -0,0 +1,18 @@
+/**
+ * RpcClient — the structural transport surface StdioAgent + NotificationRouter
+ * depend on.
+ *
+ * Both hosts keep their own transports (vscode's `StdioClient`; desktop's
+ * `JsonRpcClient` subclasses `StdioClient` / `SocketClient`); each satisfies
+ * this interface structurally (TypeScript), so the shared stdio layer never
+ * needs to know which transport backs it.
+ */
+export type NotificationHandler = (params: unknown, sessionId?: string) => void;
+export interface RpcClient {
+    /** Send a request; resolves with the JSON-RPC result. */
+    request(method: string, params?: unknown, sessionId?: string): Promise<unknown>;
+    /** Fire-and-forget JSON-RPC notification (no response expected). */
+    notify(method: string, params?: unknown, sessionId?: string): void;
+    /** Subscribe to a server→client notification method. */
+    onNotification(method: string, handler: NotificationHandler): void;
+}

package/dist/stdio/rpcClient.js

@@ -0,0 +1,10 @@
+/**
+ * RpcClient — the structural transport surface StdioAgent + NotificationRouter
+ * depend on.
+ *
+ * Both hosts keep their own transports (vscode's `StdioClient`; desktop's
+ * `JsonRpcClient` subclasses `StdioClient` / `SocketClient`); each satisfies
+ * this interface structurally (TypeScript), so the shared stdio layer never
+ * needs to know which transport backs it.
+ */
+export {};

package/dist/stdio/stdioAgent.d.ts

@@ -0,0 +1,222 @@
+/**
+ * StdioAgent — host-side typed wrapper around a JSON-RPC client that mirrors
+ * the Agent API (shared by the VS Code extension and the desktop app).
+ *
+ * In the single-shared-process architecture, all sessions share one transport
+ * client. The NotificationRouter dispatches incoming notifications to the
+ * appropriate StdioAgent via `handleNotification()`. The agent no longer
+ * subscribes directly to the client.
+ *
+ * All session-scoped requests carry `this.sessionId` on the JSON-RPC envelope
+ * so the server can route them to the right Agent.
+ *
+ * `destroy()` only unregisters from the router and sends the destroy request;
+ * it does NOT dispose the shared client.
+ *
+ * The client dependency is the structural `RpcClient` surface (request/notify/
+ * onNotification) so both hosts keep their own transports: vscode's
+ * `StdioClient` (spawn + hostLog) and desktop's `JsonRpcClient` subclasses
+ * (StdioClient / SocketClient).
+ */
+import type { Message, Task, BackgroundTaskSummary, SerializableWorkflowRun, QueuedMessage, McpServerStatus, PermissionMode, PermissionDecision, ToolPermissionContext, ToolBlockUpdateCallbackParams, SlashCommand, McpServerConfig, SubagentConfiguration, SkillMetadata } from "../types/index.js";
+import type { RpcClient } from "./rpcClient.js";
+import type { NotificationRouter } from "./notificationRouter.js";
+export interface InitializeParams {
+    workdir?: string;
+    restoreSessionId?: string;
+    apiKey?: string;
+    baseURL?: string;
+    serverUrl?: string;
+    defaultHeaders?: Record<string, string>;
+    model?: string;
+    fastModel?: string;
+    language?: string;
+    autoMemoryEnabled?: boolean;
+    autoMemoryFrequency?: number;
+    permissionMode?: PermissionMode;
+    tools?: string[];
+    allowedTools?: string[];
+    disallowedTools?: string[];
+    pluginDirs?: string[];
+    mcpServers?: Record<string, McpServerConfig>;
+    worktreeName?: string;
+    isNewWorktree?: boolean;
+}
+export interface InitializeResult {
+    sessionId: string;
+    workingDirectory: string;
+    permissionMode: PermissionMode;
+    latestTotalTokens: number;
+}
+export interface UpdateConfigParams {
+    apiKey?: string;
+    baseURL?: string;
+    serverUrl?: string;
+    defaultHeaders?: Record<string, string>;
+    model?: string;
+    fastModel?: string;
+    language?: string;
+    contextLength?: number;
+    autoMemoryEnabled?: boolean;
+    autoMemoryFrequency?: number;
+}
+export interface StdioAgentCallbacks {
+    onUserMessageAdded?: (message: Message) => void;
+    onAssistantMessageAdded?: (message: Message) => void;
+    onAssistantContentUpdated?: (params: {
+        messageId: string;
+        chunk: string;
+        stage: "streaming" | "end";
+    }) => void;
+    onAssistantReasoningUpdated?: (params: {
+        messageId: string;
+        chunk: string;
+        stage: "streaming" | "end";
+    }) => void;
+    onToolBlockUpdated?: (params: ToolBlockUpdateCallbackParams) => void;
+    onErrorBlockAdded?: (error: string) => void;
+    onCompactBlockAdded?: (content: string) => void;
+    onCompactionStateChange?: (isCompacting: boolean) => void;
+    onCompactionContentUpdate?: (content: string) => void;
+    onLoadingChange?: (loading: boolean) => void;
+    onContextUsage?: (percent: number) => void;
+    onCommandRunningChange?: (running: boolean) => void;
+    onQueuedMessagesChange?: (messages: QueuedMessage[]) => void;
+    onTasksChange?: (tasks: Task[]) => void;
+    onBackgroundTasksChange?: (tasks: BackgroundTaskSummary[]) => void;
+    onSessionIdChange?: (sessionId: string) => void;
+    onPermissionModeChange?: (mode: PermissionMode) => void;
+    onMcpServersChange?: (servers: McpServerStatus[]) => void;
+    onWorkdirChange?: (workdir: string) => void;
+    onNotificationMessageAdded?: (params: {
+        taskId: string;
+        taskType: string;
+        status: string;
+        summary: string;
+        message?: Message;
+    }) => void;
+    onPermissionRequest?: (requestId: string, context: ToolPermissionContext) => void;
+    onBtwContent?: (params: {
+        question: string;
+        content: string;
+        type: "thinking" | "content";
+    }) => void;
+}
+export declare class StdioAgent {
+    sessionId: string | undefined;
+    workingDirectory: string | undefined;
+    /**
+     * Initialize-time cwd — the session's stable root. Unlike
+     * `workingDirectory` it is never overwritten by the workdirChange
+     * notification (bash cd), so @file search and the /status workdir stay
+     * anchored to the project root.
+     */
+    sessionCwd: string | undefined;
+    latestTotalTokens: number;
+    /**
+     * Context-usage percentage reported with the most recent getMessages pull.
+     * A host whose webview was re-created long after the last token change gets
+     * no contextUsage notification, so it replays this on webviewReady instead.
+     */
+    contextUsagePercent: number | undefined;
+    permissionMode: PermissionMode | undefined;
+    messages: Message[];
+    queuedMessages: QueuedMessage[];
+    tasks: Task[];
+    backgroundTasks: BackgroundTaskSummary[];
+    isStreaming: boolean;
+    isCommandRunning: boolean;
+    isCompacting: boolean;
+    private client;
+    private router;
+    private callbacks;
+    constructor(client: RpcClient, router: NotificationRouter, callbacks: StdioAgentCallbacks);
+    initialize(params: InitializeParams): Promise<InitializeResult>;
+    destroy(): Promise<void>;
+    restoreSession(sessionId: string): Promise<void>;
+    updateConfig(params: UpdateConfigParams): Promise<{
+        sessionId: string;
+    }>;
+    sendMessage(text: string, images?: Array<{
+        path: string;
+        mimeType: string;
+    }>, force?: boolean): Promise<void>;
+    bang(command: string): Promise<void>;
+    abortMessage(): Promise<void>;
+    clearMessages(): Promise<void>;
+    compact(customInstructions?: string): Promise<void>;
+    rewindToMessage(messageId: string): Promise<{
+        inputContent: string;
+    }>;
+    askBtw(question: string): Promise<string>;
+    removeQueuedMessage(index: number): Promise<void>;
+    updateQueuedMessageById(id: string, patch: {
+        content?: string;
+        images?: Array<{
+            path: string;
+            mimeType: string;
+        }>;
+        type?: "message" | "bang";
+    }): Promise<boolean>;
+    removeQueuedMessageById(id: string): Promise<void>;
+    getFullMessageThread(): Promise<{
+        messages: Message[];
+        sessionIds: string[];
+    }>;
+    getMessages(): Promise<Message[]>;
+    listRewindCheckpoints(): Promise<{
+        checkpoints: Array<{
+            id: string;
+            content: string;
+        }>;
+    }>;
+    getConfiguredModels(): Promise<{
+        models: string[];
+        currentModel: string | undefined;
+    }>;
+    setModel(model: string): Promise<void>;
+    setPermissionMode(mode: PermissionMode): Promise<void>;
+    /** Returns cached permission mode (updated via notification). */
+    getPermissionMode(): PermissionMode | undefined;
+    /**
+     * Reads the session's current plan file (path + contents). Used by the
+     * /plan command to display the plan when already in plan mode; the CLI side
+     * awaits the path if it is still being generated after setPermissionMode.
+     */
+    getPlanFile(): Promise<{
+        path: string | null;
+        content: string | null;
+    }>;
+    sendPermissionResponse(requestId: string, decision: PermissionDecision): void;
+    getBackgroundTaskOutput(taskId: string): Promise<{
+        stdout: string;
+        stderr: string;
+        status: string;
+        outputPath?: string;
+        type: string;
+        exitCode?: number;
+    } | null>;
+    stopBackgroundTask(taskId: string): Promise<boolean>;
+    backgroundCurrentTask(): Promise<void>;
+    getWorkflowRuns(): Promise<SerializableWorkflowRun[]>;
+    stopWorkflowRun(runId: string): Promise<boolean>;
+    getMcpServers(): Promise<McpServerStatus[]>;
+    connectMcpServer(serverName: string): Promise<boolean>;
+    disconnectMcpServer(serverName: string): Promise<boolean>;
+    getMcpConfigPaths(): Promise<{
+        userPath: string | null;
+        projectPath: string | null;
+    }>;
+    removeMcpServer(scope: "user" | "project", serverName: string): Promise<boolean>;
+    deleteSkill(name: string): Promise<boolean>;
+    deleteSubagent(name: string): Promise<boolean>;
+    getHooksByScope(scope: "user" | "project" | "plugin"): Promise<{
+        hooks: Partial<Record<string, unknown[]>>;
+        configPath: string | null;
+    }>;
+    deleteHook(scope: "user" | "project", hookName: string): Promise<void>;
+    getSlashCommands(): Promise<SlashCommand[]>;
+    getSubagentConfigurations(): Promise<SubagentConfiguration[]>;
+    getSkillMetadata(): Promise<SkillMetadata[]>;
+    handleNotification(method: string, params: unknown): void;
+}