@evandu/super-pi 0.0.0-stage → 0.1.0

package/dist/server/application/run-service.js

@@ -0,0 +1,341 @@
+import { checkSubagentDepth, parentDeniedTools } from "../task-tool.js";
+import { newSubagentRunId } from "../subagents.js";
+/**
+ * Service managing execution of conversation turns, message queueing,
+ * follow-ups, and sub-agent dispatching.
+ */
+export class RunService {
+    store;
+    runtime;
+    subagents;
+    broadcaster;
+    extensionUiService;
+    activeRuns = new Map();
+    constructor(store, runtime, subagents, broadcaster, extensionUiService) {
+        this.store = store;
+        this.runtime = runtime;
+        this.subagents = subagents;
+        this.broadcaster = broadcaster;
+        this.extensionUiService = extensionUiService;
+    }
+    /**
+     * Resolves the conversation and workspace synchronously for a run.
+     */
+    turnContext(conversationId) {
+        const conversation = this.store.snapshot().conversations.find((item) => item.id === conversationId);
+        if (!conversation)
+            throw new Error("会话不存在");
+        const workspace = this.store.snapshot().workspaces.find((item) => item.id === conversation.workspaceId);
+        if (!workspace)
+            throw new Error(`会话所属的工作区 ${conversation.workspaceId} 已不存在，拒绝运行`);
+        return { conversation, workspace };
+    }
+    /**
+     * Resolves conversation and workspace working directory for subagent dispatch.
+     */
+    dispatchContext(conversationId) {
+        const { conversation, workspace } = this.turnContext(conversationId);
+        return { conversation, cwd: workspace.path };
+    }
+    /**
+     * Checks whether a conversation has an active turn running.
+     */
+    isRunning(conversationId) {
+        return this.activeRuns.has(conversationId);
+    }
+    /**
+     * Aborts all active conversation runs and sub-agents.
+     */
+    abortAll() {
+        for (const controller of this.activeRuns.values()) {
+            controller.abort();
+        }
+        this.subagents.abortAll();
+    }
+    /**
+     * Stops an active turn run for a conversation.
+     */
+    async stopRun(conversationId) {
+        this.extensionUiService.cancelPendingUi(conversationId, "aborted");
+        this.activeRuns.get(conversationId)?.abort();
+        await this.runtime.stop?.(conversationId);
+        await this.store.setStatus(conversationId, "stopped");
+        if (this.subagents.stopConversation(conversationId)) {
+            console.log(`Super Pi: stopped the sub-agent runs of conversation ${conversationId}.`);
+        }
+        this.broadcaster.broadcastState();
+    }
+    /**
+     * Handles queue snapshot updates from Pi RPC.
+     */
+    onPiQueue(conversationId, snapshot) {
+        this.broadcaster.broadcast({ type: "pi.queue", conversationId, ...snapshot });
+        const held = this.store.listQueuedMessages(conversationId).filter((message) => message.state === "sending").length;
+        const delivered = held - snapshot.steering.length;
+        if (delivered > 0) {
+            void this.store.dropSendingMessages(conversationId, delivered).then(() => this.broadcaster.broadcastState());
+        }
+    }
+    /**
+     * Opens a turn by creating user and assistant messages in store.
+     */
+    async openTurn(conversationId, prompt, images) {
+        const user = await this.store.addUserMessage(conversationId, prompt ?? "", images);
+        const assistant = await this.store.beginAssistantMessage(conversationId);
+        this.broadcaster.broadcastState();
+        return { user, assistant };
+    }
+    /**
+     * Streams a turn via AgentRuntime.
+     */
+    async streamTurn(conversation, workspace, prompt, assistant, controller, userMessageId, images) {
+        this.extensionUiService.cancelPendingUi(conversation.id, "expired");
+        let toolCalls = [];
+        let pendingTools = Promise.resolve();
+        const enqueueTools = (what, work) => {
+            pendingTools = pendingTools.then(async () => {
+                toolCalls = await work();
+                this.broadcaster.broadcast({ type: "message.tools", conversationId: conversation.id, messageId: assistant.id, toolCalls });
+            }).catch((error) => {
+                console.warn(`Super Pi: recording ${what} failed: ${error instanceof Error ? error.message : "unknown error"}`);
+            });
+        };
+        const rowByToolCallId = new Map();
+        const onToolCall = (call) => {
+            if (call.id)
+                rowByToolCallId.set(call.id, rowByToolCallId.size);
+            enqueueTools("a tool call", () => this.store.appendToolCall(conversation.id, assistant.id, { label: call.name, detail: call.detail, args: call.args }));
+        };
+        const onToolEnd = (call) => {
+            const index = call.id ? rowByToolCallId.get(call.id) : undefined;
+            if (index === undefined)
+                return;
+            enqueueTools("a tool call outcome", () => this.store.settleToolCall(conversation.id, assistant.id, index, { status: call.status, durationMs: call.durationMs }));
+        };
+        for await (const delta of this.runtime.answer({
+            conversation,
+            prompt,
+            signal: controller.signal,
+            cwd: workspace.path,
+            host: this.extensionUiService.createHost(conversation.id),
+            onPiQueue: (snapshot) => this.onPiQueue(conversation.id, snapshot),
+            onUserEntry: (entryId) => this.store.setMessagePiEntryId(conversation.id, userMessageId, entryId),
+            onToolCall,
+            onToolEnd,
+            images,
+        })) {
+            await this.store.appendAssistantDelta(conversation.id, assistant.id, delta);
+            this.broadcaster.broadcast({ type: "message.delta", conversationId: conversation.id, messageId: assistant.id, delta });
+        }
+        await pendingTools;
+    }
+    /**
+     * Loops running turns for as long as queued follow-ups exist.
+     */
+    async runConversationTurns(conversation, workspace, prompt, controller, initialImages) {
+        try {
+            const opened = await this.openTurn(conversation.id, prompt, initialImages);
+            await this.streamTurn(conversation, workspace, prompt, opened.assistant, controller, opened.user.id, initialImages);
+            for (;;) {
+                if (controller.signal.aborted)
+                    break;
+                const next = await this.store.takeNextQueuedMessage(conversation.id);
+                if (!next)
+                    break;
+                this.broadcaster.broadcastState();
+                let followUp;
+                try {
+                    followUp = await this.openTurn(conversation.id, next.content, next.images);
+                }
+                catch (error) {
+                    await this.store.enqueueMessage(conversation.id, next.content, next.images);
+                    throw error;
+                }
+                const current = this.turnContext(conversation.id).conversation;
+                await this.streamTurn(current, workspace, next.content, followUp.assistant, controller, followUp.user.id, next.images);
+            }
+        }
+        finally {
+            await this.store.releaseSendingMessages(conversation.id);
+        }
+    }
+    /**
+     * Enqueues or starts execution for a user message.
+     */
+    async enqueueAndRun(conversationId, content, images) {
+        const trimmed = content.trim();
+        const validImages = Array.isArray(images) && images.length > 0 ? images : undefined;
+        if (!trimmed && !validImages?.length)
+            return;
+        const { conversation, workspace } = this.turnContext(conversationId);
+        if (validImages?.length) {
+            const catalog = await this.runtime.catalog(conversation.model);
+            const currentModel = catalog.models.find((model) => model.provider === conversation.model?.provider && model.modelId === conversation.model?.modelId)
+                ?? catalog.models.find((m) => m.provider === catalog.defaultModel?.provider && m.modelId === catalog.defaultModel?.modelId);
+            if (currentModel && !currentModel.imageInput) {
+                throw new Error(`当前选择的模型「${currentModel.label || currentModel.modelId}」不支持图片输入`);
+            }
+        }
+        if (this.activeRuns.has(conversation.id)) {
+            await this.store.enqueueMessage(conversation.id, trimmed, validImages);
+            this.broadcaster.broadcastState();
+            return;
+        }
+        const controller = new AbortController();
+        this.activeRuns.set(conversation.id, controller);
+        try {
+            await this.runConversationTurns(conversation, workspace, trimmed, controller, validImages);
+            await this.store.setStatus(conversation.id, controller.signal.aborted ? "stopped" : "completed");
+        }
+        catch (error) {
+            await this.store.setStatus(conversation.id, "failed");
+            throw error;
+        }
+        finally {
+            this.activeRuns.delete(conversation.id);
+            this.extensionUiService.cancelPendingUi(conversation.id, "expired");
+            this.broadcaster.broadcastState();
+        }
+    }
+    /**
+     * Steers a queued message into the in-flight turn.
+     */
+    async steer(conversationId, queueId) {
+        if (!this.runtime.steer) {
+            throw new Error("当前运行时没有插队能力，无法把排队消息插到正在运行的这轮里");
+        }
+        const claimed = await this.store.claimQueuedMessage(conversationId, queueId);
+        this.broadcaster.broadcastState();
+        try {
+            const disposition = await this.runtime.steer(conversationId, claimed.content, claimed.images);
+            if (disposition === "handled") {
+                await this.store.dropSendingMessages(conversationId, 1);
+            }
+        }
+        catch (error) {
+            await this.store.releaseQueuedMessage(claimed.id);
+            throw error;
+        }
+        this.broadcaster.broadcastState();
+    }
+    /**
+     * Cancels a queued message.
+     */
+    async cancelQueued(conversationId, queueId) {
+        await this.store.cancelQueuedMessage(conversationId, queueId);
+        this.broadcaster.broadcastState();
+    }
+    /**
+     * Dispatches a subagent from client command (human dispatch).
+     */
+    async dispatchSubagent(params) {
+        const task = params.task.trim();
+        if (!task)
+            throw new Error("子 agent 的任务不能为空");
+        const { conversation, cwd } = this.dispatchContext(params.conversationId);
+        void this.subagents.dispatch({
+            conversationId: conversation.id,
+            agentId: params.agentId,
+            task,
+            cwd,
+            model: conversation.model,
+            denyTools: parentDeniedTools(await this.runtime.agentFor?.(conversation)),
+        }).catch((error) => {
+            console.warn(`Super Pi: sub-agent dispatch of ${params.agentId} failed before it could be recorded: ${error instanceof Error ? error.message : "unknown error"}`);
+            this.broadcaster.broadcast({
+                type: "error",
+                message: `无法派发子 agent ${JSON.stringify(params.agentId)}：${error instanceof Error ? error.message : "未知错误"}`,
+            });
+        });
+    }
+    /**
+     * Dispatches a subagent task requested by the task tool HTTP endpoint.
+     */
+    async dispatchTask(body) {
+        const conversationId = body.conversationId?.trim();
+        const subagentType = body.subagent_type?.trim();
+        const task = body.prompt?.trim();
+        if (!conversationId || !subagentType || !task) {
+            throw new Error("task requires conversationId, subagent_type and prompt");
+        }
+        if (body.depth !== undefined)
+            checkSubagentDepth(body.depth);
+        const { conversation, cwd } = this.dispatchContext(conversationId);
+        const parent = body.parentRunId ? this.store.snapshot().subagentRuns.find((run) => run.id === body.parentRunId) : undefined;
+        if (body.parentRunId && (!parent || parent.conversationId !== conversation.id)) {
+            throw new Error("Invalid parentRunId: dispatch ancestry is not recorded for this conversation");
+        }
+        const authoritativeDepth = parent ? (parent.depth ?? 0) + 1 : 0;
+        checkSubagentDepth(authoritativeDepth);
+        if (parent)
+            checkSubagentDepth(1);
+        const backgroundId = body.background === true ? newSubagentRunId() : undefined;
+        const dispatch = this.subagents.dispatch({
+            ...(backgroundId ? { id: backgroundId } : {}),
+            conversationId: conversation.id,
+            agentId: subagentType,
+            task,
+            cwd,
+            model: conversation.model,
+            dispatchedBy: "model",
+            ...(parent ? { parentRunId: parent.id } : {}),
+            depth: authoritativeDepth,
+            ...(body.loopId ? { loopId: body.loopId } : {}),
+            ...(body.role ? { role: body.role } : {}),
+            denyTools: parentDeniedTools(await this.runtime.agentFor?.(conversation)),
+        });
+        if (body.background === true) {
+            await this.store.setBackgroundTask({
+                id: backgroundId,
+                title: body.description?.trim() || subagentType,
+                agentId: subagentType,
+                status: "running",
+                startedAt: new Date().toISOString(),
+                resultBlockId: backgroundId,
+            });
+            this.broadcaster.broadcastState();
+            void dispatch.then(async (run) => {
+                const result = run.status === "completed"
+                    ? run.output ?? ""
+                    : `Background task failed: ${run.error ?? run.status}`;
+                const tag = run.status === "completed" ? "task_result" : "task_error";
+                const message = `<task id="${run.id}" state="${run.status === "completed" ? "completed" : "error"}">\n<summary>Background task ${run.status === "completed" ? "completed" : "failed"}: ${body.description?.trim() || subagentType}</summary>\n<${tag}>\n${result}\n</${tag}>\n</task>`;
+                await this.store.enqueueMessage(conversation.id, message);
+                await this.store.removeBackgroundTask(run.id);
+                this.broadcaster.broadcastState();
+            }).catch(async (error) => {
+                await this.store.removeBackgroundTask(backgroundId);
+                this.broadcaster.broadcastState();
+                console.warn(`Super Pi: background sub-agent dispatch failed: ${error instanceof Error ? error.message : "unknown error"}`);
+            });
+            return {
+                mode: "async",
+                status: 202,
+                body: { run: { id: backgroundId, status: "running", agentId: subagentType }, background: true },
+            };
+        }
+        const run = await dispatch;
+        return {
+            mode: "sync",
+            status: run.status === "completed" ? 200 : 422,
+            body: {
+                run: { id: run.id, status: run.status, agentId: run.agentId },
+                output: run.output ?? "",
+                error: run.error,
+                outputTruncated: run.outputTruncated ?? false,
+            },
+        };
+    }
+    /**
+     * Stops a specific subagent run by runId.
+     */
+    stopSubagent(runId) {
+        this.subagents.stop(runId);
+    }
+    /**
+     * Stops all subagent runs belonging to a conversation.
+     */
+    stopConversationSubagents(conversationId) {
+        return this.subagents.stopConversation(conversationId);
+    }
+}

