aws-runtime-bridge 1.7.50 → 1.8.1

package/dist/adapter/AcodeSdkAdapter.js

@@ -4,19 +4,35 @@
  * 主流程：直接加载随 aws-runtime-bridge 内置发布的 ACode headless runtime，
  * 不依赖外部 CLI 安装；将 ACode 的结构化事件映射为 runtime-bridge 统一事件流。
  */
-import { EventEmitter } from 'node:events';
-import path from 'node:path';
-import { pathToFileURL } from 'node:url';
-import { v4 as uuidv4 } from 'uuid';
-import { getAcodeConfigFile, getAcodeSkillsDir, getRuntimeHomeDir } from '../config.js';
-import { getReleasedAcodeEntryPath } from '../services/acode-package.js';
+import { EventEmitter } from "node:events";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+import { v4 as uuidv4 } from "uuid";
+import { getAcodeConfigFile, getAcodeSkillsDir, getRuntimeHomeDir, } from "../config.js";
+import { getReleasedAcodeEntryPath } from "../services/acode-package.js";
+import { IdlePollLoop } from "./idle-poll-loop.js";
+import { getCanonicalMcpDetail, getToolActionInfo, } from "./types.js";
 const ACODE_AUTO_POLL_PROMPT = [
-    'Continue the AgentsWork message loop now.',
-    'You MUST call the exact MCP tool named aws-mcp__poll_message as your next action and wait for the next assigned message or task.',
-    'Do not answer in plain text before calling aws-mcp__poll_message.',
-    'After handling any received work, reply through the appropriate aws-mcp messaging tool, then continue listening again.',
-].join(' ');
+    "Continue the AgentsWork message loop now.",
+    "You MUST call the exact MCP tool named aws-mcp__poll_message as your next action and wait for the next assigned message or task.",
+    "Do not answer in plain text before calling aws-mcp__poll_message.",
+    "After handling any received work, reply through the appropriate aws-mcp messaging tool, then continue listening again.",
+].join(" ");
 const ACODE_AUTO_POLL_DELAY_MS = 250;
+// Backoff used when a polling-driven turn fails (e.g., 60s MCP tool timeout,
+// model 5xx, provider unreachable). Larger than ACODE_AUTO_POLL_DELAY_MS to
+// avoid busy-looping when the same failure recurs on every retry.
+const ACODE_AUTO_POLL_FAILURE_DELAY_MS = 2000;
+const ACODE_MESSAGE_POLLING_IDLE_PROMPT = "系统提醒：当前工作已完成或运行时已进入空闲状态。请立即调用 poll_message 工具阻塞等待新消息和流程线任务提醒；收到流程任务提醒后调用 my_task 查看已由后台静默抢占的任务详情并直接处理；完成任务后调用 submit_task_result 提交结果，然后继续 poll_message。";
+function isMessagePollingIdleCommand(command) {
+    const normalized = command.trim();
+    if (!normalized)
+        return false;
+    const lower = normalized.toLowerCase();
+    return (lower.includes("poll_message") ||
+        lower.includes("get_message") ||
+        normalized.includes("取消息"));
+}
 function getAcodePackageEntryPath() {
     return path.resolve(getReleasedAcodeEntryPath());
 }
