linkshell-cli 0.2.88 → 0.2.90

package/src/runtime/acp/agent-workspace.ts

@@ -41,6 +41,87 @@ interface AgentPermission {
   options: { id: string; label: string; kind: "allow" | "deny" | "other" }[];
 }
 
+type AgentTimelineKind =
+  | "chat"
+  | "thinking"
+  | "tool_activity"
+  | "command_execution"
+  | "file_change"
+  | "subagent_action"
+  | "plan"
+  | "user_input_prompt"
+  | "review"
+  | "context_compaction";
+
+interface AgentFileChangeEntry {
+  path: string;
+  kind?: string;
+  added?: number;
+  removed?: number;
+}
+
+interface AgentFileChange {
+  entries: AgentFileChangeEntry[];
+  diff?: string;
+  summary?: string;
+  changeSetId?: string;
+  status?: AgentToolCall["status"];
+}
+
+interface AgentCommandExecution {
+  command?: string;
+  cwd?: string;
+  output?: string;
+  exitCode?: number | null;
+  status?: AgentToolCall["status"];
+}
+
+interface AgentStructuredInputOption {
+  id: string;
+  label: string;
+  description?: string;
+}
+
+interface AgentStructuredInputQuestion {
+  id: string;
+  header?: string;
+  question: string;
+  isOther?: boolean;
+  isSecret?: boolean;
+  selectionLimit?: number;
+  options?: AgentStructuredInputOption[];
+}
+
+interface AgentStructuredInput {
+  requestId: string;
+  questions: AgentStructuredInputQuestion[];
+}
+
+interface AgentSubagentRef {
+  threadId: string;
+  agentId?: string;
+  nickname?: string;
+  role?: string;
+  model?: string;
+  prompt?: string;
+}
+
+interface AgentSubagentState {
+  threadId: string;
+  status: string;
+  message?: string;
+}
+
+interface AgentSubagentAction {
+  tool: string;
+  status: string;
+  prompt?: string;
+  model?: string;
+  receiverThreadIds: string[];
+  receiverAgents: AgentSubagentRef[];
+  agentStates: Record<string, AgentSubagentState>;
+}
+
 interface AgentConversation {
   id: string;
   agentSessionId?: string;
@@ -61,10 +142,17 @@ interface AgentTimelineItem {
   id: string;
   conversationId: string;
   type: "message" | "tool_call" | "plan" | "permission" | "status" | "error";
+  kind?: AgentTimelineKind;
+  turnId?: string;
+  itemId?: string;
   role?: "user" | "assistant" | "system";
   content?: AgentContentBlock[];
   text?: string;
   toolCall?: AgentToolCall;
+  commandExecution?: AgentCommandExecution;
+  fileChange?: AgentFileChange;
+  subagent?: AgentSubagentAction;
+  structuredInput?: AgentStructuredInput;
   plan?: AgentPlanStep[];
   permission?: AgentPermission;
   status?: AgentStatus;
@@ -80,6 +168,11 @@ interface PendingPermissionWaiter {
   timer: ReturnType<typeof setTimeout>;
 }
 
+interface PendingStructuredInputWaiter {
+  resolve: (value: unknown) => void;
+  timer: ReturnType<typeof setTimeout>;
+}
+
 const PERMISSION_TIMEOUT_MS = 5 * 60_000;
 const MAX_TIMELINE_ITEMS = 200;
 
@@ -109,6 +202,32 @@ function firstString(value: Record<string, unknown> | undefined, keys: string[])
   return undefined;
 }
 
+function normalizedIdentifier(value: string | undefined): string {
+  return (value ?? "").toLowerCase().replace(/[_\-\s/]+/g, "");
+}
+
+function firstNumber(value: Record<string, unknown> | undefined, keys: string[]): number | undefined {
+  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: unknown): string[] {
+  if (!Array.isArray(value)) return [];
+  return value.filter((entry): entry is string => typeof entry === "string" && entry.length > 0);
+}
+
+function arrayFromKeys(value: Record<string, unknown>, keys: string[]): unknown[] {
+  for (const key of keys) {
+    const next = value[key];
+    if (Array.isArray(next)) return next;
+  }
+  return [];
+}
+
 function extractItem(value: unknown): Record<string, unknown> | undefined {
   const raw = asRecord(value);
   if (!raw) return undefined;
@@ -161,24 +280,29 @@ function nameFromToolMethod(method: string): string {
 }
 
 function isToolItemType(itemType: string | undefined): boolean {
+  const normalized = normalizedIdentifier(itemType);
   return (
-    itemType === "commandExecution" ||
-    itemType === "fileChange" ||
-    itemType === "mcpToolCall" ||
-    itemType === "dynamicToolCall"
+    normalized === "commandexecution" ||
+    normalized === "filechange" ||
+    normalized === "diff" ||
+    normalized === "toolcall" ||
+    normalized === "mcptoolcall" ||
+    normalized === "dynamictoolcall"
   );
 }
 
 function toolNameFromItem(item: Record<string, unknown>): string | undefined {
   const itemType = firstString(item, ["type"]);
-  if (itemType === "commandExecution") return "命令";
-  if (itemType === "fileChange") return "文件修改";
-  if (itemType === "mcpToolCall") {
+  const normalized = normalizedIdentifier(itemType);
+  if (normalized === "commandexecution") return "命令";
+  if (normalized === "filechange" || normalized === "diff") return "文件修改";
+  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(" · ") || "工具";
@@ -201,6 +325,95 @@ function summarizeFileChanges(changes: unknown[]): string | undefined {
   return lines.length > 0 ? lines.slice(0, 8).join("\n") : undefined;
 }
 
+function fileChangeEntriesFromItem(item: Record<string, unknown>): AgentFileChangeEntry[] {
+  const changes = Array.isArray(item.changes) ? item.changes : [];
+  const entries: AgentFileChangeEntry[] = [];
+  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: AgentFileChangeEntry = { 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: AgentFileChangeEntry = { path: directPath };
+    const kind = firstString(item, ["kind", "type", "operation", "action"]);
+    if (kind) entry.kind = kind;
+    return [entry];
+  }
+  return entries;
+}
+
+function commandExecutionFromItem(
+  item: Record<string, unknown>,
+  status: AgentToolCall["status"],
+  output?: string,
+): AgentCommandExecution | undefined {
+  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: Record<string, unknown>,
+  status: AgentToolCall["status"],
+  diff?: string,
+): AgentFileChange | undefined {
+  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: AgentToolCall): AgentCommandExecution | undefined {
+  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: AgentToolCall): AgentFileChange | undefined {
+  const diff = toolCall.output && looksLikeDiff(toolCall.output) ? toolCall.output : undefined;
+  const entries: AgentFileChangeEntry[] = (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: AgentFileChangeEntry = { 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: string): boolean {
   const value = text.trim();
   return (
@@ -247,13 +460,14 @@ function extractDiffText(value: unknown): string | undefined {
 
 function toolInputFromItem(item: Record<string, unknown>): string | undefined {
   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"]);
   }
@@ -271,6 +485,167 @@ function textFromBlocks(blocks: AgentContentBlock[]): string {
     .join("\n");
 }
 
+function isSubagentItemType(itemType: string | undefined): boolean {
+  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: unknown): AgentSubagentRef | undefined {
+  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: unknown): Record<string, AgentSubagentState> {
+  const result: Record<string, AgentSubagentState> = {};
+  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: unknown, index: number): AgentStructuredInputOption | undefined {
+  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: unknown, index: number): AgentStructuredInputQuestion | undefined {
+  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): option is AgentStructuredInputOption => 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: unknown): AgentStructuredInput | undefined {
+  const raw = asRecord(value) ?? {};
+  const questions = arrayFromKeys(raw, ["questions", "items", "prompts"])
+    .map(parseStructuredInputQuestion)
+    .filter((question): question is AgentStructuredInputQuestion => 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: Record<string, unknown>,
+  status: "running" | "completed" | "failed" | "pending",
+): AgentSubagentAction | undefined {
+  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): entry is AgentSubagentRef => 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: AgentSubagentAction): string {
+  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: string): string {
   return text.replace(/\s+/g, " ").trim().slice(0, 160);
 }
@@ -281,21 +656,9 @@ function providerLabel(provider: AgentProvider): string {
   return "Custom";
 }
 
-function providerSetupReason(provider: AgentProvider, activeProvider: AgentProvider, error?: string): string {
-  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 {
-  private client: AcpClient | undefined;
+  private clients = new Map<AgentProvider, AcpClient>();
+  private agentProtocols = new Map<AgentProvider, AgentProtocol>();
   private initialized = false;
   private status: AgentStatus = "unavailable";
   private error: string | undefined;
@@ -308,14 +671,15 @@ export class AgentWorkspaceProxy {
   private pendingPermissions = new Map<string, AgentPermission>();
   private permissionWaiters = new Map<string, PendingPermissionWaiter>();
   private permissionSources = new Map<string, string>();
+  private pendingStructuredInputs = new Map<string, { conversationId: string; input: AgentStructuredInput }>();
+  private structuredInputWaiters = new Map<string, PendingStructuredInputWaiter>();
   private toolConversationIds = new Map<string, string>();
-  private agentProtocol: AgentProtocol | undefined;
 
   constructor(
     private readonly input: {
       sessionId: string;
       cwd: string;
-      provider: AgentProvider;
+      availableProviders: AgentProvider[];
       command?: string;
       send: (envelope: Envelope) => void;
       verbose?: boolean;
@@ -359,7 +723,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,
         });
@@ -373,93 +738,113 @@ 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(): void {
-    this.client?.stop();
-    this.client = undefined;
+    for (const client of this.clients.values()) {
+      client.stop();
+    }
+    this.clients.clear();
+  }
+
+  private clientForProvider(provider: AgentProvider): AcpClient | undefined {
+    return this.clients.get(provider);
+  }
+
+  private protocolForProvider(provider: AgentProvider): AgentProtocol | undefined {
+    return this.agentProtocols.get(provider);
   }
 
   private async initialize(): Promise<void> {
     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();
   }
 
-  private async ensureClient(): Promise<void> {
-    if (this.client) return;
+  private async ensureProviderClient(provider: AgentProvider): Promise<AcpClient | undefined> {
+    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;
     }
   }
 
   private sendCapabilities(): void {
-    const enabled = Boolean(this.client && this.initialized && !this.error);
-    const supportsImages = enabled && this.agentProtocol === "codex-app-server";
-    const activeProvider = this.input.provider;
-    const providerIds: AgentProvider[] = ["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,
       },
     }));
   }
@@ -474,18 +859,22 @@ export class AgentWorkspaceProxy {
     permissionMode?: AgentPermissionMode;
     title?: string;
   }): Promise<AgentConversation | undefined> {
-    await this.ensureClient();
-    this.sendCapabilities();
-    if (payload.provider && payload.provider !== this.input.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,
-        `当前 CLI 只启用了 ${providerLabel(this.input.provider)} Agent，不能在这个会话里启动 ${providerLabel(payload.provider)}。`,
+        `${providerLabel(provider)} 未安装或不可用。`,
       );
     }
-    if (!this.client) {
+
+    const client = await this.ensureProviderClient(provider);
+    if (!client) {
       return this.openFailure(
         payload,
-        this.error ?? "Agent Workspace 不可用，请确认 CLI 已使用 --agent-ui 启动。",
+        `${providerLabel(provider)} 启动失败。请确认 CLI 已安装并可用。`,
       );
     }
 
@@ -513,8 +902,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}`;
@@ -522,7 +911,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,
@@ -567,7 +956,7 @@ export class AgentWorkspaceProxy {
     const now = Date.now();
     const conversation: AgentConversation = {
       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,
@@ -607,9 +996,12 @@ export class AgentWorkspaceProxy {
     const conversation =
       this.conversations.get(payload.conversationId) ??
       await this.openConversation({ conversationId: payload.conversationId });
-    if (!conversation || !this.client || !conversation.agentSessionId) return;
+    if (!conversation || !conversation.agentSessionId) return;
+    const client = this.clientForProvider(conversation.provider);
+    if (!client) return;
 
-    if (payload.contentBlocks.some((block) => block.type === "image") && this.agentProtocol !== "codex-app-server") {
+    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);
@@ -643,7 +1035,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,
@@ -670,6 +1062,9 @@ export class AgentWorkspaceProxy {
   }
 
   private handleRequest(method: string, params: unknown): Promise<unknown> | unknown {
+    if (method === "item/tool/requestUserInput" || method === "tool/requestUserInput") {
+      return this.handleStructuredInput(params, true);
+    }
     if (isPermissionRequestMethod(method)) {
       return this.handlePermission(params, true, method);
     }
@@ -696,6 +1091,10 @@ export class AgentWorkspaceProxy {
     }
 
     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;
@@ -845,14 +1244,20 @@ export class AgentWorkspaceProxy {
     const item = extractItem(params);
     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) return;
@@ -864,10 +1269,20 @@ export class AgentWorkspaceProxy {
     const item = extractItem(params);
     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) return;
@@ -1029,6 +1444,127 @@ export class AgentWorkspaceProxy {
     this.updateConversationPreview(conversationId, text, raw.done === true ? "idle" : "running");
   }
 
+  private handleSemanticSystemItem(
+    item: Record<string, unknown>,
+    status: AgentToolCall["status"],
+    streaming: boolean,
+  ): boolean {
+    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" as const,
+      role: "system" as const,
+      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;
+  }
+
+  private handleSubagentItem(
+    item: Record<string, unknown>,
+    status: AgentToolCall["status"],
+    streaming: boolean,
+  ): void {
+    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");
+  }
+
+  private handleStructuredInput(params: unknown, waitForResponse = false): Promise<unknown> | void {
+    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 });
+    });
+  }
+
   private toolCallFromItem(
     item: Record<string, unknown>,
     fallbackStatus: AgentToolCall["status"],
@@ -1036,13 +1572,14 @@ export class AgentWorkspaceProxy {
     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 {
@@ -1124,8 +1661,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,
@@ -1134,6 +1673,41 @@ export class AgentWorkspaceProxy {
     this.updateConversationStatus(payload.conversationId, "running");
   }
 
+  private respondStructuredInput(payload: {
+    conversationId: string;
+    requestId: string;
+    answers: Record<string, string[]>;
+  }): void {
+    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");
+  }
+
+  private markStructuredInput(
+    conversationId: string,
+    requestId: string,
+    metadata: Record<string, unknown>,
+  ): void {
+    const item = this.findItem(conversationId, `input:${requestId}`);
+    if (!item) return;
+    this.upsertItem(conversationId, {
+      ...item,
+      metadata: { ...(item.metadata ?? {}), ...metadata },
+      updatedAt: Date.now(),
+    });
+  }
+
   private addItem(conversationId: string, item: AgentTimelineItem): void {
     const timeline = this.timelines.get(conversationId) ?? [];
     timeline.push(item);
@@ -1173,11 +1747,20 @@ export class AgentWorkspaceProxy {
     };
     this.toolConversationIds.set(toolCall.id, conversationId);
     this.toolConversationIds.set(nextToolCall.id, conversationId);
+    const kind: AgentTimelineKind = 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(),
     });
@@ -1348,12 +1931,12 @@ export class AgentWorkspaceProxy {
     return undefined;
   }
 
-  private handleExit(message: string): void {
+  private handleProviderExit(provider: AgentProvider, message: string): void {
+    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();
@@ -1366,6 +1949,7 @@ export class AgentWorkspaceProxy {
         createdAt: Date.now(),
       });
     }
+    this.sendCapabilities();
   }
 
   private cancelPendingPermissions(conversationId?: string): void {
@@ -1380,6 +1964,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");
   }
 
@@ -1452,11 +2049,21 @@ function isPermissionRequestMethod(method: string): boolean {
   return (
     method === "session/request_permission" ||
     method.endsWith("/requestApproval") ||
-    method === "mcpServer/elicitation/request" ||
-    method === "item/tool/requestUserInput"
+    method === "mcpServer/elicitation/request"
   );
 }
 
+function formatStructuredInputResponse(answers: Record<string, string[]>): unknown {
+  return {
+    answers: Object.fromEntries(
+      Object.entries(answers).map(([questionId, values]) => [
+        questionId,
+        { answers: values.map((value) => value.trim()).filter(Boolean) },
+      ]),
+    ),
+  };
+}
+
 function formatPermissionResponse(
   source: string | undefined,
   outcome: "allow" | "deny" | "cancelled",