package/dist/server/application/workspace-service.d.ts

@@ -0,0 +1,45 @@
+import type { Store } from "../store.js";
+import type { AgentRuntime } from "../runtime.js";
+import type { EventBroadcaster } from "../server-context.js";
+import type { CatalogService } from "./catalog-service.js";
+import type { RunService } from "./run-service.js";
+import type { ExtensionUiService } from "./extension-ui-service.js";
+export interface WorkspaceSettingsUpdate {
+    model?: {
+        provider: string;
+        modelId: string;
+    } | null;
+    thinkingLevel?: string | null;
+    agentId?: string | null;
+}
+/**
+ * Service managing workspaces: creation, rename, cascade deletion, and defaults configuration.
+ */
+export declare class WorkspaceService {
+    private readonly store;
+    private readonly runtime;
+    private readonly broadcaster;
+    private readonly catalogService;
+    private readonly runService;
+    private readonly extensionUiService;
+    private readonly uploadsDir;
+    private readonly agentsDir;
+    constructor(store: Store, runtime: AgentRuntime, broadcaster: EventBroadcaster, catalogService: CatalogService, runService: RunService, extensionUiService: ExtensionUiService, uploadsDir: string, agentsDir: string);
+    /**
+     * Creates a new workspace.
+     */
+    createWorkspace(name: string, path?: string): Promise<void>;
+    /**
+     * Renames an existing workspace.
+     */
+    renameWorkspace(workspaceId: string, name: string): Promise<void>;
+    /**
+     * Deletes a workspace and cascades cleanup to active runs, subagent runs,
+     * uploaded files, and stored conversations.
+     */
+    deleteWorkspace(workspaceId: string): Promise<void>;
+    /**
+     * Updates workspace default settings (model, thinking level, default agent).
+     */
+    updateSettings(workspaceId: string, settings: WorkspaceSettingsUpdate): Promise<void>;
+}