@@ -24,15 +40,26 @@ export function toAcodeEsmImportSpecifier(modulePath) {
     return pathToFileURL(path.resolve(modulePath)).href;
 }
 function toUsage(value) {
-    if (!value || typeof value !== 'object') {
+    if (!value || typeof value !== "object") {
         return undefined;
     }
     const usage = value;
+    const inputTokens = toFiniteTokenCount(usage.inputTokens, usage.input_tokens, usage.promptTokens, usage.prompt_tokens);
+    const outputTokens = toFiniteTokenCount(usage.outputTokens, usage.output_tokens, usage.completionTokens, usage.completion_tokens);
     return {
-        inputTokens: Number(usage.inputTokens) || 0,
-        outputTokens: Number(usage.outputTokens) || 0,
+        inputTokens,
+        outputTokens,
     };
 }
+function toFiniteTokenCount(...values) {
+    for (const value of values) {
+        const count = Number(value);
+        if (Number.isFinite(count) && count > 0) {
+            return count;
+        }
+    }
+    return 0;
+}
 /**
  * Check whether an ACode turn_complete event represents a failed turn.
  * Main flow: only explicit failed=true prevents error status from being reset to waiting_input.
@@ -40,18 +67,34 @@ function toUsage(value) {
 export function isFailedAcodeTurnComplete(data) {
     return data.failed === true;
 }
+function toAcodeMcpActionDetail(actionDetail, server, tool) {
+    if (!actionDetail) {
+        return tool ? `${server}/${tool}` : server;
+    }
+    const prefix = `${server}__`;
+    if (actionDetail.startsWith(prefix)) {
+        return getCanonicalMcpDetail(`${server}__${actionDetail.slice(prefix.length)}`);
+    }
+    return getCanonicalMcpDetail(actionDetail.replace("/", "__"));
+}
+function isAcodeSemanticToolAction(actionType) {
+    return (actionType === "read_file" ||
+        actionType === "edit_file" ||
+        actionType === "write_file" ||
+        actionType === "bash");
+}
 export class AcodeSdkAdapter extends EventEmitter {
     constructor() {
         super(...arguments);
-        this.providerId = 'acode';
-        this.displayName = 'ACode';
+        this.providerId = "acode";
+        this.displayName = "ACode";
         this.sessions = new Map();
     }
     async startSession(sessionId, config) {
         const runtimeHome = getRuntimeHomeDir();
         const session = {
             sessionId,
-            status: 'starting',
+            status: "starting",
             messages: [],
             createdAt: new Date().toISOString(),
             totalUsage: { inputTokens: 0, outputTokens: 0 },
@@ -62,33 +105,58 @@ export class AcodeSdkAdapter extends EventEmitter {
             runtime: await this.createRuntime(sessionId, config, runtimeHome),
             autoPollActive: false,
         });
-        this.emit('status-change', sessionId, 'starting');
+        this.emit("status-change", sessionId, "starting");
         const entry = this.sessions.get(sessionId);
         if (!entry) {
-            throw new Error('ACode session was not initialized');
+            throw new Error("ACode session was not initialized");
+        }
+        try {
+            await entry.runtime.start();
+            session.status = "waiting_input";
+            this.emit("status-change", sessionId, "waiting_input");
+            if (config.initialPrompt?.trim()) {
+                this.startInitialPromptTurn(sessionId, config.initialPrompt);
+            }
+            else {
+                // R1 fix: when no initial prompt is provided, explicitly arm the
+                // auto-poll loop. Without this, the session sits at 'waiting_input'
+                // forever if setIdleCommands hasn't been called yet (or is configured
+                // with a non-polling command). setIdleCommands will cancel this timer
+                // and replace it with the configured idle loop when invoked.
+                this.armIdleLoopOrAutoPoll(sessionId);
+            }
         }
-        await entry.runtime.start();
-        session.status = 'waiting_input';
-        this.emit('status-change', sessionId, 'waiting_input');
-        if (config.initialPrompt?.trim()) {
-            this.startInitialPromptTurn(sessionId, config.initialPrompt);
+        catch (error) {
+            session.status = "error";
+            this.emitRuntimeErrorEvent(sessionId, error);
+            this.emit("status-change", sessionId, "error");
+            this.sessions.delete(sessionId);
+            throw error;
         }
     }
     async sendMessage(sessionId, message) {
         const entry = this.requireSession(sessionId);
         this.cancelScheduledAutoPoll(entry);
+        entry.failedTurnRecoveryScheduled = false;
+        entry.idlePollLoop?.stop();
         const userMessage = {
             id: uuidv4(),
             sessionId,
-            role: 'user',
+            role: "user",
             content: message,
             timestamp: new Date().toISOString(),
         };
         entry.adapterSession.messages.push(userMessage);
-        this.emit('conversation-message', sessionId, userMessage);
-        entry.adapterSession.status = 'thinking';
-        this.emit('status-change', sessionId, 'thinking');
-        await entry.runtime.submit(message);
+        this.emit("conversation-message", sessionId, userMessage);
+        entry.adapterSession.status = "thinking";
+        this.emit("status-change", sessionId, "thinking");
+        try {
+            await entry.runtime.submit(message);
+            this.recoverResolvedTurnWithoutTerminalEvent(sessionId);
+        }
+        catch (error) {
+            this.emitRuntimeError(sessionId, error, { recover: true });
+        }
     }
     async sendConfirmation(_sessionId, _accept) { }
     async abortCurrentTurn(sessionId) {
@@ -100,10 +168,12 @@ export class AcodeSdkAdapter extends EventEmitter {
             return;
         }
         this.cancelScheduledAutoPoll(entry);
+        entry.failedTurnRecoveryScheduled = false;
+        entry.idlePollLoop?.stop();
         await entry.runtime.stop();
-        entry.adapterSession.status = 'terminated';
+        entry.adapterSession.status = "terminated";
         this.sessions.delete(sessionId);
-        this.emit('status-change', sessionId, 'terminated');
+        this.emit("status-change", sessionId, "terminated");
     }
     getConversation(sessionId) {
         return this.sessions.get(sessionId)?.adapterSession.messages ?? [];
@@ -122,6 +192,23 @@ export class AcodeSdkAdapter extends EventEmitter {
             void this.terminateSession(sessionId);
         }
     }
+    setIdleCommands(sessionId, commands) {
+        const entry = this.sessions.get(sessionId);
+        if (!entry)
+            return;
+        entry.idleCommands = commands;
+        this.cancelScheduledAutoPoll(entry);
+        if (commands.idleInputCommand &&
+            isMessagePollingIdleCommand(commands.idleInputCommand)) {
+            const loop = this.getIdlePollLoop(entry);
+            loop.start();
+            return;
+        }
+        if (entry.adapterSession.status === "waiting_input" &&
+            (commands.idleInputCommand || commands.nonInputCommand)) {
+            this.getIdlePollLoop(entry).start();
+        }
+    }
     /** Injects a runtime constructor for adapter tests without loading the packaged ACode module. */
     setRuntimeConstructorForTest(runtimeConstructor) {
         this.runtimeConstructor = runtimeConstructor;
@@ -134,10 +221,12 @@ export class AcodeSdkAdapter extends EventEmitter {
             configPath: config.mcpConfigPath || getAcodeConfigFile(runtimeHome),
             skillsDir: getAcodeSkillsDir(runtimeHome),
             model: config.model,
-            systemPrompt: typeof config.systemPrompt === 'string' ? config.systemPrompt : undefined,
+            systemPrompt: typeof config.systemPrompt === "string"
+                ? config.systemPrompt
+                : undefined,
             env: config.envOverrides,
         });
-        runtime.on('event', (event) => this.forwardAcodeEvent(event));
+        runtime.on("event", (event) => this.forwardAcodeEvent(event));
         return runtime;
     }
     async loadRuntimeConstructor() {
@@ -145,7 +234,7 @@ export class AcodeSdkAdapter extends EventEmitter {
             return this.runtimeConstructor;
         }
         const modulePath = getAcodePackageEntryPath();
-        const module = await import(toAcodeEsmImportSpecifier(modulePath));
+        const module = (await import(toAcodeEsmImportSpecifier(modulePath)));
         if (!module.ACodeRuntime) {
             throw new Error(`ACode runtime export not found: ${modulePath}`);
         }
@@ -155,7 +244,7 @@ export class AcodeSdkAdapter extends EventEmitter {
     requireSession(sessionId) {
         const entry = this.sessions.get(sessionId);
         if (!entry) {
-            throw new Error('ACode session not found');
+            throw new Error("ACode session not found");
         }
         return entry;
     }
@@ -169,22 +258,25 @@ export class AcodeSdkAdapter extends EventEmitter {
         if (!entry) {
             return;
         }
-        entry.adapterSession.status = 'thinking';
-        this.emit('status-change', sessionId, 'thinking');
-        void entry.runtime.submit(initialPrompt).catch((error) => {
+        entry.adapterSession.status = "thinking";
+        this.emit("status-change", sessionId, "thinking");
+        void entry.runtime
+            .submit(initialPrompt)
+            .then(() => {
+            this.recoverResolvedTurnWithoutTerminalEvent(sessionId);
+        })
+            .catch((error) => {
             const currentEntry = this.sessions.get(sessionId);
             if (!currentEntry) {
                 return;
             }
-            currentEntry.adapterSession.status = 'error';
-            const timestamp = new Date().toISOString();
-            this.emit('event', {
-                type: 'error',
-                sessionId,
-                timestamp,
-                data: { text: error instanceof Error ? error.message : String(error) },
-            });
-            this.emit('status-change', sessionId, 'error');
+            // R4 fix: a failed initial prompt turn used to leave the session
+            // permanently in 'error' because autoPollActive was false at this
+            // point (only set by submitAutoPollPrompt), so the R2 recovery in
+            // forwardAcodeEvent skipped it, and no idle loop was armed.
+            // Now we always recover to 'waiting_input' and arm the idle loop
+            // so the agent can retry via poll_message.
+            this.emitRuntimeError(sessionId, error, { recover: true });
         });
     }
     forwardAcodeEvent(event) {
@@ -192,107 +284,308 @@ export class AcodeSdkAdapter extends EventEmitter {
         if (!entry) {
             return;
         }
-        if (event.type === 'assistant_delta') {
-            const text = typeof event.data.text === 'string' ? event.data.text : '';
+        if (event.type === "assistant_delta") {
+            const text = typeof event.data.text === "string" ? event.data.text : "";
+            if (entry.autoPollActive) {
+                entry.autoPollObservedAssistantText = true;
+            }
             entry.adapterSession.messages.push({
                 id: uuidv4(),
                 sessionId: event.sessionId,
-                role: 'assistant',
+                role: "assistant",
                 content: text,
                 timestamp: event.timestamp,
             });
-            this.emitProviderEvent(event, 'text_delta', { text });
+            this.emitProviderEvent(event, "text_delta", { text });
+            return;
+        }
+        if (event.type === "thinking_delta") {
+            const text = typeof event.data.text === "string" ? event.data.text : "";
+            this.emitProviderEvent(event, "thinking", { text });
+            return;
+        }
+        if (event.type === "ai_request") {
+            this.emitProviderEvent(event, "ai_request", {
+                model: typeof event.data.model === "string" ? event.data.model : undefined,
+                endpoint: typeof event.data.endpoint === "string"
+                    ? event.data.endpoint
+                    : undefined,
+                stream: typeof event.data.stream === "boolean"
+                    ? event.data.stream
+                    : undefined,
+                messageCount: typeof event.data.messageCount === "number"
+                    ? event.data.messageCount
+                    : undefined,
+                toolCount: typeof event.data.toolCount === "number"
+                    ? event.data.toolCount
+                    : undefined,
+                lastUserMessagePreview: typeof event.data.lastUserMessagePreview === "string"
+                    ? event.data.lastUserMessagePreview
+                    : undefined,
+                requestBody: typeof event.data.requestBody === "string"
+                    ? event.data.requestBody
+                    : undefined,
+            });
             return;
         }
-        if (event.type === 'turn_complete') {
+        if (event.type === "turn_complete") {
             const usage = toUsage(event.data.usage);
             if (usage) {
                 entry.adapterSession.totalUsage.inputTokens += usage.inputTokens;
                 entry.adapterSession.totalUsage.outputTokens += usage.outputTokens;
             }
             if (isFailedAcodeTurnComplete(event.data)) {
+                // R2 fix: a failed polling-driven turn (e.g., 60s MCP tool timeout,
+                // model 5xx, provider unreachable) used to leave the session parked
+                // in 'error' or 'thinking' forever, so the agent stopped calling
+                // poll_message permanently. Recover to 'waiting_input' and re-arm
+                // the auto-poll with a longer backoff so a transient failure
+                // doesn't break the message loop.
+                //
+                // R4 fix: previously this only recovered when autoPollActive was
+                // true (i.e. during a submitAutoPollPrompt-driven turn). When the
+                // initial prompt turn failed, autoPollActive was false and the
+                // session got permanently stuck in 'error'. Now we always recover
+                // for non-terminal sessions so the idle loop can retry.
+                this.recoverTurnFailure(event.sessionId, entry);
+                return;
+            }
+            this.emitProviderEvent(event, "turn_complete", {
+                usage: entry.adapterSession.totalUsage,
+                responseBody: typeof event.data.responseBody === "string"
+                    ? event.data.responseBody
+                    : undefined,
+                finishReason: typeof event.data.finishReason === "string"
+                    ? event.data.finishReason
+                    : undefined,
+            });
+            entry.adapterSession.status = "waiting_input";
+            this.emit("status-change", event.sessionId, "waiting_input", {
+                usage: entry.adapterSession.totalUsage,
+            });
+            if (entry.autoPollActive &&
+                entry.autoPollObservedAssistantText &&
+                !entry.autoPollObservedPollingTool) {
+                entry.stopAutoPollAfterCurrentTurn = true;
+                console.warn(`[${this.displayName}] Auto-poll turn produced assistant text without calling poll_message; stopping auto-poll rearm for session ${event.sessionId}`);
                 return;
             }
-            this.emitProviderEvent(event, 'turn_complete', { usage: entry.adapterSession.totalUsage });
-            entry.adapterSession.status = 'waiting_input';
-            this.emit('status-change', event.sessionId, 'waiting_input', { usage: entry.adapterSession.totalUsage });
-            this.scheduleAutoPoll(event.sessionId);
+            this.armIdleLoopOrAutoPoll(event.sessionId);
             return;
         }
-        if (event.type === 'session_complete') {
-            entry.adapterSession.status = 'completed';
-            this.emitProviderEvent(event, 'session_complete', { exitCode: Number(event.data.exitCode) || 0 });
-            this.emit('status-change', event.sessionId, 'completed');
+        if (event.type === "session_complete") {
+            this.cancelScheduledAutoPoll(entry);
+            entry.failedTurnRecoveryScheduled = false;
+            entry.idlePollLoop?.stop();
+            entry.adapterSession.status = "completed";
+            this.emitProviderEvent(event, "session_complete", {
+                exitCode: Number(event.data.exitCode) || 0,
+            });
+            this.emit("status-change", event.sessionId, "completed");
             return;
         }
-        if (event.type === 'error') {
-            entry.adapterSession.status = 'error';
-            this.emitProviderEvent(event, 'error', { text: String(event.data.message || 'ACode runtime error') });
-            this.emit('status-change', event.sessionId, 'error');
+        if (event.type === "error") {
+            entry.adapterSession.status = "error";
+            this.emitProviderEvent(event, "error", {
+                text: String(event.data.message || "ACode runtime error"),
+            });
+            this.emit("status-change", event.sessionId, "error");
+            if (!entry.autoPollActive) {
+                this.recoverTurnFailure(event.sessionId, entry);
+            }
             return;
         }
-        if (event.type === 'mcp_status') {
-            const server = typeof event.data.server === 'string' ? event.data.server : 'mcp';
-            const tool = typeof event.data.tool === 'string' ? event.data.tool : '';
-            const actionDetail = tool ? `${server}/${tool}` : server;
-            entry.adapterSession.status = 'tool_using';
-            this.emitProviderEvent(event, 'tool_use_start', {
+        if (event.type === "mcp_status") {
+            // R3 fix: the ACode runtime emits a startup mcp_status event with no
+            // `action` field but containing a `tools` array describing what the
+            // LLM can actually call. Validate that a poll_message tool is exposed,
+            // otherwise the message loop cannot continue.
+            //
+            // The previous version of this check matched the literal string
+            // 'aws-mcp' against the user-configured MCP server keys in the
+            // `servers` field, which produced false positives when the operator
+            // named the entry differently (e.g. 'aws-mcp-server' or 'agent-mcp')
+            // while still exposing aws-mcp's tools to the LLM. Worse, on a
+            // mismatch it emitted a generic `type: 'error'` ProviderEvent, which
+            // the rest of the bridge promotes to a fatal session-level 'error'
+            // status that the dashboard cannot recover from — the LLM keeps
+            // working but the timeline header gets stuck on "发生错误" forever.
+            //
+            // The fix below validates against the actual `tools` list (the same
+            // tools the LLM sees) and on a missing poll_message it only logs a
+            // warning. The runtime will naturally emit a real 'error' event the
+            // first time the LLM tries to call a missing tool, which the existing
+            // error handling already routes correctly without permanently locking
+            // the session status.
+            if (!event.data.action && Array.isArray(event.data.tools)) {
+                const tools = event.data.tools;
+                const hasPollMessage = tools.some((tool) => typeof tool?.name === "string" &&
+                    tool.name.includes("poll_message"));
+                if (!hasPollMessage) {
+                    const message = "ACode runtime is not exposing a poll_message tool. The LLM cannot call poll_message. " +
+                        "Please configure an MCP server that provides poll_message (e.g. aws-mcp) in the dashboard panel for this runtime.";
+                    console.warn(`[${this.displayName}] ${message}`);
+                }
+                return;
+            }
+            const server = typeof event.data.server === "string" ? event.data.server : "mcp";
+            const tool = typeof event.data.tool === "string" ? event.data.tool : "";
+            const toolName = server && tool ? `${server}__${tool}` : tool || server;
+            const toolInput = event.data.arguments && typeof event.data.arguments === "object" && !Array.isArray(event.data.arguments)
+                ? event.data.arguments
+                : undefined;
+            const actionInfo = getToolActionInfo(toolName, toolInput);
+            if (entry.autoPollActive && actionInfo.actionType === "idle") {
+                entry.autoPollObservedPollingTool = true;
+            }
+            const actionDetail = isAcodeSemanticToolAction(actionInfo.actionType)
+                ? actionInfo.actionDetail || toAcodeMcpActionDetail(undefined, server, tool)
+                : toAcodeMcpActionDetail(actionInfo.actionDetail, server, tool);
+            const toolUseId = typeof event.data.toolUseId === "string"
+                ? event.data.toolUseId
+                : undefined;
+            const eventData = {
                 toolName: actionDetail,
-                actionType: 'mcp',
-                actionLabel: 'Calling MCP',
-                actionDetail,
-            });
-            this.emit('status-change', event.sessionId, 'tool_using', {
-                actionType: 'mcp',
-                actionLabel: 'Calling MCP',
+                actionType: actionInfo.actionType,
+                actionLabel: actionInfo.actionLabel,
                 actionDetail,
-            });
+                ...(toolInput ? { toolInput } : {}),
+                ...(toolUseId ? { toolUseId, actionId: toolUseId } : {}),
+            };
+            if (event.data.action === "tool_result") {
+                this.emitProviderEvent(event, "tool_use_end", {
+                    ...eventData,
+                    toolResult: typeof event.data.result === "string"
+                        ? event.data.result
+                        : JSON.stringify(event.data.result ?? ""),
+                });
+                entry.adapterSession.status = "thinking";
+                this.emit("status-change", event.sessionId, "thinking");
+                return;
+            }
+            const status = actionInfo.actionType === "idle" ? "waiting_input" : "tool_using";
+            entry.adapterSession.status = status;
+            this.emitProviderEvent(event, "tool_use_start", eventData);
+            this.emit("status-change", event.sessionId, status, eventData);
             return;
         }
-        this.emitProviderEvent(event, 'thinking', {
+        this.emitProviderEvent(event, "thinking", {
             text: JSON.stringify(event.data),
         });
     }
     emitProviderEvent(event, type, data) {
-        this.emit('event', {
+        this.emit("event", {
             type,
             sessionId: event.sessionId,
             timestamp: event.timestamp,
             data,
         });
     }
+    /**
+     * After a completed turn, prefer the configured IdlePollLoop (set via setIdleCommands).
+     * Fall back to the legacy auto-poll mechanism when no idle commands are configured.
+     */
+    armIdleLoopOrAutoPoll(sessionId) {
+        const entry = this.sessions.get(sessionId);
+        if (!entry || this.isTerminalStatus(entry.adapterSession.status)) {
+            return;
+        }
+        if (entry.idleCommands?.idleInputCommand) {
+            entry.idlePollLoop?.start();
+            return;
+        }
+        this.scheduleAutoPoll(sessionId);
+    }
+    getIdlePollLoop(entry) {
+        if (entry.idlePollLoop)
+            return entry.idlePollLoop;
+        const sessionId = entry.adapterSession.sessionId;
+        entry.idlePollLoop = new IdlePollLoop({
+            getStatus: () => this.sessions.get(sessionId)?.adapterSession.status,
+            getCommand: () => this.sessions.get(sessionId)?.idleCommands?.idleInputCommand,
+            isPollingCommand: (command) => isMessagePollingIdleCommand(command),
+            dispatchPollingPrompt: () => this.submitAutoPollPrompt(sessionId, ACODE_MESSAGE_POLLING_IDLE_PROMPT),
+            dispatchRegularIdleCommand: (command) => this.submitAutoPollPrompt(sessionId, command),
+        });
+        return entry.idlePollLoop;
+    }
+    submitAutoPollPrompt(sessionId, prompt) {
+        const entry = this.sessions.get(sessionId);
+        if (!entry || this.isTerminalStatus(entry.adapterSession.status))
+            return;
+        entry.autoPollActive = true;
+        entry.autoPollObservedPollingTool = false;
+        entry.autoPollObservedAssistantText = false;
+        entry.stopAutoPollAfterCurrentTurn = false;
+        entry.adapterSession.status = "thinking";
+        this.emit("status-change", sessionId, "thinking");
+        void entry.runtime
+            .submit(prompt)
+            .catch((error) => {
+            this.emitRuntimeError(sessionId, error);
+        })
+            .finally(() => {
+            const latestEntry = this.sessions.get(sessionId);
+            if (!latestEntry)
+                return;
+            latestEntry.autoPollActive = false;
+            // If the R2 recovery path already scheduled a delayed re-arm for a
+            // failed polling-driven turn, skip armIdleLoopOrAutoPoll so we do
+            // not double-arm (immediate fire via IdlePollLoop AND a 2s timer).
+            // The recovery timer is the source of truth here: the flag is just
+            // a defensive marker; the timer itself is what matters.
+            if (latestEntry.failedTurnRecoveryScheduled ||
+                latestEntry.autoPollTimer) {
+                latestEntry.failedTurnRecoveryScheduled = false;
+                return;
+            }
+            if (latestEntry.stopAutoPollAfterCurrentTurn) {
+                latestEntry.stopAutoPollAfterCurrentTurn = false;
+                latestEntry.autoPollObservedPollingTool = false;
+                latestEntry.autoPollObservedAssistantText = false;
+                return;
+            }
+            if (latestEntry.adapterSession.status === "error") {
+                this.recoverTurnFailure(sessionId, latestEntry);
+                return;
+            }
+            if (latestEntry.adapterSession.status === "thinking" ||
+                latestEntry.adapterSession.status === "tool_using") {
+                this.recoverResolvedTurnWithoutTerminalEvent(sessionId);
+                return;
+            }
+            if (latestEntry.adapterSession.status === "waiting_input") {
+                this.armIdleLoopOrAutoPoll(sessionId);
+            }
+        });
+    }
     /**
      * Continue ACode's headless agent loop after a completed turn.
      * Main flow: debounce duplicate scheduling -> mark busy -> submit an internal
      * poll instruction -> let normal ACode events publish MCP/tool/turn states.
+     *
+     * @param delayMs Optional override for the default 250ms backoff. The R2
+     *   recovery path uses ACODE_AUTO_POLL_FAILURE_DELAY_MS (2s) to avoid
+     *   busy-looping when the same failure recurs on every retry.
      */
-    scheduleAutoPoll(sessionId) {
+    scheduleAutoPoll(sessionId, delayMs = ACODE_AUTO_POLL_DELAY_MS) {
         const entry = this.sessions.get(sessionId);
-        if (!entry || entry.autoPollActive || entry.autoPollTimer || this.isTerminalStatus(entry.adapterSession.status)) {
+        if (!entry ||
+            entry.autoPollActive ||
+            entry.autoPollTimer ||
+            this.isTerminalStatus(entry.adapterSession.status)) {
             return;
         }
         entry.autoPollTimer = setTimeout(() => {
             const currentEntry = this.sessions.get(sessionId);
-            if (!currentEntry || currentEntry.autoPollActive || this.isTerminalStatus(currentEntry.adapterSession.status)) {
+            if (!currentEntry ||
+                currentEntry.autoPollActive ||
+                this.isTerminalStatus(currentEntry.adapterSession.status)) {
                 return;
             }
             currentEntry.autoPollTimer = undefined;
-            currentEntry.autoPollActive = true;
-            currentEntry.adapterSession.status = 'thinking';
-            this.emit('status-change', sessionId, 'thinking');
-            void currentEntry.runtime.submit(ACODE_AUTO_POLL_PROMPT).catch((error) => {
-                this.emitRuntimeError(sessionId, error);
-            }).finally(() => {
-                const latestEntry = this.sessions.get(sessionId);
-                if (!latestEntry) {
-                    return;
-                }
-                latestEntry.autoPollActive = false;
-                if (latestEntry.adapterSession.status === 'waiting_input') {
-                    this.scheduleAutoPoll(sessionId);
-                }
-            });
-        }, ACODE_AUTO_POLL_DELAY_MS);
+            this.submitAutoPollPrompt(sessionId, ACODE_AUTO_POLL_PROMPT);
+        }, delayMs);
     }
     cancelScheduledAutoPoll(entry) {
         if (!entry.autoPollTimer) {
@@ -302,21 +595,84 @@ export class AcodeSdkAdapter extends EventEmitter {
         entry.autoPollTimer = undefined;
     }
     isTerminalStatus(status) {
-        return status === 'completed' || status === 'terminated' || status === 'error';
+        return status === "completed" || status === "terminated";
     }
-    emitRuntimeError(sessionId, error) {
+    emitRuntimeError(sessionId, error, options) {
         const currentEntry = this.sessions.get(sessionId);
         if (!currentEntry) {
             return;
         }
-        currentEntry.adapterSession.status = 'error';
+        currentEntry.adapterSession.status = "error";
+        this.emitRuntimeErrorEvent(sessionId, error);
+        this.emit("status-change", sessionId, "error");
+        if (options?.recover) {
+            this.recoverTurnFailure(sessionId, currentEntry);
+        }
+    }
+    emitRuntimeErrorEvent(sessionId, error) {
         const timestamp = new Date().toISOString();
-        this.emit('event', {
-            type: 'error',
+        this.emit("event", {
+            type: "error",
             sessionId,
             timestamp,
             data: { text: error instanceof Error ? error.message : String(error) },
         });
-        this.emit('status-change', sessionId, 'error');
+    }
+    recoverTurnFailure(sessionId, entry) {
+        if (this.isTerminalStatus(entry.adapterSession.status)) {
+            return;
+        }
+        if (entry.autoPollTimer || entry.failedTurnRecoveryScheduled) {
+            if (entry.adapterSession.status !== "waiting_input") {
+                entry.adapterSession.status = "waiting_input";
+                this.emit("status-change", sessionId, "waiting_input");
+            }
+            return;
+        }
+        this.cancelScheduledAutoPoll(entry);
+        entry.adapterSession.status = "waiting_input";
+        this.emit("status-change", sessionId, "waiting_input");
+        entry.failedTurnRecoveryScheduled = true;
+        entry.autoPollTimer = setTimeout(() => {
+            const currentEntry = this.sessions.get(sessionId);
+            if (!currentEntry ||
+                currentEntry.autoPollActive ||
+                this.isTerminalStatus(currentEntry.adapterSession.status)) {
+                if (currentEntry) {
+                    currentEntry.failedTurnRecoveryScheduled = false;
+                }
+                return;
+            }
+            currentEntry.autoPollTimer = undefined;
+            currentEntry.failedTurnRecoveryScheduled = false;
+            if (currentEntry.idleCommands?.idleInputCommand) {
+                this.getIdlePollLoop(currentEntry).start();
+            }
+            else {
+                this.submitAutoPollPrompt(sessionId, ACODE_AUTO_POLL_PROMPT);
+            }
+        }, ACODE_AUTO_POLL_FAILURE_DELAY_MS);
+    }
+    /**
+     * Recover turns where runtime.submit() resolved but no terminal turn event arrived.
+     *
+     * Main flow: ACode should normally emit turn_complete/session_complete/error before
+     * submit resolves. Some edge paths can emit only intermediate events (for example
+     * command_status or tool_result), then resolve. At that point there is no active
+     * turn anymore, so keeping the adapter at thinking/tool_using makes the dashboard
+     * look permanently stuck. Recover to waiting_input and arm the listening loop.
+     */
+    recoverResolvedTurnWithoutTerminalEvent(sessionId) {
+        const entry = this.sessions.get(sessionId);
+        if (!entry || this.isTerminalStatus(entry.adapterSession.status)) {
+            return;
+        }
+        if (entry.adapterSession.status !== "thinking" &&
+            entry.adapterSession.status !== "tool_using") {
+            return;
+        }
+        entry.adapterSession.status = "waiting_input";
+        this.emit("status-change", sessionId, "waiting_input");
+        this.armIdleLoopOrAutoPoll(sessionId);
     }
 }