linkshell-cli 0.2.99 → 0.2.101

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

@@ -1,6 +1,7 @@
 import { basename } from "node:path";
 import { createEnvelope, parseTypedPayload, } from "@linkshell/protocol";
 import { AcpClient } from "./acp-client.js";
+import { ClaudeSdkClient } from "./claude-sdk-client.js";
 import { ClaudeStreamJsonClient } from "./claude-stream-json-client.js";
 import { resolveAgentCommand } from "./provider-resolver.js";
 const PERMISSION_TIMEOUT_MS = 5 * 60_000;
@@ -219,9 +220,20 @@ function commandExecutionFromTool(toolCall) {
         status: toolCall.status,
     };
 }
-function fileChangeFromTool(toolCall) {
-    const diff = toolCall.output && looksLikeDiff(toolCall.output) ? toolCall.output : undefined;
-    const entries = (toolCall.input ?? "")
+function fileChangeFromStructuredInput(input) {
+    const raw = input?.trim();
+    if (!raw)
+        return [];
+    try {
+        const parsed = JSON.parse(raw);
+        if (parsed && typeof parsed === "object") {
+            return fileChangeEntriesFromItem(parsed);
+        }
+    }
+    catch {
+        // Fall through to line parser.
+    }
+    return raw
         .split("\n")
         .map((line) => line.trim())
         .filter(Boolean)
@@ -234,6 +246,10 @@ function fileChangeFromTool(toolCall) {
         return entry;
     })
         .filter((entry) => entry.path.length > 0);
+}
+function fileChangeFromTool(toolCall) {
+    const diff = toolCall.output && looksLikeDiff(toolCall.output) ? toolCall.output : undefined;
+    const entries = fileChangeFromStructuredInput(toolCall.input);
     if (entries.length === 0 && !diff && !toolCall.output)
         return undefined;
     return {
@@ -486,35 +502,95 @@ function providerLabel(provider) {
         return "Claude";
     return "Custom";
 }
-function providerModels(provider) {
-    if (provider === "claude") {
-        return [
-            { id: "default", label: "默认模型" },
-            { id: "opus", label: "Opus 4.7" },
-            { id: "sonnet", label: "Sonnet 4.6" },
-            { id: "haiku", label: "Haiku 4.5" },
-        ];
+const ALL_REASONING_EFFORTS = ["none", "minimal", "low", "medium", "high", "xhigh"];
+const ALL_PERMISSION_MODES = ["read_only", "workspace_write", "full_access"];
+function parseModelListCapabilities(value) {
+    const raw = asRecord(value);
+    const modelsValue = Array.isArray(value) ? value :
+        Array.isArray(raw?.models) ? raw.models :
+            Array.isArray(raw?.items) ? raw.items :
+                Array.isArray(raw?.modelOptions) ? raw.modelOptions :
+                    [];
+    const models = modelsValue
+        .map((entry, index) => {
+        const model = asRecord(entry);
+        if (!model) {
+            return typeof entry === "string" && entry
+                ? { id: entry, label: entry }
+                : undefined;
+        }
+        const modelId = firstString(model, ["id", "model", "name", "value"]) ?? `model-${index + 1}`;
+        const label = firstString(model, ["label", "title", "displayName", "name"]) ?? modelId;
+        return { id: modelId, label };
+    })
+        .filter((entry) => Boolean(entry));
+    const defaultModel = firstString(raw, ["defaultModel", "default_model", "currentModel"]) ??
+        firstString(asRecord(raw?.defaults), ["model"]);
+    const effortsValue = Array.isArray(raw?.reasoningEfforts) ? raw.reasoningEfforts :
+        Array.isArray(raw?.reasoning_efforts) ? raw.reasoning_efforts :
+            Array.isArray(raw?.efforts) ? raw.efforts :
+                undefined;
+    const reasoningEfforts = effortsValue
+        ?.filter((entry) => typeof entry === "string" && ALL_REASONING_EFFORTS.includes(entry));
+    if (models.length === 0 && !defaultModel && !reasoningEfforts?.length)
+        return undefined;
+    return {
+        ...(models.length > 0 ? { models: [{ id: "default", label: "默认模型" }, ...models] } : {}),
+        ...(defaultModel ? { defaultModel } : {}),
+        ...(reasoningEfforts?.length ? { reasoningEfforts } : {}),
+    };
+}
+function parseTimestamp(value) {
+    if (typeof value === "number" && Number.isFinite(value)) {
+        return value > 10_000_000_000 ? value : value * 1000;
     }
-    if (provider === "codex") {
-        return [
-            { id: "default", label: "默认模型" },
-            { id: "gpt-5.5", label: "GPT-5.5" },
-            { id: "gpt-5.4", label: "GPT-5.4" },
-            { id: "gpt-5.4-mini", label: "GPT-5.4 Mini" },
-            { id: "gpt-5.3-codex", label: "GPT-5.3 Codex" },
-        ];
+    if (typeof value === "string" && value.trim()) {
+        const parsed = Date.parse(value);
+        return Number.isNaN(parsed) ? undefined : parsed;
     }
-    return [{ id: "default", label: "默认模型" }];
+    return undefined;
+}
+function parseRemoteSessions(value) {
+    const raw = asRecord(value);
+    const sessionsValue = Array.isArray(value) ? value :
+        Array.isArray(raw?.threads) ? raw.threads :
+            Array.isArray(raw?.sessions) ? raw.sessions :
+                Array.isArray(raw?.items) ? raw.items :
+                    [];
+    const result = [];
+    for (const entry of sessionsValue) {
+        const session = asRecord(entry);
+        if (!session) {
+            if (typeof entry === "string" && entry)
+                result.push({ id: entry });
+            continue;
+        }
+        const nestedThread = asRecord(session.thread);
+        const source = nestedThread ?? session;
+        const id = firstString(source, ["id", "threadId", "sessionId", "agentSessionId"]);
+        if (!id)
+            continue;
+        result.push({
+            id,
+            cwd: firstString(source, ["cwd", "workingDirectory", "workspacePath"]),
+            title: firstString(source, ["title", "name", "summary"]),
+            model: firstString(source, ["model", "modelId"]),
+            createdAt: parseTimestamp(source.createdAt ?? source.created_at),
+            lastActivityAt: parseTimestamp(source.lastActivityAt ?? source.updatedAt ?? source.modifiedAt ?? source.lastModified ?? source.updated_at),
+        });
+    }
+    return result;
 }
 export class AgentWorkspaceProxy {
     input;
     clients = new Map();
     agentProtocols = new Map();
+    providerCapabilities = new Map();
     initialized = false;
     status = "unavailable";
     error;
     activeConversationId;
-    currentTurnId;
+    currentTurnIds = new Map();
     conversations = new Map();
     conversationByAgentSessionId = new Map();
     timelines = new Map();
@@ -541,6 +617,7 @@ export class AgentWorkspaceProxy {
             }
             case "agent.v2.conversation.list": {
                 const payload = parseTypedPayload("agent.v2.conversation.list", envelope.payload);
+                await this.syncProviderSessions();
                 const conversations = [...this.conversations.values()].filter((conversation) => payload.includeArchived ? true : !conversation.archived);
                 this.input.send(createEnvelope({
                     type: "agent.v2.conversation.list.result",
@@ -566,9 +643,9 @@ export class AgentWorkspaceProxy {
                 const cancelClient = conversation ? this.clientForProvider(conversation.provider) : undefined;
                 cancelClient?.cancel({
                     sessionId: conversation?.agentSessionId,
-                    turnId: this.currentTurnId,
+                    turnId: this.currentTurnIds.get(payload.conversationId),
                 });
-                this.currentTurnId = undefined;
+                this.currentTurnIds.delete(payload.conversationId);
                 this.updateConversationStatus(payload.conversationId, "idle");
                 this.emitStatus(payload.conversationId, "idle", "已停止");
                 break;
@@ -622,61 +699,174 @@ export class AgentWorkspaceProxy {
             }
             return undefined;
         }
-        try {
-            this.agentProtocols.set(provider, resolved.protocol);
-            const isClaudeStreamJson = resolved.protocol === "claude-stream-json";
-            const client = isClaudeStreamJson
-                ? new ClaudeStreamJsonClient({
-                    command: resolved.command,
-                    protocol: resolved.protocol,
-                    framing: resolved.framing,
+        const tryCreateClient = async (config) => {
+            this.agentProtocols.set(provider, config.protocol);
+            const isClaudeSdk = config.protocol === "claude-agent-sdk";
+            const isClaudeStreamJson = config.protocol === "claude-stream-json";
+            const client = isClaudeSdk
+                ? new ClaudeSdkClient({
+                    command: config.command,
+                    protocol: config.protocol,
+                    framing: config.framing,
                     cwd: this.input.cwd,
                     onNotification: (method, params) => this.handleNotification(method, params),
                     onRequest: (method, params) => this.handleRequest(method, params),
                     onExit: (message) => this.handleProviderExit(provider, message),
                 })
-                : 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.handleProviderExit(provider, message),
-                });
+                : isClaudeStreamJson
+                    ? new ClaudeStreamJsonClient({
+                        command: config.command,
+                        protocol: config.protocol,
+                        framing: config.framing,
+                        cwd: this.input.cwd,
+                        onNotification: (method, params) => this.handleNotification(method, params),
+                        onRequest: (method, params) => this.handleRequest(method, params),
+                        onExit: (message) => this.handleProviderExit(provider, message),
+                    })
+                    : new AcpClient({
+                        command: config.command,
+                        protocol: config.protocol,
+                        framing: config.framing,
+                        cwd: this.input.cwd,
+                        onNotification: (method, params) => this.handleNotification(method, params),
+                        onRequest: (method, params) => this.handleRequest(method, params),
+                        onExit: (message) => this.handleProviderExit(provider, message),
+                    });
             await client.initialize();
+            return client;
+        };
+        try {
+            const client = await tryCreateClient(resolved);
             this.clients.set(provider, client);
+            await this.refreshProviderCapabilities(provider, client, resolved.protocol);
             this.status = "idle";
             this.error = undefined;
             this.sendCapabilities();
             return client;
         }
         catch (error) {
+            if (provider === "claude" && resolved.protocol === "claude-agent-sdk") {
+                if (this.input.verbose) {
+                    process.stderr.write(`[agent:v2] Claude SDK failed, falling back to stream-json: ${error instanceof Error ? error.message : String(error)}\n`);
+                }
+                try {
+                    const fallback = {
+                        provider,
+                        command: "claude --print --output-format stream-json --input-format stream-json --verbose --permission-mode bypassPermissions",
+                        protocol: "claude-stream-json",
+                        framing: "newline",
+                    };
+                    const client = await tryCreateClient(fallback);
+                    this.clients.set(provider, client);
+                    await this.refreshProviderCapabilities(provider, client, fallback.protocol);
+                    this.status = "idle";
+                    this.error = undefined;
+                    this.sendCapabilities();
+                    return client;
+                }
+                catch (fallbackError) {
+                    if (this.input.verbose) {
+                        process.stderr.write(`[agent:v2] Claude stream-json fallback failed: ${fallbackError instanceof Error ? fallbackError.message : String(fallbackError)}\n`);
+                    }
+                }
+            }
             if (this.input.verbose) {
                 process.stderr.write(`[agent:v2] failed to start ${provider}: ${error instanceof Error ? error.message : String(error)}\n`);
             }
             return undefined;
         }
     }
+    async refreshProviderCapabilities(provider, client, protocol) {
+        if (!(client instanceof AcpClient) || protocol !== "codex-app-server")
+            return;
+        try {
+            const result = await client.listModels();
+            const runtimeCapabilities = parseModelListCapabilities(result);
+            if (runtimeCapabilities)
+                this.providerCapabilities.set(provider, runtimeCapabilities);
+        }
+        catch (error) {
+            if (this.input.verbose) {
+                process.stderr.write(`[agent:v2] model/list failed for ${provider}: ${error instanceof Error ? error.message : String(error)}\n`);
+            }
+        }
+    }
+    async syncProviderSessions() {
+        await this.initialize();
+        for (const [provider, client] of this.clients) {
+            try {
+                const result = await client.listSessions();
+                for (const remote of parseRemoteSessions(result)) {
+                    const agentSessionId = remote.id;
+                    const existingId = this.conversationByAgentSessionId.get(agentSessionId);
+                    const now = Date.now();
+                    const conversationId = existingId ?? `agent:${agentSessionId}`;
+                    const existing = this.conversations.get(conversationId);
+                    const cwd = remote.cwd ?? existing?.cwd ?? this.input.cwd;
+                    const conversation = {
+                        id: conversationId,
+                        agentSessionId,
+                        provider,
+                        cwd,
+                        title: remote.title ?? existing?.title ?? titleFromCwd(cwd),
+                        model: remote.model ?? existing?.model,
+                        reasoningEffort: existing?.reasoningEffort,
+                        permissionMode: existing?.permissionMode,
+                        status: existing?.status ?? "idle",
+                        archived: existing?.archived ?? false,
+                        lastMessagePreview: existing?.lastMessagePreview,
+                        lastActivityAt: remote.lastActivityAt ?? existing?.lastActivityAt ?? now,
+                        createdAt: remote.createdAt ?? existing?.createdAt ?? now,
+                    };
+                    this.conversations.set(conversation.id, conversation);
+                    this.conversationByAgentSessionId.set(agentSessionId, conversation.id);
+                    this.timelines.set(conversation.id, this.timelines.get(conversation.id) ?? []);
+                }
+            }
+            catch (error) {
+                if (this.input.verbose) {
+                    process.stderr.write(`[agent:v2] session list failed for ${provider}: ${error instanceof Error ? error.message : String(error)}\n`);
+                }
+            }
+        }
+    }
     sendCapabilities() {
         const providers = this.input.availableProviders.map((provider) => {
             const client = this.clients.get(provider);
             const protocol = this.agentProtocols.get(provider);
+            const runtimeCapabilities = this.providerCapabilities.get(provider);
             const enabled = Boolean(client);
             const supportsImages = enabled && protocol === "codex-app-server";
+            const isClaudeFallback = protocol === "claude-stream-json";
+            const supportsPermission = enabled && !isClaudeFallback;
+            const supportsReasoningEffort = enabled && !isClaudeFallback;
             return {
                 id: provider,
                 label: providerLabel(provider),
                 enabled,
                 reason: enabled ? undefined : `${providerLabel(provider)} 未安装或启动失败`,
                 supportsImages,
-                supportsPermission: enabled,
+                supportsPermission,
                 supportsPlan: enabled,
                 supportsCancel: enabled,
-                models: providerModels(provider),
+                models: runtimeCapabilities?.models ?? [{ id: "default", label: "默认模型" }],
+                defaultModel: runtimeCapabilities?.defaultModel ?? "default",
+                reasoningEfforts: supportsReasoningEffort
+                    ? runtimeCapabilities?.reasoningEfforts ?? [...ALL_REASONING_EFFORTS]
+                    : [],
+                permissionModes: supportsPermission ? [...ALL_PERMISSION_MODES] : [],
+                features: {
+                    images: supportsImages,
+                    permissions: supportsPermission,
+                    plan: enabled,
+                    cancel: enabled,
+                    reasoningEffort: supportsReasoningEffort,
+                    streamJsonFallback: isClaudeFallback,
+                },
             };
         });
         const anyEnabled = providers.some((p) => p.enabled);
+        const anyPermission = providers.some((p) => p.supportsPermission);
         this.input.send(createEnvelope({
             type: "agent.v2.capabilities",
             sessionId: this.input.sessionId,
@@ -691,7 +881,7 @@ export class AgentWorkspaceProxy {
                 supportsSessionLoad: anyEnabled,
                 supportsImages: providers.some((p) => p.supportsImages),
                 supportsAudio: false,
-                supportsPermission: anyEnabled,
+                supportsPermission: anyPermission,
                 supportsPlan: anyEnabled,
                 supportsCancel: anyEnabled,
             },
@@ -849,8 +1039,17 @@ export class AgentWorkspaceProxy {
                 permissionMode: payload.permissionMode,
                 cwd: conversation.cwd,
             });
-            this.currentTurnId = this.extractTurnId(result) ?? this.currentTurnId;
-            if (conversation.status === "running") {
+            const nextAgentSessionId = this.extractSessionId(result);
+            if (nextAgentSessionId && nextAgentSessionId !== conversation.agentSessionId) {
+                if (conversation.agentSessionId)
+                    this.conversationByAgentSessionId.delete(conversation.agentSessionId);
+                conversation.agentSessionId = nextAgentSessionId;
+                this.conversationByAgentSessionId.set(nextAgentSessionId, conversation.id);
+            }
+            const turnId = this.extractTurnId(result);
+            if (turnId)
+                this.currentTurnIds.set(conversation.id, turnId);
+            if (conversation.status === "running" && protocol !== "codex-app-server") {
                 this.updateConversationStatus(conversation.id, "idle");
             }
         }
@@ -870,6 +1069,9 @@ export class AgentWorkspaceProxy {
         if (method === "item/tool/requestUserInput" || method === "tool/requestUserInput") {
             return this.handleStructuredInput(params, true);
         }
+        if (method === "mcpServer/elicitation/request") {
+            return this.handleStructuredInput({ ...(asRecord(params) ?? {}), source: method }, true);
+        }
         if (isPermissionRequestMethod(method)) {
             return this.handlePermission(params, true, method);
         }
@@ -896,6 +1098,10 @@ export class AgentWorkspaceProxy {
             this.handleStructuredInput(params);
             return;
         }
+        if (method === "mcpServer/elicitation/request") {
+            this.handleStructuredInput({ ...(asRecord(params) ?? {}), source: method });
+            return;
+        }
         if (isPermissionRequestMethod(method)) {
             this.handlePermission(params, false, method);
             return;
@@ -911,15 +1117,19 @@ export class AgentWorkspaceProxy {
             return;
         }
         if (method === "turn/started") {
-            this.currentTurnId = this.extractTurnId(params) ?? this.currentTurnId;
-            if (conversationId)
+            if (conversationId) {
+                const turnId = this.extractTurnId(params);
+                if (turnId)
+                    this.currentTurnIds.set(conversationId, turnId);
                 this.updateConversationStatus(conversationId, "running");
+            }
             return;
         }
         if (method === "turn/completed") {
-            this.currentTurnId = undefined;
-            if (conversationId)
+            if (conversationId) {
+                this.currentTurnIds.delete(conversationId);
                 this.updateConversationStatus(conversationId, "idle");
+            }
             return;
         }
         if (method === "session/request_permission") {
@@ -957,7 +1167,11 @@ export class AgentWorkspaceProxy {
                 this.handleCommandExecDelta(params);
                 return;
             case "item/autoApprovalReview/started":
+                this.handleAutoApprovalReview(params, true);
+                return;
             case "item/autoApprovalReview/completed":
+                this.handleAutoApprovalReview(params, false);
+                return;
             case "item/commandExecution/terminalInteraction":
                 return;
         }
@@ -1199,6 +1413,36 @@ export class AgentWorkspaceProxy {
             status: "running",
         });
     }
+    handleAutoApprovalReview(params, streaming) {
+        const raw = asRecord(params) ?? {};
+        const conversationId = this.conversationIdFromParams(raw) ?? this.activeConversationId;
+        if (!conversationId)
+            return;
+        const itemId = firstString(raw, ["itemId", "id", "reviewId"]) ?? "auto-approval-review";
+        const existing = this.findItem(conversationId, itemId);
+        const decision = firstString(raw, ["decision", "result", "outcome", "status"]);
+        const summary = firstString(raw, ["summary", "message", "text", "reason"]) ??
+            stringifyDefined(raw.review ?? raw.details);
+        this.upsertItem(conversationId, {
+            id: itemId,
+            conversationId,
+            type: "status",
+            kind: "review",
+            role: "system",
+            turnId: this.extractTurnId(raw) ?? this.currentTurnIds.get(conversationId),
+            itemId,
+            text: summary ?? (streaming ? "正在审查自动授权" : decision ? `自动授权审查：${decision}` : "已完成自动授权审查"),
+            metadata: {
+                ...(existing?.metadata ?? {}),
+                autoApprovalReview: true,
+                ...(decision ? { decision } : {}),
+            },
+            createdAt: existing?.createdAt ?? Date.now(),
+            updatedAt: Date.now(),
+            isStreaming: streaming,
+        });
+        this.updateConversationPreview(conversationId, streaming ? "正在审查自动授权" : "已完成自动授权审查", streaming ? "running" : undefined);
+    }
     handleCompletedMessageItem(item, streaming) {
         const conversationId = this.conversationIdFromParams(item) ?? this.activeConversationId;
         if (!conversationId)
@@ -1271,7 +1515,7 @@ export class AgentWorkspaceProxy {
             conversationId,
             type: "status",
             role: "system",
-            turnId: this.extractTurnId(item) ?? this.currentTurnId,
+            turnId: this.extractTurnId(item) ?? this.currentTurnIds.get(conversationId),
             itemId,
             createdAt: existing?.createdAt ?? Date.now(),
             updatedAt: Date.now(),
@@ -1280,10 +1524,12 @@ export class AgentWorkspaceProxy {
         if (normalized === "reasoning" || normalized === "thinking") {
             const text = firstString(item, ["text", "content", "summary", "message"]) ??
                 stringifyDefined(item.contentItems ?? item.summary);
+            if (!text?.trim())
+                return true;
             this.upsertItem(conversationId, {
                 ...base,
                 kind: "thinking",
-                text: text ?? (streaming ? "正在思考" : "完成思考"),
+                text,
             });
             return true;
         }
@@ -1322,7 +1568,7 @@ export class AgentWorkspaceProxy {
             type: "status",
             kind: "subagent_action",
             role: "system",
-            turnId: this.extractTurnId(item) ?? this.currentTurnId,
+            turnId: this.extractTurnId(item) ?? this.currentTurnIds.get(conversationId),
             itemId,
             text,
             subagent,
@@ -1335,11 +1581,15 @@ export class AgentWorkspaceProxy {
     handleStructuredInput(params, waitForResponse = false) {
         const raw = asRecord(params) ?? {};
         const conversationId = this.conversationIdFromParams(raw) ?? this.activeConversationId;
+        const source = firstString(raw, ["method", "source", "requestMethod"]);
+        const formatResponse = source === "mcpServer/elicitation/request"
+            ? formatMcpElicitationResponse
+            : formatStructuredInputResponse;
         if (!conversationId)
-            return waitForResponse ? Promise.resolve(formatStructuredInputResponse({})) : undefined;
+            return waitForResponse ? Promise.resolve(formatResponse({})) : undefined;
         const structuredInput = decodeStructuredInput(raw);
         if (!structuredInput)
-            return waitForResponse ? Promise.resolve(formatStructuredInputResponse({})) : undefined;
+            return waitForResponse ? Promise.resolve(formatResponse({})) : undefined;
         const text = structuredInput.questions.map((question) => question.question).join("\n");
         this.pendingStructuredInputs.set(structuredInput.requestId, { conversationId, input: structuredInput });
         this.upsertItem(conversationId, {
@@ -1361,13 +1611,13 @@ export class AgentWorkspaceProxy {
             const timer = setTimeout(() => {
                 this.pendingStructuredInputs.delete(structuredInput.requestId);
                 this.structuredInputWaiters.delete(structuredInput.requestId);
-                resolve(formatStructuredInputResponse({}));
+                resolve(formatResponse({}));
                 this.markStructuredInput(conversationId, structuredInput.requestId, {
                     inputPending: false,
                     inputError: "等待用户输入超时",
                 });
             }, PERMISSION_TIMEOUT_MS);
-            this.structuredInputWaiters.set(structuredInput.requestId, { resolve, timer });
+            this.structuredInputWaiters.set(structuredInput.requestId, { resolve, timer, source });
         });
     }
     toolCallFromItem(item, fallbackStatus) {
@@ -1460,6 +1710,12 @@ export class AgentWorkspaceProxy {
                 optionId: selectedOptionId,
             });
         }
+        this.markPermission(payload.conversationId, payload.requestId, {
+            permissionOutcome: payload.outcome,
+            optionId: selectedOptionId,
+            permissionError: undefined,
+            permissionPending: false,
+        });
         this.updateConversationStatus(payload.conversationId, "running");
     }
     respondStructuredInput(payload) {
@@ -1469,15 +1725,30 @@ export class AgentWorkspaceProxy {
         if (waiter) {
             clearTimeout(waiter.timer);
             this.structuredInputWaiters.delete(payload.requestId);
-            waiter.resolve(formatStructuredInputResponse(payload.answers));
+            const formatResponse = waiter.source === "mcpServer/elicitation/request"
+                ? formatMcpElicitationResponse
+                : formatStructuredInputResponse;
+            waiter.resolve(formatResponse(payload.answers));
         }
         this.markStructuredInput(payload.conversationId, payload.requestId, {
             inputPending: false,
             inputSubmitted: true,
+            inputSubmitting: false,
+            inputError: undefined,
             answers: payload.answers,
         });
         this.updateConversationStatus(pending?.conversationId ?? payload.conversationId, "running");
     }
+    markPermission(conversationId, requestId, metadata) {
+        const item = this.findItem(conversationId, `permission:${requestId}`);
+        if (!item)
+            return;
+        this.upsertItem(conversationId, {
+            ...item,
+            metadata: { ...(item.metadata ?? {}), ...metadata },
+            updatedAt: Date.now(),
+        });
+    }
     markStructuredInput(conversationId, requestId, metadata) {
         const item = this.findItem(conversationId, `input:${requestId}`);
         if (!item)
@@ -1795,7 +2066,8 @@ function selectPermissionOption(permission, outcome) {
 function isPermissionRequestMethod(method) {
     return (method === "session/request_permission" ||
         method.endsWith("/requestApproval") ||
-        method === "mcpServer/elicitation/request");
+        method === "mcpServer/elicitation/request" ||
+        method === "claude/requestApproval");
 }
 function formatStructuredInputResponse(answers) {
     return {
@@ -1805,6 +2077,17 @@ function formatStructuredInputResponse(answers) {
         ])),
     };
 }
+function formatMcpElicitationResponse(answers) {
+    const content = Object.fromEntries(Object.entries(answers).map(([questionId, values]) => [
+        questionId,
+        values.length <= 1 ? values[0] ?? "" : values,
+    ]));
+    return {
+        action: Object.keys(content).length > 0 ? "accept" : "cancel",
+        content,
+        _meta: { source: "linkshell" },
+    };
+}
 function formatPermissionResponse(source, outcome, optionId) {
     if (source === "item/commandExecution/requestApproval" || source === "item/fileChange/requestApproval") {
         return { decision: outcome === "allow" ? "accept" : outcome === "deny" ? "decline" : "cancel" };
@@ -1818,6 +2101,14 @@ function formatPermissionResponse(source, outcome, optionId) {
         }
         return { permissions: { type: "managed", network: { enabled: false }, fileSystem: { type: "readOnly" } } };
     }
+    if (source === "claude/requestApproval") {
+        return { behavior: outcome === "allow" ? "allow" : "deny" };
+    }
+    if (source === "mcpServer/elicitation/request") {
+        return outcome === "allow"
+            ? { action: "accept", content: { optionId }, _meta: { source: "linkshell" } }
+            : { action: outcome === "cancelled" ? "cancel" : "decline", content: {}, _meta: { source: "linkshell" } };
+    }
     return {
         outcome: outcome === "cancelled"
             ? { outcome: "cancelled" }