package/dist/server/application/workspace-service.js

@@ -0,0 +1,106 @@
+import { deleteConversationUploads } from "../upload.js";
+/**
+ * Service managing workspaces: creation, rename, cascade deletion, and defaults configuration.
+ */
+export class WorkspaceService {
+    store;
+    runtime;
+    broadcaster;
+    catalogService;
+    runService;
+    extensionUiService;
+    uploadsDir;
+    agentsDir;
+    constructor(store, runtime, broadcaster, catalogService, runService, extensionUiService, uploadsDir, agentsDir) {
+        this.store = store;
+        this.runtime = runtime;
+        this.broadcaster = broadcaster;
+        this.catalogService = catalogService;
+        this.runService = runService;
+        this.extensionUiService = extensionUiService;
+        this.uploadsDir = uploadsDir;
+        this.agentsDir = agentsDir;
+    }
+    /**
+     * Creates a new workspace.
+     */
+    async createWorkspace(name, path) {
+        await this.store.createWorkspace(name, path);
+        this.broadcaster.broadcastState();
+    }
+    /**
+     * Renames an existing workspace.
+     */
+    async renameWorkspace(workspaceId, name) {
+        await this.store.renameWorkspace(workspaceId, name);
+        this.broadcaster.broadcastState();
+    }
+    /**
+     * Deletes a workspace and cascades cleanup to active runs, subagent runs,
+     * uploaded files, and stored conversations.
+     */
+    async deleteWorkspace(workspaceId) {
+        const snapshot = this.store.snapshot();
+        const doomed = snapshot.conversations.filter((c) => c.workspaceId === workspaceId);
+        for (const c of doomed) {
+            this.extensionUiService.cancelPendingUi(c.id, "aborted");
+            if (this.runService.isRunning(c.id)) {
+                await this.runService.stopRun(c.id);
+            }
+            this.runService.stopConversationSubagents(c.id);
+        }
+        const doomedIds = await this.store.deleteWorkspace(workspaceId);
+        await Promise.all(doomedIds.map((id) => deleteConversationUploads(this.uploadsDir, id)));
+        this.broadcaster.broadcastState();
+    }
+    /**
+     * Updates workspace default settings (model, thinking level, default agent).
+     */
+    async updateSettings(workspaceId, settings) {
+        const workspace = this.store.snapshot().workspaces.find((item) => item.id === workspaceId);
+        if (!workspace)
+            throw new Error("Workspace not found");
+        let selection;
+        const requested = settings.model;
+        if (requested) {
+            const catalog = await this.runtime.catalog();
+            const option = catalog.source === "pi"
+                ? catalog.models.find((model) => model.provider === requested.provider && model.modelId === requested.modelId)
+                : undefined;
+            if (catalog.source === "pi" && !option) {
+                throw this.catalogService.notOffered(`模型 ${requested.provider}/${requested.modelId}`, catalog);
+            }
+            selection = option
+                ? { provider: option.provider, modelId: option.modelId, label: option.label }
+                : { provider: requested.provider, modelId: requested.modelId, label: requested.modelId };
+        }
+        if (settings.thinkingLevel) {
+            const catalog = await this.runtime.catalog(selection ?? workspace.defaultModel);
+            if (catalog.source === "pi" && !catalog.levels.includes(settings.thinkingLevel)) {
+                throw this.catalogService.notOffered(`思考等级 ${settings.thinkingLevel}`, catalog);
+            }
+        }
+        let agentToStore;
+        if (settings.agentId !== undefined) {
+            if (settings.agentId === null) {
+                agentToStore = null;
+            }
+            else {
+                if (!this.runtime.agentFor) {
+                    throw new Error("当前运行时没有 agent 机制，无法设置默认 agent");
+                }
+                const agent = await this.runtime.agentFor({ id: workspaceId, agentId: settings.agentId });
+                if (!agent) {
+                    throw new Error(`Agent ${JSON.stringify(settings.agentId)} 不存在或不是可用的 primary agent（目录：${this.agentsDir}）`);
+                }
+                agentToStore = agent.id;
+            }
+        }
+        await this.store.setWorkspaceDefaults(workspaceId, {
+            model: selection,
+            thinkingLevel: settings.thinkingLevel ?? undefined,
+            agentId: agentToStore,
+        });
+        this.broadcaster.broadcastState();
+    }
+}

