linkshell-cli 0.2.88 → 0.2.90

package/dist/cli/src/runtime/acp/agent-workspace.js

@@ -30,6 +30,32 @@ function firstString(value, keys) {
     }
     return undefined;
 }
+function normalizedIdentifier(value) {
+    return (value ?? "").toLowerCase().replace(/[_\-\s/]+/g, "");
+}
+function firstNumber(value, keys) {
+    if (!value)
+        return undefined;
+    for (const key of keys) {
+        const next = value[key];
+        if (typeof next === "number" && Number.isFinite(next))
+            return next;
+    }
+    return undefined;
+}
+function stringArray(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value.filter((entry) => typeof entry === "string" && entry.length > 0);
+}
+function arrayFromKeys(value, keys) {
+    for (const key of keys) {
+        const next = value[key];
+        if (Array.isArray(next))
+            return next;
+    }
+    return [];
+}
 function extractItem(value) {
     const raw = asRecord(value);
     if (!raw)
@@ -87,23 +113,29 @@ function nameFromToolMethod(method) {
     return "工具";
 }
 function isToolItemType(itemType) {
-    return (itemType === "commandExecution" ||
-        itemType === "fileChange" ||
-        itemType === "mcpToolCall" ||
-        itemType === "dynamicToolCall");
+    const normalized = normalizedIdentifier(itemType);
+    return (normalized === "commandexecution" ||
+        normalized === "filechange" ||
+        normalized === "diff" ||
+        normalized === "toolcall" ||
+        normalized === "mcptoolcall" ||
+        normalized === "dynamictoolcall");
 }
 function toolNameFromItem(item) {
     const itemType = firstString(item, ["type"]);
-    if (itemType === "commandExecution")
+    const normalized = normalizedIdentifier(itemType);
+    if (normalized === "commandexecution")
         return "命令";
-    if (itemType === "fileChange")
+    if (normalized === "filechange" || normalized === "diff")
         return "文件修改";
-    if (itemType === "mcpToolCall") {
+    if (normalized === "toolcall")
+        return firstString(item, ["toolName", "tool", "name", "title"]) ?? "工具";
+    if (normalized === "mcptoolcall") {
         const server = firstString(item, ["server"]);
         const tool = firstString(item, ["tool", "toolName", "name"]);
         return [server, tool].filter(Boolean).join(" · ") || "MCP 工具";
     }
-    if (itemType === "dynamicToolCall") {
+    if (normalized === "dynamictoolcall") {
         const namespace = firstString(item, ["namespace"]);
         const tool = firstString(item, ["tool", "toolName", "name"]);
         return [namespace, tool].filter(Boolean).join(" · ") || "工具";
@@ -124,6 +156,92 @@ function summarizeFileChanges(changes) {
         .filter((line) => Boolean(line));
     return lines.length > 0 ? lines.slice(0, 8).join("\n") : undefined;
 }
+function fileChangeEntriesFromItem(item) {
+    const changes = Array.isArray(item.changes) ? item.changes : [];
+    const entries = [];
+    for (const change of changes) {
+        const raw = asRecord(change);
+        if (!raw)
+            continue;
+        const path = firstString(raw, ["path", "file", "filePath", "absolutePath", "relativePath"]) ??
+            firstString(asRecord(raw.update), ["path", "file", "filePath"]);
+        if (!path)
+            continue;
+        const totals = asRecord(raw.totals) ?? asRecord(raw.diffStats) ?? asRecord(raw.stats);
+        const entry = { path };
+        const kind = firstString(raw, ["kind", "type", "operation", "action"]);
+        const added = firstNumber(raw, ["added", "additions"]) ?? firstNumber(totals, ["added", "additions"]);
+        const removed = firstNumber(raw, ["removed", "deletions"]) ?? firstNumber(totals, ["removed", "deletions"]);
+        if (kind)
+            entry.kind = kind;
+        if (added !== undefined)
+            entry.added = added;
+        if (removed !== undefined)
+            entry.removed = removed;
+        entries.push(entry);
+    }
+    const directPath = firstString(item, ["path", "file", "filePath", "absolutePath", "relativePath"]);
+    if (entries.length === 0 && directPath) {
+        const entry = { path: directPath };
+        const kind = firstString(item, ["kind", "type", "operation", "action"]);
+        if (kind)
+            entry.kind = kind;
+        return [entry];
+    }
+    return entries;
+}
+function commandExecutionFromItem(item, status, output) {
+    const command = firstString(item, ["command"]);
+    const cwd = firstString(item, ["cwd"]);
+    const exitCode = firstNumber(item, ["exitCode", "code"]);
+    if (!command && !cwd && !output && exitCode === undefined)
+        return undefined;
+    return { command, cwd, output, exitCode: exitCode ?? undefined, status };
+}
+function fileChangeFromItem(item, status, diff) {
+    const entries = fileChangeEntriesFromItem(item);
+    const summary = summarizeFileChanges(Array.isArray(item.changes) ? item.changes : []);
+    const changeSetId = firstString(item, ["changeSetId", "changesetId", "patchId"]);
+    if (entries.length === 0 && !diff && !summary && !changeSetId)
+        return undefined;
+    return { entries, diff, summary, changeSetId, status };
+}
+function commandExecutionFromTool(toolCall) {
+    const input = toolCall.input?.trim();
+    if (!input && !toolCall.output)
+        return undefined;
+    const [commandPart, cwdPart] = input?.split(/\n\ncwd:\s*/i) ?? [];
+    return {
+        command: commandPart || input,
+        cwd: cwdPart,
+        output: toolCall.output,
+        status: toolCall.status,
+    };
+}
+function fileChangeFromTool(toolCall) {
+    const diff = toolCall.output && looksLikeDiff(toolCall.output) ? toolCall.output : undefined;
+    const entries = (toolCall.input ?? "")
+        .split("\n")
+        .map((line) => line.trim())
+        .filter(Boolean)
+        .map((line) => {
+        const [kind, ...rest] = line.split(/\s+/);
+        const path = rest.length > 0 ? rest.join(" ") : kind;
+        const entry = { path: path ?? line };
+        if (rest.length > 0 && kind)
+            entry.kind = kind;
+        return entry;
+    })
+        .filter((entry) => entry.path.length > 0);
+    if (entries.length === 0 && !diff && !toolCall.output)
+        return undefined;
+    return {
+        entries,
+        diff,
+        summary: diff ? undefined : toolCall.output,
+        status: toolCall.status,
+    };
+}
 function looksLikeDiff(text) {
     const value = text.trim();
     return (value.startsWith("diff --git ") ||
@@ -170,14 +288,15 @@ function extractDiffText(value) {
 }
 function toolInputFromItem(item) {
     const itemType = firstString(item, ["type"]);
-    if (itemType === "commandExecution") {
+    const normalized = normalizedIdentifier(itemType);
+    if (normalized === "commandexecution") {
         const command = firstString(item, ["command"]);
         const cwd = firstString(item, ["cwd"]);
         if (command && cwd)
             return `${command}\n\ncwd: ${cwd}`;
         return command ?? cwd;
     }
-    if (itemType === "fileChange") {
+    if (normalized === "filechange" || normalized === "diff") {
         const changes = Array.isArray(item.changes) ? item.changes : [];
         return summarizeFileChanges(changes) ?? firstString(item, ["path", "file", "filePath", "absolutePath", "relativePath"]);
     }
@@ -192,6 +311,170 @@ function textFromBlocks(blocks) {
         .filter(Boolean)
         .join("\n");
 }
+function isSubagentItemType(itemType) {
+    const normalized = normalizedIdentifier(itemType);
+    return (normalized === "collabagenttoolcall" ||
+        normalized === "collabtoolcall" ||
+        normalized.startsWith("collabagentspawn") ||
+        normalized.startsWith("collabwaiting") ||
+        normalized.startsWith("collabclose") ||
+        normalized.startsWith("collabresume") ||
+        normalized.startsWith("collabagentinteraction"));
+}
+function parseSubagentRef(value) {
+    const raw = asRecord(value);
+    if (!raw)
+        return undefined;
+    const threadId = firstString(raw, ["threadId", "threadID", "id", "sessionId"]);
+    if (!threadId)
+        return undefined;
+    return {
+        threadId,
+        agentId: firstString(raw, ["agentId", "agentID"]),
+        nickname: firstString(raw, ["nickname", "name", "label"]),
+        role: firstString(raw, ["role", "kind"]),
+        model: firstString(raw, ["model", "modelName"]),
+        prompt: firstString(raw, ["prompt", "instructions", "message"]),
+    };
+}
+function parseSubagentStates(value) {
+    const result = {};
+    if (Array.isArray(value)) {
+        for (const entry of value) {
+            const raw = asRecord(entry);
+            const threadId = firstString(raw, ["threadId", "threadID", "id", "sessionId"]);
+            const status = firstString(raw, ["status", "state", "phase"]);
+            if (!threadId || !status)
+                continue;
+            result[threadId] = {
+                threadId,
+                status,
+                message: firstString(raw, ["message", "summary", "text"]),
+            };
+        }
+        return result;
+    }
+    const raw = asRecord(value);
+    if (!raw)
+        return result;
+    for (const [threadId, entry] of Object.entries(raw)) {
+        const state = asRecord(entry);
+        if (state) {
+            result[threadId] = {
+                threadId,
+                status: firstString(state, ["status", "state", "phase"]) ?? "running",
+                message: firstString(state, ["message", "summary", "text"]),
+            };
+        }
+        else if (typeof entry === "string") {
+            result[threadId] = { threadId, status: entry };
+        }
+    }
+    return result;
+}
+function parseStructuredInputOption(value, index) {
+    const raw = asRecord(value);
+    if (!raw) {
+        if (typeof value === "string" && value.trim()) {
+            return { id: `option-${index + 1}`, label: value.trim() };
+        }
+        return undefined;
+    }
+    const label = firstString(raw, ["label", "title", "text", "value"]);
+    if (!label)
+        return undefined;
+    return {
+        id: firstString(raw, ["id", "optionId", "value"]) ?? `option-${index + 1}`,
+        label,
+        description: firstString(raw, ["description", "detail", "subtitle"]),
+    };
+}
+function parseStructuredInputQuestion(value, index) {
+    const raw = asRecord(value);
+    if (!raw)
+        return undefined;
+    const question = firstString(raw, ["question", "prompt", "text", "message", "label"]);
+    if (!question)
+        return undefined;
+    const options = arrayFromKeys(raw, ["options", "choices", "items"])
+        .map(parseStructuredInputOption)
+        .filter((option) => Boolean(option));
+    return {
+        id: firstString(raw, ["id", "questionId", "key"]) ?? `question-${index + 1}`,
+        header: firstString(raw, ["header", "title"]),
+        question,
+        isOther: raw.isOther === true,
+        isSecret: raw.isSecret === true || raw.secret === true,
+        selectionLimit: firstNumber(raw, ["selectionLimit", "maxSelections"]),
+        options: options.length > 0 ? options : undefined,
+    };
+}
+function decodeStructuredInput(value) {
+    const raw = asRecord(value) ?? {};
+    const questions = arrayFromKeys(raw, ["questions", "items", "prompts"])
+        .map(parseStructuredInputQuestion)
+        .filter((question) => Boolean(question));
+    if (questions.length === 0) {
+        const single = parseStructuredInputQuestion(raw, 0);
+        if (single)
+            questions.push(single);
+    }
+    if (questions.length === 0)
+        return undefined;
+    return {
+        requestId: firstString(raw, ["requestId", "id", "inputId"]) ?? id("input"),
+        questions,
+    };
+}
+function decodeSubagentAction(item, status) {
+    const nested = asRecord(item.action) ?? asRecord(item.toolCall) ?? asRecord(item.call) ?? {};
+    const receiverAgents = [
+        ...arrayFromKeys(item, ["receiverAgents", "agents", "subagents", "receivers"]).map(parseSubagentRef),
+        ...arrayFromKeys(nested, ["receiverAgents", "agents", "subagents", "receivers"]).map(parseSubagentRef),
+    ].filter((entry) => Boolean(entry));
+    const receiverThreadIds = [
+        ...stringArray(item.receiverThreadIds),
+        ...stringArray(item.threadIds),
+        ...stringArray(item.childThreadIds),
+        ...stringArray(item.agentThreadIds),
+        ...stringArray(nested.receiverThreadIds),
+        ...stringArray(nested.threadIds),
+        ...receiverAgents.map((agent) => agent.threadId),
+    ].filter((threadId, index, array) => array.indexOf(threadId) === index);
+    const agentStates = {
+        ...parseSubagentStates(item.agentStates ?? item.states ?? item.statusByThread),
+        ...parseSubagentStates(nested.agentStates ?? nested.states ?? nested.statusByThread),
+    };
+    if (receiverThreadIds.length === 0 && Object.keys(agentStates).length === 0)
+        return undefined;
+    return {
+        tool: firstString(item, ["tool", "toolName", "name", "type"]) ??
+            firstString(nested, ["tool", "toolName", "name", "type"]) ??
+            "subagent",
+        status,
+        prompt: firstString(item, ["prompt", "instructions", "message"]) ??
+            firstString(nested, ["prompt", "instructions", "message"]),
+        model: firstString(item, ["model", "modelName"]) ?? firstString(nested, ["model", "modelName"]),
+        receiverThreadIds,
+        receiverAgents,
+        agentStates,
+    };
+}
+function summarizeSubagentAction(action) {
+    const count = Math.max(1, action.receiverThreadIds.length, action.receiverAgents.length);
+    const normalized = normalizedIdentifier(action.tool);
+    if (normalized.includes("spawn"))
+        return `启动 ${count} 个子 Agent`;
+    if (normalized.includes("wait"))
+        return `等待 ${count} 个子 Agent`;
+    if (normalized.includes("resume"))
+        return `恢复 ${count} 个子 Agent`;
+    if (normalized.includes("close"))
+        return `关闭 ${count} 个子 Agent`;
+    if (normalized.includes("sendinput"))
+        return `更新 ${count} 个子 Agent`;
+    return count === 1 ? "子 Agent 活动" : `${count} 个子 Agent 活动`;
+}
 function previewText(text) {
     return text.replace(/\s+/g, " ").trim().slice(0, 160);
 }
@@ -202,21 +485,10 @@ function providerLabel(provider) {
         return "Claude";
     return "Custom";
 }
-function providerSetupReason(provider, activeProvider, error) {
-    if (provider === activeProvider) {
-        return error ?? `${providerLabel(provider)} Agent 正在初始化或不可用。`;
-    }
-    if (provider === "codex") {
-        return `当前 CLI 启用的是 ${providerLabel(activeProvider)} Agent。`;
-    }
-    if (provider === "claude") {
-        return "Claude ACP adapter 尚未启用，请用 --agent-provider claude --agent-command 配置。";
-    }
-    return "Custom Agent 需要用 --agent-provider custom --agent-command 配置后才能使用。";
-}
 export class AgentWorkspaceProxy {
     input;
-    client;
+    clients = new Map();
+    agentProtocols = new Map();
     initialized = false;
     status = "unavailable";
     error;
@@ -229,8 +501,9 @@ export class AgentWorkspaceProxy {
     pendingPermissions = new Map();
     permissionWaiters = new Map();
     permissionSources = new Map();
+    pendingStructuredInputs = new Map();
+    structuredInputWaiters = new Map();
     toolConversationIds = new Map();
-    agentProtocol;
     constructor(input) {
         this.input = input;
     }
@@ -269,7 +542,8 @@ export class AgentWorkspaceProxy {
                 const payload = parseTypedPayload("agent.v2.cancel", envelope.payload);
                 const conversation = this.conversations.get(payload.conversationId);
                 this.cancelPendingPermissions(payload.conversationId);
-                this.client?.cancel({
+                const cancelClient = conversation ? this.clientForProvider(conversation.provider) : undefined;
+                cancelClient?.cancel({
                     sessionId: conversation?.agentSessionId,
                     turnId: this.currentTurnId,
                 });
@@ -283,102 +557,122 @@ export class AgentWorkspaceProxy {
                 this.respondPermission(payload);
                 break;
             }
+            case "agent.v2.structured_input.respond": {
+                const payload = parseTypedPayload("agent.v2.structured_input.respond", envelope.payload);
+                this.respondStructuredInput(payload);
+                break;
+            }
         }
     }
     stop() {
-        this.client?.stop();
-        this.client = undefined;
+        for (const client of this.clients.values()) {
+            client.stop();
+        }
+        this.clients.clear();
+    }
+    clientForProvider(provider) {
+        return this.clients.get(provider);
+    }
+    protocolForProvider(provider) {
+        return this.agentProtocols.get(provider);
     }
     async initialize() {
         if (this.initialized)
             return;
-        await this.ensureClient();
+        // trigger capability report immediately, lazy-start providers on first use
+        this.initialized = true;
+        this.status = "idle";
+        this.error = undefined;
+        this.sendCapabilities();
     }
-    async ensureClient() {
-        if (this.client)
-            return;
+    async ensureProviderClient(provider) {
+        const existing = this.clients.get(provider);
+        if (existing)
+            return existing;
         const resolved = resolveAgentCommand({
-            provider: this.input.provider,
+            provider,
             command: this.input.command,
         });
         if (!resolved) {
-            this.status = "unavailable";
-            this.error = `Agent Workspace requires --agent-command for ${this.input.provider}`;
-            return;
+            if (this.input.verbose) {
+                process.stderr.write(`[agent:v2] no command for provider ${provider}\n`);
+            }
+            return undefined;
         }
         try {
-            this.agentProtocol = resolved.protocol;
-            this.client = new AcpClient({
+            this.agentProtocols.set(provider, resolved.protocol);
+            const client = new AcpClient({
                 command: resolved.command,
                 protocol: resolved.protocol,
                 framing: resolved.framing,
                 cwd: this.input.cwd,
                 onNotification: (method, params) => this.handleNotification(method, params),
                 onRequest: (method, params) => this.handleRequest(method, params),
-                onExit: (message) => this.handleExit(message),
+                onExit: (message) => this.handleProviderExit(provider, message),
             });
-            await this.client.initialize();
-            this.initialized = true;
+            await client.initialize();
+            this.clients.set(provider, client);
             this.status = "idle";
             this.error = undefined;
+            this.sendCapabilities();
+            return client;
         }
         catch (error) {
-            this.client?.stop();
-            this.client = undefined;
-            this.status = "error";
-            this.error = error instanceof Error ? error.message : String(error);
+            if (this.input.verbose) {
+                process.stderr.write(`[agent:v2] failed to start ${provider}: ${error instanceof Error ? error.message : String(error)}\n`);
+            }
+            return undefined;
         }
     }
     sendCapabilities() {
-        const enabled = Boolean(this.client && this.initialized && !this.error);
-        const supportsImages = enabled && this.agentProtocol === "codex-app-server";
-        const activeProvider = this.input.provider;
-        const providerIds = ["codex", "claude"];
-        if (activeProvider === "custom")
-            providerIds.push("custom");
+        const providers = this.input.availableProviders.map((provider) => {
+            const client = this.clients.get(provider);
+            const protocol = this.agentProtocols.get(provider);
+            const enabled = Boolean(client);
+            const supportsImages = enabled && protocol === "codex-app-server";
+            return {
+                id: provider,
+                label: providerLabel(provider),
+                enabled,
+                reason: enabled ? undefined : `${providerLabel(provider)} 未安装或启动失败`,
+                supportsImages,
+                supportsPermission: enabled,
+                supportsPlan: enabled,
+                supportsCancel: enabled,
+            };
+        });
+        const anyEnabled = providers.some((p) => p.enabled);
         this.input.send(createEnvelope({
             type: "agent.v2.capabilities",
             sessionId: this.input.sessionId,
             payload: {
-                enabled,
-                provider: activeProvider,
-                providers: providerIds.map((provider) => {
-                    const isActive = provider === activeProvider;
-                    const canUse = isActive && enabled;
-                    return {
-                        id: provider,
-                        label: providerLabel(provider),
-                        enabled: canUse,
-                        reason: canUse
-                            ? undefined
-                            : providerSetupReason(provider, activeProvider, isActive ? this.error : undefined),
-                        supportsImages: canUse && supportsImages,
-                        supportsPermission: canUse,
-                        supportsPlan: canUse,
-                        supportsCancel: canUse,
-                    };
-                }),
+                enabled: anyEnabled,
+                provider: this.input.availableProviders[0] ?? "codex",
+                providers,
                 protocolVersion: 1,
                 workspaceProtocolVersion: 2,
-                error: enabled ? undefined : this.error,
-                supportsSessionList: enabled,
-                supportsSessionLoad: enabled,
-                supportsImages,
+                error: anyEnabled ? undefined : "没有可用的 Agent provider。请安装 Claude Code 或 Codex CLI。",
+                supportsSessionList: anyEnabled,
+                supportsSessionLoad: anyEnabled,
+                supportsImages: providers.some((p) => p.supportsImages),
                 supportsAudio: false,
-                supportsPermission: enabled,
-                supportsPlan: enabled,
-                supportsCancel: enabled,
+                supportsPermission: anyEnabled,
+                supportsPlan: anyEnabled,
+                supportsCancel: anyEnabled,
             },
         }));
     }
     async openConversation(payload) {
-        await this.ensureClient();
-        this.sendCapabilities();
-        if (payload.provider && payload.provider !== this.input.provider) {
-            return this.openFailure(payload, `当前 CLI 只启用了 ${providerLabel(this.input.provider)} Agent，不能在这个会话里启动 ${providerLabel(payload.provider)}。`);
+        const provider = payload.provider ?? this.input.availableProviders[0];
+        if (!provider) {
+            return this.openFailure(payload, "没有可用的 Agent provider。");
+        }
+        if (!this.input.availableProviders.includes(provider)) {
+            return this.openFailure(payload, `${providerLabel(provider)} 未安装或不可用。`);
         }
-        if (!this.client) {
-            return this.openFailure(payload, this.error ?? "Agent Workspace 不可用，请确认 CLI 已使用 --agent-ui 启动。");
+        const client = await this.ensureProviderClient(provider);
+        if (!client) {
+            return this.openFailure(payload, `${providerLabel(provider)} 启动失败。请确认 CLI 已安装并可用。`);
         }
         const cwd = payload.cwd ?? this.input.cwd;
         let agentSessionId = payload.agentSessionId;
@@ -401,8 +695,8 @@ export class AgentWorkspaceProxy {
         }
         try {
             const result = agentSessionId
-                ? await this.client.loadSession({ sessionId: agentSessionId, cwd })
-                : await this.client.newSession({ cwd });
+                ? await client.loadSession({ sessionId: agentSessionId, cwd })
+                : await client.newSession({ cwd });
             agentSessionId = this.extractSessionId(result) ?? agentSessionId ?? id("agent-session");
             const now = Date.now();
             const conversationId = payload.conversationId ?? `agent:${agentSessionId}`;
@@ -410,7 +704,7 @@ export class AgentWorkspaceProxy {
                 ...existingConversation,
                 id: conversationId,
                 agentSessionId,
-                provider: payload.provider ?? this.input.provider,
+                provider,
                 cwd,
                 title: payload.title ?? existingConversation?.title ?? titleFromCwd(cwd),
                 model: payload.model ?? existingConversation?.model,
@@ -443,7 +737,7 @@ export class AgentWorkspaceProxy {
         const now = Date.now();
         const conversation = {
             id: fallbackId,
-            provider: payload.provider ?? this.input.provider,
+            provider: payload.provider ?? this.input.availableProviders[0] ?? "codex",
             cwd,
             title: payload.title ?? titleFromCwd(cwd),
             model: payload.model,
@@ -474,9 +768,13 @@ export class AgentWorkspaceProxy {
     async sendPrompt(payload) {
         const conversation = this.conversations.get(payload.conversationId) ??
             await this.openConversation({ conversationId: payload.conversationId });
-        if (!conversation || !this.client || !conversation.agentSessionId)
+        if (!conversation || !conversation.agentSessionId)
             return;
-        if (payload.contentBlocks.some((block) => block.type === "image") && this.agentProtocol !== "codex-app-server") {
+        const client = this.clientForProvider(conversation.provider);
+        if (!client)
+            return;
+        const protocol = this.protocolForProvider(conversation.provider);
+        if (payload.contentBlocks.some((block) => block.type === "image") && protocol !== "codex-app-server") {
             conversation.status = "idle";
             conversation.lastActivityAt = Date.now();
             this.emitConversation(conversation);
@@ -507,7 +805,7 @@ export class AgentWorkspaceProxy {
         });
         this.emitConversation(conversation);
         try {
-            const result = await this.client.prompt({
+            const result = await client.prompt({
                 sessionId: conversation.agentSessionId,
                 content: payload.contentBlocks,
                 clientMessageId: payload.clientMessageId,
@@ -534,6 +832,9 @@ export class AgentWorkspaceProxy {
         }
     }
     handleRequest(method, params) {
+        if (method === "item/tool/requestUserInput" || method === "tool/requestUserInput") {
+            return this.handleStructuredInput(params, true);
+        }
         if (isPermissionRequestMethod(method)) {
             return this.handlePermission(params, true, method);
         }
@@ -556,6 +857,10 @@ export class AgentWorkspaceProxy {
             return;
         }
         const conversationId = this.conversationIdFromParams(params) ?? this.activeConversationId;
+        if (method === "item/tool/requestUserInput" || method === "tool/requestUserInput") {
+            this.handleStructuredInput(params);
+            return;
+        }
         if (isPermissionRequestMethod(method)) {
             this.handlePermission(params, false, method);
             return;
@@ -712,14 +1017,21 @@ export class AgentWorkspaceProxy {
         if (!item)
             return;
         const itemType = firstString(item, ["type"]);
-        if (itemType === "agentMessage" || itemType === "assistantMessage") {
+        const normalizedItemType = normalizedIdentifier(itemType);
+        if (normalizedItemType === "agentmessage" || normalizedItemType === "assistantmessage") {
             this.handleCompletedMessageItem(item, true);
             return;
         }
-        if (itemType === "plan") {
+        if (normalizedItemType === "plan") {
             this.handlePlanUpdated({ plan: [item] });
             return;
         }
+        if (isSubagentItemType(itemType)) {
+            this.handleSubagentItem(item, "running", true);
+            return;
+        }
+        if (this.handleSemanticSystemItem(item, "running", true))
+            return;
         const conversationId = this.conversationIdFromParams(item) ?? this.activeConversationId;
         const toolCall = this.toolCallFromItem(item, "running");
         if (!conversationId || !toolCall)
@@ -732,10 +1044,21 @@ export class AgentWorkspaceProxy {
         if (!item)
             return;
         const itemType = firstString(item, ["type"]);
-        if (itemType === "agentMessage" || itemType === "assistantMessage") {
+        const normalizedItemType = normalizedIdentifier(itemType);
+        if (normalizedItemType === "agentmessage" || normalizedItemType === "assistantmessage") {
             this.handleCompletedMessageItem(item, false);
             return;
         }
+        if (normalizedItemType === "plan") {
+            this.handlePlanDelta({ ...item, delta: firstString(item, ["text", "content", "message"]) });
+            return;
+        }
+        if (isSubagentItemType(itemType)) {
+            this.handleSubagentItem(item, normalizeToolStatus(item.status, true), false);
+            return;
+        }
+        if (this.handleSemanticSystemItem(item, normalizeToolStatus(item.status, true), false))
+            return;
         const conversationId = this.conversationIdFromParams(item) ?? this.activeConversationId;
         const toolCall = this.toolCallFromItem(item, normalizeToolStatus(item.status, true));
         if (!conversationId || !toolCall)
@@ -900,18 +1223,131 @@ export class AgentWorkspaceProxy {
         });
         this.updateConversationPreview(conversationId, text, raw.done === true ? "idle" : "running");
     }
+    handleSemanticSystemItem(item, status, streaming) {
+        const itemType = firstString(item, ["type"]);
+        const normalized = normalizedIdentifier(itemType);
+        const conversationId = this.conversationIdFromParams(item) ?? this.activeConversationId;
+        if (!conversationId)
+            return false;
+        const itemId = firstString(item, ["id", "itemId"]) ?? id("item");
+        const existing = this.findItem(conversationId, itemId);
+        const base = {
+            id: itemId,
+            conversationId,
+            type: "status",
+            role: "system",
+            turnId: this.extractTurnId(item) ?? this.currentTurnId,
+            itemId,
+            createdAt: existing?.createdAt ?? Date.now(),
+            updatedAt: Date.now(),
+            isStreaming: streaming,
+        };
+        if (normalized === "reasoning" || normalized === "thinking") {
+            const text = firstString(item, ["text", "content", "summary", "message"]) ??
+                stringifyDefined(item.contentItems ?? item.summary);
+            this.upsertItem(conversationId, {
+                ...base,
+                kind: "thinking",
+                text: text ?? (streaming ? "正在思考" : "完成思考"),
+            });
+            return true;
+        }
+        if (normalized === "enteredreviewmode") {
+            const target = firstString(item, ["review", "target", "label"]) ?? "changes";
+            this.upsertItem(conversationId, {
+                ...base,
+                kind: "review",
+                text: status === "completed" ? `已完成审查 ${target}` : `正在审查 ${target}`,
+            });
+            return true;
+        }
+        if (normalized === "contextcompaction") {
+            this.upsertItem(conversationId, {
+                ...base,
+                kind: "context_compaction",
+                text: status === "completed" ? "上下文已压缩" : "正在压缩上下文",
+            });
+            return true;
+        }
+        return false;
+    }
+    handleSubagentItem(item, status, streaming) {
+        const conversationId = this.conversationIdFromParams(item) ?? this.activeConversationId;
+        if (!conversationId)
+            return;
+        const subagent = decodeSubagentAction(item, status);
+        if (!subagent)
+            return;
+        const itemId = firstString(item, ["id", "itemId"]) ?? id("subagent");
+        const text = summarizeSubagentAction(subagent);
+        const existing = this.findItem(conversationId, itemId);
+        this.upsertItem(conversationId, {
+            id: itemId,
+            conversationId,
+            type: "status",
+            kind: "subagent_action",
+            role: "system",
+            turnId: this.extractTurnId(item) ?? this.currentTurnId,
+            itemId,
+            text,
+            subagent,
+            createdAt: existing?.createdAt ?? Date.now(),
+            updatedAt: Date.now(),
+            isStreaming: streaming,
+        });
+        this.updateConversationPreview(conversationId, text, streaming ? "running" : "idle");
+    }
+    handleStructuredInput(params, waitForResponse = false) {
+        const raw = asRecord(params) ?? {};
+        const conversationId = this.conversationIdFromParams(raw) ?? this.activeConversationId;
+        if (!conversationId)
+            return waitForResponse ? Promise.resolve(formatStructuredInputResponse({})) : undefined;
+        const structuredInput = decodeStructuredInput(raw);
+        if (!structuredInput)
+            return waitForResponse ? Promise.resolve(formatStructuredInputResponse({})) : undefined;
+        const text = structuredInput.questions.map((question) => question.question).join("\n");
+        this.pendingStructuredInputs.set(structuredInput.requestId, { conversationId, input: structuredInput });
+        this.upsertItem(conversationId, {
+            id: `input:${structuredInput.requestId}`,
+            conversationId,
+            type: "status",
+            kind: "user_input_prompt",
+            role: "system",
+            text,
+            structuredInput,
+            metadata: { inputPending: true },
+            createdAt: this.findItem(conversationId, `input:${structuredInput.requestId}`)?.createdAt ?? Date.now(),
+            updatedAt: Date.now(),
+        });
+        this.updateConversationPreview(conversationId, "需要用户输入", "running");
+        if (!waitForResponse)
+            return;
+        return new Promise((resolve) => {
+            const timer = setTimeout(() => {
+                this.pendingStructuredInputs.delete(structuredInput.requestId);
+                this.structuredInputWaiters.delete(structuredInput.requestId);
+                resolve(formatStructuredInputResponse({}));
+                this.markStructuredInput(conversationId, structuredInput.requestId, {
+                    inputPending: false,
+                    inputError: "等待用户输入超时",
+                });
+            }, PERMISSION_TIMEOUT_MS);
+            this.structuredInputWaiters.set(structuredInput.requestId, { resolve, timer });
+        });
+    }
     toolCallFromItem(item, fallbackStatus) {
         const itemId = firstString(item, ["id", "itemId", "toolCallId"]);
         if (!itemId)
             return undefined;
         const itemType = firstString(item, ["type"]);
+        const normalizedItemType = normalizedIdentifier(itemType);
         const name = toolNameFromItem(item);
         if (!name && !isToolItemType(itemType))
             return undefined;
         const bufferedOutput = this.toolOutputBuffers.get(itemId);
         const rawOutput = firstString(item, ["aggregatedOutput", "output", "stdout", "stderr"]) ??
             stringifyDefined(item.result ?? item.error ?? item.contentItems);
-        const output = itemType === "fileChange"
+        const output = normalizedItemType === "filechange" || normalizedItemType === "diff"
             ? extractDiffText(item) ?? bufferedOutput ?? rawOutput
             : rawOutput ?? bufferedOutput;
         return {
@@ -980,8 +1416,10 @@ export class AgentWorkspaceProxy {
             this.permissionSources.delete(payload.requestId);
         }
         else {
-            this.client?.respondPermission({
-                sessionId: this.conversations.get(payload.conversationId)?.agentSessionId,
+            const conversation = this.conversations.get(payload.conversationId);
+            const respondClient = conversation ? this.clientForProvider(conversation.provider) : undefined;
+            respondClient?.respondPermission({
+                sessionId: conversation?.agentSessionId,
                 requestId: payload.requestId,
                 outcome: payload.outcome === "cancelled" ? "deny" : payload.outcome,
                 optionId: selectedOptionId,
@@ -989,6 +1427,32 @@ export class AgentWorkspaceProxy {
         }
         this.updateConversationStatus(payload.conversationId, "running");
     }
+    respondStructuredInput(payload) {
+        const pending = this.pendingStructuredInputs.get(payload.requestId);
+        this.pendingStructuredInputs.delete(payload.requestId);
+        const waiter = this.structuredInputWaiters.get(payload.requestId);
+        if (waiter) {
+            clearTimeout(waiter.timer);
+            this.structuredInputWaiters.delete(payload.requestId);
+            waiter.resolve(formatStructuredInputResponse(payload.answers));
+        }
+        this.markStructuredInput(payload.conversationId, payload.requestId, {
+            inputPending: false,
+            inputSubmitted: true,
+            answers: payload.answers,
+        });
+        this.updateConversationStatus(pending?.conversationId ?? payload.conversationId, "running");
+    }
+    markStructuredInput(conversationId, requestId, metadata) {
+        const item = this.findItem(conversationId, `input:${requestId}`);
+        if (!item)
+            return;
+        this.upsertItem(conversationId, {
+            ...item,
+            metadata: { ...(item.metadata ?? {}), ...metadata },
+            updatedAt: Date.now(),
+        });
+    }
     addItem(conversationId, item) {
         const timeline = this.timelines.get(conversationId) ?? [];
         timeline.push(item);
@@ -1028,11 +1492,20 @@ export class AgentWorkspaceProxy {
         };
         this.toolConversationIds.set(toolCall.id, conversationId);
         this.toolConversationIds.set(nextToolCall.id, conversationId);
+        const kind = nextToolCall.name.includes("文件")
+            ? "file_change"
+            : nextToolCall.name.includes("命令")
+                ? "command_execution"
+                : "tool_activity";
         this.upsertItem(conversationId, {
             id: `tool:${nextToolCall.id}`,
             conversationId,
             type: "tool_call",
+            kind,
+            itemId: nextToolCall.id,
             toolCall: nextToolCall,
+            commandExecution: kind === "command_execution" ? commandExecutionFromTool(nextToolCall) : undefined,
+            fileChange: kind === "file_change" ? fileChangeFromTool(nextToolCall) : undefined,
             createdAt: nextToolCall.createdAt ?? Date.now(),
             updatedAt: Date.now(),
         });
@@ -1178,12 +1651,13 @@ export class AgentWorkspaceProxy {
             return this.conversationByAgentSessionId.get(threadId);
         return undefined;
     }
-    handleExit(message) {
+    handleProviderExit(provider, message) {
+        this.clients.delete(provider);
+        this.agentProtocols.delete(provider);
         this.cancelPendingPermissions();
-        this.status = "error";
-        this.error = message;
-        this.client = undefined;
         for (const conversation of this.conversations.values()) {
+            if (conversation.provider !== provider)
+                continue;
             conversation.status = "error";
             conversation.lastMessagePreview = message;
             conversation.lastActivityAt = Date.now();
@@ -1196,6 +1670,7 @@ export class AgentWorkspaceProxy {
                 createdAt: Date.now(),
             });
         }
+        this.sendCapabilities();
     }
     cancelPendingPermissions(conversationId) {
         for (const [requestId, waiter] of this.permissionWaiters) {
@@ -1205,6 +1680,19 @@ export class AgentWorkspaceProxy {
             this.permissionSources.delete(requestId);
         }
         this.permissionWaiters.clear();
+        for (const [requestId, waiter] of this.structuredInputWaiters) {
+            clearTimeout(waiter.timer);
+            waiter.resolve(formatStructuredInputResponse({}));
+            const pending = this.pendingStructuredInputs.get(requestId);
+            if (pending) {
+                this.markStructuredInput(pending.conversationId, requestId, {
+                    inputPending: false,
+                    inputError: "已停止",
+                });
+            }
+            this.pendingStructuredInputs.delete(requestId);
+        }
+        this.structuredInputWaiters.clear();
         if (conversationId)
             this.updateConversationStatus(conversationId, "idle");
     }
@@ -1272,8 +1760,15 @@ function selectPermissionOption(permission, outcome) {
 function isPermissionRequestMethod(method) {
     return (method === "session/request_permission" ||
         method.endsWith("/requestApproval") ||
-        method === "mcpServer/elicitation/request" ||
-        method === "item/tool/requestUserInput");
+        method === "mcpServer/elicitation/request");
+}
+function formatStructuredInputResponse(answers) {
+    return {
+        answers: Object.fromEntries(Object.entries(answers).map(([questionId, values]) => [
+            questionId,
+            { answers: values.map((value) => value.trim()).filter(Boolean) },
+        ])),
+    };
 }
 function formatPermissionResponse(source, outcome, optionId) {
     if (source === "item/commandExecution/requestApproval" || source === "item/fileChange/requestApproval") {