aws-runtime-bridge 1.7.49 → 1.8.0

package/dist/routes/terminal.test.js

@@ -1,329 +1,517 @@
-import { mkdtemp, mkdir, writeFile } from 'node:fs/promises';
-import os from 'node:os';
-import path from 'node:path';
-import { describe, expect, it } from 'vitest';
-import { SDK_PROVIDER_DEFINITIONS } from '../adapter/SdkProviderSpi.js';
-import { buildClaudeCodeLaunchConfig, buildRuntimeEnv, buildToolResultTimelineActionInfo, createTerminalOutputDecoder, decodeTerminalOutputChunk, evaluatePersistedSessionReuse, formatTerminalPrompt, formatSdkOutputEvent, normalizeTerminalCommandInput, parseTerminalDirectoryChangeTarget, resolveSdkInputMessage, resolveTerminalOutputEncoding, resolveSdkProviderId, resolveStatusChangeUsage, } from './terminal.js';
-describe('terminal route validation', () => {
-    it('requires agentId and workspacePath for start', () => {
+import { mkdtemp, mkdir, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { describe, expect, it } from "vitest";
+import { SDK_PROVIDER_DEFINITIONS } from "../adapter/SdkProviderSpi.js";
+import { buildAcodeCommandOutputPath, buildClaudeCodeLaunchConfig, buildRuntimeEnv, buildToolResultTimelineActionInfo, countTerminalOutputLines, createTerminalOutputDecoder, decodeTerminalOutputChunk, evaluatePersistedSessionReuse, formatCommandInactivityTimeoutNotice, formatCommandOutputSpilloverNotice, formatTerminalPrompt, formatSdkOutputEvent, normalizeTerminalCommandInput, parseTerminalDirectoryChangeTarget, resolveSdkInputMessage, resolveTerminalOutputEncoding, resolveSdkProviderId, resolveSdkSessionDisplayStatus, resolveRuntimeStatusFromProviderEvent, resolveStatusChangeUsage, } from "./terminal.js";
+describe("terminal route validation", () => {
+    it("requires agentId and workspacePath for start", () => {
         const validateStartRequest = (body) => {
             if (!body.agentId || !body.workspacePath)
-                return { valid: false, error: 'agentId and workspacePath are required' };
+                return {
+                    valid: false,
+                    error: "agentId and workspacePath are required",
+                };
             return { valid: true };
         };
         expect(validateStartRequest({}).valid).toBe(false);
-        expect(validateStartRequest({ agentId: 'agent-1', workspacePath: '/path' }).valid).toBe(true);
-    });
-    it('uses SDK default command when not provided', () => {
-        const resolveCommand = (command) => command || 'claude';
-        expect(resolveCommand(undefined)).toBe('claude');
-        expect(resolveCommand('codex')).toBe('codex');
-    });
-    it('uses SDK launch mode for unsupported mode values', () => {
-        const resolveLaunchMode = (mode) => (mode === 'sdk' ? 'sdk' : 'sdk');
-        expect(resolveLaunchMode(undefined)).toBe('sdk');
-        expect(resolveLaunchMode('sdk')).toBe('sdk');
-        expect(resolveLaunchMode('unsupported')).toBe('sdk');
-    });
-    it('keeps shortcut mode available for manual key injection', () => {
-        const buildInputResponse = (mode) => mode === 'shortcut' ? { ok: true, mode: 'shortcut' } : { ok: true, mode: 'sdk' };
-        expect(buildInputResponse('shortcut')).toEqual({ ok: true, mode: 'shortcut' });
-        expect(buildInputResponse(undefined)).toEqual({ ok: true, mode: 'sdk' });
-    });
-    it('does not downgrade unsupported shortcut input to normal SDK messages', () => {
-        const buildShortcutFallbackResponse = (hasShortcutSupport) => (hasShortcutSupport
-            ? { status: 200, body: { ok: true, mode: 'shortcut' } }
-            : { status: 400, body: { error: 'shortcut input is not supported by this SDK provider' } });
+        expect(validateStartRequest({ agentId: "agent-1", workspacePath: "/path" })
+            .valid).toBe(true);
+    });
+    it("uses SDK default command when not provided", () => {
+        const resolveCommand = (command) => command || "acode";
+        expect(resolveCommand(undefined)).toBe("acode");
+        expect(resolveCommand("codex")).toBe("codex");
+    });
+    it("uses SDK launch mode for unsupported mode values", () => {
+        const resolveLaunchMode = (mode) => mode === "sdk" ? "sdk" : "sdk";
+        expect(resolveLaunchMode(undefined)).toBe("sdk");
+        expect(resolveLaunchMode("sdk")).toBe("sdk");
+        expect(resolveLaunchMode("unsupported")).toBe("sdk");
+    });
+    it("keeps shortcut mode available for manual key injection", () => {
+        const buildInputResponse = (mode) => mode === "shortcut"
+            ? { ok: true, mode: "shortcut" }
+            : { ok: true, mode: "sdk" };
+        expect(buildInputResponse("shortcut")).toEqual({
+            ok: true,
+            mode: "shortcut",
+        });
+        expect(buildInputResponse(undefined)).toEqual({ ok: true, mode: "sdk" });
+    });
+    it("does not downgrade unsupported shortcut input to normal SDK messages", () => {
+        const buildShortcutFallbackResponse = (hasShortcutSupport) => hasShortcutSupport
+            ? { status: 200, body: { ok: true, mode: "shortcut" } }
+            : {
+                status: 400,
+                body: {
+                    error: "shortcut input is not supported by this SDK provider",
+                },
+            };
         expect(buildShortcutFallbackResponse(false)).toEqual({
             status: 400,
-            body: { error: 'shortcut input is not supported by this SDK provider' },
+            body: { error: "shortcut input is not supported by this SDK provider" },
         });
     });
-    it('requires sessionId and input for SDK terminal input', () => {
+    it("requires sessionId and input for SDK terminal input", () => {
         const validateInputRequest = (body) => {
             if (!body.sessionId || body.input === undefined || body.input === null) {
-                return { valid: false, error: 'sessionId and input are required' };
+                return { valid: false, error: "sessionId and input are required" };
             }
             return { valid: true };
         };
         expect(validateInputRequest({}).valid).toBe(false);
-        expect(validateInputRequest({ sessionId: 'session-1', input: 'continue' }).valid).toBe(true);
-    });
-    it('keeps resize contract as SDK no-op compatibility endpoint', () => {
-        const buildResizeResponse = (cols, rows) => ({ ok: true, mode: 'sdk', noop: true, cols, rows });
-        expect(buildResizeResponse(120, 30)).toEqual({ ok: true, mode: 'sdk', noop: true, cols: 120, rows: 30 });
+        expect(validateInputRequest({ sessionId: "session-1", input: "continue" }).valid).toBe(true);
+    });
+    it("keeps resize contract as SDK no-op compatibility endpoint", () => {
+        const buildResizeResponse = (cols, rows) => ({
+            ok: true,
+            mode: "sdk",
+            noop: true,
+            cols,
+            rows,
+        });
+        expect(buildResizeResponse(120, 30)).toEqual({
+            ok: true,
+            mode: "sdk",
+            noop: true,
+            cols: 120,
+            rows: 30,
+        });
     });
-    it('requires sessionId for stop', () => {
+    it("requires sessionId for stop", () => {
         const validateStopRequest = (body) => {
             if (!body.sessionId)
-                return { valid: false, error: 'sessionId is required' };
+                return { valid: false, error: "sessionId is required" };
             return { valid: true };
         };
         expect(validateStopRequest({}).valid).toBe(false);
-        expect(validateStopRequest({ sessionId: 'session-1' }).valid).toBe(true);
+        expect(validateStopRequest({ sessionId: "session-1" }).valid).toBe(true);
+    });
+});
+describe("SDK startup idle command ordering", () => {
+    it("sets idle commands immediately after adapter startup and before PID probing or persistence", async () => {
+        const calls = [];
+        const adapter = {
+            async startSession() {
+                calls.push("startSession");
+            },
+            setIdleCommands() {
+                calls.push("setIdleCommands");
+            },
+        };
+        const startFlow = async () => {
+            await adapter.startSession();
+            adapter.setIdleCommands();
+            calls.push("probePid");
+            calls.push("persistSession");
+        };
+        await startFlow();
+        expect(calls).toEqual([
+            "startSession",
+            "setIdleCommands",
+            "probePid",
+            "persistSession",
+        ]);
     });
 });
-describe('terminal configuration', () => {
-    it('builds correct SDK runtime environment', () => {
-        const env = buildRuntimeEnv('agent-123', undefined, { PATH: '/usr/bin' });
-        expect(env.AWS_AGENT_ID).toBe('agent-123');
+describe("terminal configuration", () => {
+    it("builds correct SDK runtime environment", () => {
+        const env = buildRuntimeEnv("agent-123", undefined, { PATH: "/usr/bin" });
+        expect(env.AWS_AGENT_ID).toBe("agent-123");
         expect(env.AWS_MCP_LAUNCH_BINDING_ID).toBeUndefined();
-        expect(env.AWS_MCP_CLAIM_LAUNCH_BINDING).toBe('true');
-    });
-    it('merges launch env overrides without allowing agent identity override', () => {
-        const env = buildRuntimeEnv('agent-123', '/workspace', { PATH: '/usr/bin' }, {
-            ANTHROPIC_BASE_URL: ' https://api.example.com ',
-            ANTHROPIC_AUTH_TOKEN: 'secret-token',
-            ANTHROPIC_MODEL: 'claude-sonnet-4-5',
-            AWS_AGENT_ID: 'malicious-agent',
-            EMPTY_VALUE: '   ',
+        expect(env.AWS_MCP_CLAIM_LAUNCH_BINDING).toBe("true");
+    });
+    it("merges launch env overrides without allowing agent identity override", () => {
+        const env = buildRuntimeEnv("agent-123", "/workspace", { PATH: "/usr/bin" }, {
+            ANTHROPIC_BASE_URL: " https://api.example.com ",
+            ANTHROPIC_AUTH_TOKEN: "secret-token",
+            ANTHROPIC_MODEL: "claude-sonnet-4-5",
+            AWS_AGENT_ID: "malicious-agent",
+            EMPTY_VALUE: "   ",
         });
-        expect(env.ANTHROPIC_BASE_URL).toBe('https://api.example.com');
-        expect(env.ANTHROPIC_AUTH_TOKEN).toBe('secret-token');
-        expect(env.ANTHROPIC_MODEL).toBe('claude-sonnet-4-5');
+        expect(env.ANTHROPIC_BASE_URL).toBe("https://api.example.com");
+        expect(env.ANTHROPIC_AUTH_TOKEN).toBe("secret-token");
+        expect(env.ANTHROPIC_MODEL).toBe("claude-sonnet-4-5");
         expect(env.EMPTY_VALUE).toBeUndefined();
-        expect(env.AWS_AGENT_ID).toBe('agent-123');
-        expect(env.AWS_WORKSPACE_PATH).toBe('/workspace');
+        expect(env.AWS_AGENT_ID).toBe("agent-123");
+        expect(env.AWS_WORKSPACE_PATH).toBe("/workspace");
     });
-    it('merges saved ClaudeCode AI settings into SDK launch env with request overrides taking precedence', () => {
+    it("merges saved ClaudeCode AI settings into SDK launch env with request overrides taking precedence", () => {
         const launchConfig = buildClaudeCodeLaunchConfig({
             env: {
-                ANTHROPIC_BASE_URL: 'https://saved.example.com',
-                ANTHROPIC_AUTH_TOKEN: 'sk-saved',
-                ANTHROPIC_MODEL: 'claude-saved',
-                EMPTY_SAVED: '   ',
+                ANTHROPIC_BASE_URL: "https://saved.example.com",
+                ANTHROPIC_AUTH_TOKEN: "sk-saved",
+                ANTHROPIC_MODEL: "claude-saved",
+                EMPTY_SAVED: "   ",
             },
         }, {
-            ANTHROPIC_MODEL: ' claude-request ',
-            EXTRA_VALUE: 'enabled',
+            ANTHROPIC_MODEL: " claude-request ",
+            EXTRA_VALUE: "enabled",
         });
         expect(launchConfig).toEqual({
             envOverrides: {
-                ANTHROPIC_BASE_URL: 'https://saved.example.com',
-                ANTHROPIC_AUTH_TOKEN: 'sk-saved',
-                ANTHROPIC_MODEL: 'claude-request',
-                EXTRA_VALUE: 'enabled',
+                ANTHROPIC_BASE_URL: "https://saved.example.com",
+                ANTHROPIC_AUTH_TOKEN: "sk-saved",
+                ANTHROPIC_MODEL: "claude-request",
+                EXTRA_VALUE: "enabled",
             },
-            model: 'claude-request',
+            model: "claude-request",
         });
     });
-    it('uses CODEX_MODEL from request env overrides as SDK launch model', () => {
+    it("uses CODEX_MODEL from request env overrides as SDK launch model", () => {
         const launchConfig = buildClaudeCodeLaunchConfig(null, {
-            OPENAI_API_KEY: 'sk-codex',
-            CODEX_MODEL: ' gpt-5.3-codex ',
+            OPENAI_API_KEY: "sk-codex",
+            CODEX_MODEL: " gpt-5.3-codex ",
         });
         expect(launchConfig).toEqual({
             envOverrides: {
-                OPENAI_API_KEY: 'sk-codex',
-                CODEX_MODEL: 'gpt-5.3-codex',
+                OPENAI_API_KEY: "sk-codex",
+                CODEX_MODEL: "gpt-5.3-codex",
             },
-            model: 'gpt-5.3-codex',
+            model: "gpt-5.3-codex",
         });
     });
 });
-describe('persisted SDK session reuse', () => {
-    it('does not reuse a persisted session without a PID', () => {
+describe("persisted SDK session reuse", () => {
+    it("does not reuse a persisted session without a PID", () => {
         const decision = evaluatePersistedSessionReuse({}, () => true);
-        expect(decision).toEqual({ reusable: false, reason: 'missing-pid' });
+        expect(decision).toEqual({ reusable: false, reason: "missing-pid" });
     });
-    it('does not reuse a persisted session when its PID is no longer running', () => {
+    it("does not reuse a persisted session when its PID is no longer running", () => {
         const decision = evaluatePersistedSessionReuse({ pid: 1234 }, () => false);
-        expect(decision).toEqual({ reusable: false, reason: 'dead-pid' });
+        expect(decision).toEqual({ reusable: false, reason: "dead-pid" });
+    });
+    it("reuses a persisted session only when its PID is still running for externally controllable providers", () => {
+        const decision = evaluatePersistedSessionReuse({ pid: 1234, command: "claude" }, () => true);
+        expect(decision).toEqual({ reusable: true, reason: "active-pid" });
     });
-    it('reuses a persisted session only when its PID is still running', () => {
-        const decision = evaluatePersistedSessionReuse({ pid: 1234 }, () => true);
-        expect(decision).toEqual({ reusable: true, reason: 'active-pid' });
+    it("does not reuse ACode persisted sessions because their control channel is in-process only", () => {
+        const decision = evaluatePersistedSessionReuse({ pid: 1234, command: "acode" }, () => true);
+        expect(decision).toEqual({
+            reusable: false,
+            reason: "in-process-provider",
+        });
     });
 });
-describe('terminal command helpers', () => {
-    it('expands a whole mini-term clipboard paste file path into SDK input content', async () => {
-        const tempDir = await mkdtemp(path.join(os.tmpdir(), 'terminal-input-'));
-        const clipboardDir = path.join(tempDir, 'mini-term-clipboard');
+describe("SDK session display status", () => {
+    it("prefers adapter fine-grained status over coarse running fallback", () => {
+        expect(resolveSdkSessionDisplayStatus("waiting_input", "running")).toBe("waiting_input");
+        expect(resolveSdkSessionDisplayStatus("thinking", "running")).toBe("thinking");
+    });
+    it("uses in-memory runtime status when adapter status is temporarily unavailable", () => {
+        expect(resolveSdkSessionDisplayStatus(undefined, "tool_using")).toBe("tool_using");
+    });
+    it("falls back to running only when no fine-grained state exists", () => {
+        expect(resolveSdkSessionDisplayStatus(undefined, undefined)).toBe("running");
+    });
+});
+describe("SDK provider event runtime status mapping", () => {
+    const event = (type, data = {}) => ({
+        type,
+        sessionId: "session-1",
+        timestamp: new Date().toISOString(),
+        data,
+    });
+    it("maps text and thinking stream events to thinking status", () => {
+        expect(resolveRuntimeStatusFromProviderEvent(event("thinking"))?.status).toBe("thinking");
+        expect(resolveRuntimeStatusFromProviderEvent(event("text_delta"))?.status).toBe("thinking");
+    });
+    it("maps AI request events to thinking status with request details", () => {
+        const state = resolveRuntimeStatusFromProviderEvent(event("ai_request", {
+            model: "test-model",
+            endpoint: "https://example.invalid/v1/chat/completions",
+            stream: true,
+            messageCount: 3,
+            toolCount: 2,
+            lastUserMessagePreview: "inspect status",
+            requestBody: '{"model":"test-model"}',
+        }));
+        expect(state?.status).toBe("thinking");
+        expect(state?.actionInfo).toMatchObject({
+            actionType: "ai_request",
+            actionLabel: "AI请求",
+        });
+        expect(state?.actionInfo?.actionDetail).toContain("模型: test-model");
+        expect(state?.actionInfo?.actionDetail).toContain("接口: https://example.invalid/v1/chat/completions");
+        expect(state?.actionInfo?.actionDetail).toContain("最后请求: inspect status");
+        expect(state?.actionInfo?.actionDetail).toContain('请求体:\n{"model":"test-model"}');
+    });
+    it("maps tool start events to tool_using with action info", () => {
+        const state = resolveRuntimeStatusFromProviderEvent(event("tool_use_start", {
+            toolName: "mcp__aws__my_task",
+            toolUseId: "tool-1",
+        }));
+        expect(state?.status).toBe("tool_using");
+        expect(state?.actionInfo?.actionType).toBe("mcp");
+        expect(state?.actionInfo?.actionId).toBe("tool-1");
+    });
+    it("maps turn completion to idle waiting_input status", () => {
+        expect(resolveRuntimeStatusFromProviderEvent(event("turn_complete"))?.status).toBe("waiting_input");
+    });
+    it("keeps idle tool action info with waiting_input status for display", () => {
+        const state = resolveRuntimeStatusFromProviderEvent(event("tool_use_start", {
+            actionType: "idle",
+            actionLabel: "监听消息",
+            actionDetail: "poll_message",
+            toolUseId: "tool-idle-1",
+        }));
+        expect(state?.status).toBe("waiting_input");
+        expect(state?.actionInfo).toMatchObject({
+            actionType: "idle",
+            actionLabel: "监听消息",
+            actionDetail: "poll_message",
+            actionId: "tool-idle-1",
+        });
+    });
+});
+describe("terminal command helpers", () => {
+    it("expands a whole mini-term clipboard paste file path into SDK input content", async () => {
+        const tempDir = await mkdtemp(path.join(os.tmpdir(), "terminal-input-"));
+        const clipboardDir = path.join(tempDir, "mini-term-clipboard");
         await mkdir(clipboardDir, { recursive: true });
-        const pasteFile = path.join(clipboardDir, 'paste-1780491671137.txt');
-        await writeFile(pasteFile, 'real pasted prompt', 'utf-8');
-        await expect(resolveSdkInputMessage(`"${pasteFile}"`)).resolves.toBe('real pasted prompt');
+        const pasteFile = path.join(clipboardDir, "paste-1780491671137.txt");
+        await writeFile(pasteFile, "real pasted prompt", "utf-8");
+        await expect(resolveSdkInputMessage(`"${pasteFile}"`)).resolves.toBe("real pasted prompt");
     });
-    it('keeps explicit commands that mention mini-term clipboard files unchanged', async () => {
+    it("keeps explicit commands that mention mini-term clipboard files unchanged", async () => {
         const command = 'type "C:\\Users\\ZHUANG~1\\AppData\\Local\\Temp\\mini-term-clipboard\\paste-1780491671137.txt"';
         await expect(resolveSdkInputMessage(command)).resolves.toBe(command);
     });
-    it('normalizes carriage-return terminal input into executable command text', () => {
-        expect(normalizeTerminalCommandInput('npm test\r')).toBe('npm test');
-        expect(normalizeTerminalCommandInput(' pwd \n')).toBe('pwd');
+    it("normalizes carriage-return terminal input into executable command text", () => {
+        expect(normalizeTerminalCommandInput("npm test\r")).toBe("npm test");
+        expect(normalizeTerminalCommandInput(" pwd \n")).toBe("pwd");
     });
-    it('parses cd commands without treating other shell commands as directory changes', () => {
-        expect(parseTerminalDirectoryChangeTarget('cd')).toBeNull();
-        expect(parseTerminalDirectoryChangeTarget('cd /d "D:\\code\\repo"')).toBe('D:\\code\\repo');
-        expect(parseTerminalDirectoryChangeTarget('npm run build')).toBeUndefined();
+    it("parses cd commands without treating other shell commands as directory changes", () => {
+        expect(parseTerminalDirectoryChangeTarget("cd")).toBeNull();
+        expect(parseTerminalDirectoryChangeTarget('cd /d "D:\\code\\repo"')).toBe("D:\\code\\repo");
+        expect(parseTerminalDirectoryChangeTarget("npm run build")).toBeUndefined();
     });
-    it('formats the working directory prompt as terminal output text', () => {
-        expect(formatTerminalPrompt('D:\\code\\repo')).toBe('\x1b[36mD:\\code\\repo>\x1b[0m ');
+    it("formats the working directory prompt as terminal output text", () => {
+        expect(formatTerminalPrompt("D:\\code\\repo")).toBe("\x1b[36mD:\\code\\repo>\x1b[0m ");
     });
-    it('defaults Windows terminal command output to GB18030 decoding', () => {
-        expect(resolveTerminalOutputEncoding('win32', {})).toBe('gb18030');
-        expect(resolveTerminalOutputEncoding('linux', {})).toBe('utf-8');
-        expect(resolveTerminalOutputEncoding('win32', { AWS_TERMINAL_OUTPUT_ENCODING: 'utf-8' })).toBe('utf-8');
+    it("defaults Windows terminal command output to GB18030 decoding", () => {
+        expect(resolveTerminalOutputEncoding("win32", {})).toBe("gb18030");
+        expect(resolveTerminalOutputEncoding("linux", {})).toBe("utf-8");
+        expect(resolveTerminalOutputEncoding("win32", {
+            AWS_TERMINAL_OUTPUT_ENCODING: "utf-8",
+        })).toBe("utf-8");
     });
-    it('decodes GB18030 Chinese output across chunk boundaries', () => {
-        const decoder = createTerminalOutputDecoder('gb18030');
+    it("decodes GB18030 Chinese output across chunk boundaries", () => {
+        const decoder = createTerminalOutputDecoder("gb18030");
         const first = decodeTerminalOutputChunk(decoder, Buffer.from([0xd6]));
         const second = decodeTerminalOutputChunk(decoder, Buffer.from([0xd0, 0xce, 0xc4]));
         const flushed = decodeTerminalOutputChunk(decoder, undefined, true);
-        expect(`${first}${second}${flushed}`).toBe('中文');
+        expect(`${first}${second}${flushed}`).toBe("中文");
+    });
+    it("counts terminal output lines without treating a trailing line break as an extra line", () => {
+        expect(countTerminalOutputLines("")).toBe(0);
+        expect(countTerminalOutputLines("one")).toBe(1);
+        expect(countTerminalOutputLines("one\ntwo\n")).toBe(2);
+        expect(countTerminalOutputLines("one\r\ntwo\rthree")).toBe(3);
+    });
+    it("builds ACode command output spillover paths under the workspace cmd-dist directory", () => {
+        const outputPath = buildAcodeCommandOutputPath(path.join("D:", "code", "repo"), new Date(2026, 1, 3, 4, 5, 6, 7));
+        expect(outputPath).toBe(path.join("D:", "code", "repo", ".agentswork", "acode", "cmd-dist", "2026-02-03", "04", "05", "20260203-040506-007-cmd.out"));
+    });
+    it("formats ACode long-output and inactivity notices for terminal users", () => {
+        expect(formatCommandOutputSpilloverNotice("/repo/out.txt", 100)).toContain("命令输出超过 100 行");
+        expect(formatCommandOutputSpilloverNotice("/repo/out.txt", 100)).toContain("/repo/out.txt");
+        expect(formatCommandInactivityTimeoutNotice(60_000)).toContain("超过 60 秒没有新的输出");
     });
 });
-describe('resolveSdkProviderId', () => {
-    it('exposes codex through the SDK provider SPI', () => {
-        expect(SDK_PROVIDER_DEFINITIONS.map((definition) => definition.runtimeMode)).toContain('codex');
-        expect(SDK_PROVIDER_DEFINITIONS.find((definition) => definition.runtimeMode === 'codex')).toMatchObject({
-            providerId: 'codex',
-            defaultCommand: 'codex',
+describe("resolveSdkProviderId", () => {
+    it("exposes codex through the SDK provider SPI", () => {
+        expect(SDK_PROVIDER_DEFINITIONS.map((definition) => definition.runtimeMode)).toContain("codex");
+        expect(SDK_PROVIDER_DEFINITIONS.find((definition) => definition.runtimeMode === "codex")).toMatchObject({
+            providerId: "codex",
+            defaultCommand: "codex",
         });
     });
-    it('resolves codex commands to codex provider', () => {
-        expect(resolveSdkProviderId('codex')).toBe('codex');
-        expect(resolveSdkProviderId('npx codex --model gpt-5-codex')).toBe('codex');
+    it("resolves codex commands to codex provider", () => {
+        expect(resolveSdkProviderId("codex")).toBe("codex");
+        expect(resolveSdkProviderId("npx codex --model gpt-5-codex")).toBe("codex");
     });
-    it('resolves opencode commands to opencode provider', () => {
-        expect(resolveSdkProviderId('opencode')).toBe('opencode');
+    it("resolves opencode commands to opencode provider", () => {
+        expect(resolveSdkProviderId("opencode")).toBe("opencode");
     });
-    it('falls back to claude-code for claude or unknown commands', () => {
-        expect(resolveSdkProviderId('claude')).toBe('claude-code');
-        expect(resolveSdkProviderId('custom-binary')).toBe('claude-code');
-        expect(resolveSdkProviderId(undefined)).toBe('claude-code');
+    it("falls back to acode for unknown or empty commands while keeping claude mapped to claude-code", () => {
+        expect(resolveSdkProviderId("claude")).toBe("claude-code");
+        expect(resolveSdkProviderId("acode")).toBe("acode");
+        expect(resolveSdkProviderId("custom-binary")).toBe("acode");
+        expect(resolveSdkProviderId(undefined)).toBe("acode");
     });
 });
-describe('SDK status usage forwarding', () => {
-    it('keeps accumulated usage from status-change action info', () => {
-        expect(resolveStatusChangeUsage({ usage: { inputTokens: 12000, outputTokens: 345 } })).toEqual({
+describe("SDK status usage forwarding", () => {
+    it("keeps accumulated usage from status-change action info", () => {
+        expect(resolveStatusChangeUsage({
+            usage: { inputTokens: 12000, outputTokens: 345 },
+        })).toEqual({
             inputTokens: 12000,
             outputTokens: 345,
         });
         expect(resolveStatusChangeUsage({ usage: { inputTokens: 0, outputTokens: 0 } })).toBeUndefined();
-        expect(resolveStatusChangeUsage({ actionType: 'mcp', actionLabel: 'Calling MCP' })).toBeUndefined();
+        expect(resolveStatusChangeUsage({
+            actionType: "mcp",
+            actionLabel: "Calling MCP",
+        })).toBeUndefined();
+    });
+    it("forwards structured AI response body through action result", () => {
+        const runtimeStatus = resolveRuntimeStatusFromProviderEvent({
+            type: "turn_complete",
+            sessionId: "session-1",
+            timestamp: new Date(0).toISOString(),
+            data: {
+                usage: { inputTokens: 12, outputTokens: 4 },
+                responseBody: '{"choices":[{"message":{"content":"done"}}]}',
+                finishReason: "stop",
+            },
+        });
+        expect(runtimeStatus).toEqual({
+            status: "waiting_input",
+            actionInfo: {
+                actionType: "ai_request",
+                actionLabel: "AI响应",
+                actionResult: '{"choices":[{"message":{"content":"done"}}]}',
+                usage: { inputTokens: 12, outputTokens: 4 },
+            },
+        });
     });
 });
-describe('SDK output forwarding', () => {
-    it('formats text and thinking provider events for the terminal output callback path', () => {
+describe("SDK output forwarding", () => {
+    it("formats assistant text provider events for the terminal output callback path", () => {
         const textEvent = {
-            type: 'text_delta',
-            sessionId: 'session-1',
+            type: "text_delta",
+            sessionId: "session-1",
             timestamp: new Date(0).toISOString(),
-            data: { text: 'hello' },
+            data: { text: "hello" },
         };
+        expect(formatSdkOutputEvent(textEvent)).toBe("hello");
+    });
+    it("formats thinking provider events as typed realtime output chunks", () => {
         const thinkingEvent = {
-            type: 'thinking',
-            sessionId: 'session-1',
+            type: "thinking",
+            sessionId: "session-1",
             timestamp: new Date(0).toISOString(),
-            data: { text: 'thinking...' },
+            data: { text: "internal prompt or reasoning" },
         };
-        expect(formatSdkOutputEvent(textEvent)).toBe('hello');
-        expect(formatSdkOutputEvent(thinkingEvent)).toBe('thinking...');
+        expect(formatSdkOutputEvent(thinkingEvent)).toBe("internal prompt or reasoning");
     });
-    it('formats SDK errors as terminal output and ignores non-output events', () => {
+    it("formats SDK errors as terminal output and ignores non-output events", () => {
         const errorEvent = {
-            type: 'error',
-            sessionId: 'session-1',
+            type: "error",
+            sessionId: "session-1",
             timestamp: new Date(0).toISOString(),
-            data: { text: 'boom' },
+            data: { text: "boom" },
         };
         const toolEvent = {
-            type: 'tool_use_start',
-            sessionId: 'session-1',
+            type: "tool_use_start",
+            sessionId: "session-1",
             timestamp: new Date(0).toISOString(),
-            data: { toolName: 'read_file' },
+            data: { toolName: "read_file" },
         };
-        expect(formatSdkOutputEvent(errorEvent)).toBe('\r\n[SDK Error] boom\r\n');
+        expect(formatSdkOutputEvent(errorEvent)).toBe("\r\n[SDK Error] boom\r\n");
         expect(formatSdkOutputEvent(toolEvent)).toBeUndefined();
     });
+    it("formats AI request events as immediate realtime ACode output", () => {
+        const requestEvent = {
+            type: "ai_request",
+            sessionId: "session-1",
+            timestamp: new Date(0).toISOString(),
+            data: {
+                model: "test-model",
+                lastUserMessagePreview: "inspect status",
+            },
+        };
+        expect(formatSdkOutputEvent(requestEvent)).toBe("\r\n[ACode] 正在请求模型 test-model：inspect status\r\n");
+    });
 });
-describe('SDK tool result timeline action info', () => {
-    it('keeps MCP tool results on MCP timeline events', () => {
+describe("SDK tool result timeline action info", () => {
+    it("keeps MCP tool results on MCP timeline events", () => {
         const event = {
-            type: 'tool_use_end',
-            sessionId: 'session-1',
+            type: "tool_use_end",
+            sessionId: "session-1",
             timestamp: new Date(0).toISOString(),
             data: {
-                toolName: 'mcp__aws-mcp__get_profile',
-                toolUseId: 'tool-1',
+                toolName: "mcp__aws-mcp__get_profile",
+                toolUseId: "tool-1",
                 toolResult: '{"displayName":"Agent"}',
             },
         };
         expect(buildToolResultTimelineActionInfo(event)).toEqual({
-            actionType: 'mcp',
-            actionLabel: 'MCP返回',
-            actionDetail: 'mcp__aws-mcp__get_profile',
-            actionId: 'tool-1',
+            actionType: "mcp",
+            actionLabel: "MCP返回",
+            actionDetail: "mcp__aws-mcp__get_profile",
+            actionId: "tool-1",
             actionResult: '{"displayName":"Agent"}',
         });
     });
-    it('forwards bash tool results to command timeline events', () => {
+    it("forwards bash tool results to command timeline events", () => {
         const event = {
-            type: 'tool_use_end',
-            sessionId: 'session-1',
+            type: "tool_use_end",
+            sessionId: "session-1",
             timestamp: new Date(0).toISOString(),
             data: {
-                toolName: 'bash',
-                toolInput: { command: 'npm run build' },
-                toolUseId: 'tool-2',
-                toolResult: 'build passed',
+                toolName: "bash",
+                toolInput: { command: "npm run build" },
+                toolUseId: "tool-2",
+                toolResult: "build passed",
             },
         };
         expect(buildToolResultTimelineActionInfo(event)).toEqual({
-            actionType: 'bash',
-            actionLabel: '执行命令',
-            actionDetail: 'npm run build',
-            actionId: 'tool-2',
-            actionResult: 'build passed',
+            actionType: "bash",
+            actionLabel: "执行命令",
+            actionDetail: "npm run build",
+            actionId: "tool-2",
+            actionResult: "build passed",
         });
     });
-    it('forwards read tool results to file-read timeline events', () => {
+    it("forwards read tool results to file-read timeline events", () => {
         const event = {
-            type: 'tool_use_end',
-            sessionId: 'session-1',
+            type: "tool_use_end",
+            sessionId: "session-1",
             timestamp: new Date(0).toISOString(),
             data: {
-                toolName: 'read_file',
-                toolInput: { path: 'src/index.ts' },
-                actionId: 'tool-3',
-                actionResult: 'export const ok = true',
+                toolName: "read_file",
+                toolInput: { path: "src/index.ts" },
+                actionId: "tool-3",
+                actionResult: "export const ok = true",
             },
         };
         expect(buildToolResultTimelineActionInfo(event)).toEqual({
-            actionType: 'read_file',
-            actionLabel: '读取文件',
-            actionDetail: 'src/index.ts',
-            actionId: 'tool-3',
-            actionResult: 'export const ok = true',
+            actionType: "read_file",
+            actionLabel: "读取文件",
+            actionDetail: "src/index.ts",
+            actionId: "tool-3",
+            actionResult: "export const ok = true",
         });
     });
-    it('keeps MCP-named filesystem results on semantic file-read timeline events', () => {
+    it("keeps MCP-named filesystem results on semantic file-read timeline events", () => {
         const event = {
-            type: 'tool_use_end',
-            sessionId: 'session-1',
+            type: "tool_use_end",
+            sessionId: "session-1",
             timestamp: new Date(0).toISOString(),
             data: {
-                toolName: 'mcp__filesystem__read_file',
-                toolInput: { path: 'src/index.ts' },
-                toolUseId: 'tool-4',
-                toolResult: 'export const ok = true',
+                toolName: "mcp__filesystem__read_file",
+                toolInput: { path: "src/index.ts" },
+                toolUseId: "tool-4",
+                toolResult: "export const ok = true",
             },
         };
         expect(buildToolResultTimelineActionInfo(event)).toEqual({
-            actionType: 'read_file',
-            actionLabel: '读取文件',
-            actionDetail: 'src/index.ts',
-            actionId: 'tool-4',
-            actionResult: 'export const ok = true',
+            actionType: "read_file",
+            actionLabel: "读取文件",
+            actionDetail: "src/index.ts",
+            actionId: "tool-4",
+            actionResult: "export const ok = true",
         });
     });
-    it('ignores tool result events without displayable result content', () => {
+    it("ignores tool result events without displayable result content", () => {
         const event = {
-            type: 'tool_use_end',
-            sessionId: 'session-1',
+            type: "tool_use_end",
+            sessionId: "session-1",
             timestamp: new Date(0).toISOString(),
-            data: { toolName: 'read_file', toolResult: '   ' },
+            data: { toolName: "read_file", toolResult: "   " },
         };
         expect(buildToolResultTimelineActionInfo(event)).toBeUndefined();
     });