package/dist/server/command-handler.d.ts

@@ -0,0 +1,22 @@
+import type { ClientCommand, ServerEvent } from "./types.js";
+import type { WorkspaceService } from "./application/workspace-service.js";
+import type { ConversationService } from "./application/conversation-service.js";
+import type { RunService } from "./application/run-service.js";
+import type { ExtensionUiService } from "./application/extension-ui-service.js";
+import type { CatalogService } from "./application/catalog-service.js";
+export type SocketSender = (event: ServerEvent) => void;
+/**
+ * Routes client commands to appropriate application services and converts results or errors.
+ */
+export declare class CommandHandler {
+    private readonly workspaceService;
+    private readonly conversationService;
+    private readonly runService;
+    private readonly extensionUiService;
+    private readonly catalogService;
+    constructor(workspaceService: WorkspaceService, conversationService: ConversationService, runService: RunService, extensionUiService: ExtensionUiService, catalogService: CatalogService);
+    /**
+     * Processes a client command.
+     */
+    handleCommand(command: ClientCommand, sendToSocket?: SocketSender): Promise<void>;
+}

package/dist/server/command-handler.js

@@ -0,0 +1,137 @@
+/**
+ * Routes client commands to appropriate application services and converts results or errors.
+ */
+export class CommandHandler {
+    workspaceService;
+    conversationService;
+    runService;
+    extensionUiService;
+    catalogService;
+    constructor(workspaceService, conversationService, runService, extensionUiService, catalogService) {
+        this.workspaceService = workspaceService;
+        this.conversationService = conversationService;
+        this.runService = runService;
+        this.extensionUiService = extensionUiService;
+        this.catalogService = catalogService;
+    }
+    /**
+     * Processes a client command.
+     */
+    async handleCommand(command, sendToSocket) {
+        if (command.type === "workspace.create") {
+            await this.workspaceService.createWorkspace(command.name, command.path);
+            return;
+        }
+        if (command.type === "workspace.rename") {
+            await this.workspaceService.renameWorkspace(command.workspaceId, command.name);
+            return;
+        }
+        if (command.type === "workspace.delete") {
+            await this.workspaceService.deleteWorkspace(command.workspaceId);
+            return;
+        }
+        if (command.type === "workspace.settings") {
+            await this.workspaceService.updateSettings(command.workspaceId, {
+                model: command.model,
+                thinkingLevel: command.thinkingLevel,
+                agentId: command.agentId,
+            });
+            return;
+        }
+        if (command.type === "conversation.create") {
+            await this.conversationService.createConversation(command.workspaceId);
+            return;
+        }
+        if (command.type === "conversation.select") {
+            await this.conversationService.selectConversation(command.conversationId);
+            return;
+        }
+        if (command.type === "conversation.archive") {
+            await this.conversationService.archiveConversation(command.conversationId);
+            return;
+        }
+        if (command.type === "conversation.unarchive") {
+            await this.conversationService.unarchiveConversation(command.conversationId);
+            return;
+        }
+        if (command.type === "conversation.rename") {
+            await this.conversationService.renameConversation(command.conversationId, command.name);
+            return;
+        }
+        if (command.type === "conversation.fork") {
+            const result = await this.conversationService.forkConversation(command.conversationId);
+            if (sendToSocket) {
+                sendToSocket({
+                    type: "conversation.fork.result",
+                    conversationId: command.conversationId,
+                    ...result,
+                });
+            }
+            return;
+        }
+        if (command.type === "conversation.model") {
+            await this.conversationService.setModel(command.conversationId, command.provider, command.modelId);
+            return;
+        }
+        if (command.type === "conversation.thinking") {
+            await this.conversationService.setThinking(command.conversationId, command.level);
+            return;
+        }
+        if (command.type === "conversation.agent") {
+            await this.conversationService.setAgent(command.conversationId, command.agentId);
+            return;
+        }
+        if (command.type === "message.send") {
+            await this.runService.enqueueAndRun(command.conversationId, command.content, command.images);
+            return;
+        }
+        if (command.type === "message.steer") {
+            await this.runService.steer(command.conversationId, command.queueId);
+            return;
+        }
+        if (command.type === "message.cancel") {
+            await this.runService.cancelQueued(command.conversationId, command.queueId);
+            return;
+        }
+        if (command.type === "message.revert") {
+            await this.conversationService.revertMessage(command.conversationId, command.messageId);
+            return;
+        }
+        if (command.type === "run.stop") {
+            await this.runService.stopRun(command.conversationId);
+            return;
+        }
+        if (command.type === "subagent.run") {
+            await this.runService.dispatchSubagent({
+                conversationId: command.conversationId,
+                agentId: command.agentId,
+                task: command.task,
+            });
+            return;
+        }
+        if (command.type === "subagent.stop") {
+            this.runService.stopSubagent(command.runId);
+            return;
+        }
+        if (command.type === "extension.ui.answer") {
+            const answer = command.cancelled
+                ? { cancelled: true }
+                : { value: command.value, confirmed: command.confirmed };
+            this.extensionUiService.answerUi(command.conversationId, command.requestId, answer);
+            return;
+        }
+        if (command.type === "catalog.fetch") {
+            await this.catalogService.broadcastCatalog();
+            return;
+        }
+        if (command.type === "agent.catalog.fetch") {
+            await this.catalogService.broadcastAgents();
+            return;
+        }
+        if (command.type === "subagent.catalog.fetch") {
+            await this.catalogService.broadcastSubagents();
+            return;
+        }
+        throw new Error(`未知的命令类型：${JSON.stringify(command.type ?? null)}`);
+    }
+}