aws-runtime-bridge 1.7.49 → 1.7.50

package/dist/adapter/AcodeSdkAdapter.d.ts

@@ -0,0 +1,77 @@
+/**
+ * ACode SDK Adapter
+ *
+ * 主流程：直接加载随 aws-runtime-bridge 内置发布的 ACode headless runtime，
+ * 不依赖外部 CLI 安装；将 ACode 的结构化事件映射为 runtime-bridge 统一事件流。
+ */
+import { EventEmitter } from 'node:events';
+import type { AdapterSessionConfig, BaseProviderAdapter, ConversationMessage, SessionStatus } from './types.js';
+type ACodeEvent = {
+    type: string;
+    sessionId: string;
+    timestamp: string;
+    data: Record<string, unknown>;
+};
+type ACodeRuntimeInstance = {
+    on(eventName: 'event', listener: (event: ACodeEvent) => void): void;
+    start(): Promise<void>;
+    submit(message: string): Promise<void>;
+    abort(): Promise<void>;
+    stop(): Promise<void>;
+};
+type ACodeRuntimeConstructor = new (config: {
+    sessionId: string;
+    workingDirectory: string;
+    configPath?: string;
+    skillsDir?: string;
+    initialPrompt?: string;
+    model?: string;
+    systemPrompt?: string;
+    env?: Record<string, string>;
+}) => ACodeRuntimeInstance;
+export declare function toAcodeEsmImportSpecifier(modulePath: string): string;
+/**
+ * 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.
+ */
+export declare function isFailedAcodeTurnComplete(data: Record<string, unknown>): boolean;
+export declare class AcodeSdkAdapter extends EventEmitter implements BaseProviderAdapter {
+    readonly providerId = "acode";
+    readonly displayName = "ACode";
+    private sessions;
+    private runtimeConstructor?;
+    startSession(sessionId: string, config: AdapterSessionConfig): Promise<void>;
+    sendMessage(sessionId: string, message: string): Promise<void>;
+    sendConfirmation(_sessionId: string, _accept: boolean): Promise<void>;
+    abortCurrentTurn(sessionId: string): Promise<void>;
+    terminateSession(sessionId: string): Promise<void>;
+    getConversation(sessionId: string): ConversationMessage[];
+    hasSession(sessionId: string): boolean;
+    getProviderSessionId(sessionId: string): string | undefined;
+    getSessionStatus(sessionId: string): SessionStatus | undefined;
+    cleanup(): void;
+    /** Injects a runtime constructor for adapter tests without loading the packaged ACode module. */
+    setRuntimeConstructorForTest(runtimeConstructor: ACodeRuntimeConstructor): void;
+    private createRuntime;
+    private loadRuntimeConstructor;
+    private requireSession;
+    /**
+     * Run the startup prompt after the HTTP launch has already completed.
+     * Main flow: mark the session busy -> submit the prompt in the background ->
+     * rely on normal ACode events to publish turn completion or errors.
+     */
+    private startInitialPromptTurn;
+    private forwardAcodeEvent;
+    private emitProviderEvent;
+    /**
+     * 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.
+     */
+    private scheduleAutoPoll;
+    private cancelScheduledAutoPoll;
+    private isTerminalStatus;
+    private emitRuntimeError;
+}
+export {};
+//# sourceMappingURL=AcodeSdkAdapter.d.ts.map

package/dist/adapter/AcodeSdkAdapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AcodeSdkAdapter.d.ts","sourceRoot":"","sources":["../../src/adapter/AcodeSdkAdapter.ts"],"names":[],"mappings":"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"}

package/dist/adapter/AcodeSdkAdapter.js

@@ -0,0 +1,322 @@
+/**
+ * ACode SDK Adapter
+ *
+ * 主流程：直接加载随 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';
+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(' ');
+const ACODE_AUTO_POLL_DELAY_MS = 250;
+function getAcodePackageEntryPath() {
+    return path.resolve(getReleasedAcodeEntryPath());
+}
+export function toAcodeEsmImportSpecifier(modulePath) {
+    return pathToFileURL(path.resolve(modulePath)).href;
+}
+function toUsage(value) {
+    if (!value || typeof value !== 'object') {
+        return undefined;
+    }
+    const usage = value;
+    return {
+        inputTokens: Number(usage.inputTokens) || 0,
+        outputTokens: Number(usage.outputTokens) || 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.
+ */
+export function isFailedAcodeTurnComplete(data) {
+    return data.failed === true;
+}
+export class AcodeSdkAdapter extends EventEmitter {
+    constructor() {
+        super(...arguments);
+        this.providerId = 'acode';
+        this.displayName = 'ACode';
+        this.sessions = new Map();
+    }
+    async startSession(sessionId, config) {
+        const runtimeHome = getRuntimeHomeDir();
+        const session = {
+            sessionId,
+            status: 'starting',
+            messages: [],
+            createdAt: new Date().toISOString(),
+            totalUsage: { inputTokens: 0, outputTokens: 0 },
+        };
+        this.sessions.set(sessionId, {
+            adapterSession: session,
+            config,
+            runtime: await this.createRuntime(sessionId, config, runtimeHome),
+            autoPollActive: false,
+        });
+        this.emit('status-change', sessionId, 'starting');
+        const entry = this.sessions.get(sessionId);
+        if (!entry) {
+            throw new Error('ACode session was not initialized');
+        }
+        await entry.runtime.start();
+        session.status = 'waiting_input';
+        this.emit('status-change', sessionId, 'waiting_input');
+        if (config.initialPrompt?.trim()) {
+            this.startInitialPromptTurn(sessionId, config.initialPrompt);
+        }
+    }
+    async sendMessage(sessionId, message) {
+        const entry = this.requireSession(sessionId);
+        this.cancelScheduledAutoPoll(entry);
+        const userMessage = {
+            id: uuidv4(),
+            sessionId,
+            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);
+    }
+    async sendConfirmation(_sessionId, _accept) { }
+    async abortCurrentTurn(sessionId) {
+        await this.requireSession(sessionId).runtime.abort();
+    }
+    async terminateSession(sessionId) {
+        const entry = this.sessions.get(sessionId);
+        if (!entry) {
+            return;
+        }
+        this.cancelScheduledAutoPoll(entry);
+        await entry.runtime.stop();
+        entry.adapterSession.status = 'terminated';
+        this.sessions.delete(sessionId);
+        this.emit('status-change', sessionId, 'terminated');
+    }
+    getConversation(sessionId) {
+        return this.sessions.get(sessionId)?.adapterSession.messages ?? [];
+    }
+    hasSession(sessionId) {
+        return this.sessions.has(sessionId);
+    }
+    getProviderSessionId(sessionId) {
+        return this.sessions.has(sessionId) ? sessionId : undefined;
+    }
+    getSessionStatus(sessionId) {
+        return this.sessions.get(sessionId)?.adapterSession.status;
+    }
+    cleanup() {
+        for (const sessionId of this.sessions.keys()) {
+            void this.terminateSession(sessionId);
+        }
+    }
+    /** Injects a runtime constructor for adapter tests without loading the packaged ACode module. */
+    setRuntimeConstructorForTest(runtimeConstructor) {
+        this.runtimeConstructor = runtimeConstructor;
+    }
+    async createRuntime(sessionId, config, runtimeHome) {
+        const ACodeRuntime = await this.loadRuntimeConstructor();
+        const runtime = new ACodeRuntime({
+            sessionId,
+            workingDirectory: config.workingDirectory,
+            configPath: config.mcpConfigPath || getAcodeConfigFile(runtimeHome),
+            skillsDir: getAcodeSkillsDir(runtimeHome),
+            model: config.model,
+            systemPrompt: typeof config.systemPrompt === 'string' ? config.systemPrompt : undefined,
+            env: config.envOverrides,
+        });
+        runtime.on('event', (event) => this.forwardAcodeEvent(event));
+        return runtime;
+    }
+    async loadRuntimeConstructor() {
+        if (this.runtimeConstructor) {
+            return this.runtimeConstructor;
+        }
+        const modulePath = getAcodePackageEntryPath();
+        const module = await import(toAcodeEsmImportSpecifier(modulePath));
+        if (!module.ACodeRuntime) {
+            throw new Error(`ACode runtime export not found: ${modulePath}`);
+        }
+        this.runtimeConstructor = module.ACodeRuntime;
+        return this.runtimeConstructor;
+    }
+    requireSession(sessionId) {
+        const entry = this.sessions.get(sessionId);
+        if (!entry) {
+            throw new Error('ACode session not found');
+        }
+        return entry;
+    }
+    /**
+     * Run the startup prompt after the HTTP launch has already completed.
+     * Main flow: mark the session busy -> submit the prompt in the background ->
+     * rely on normal ACode events to publish turn completion or errors.
+     */
+    startInitialPromptTurn(sessionId, initialPrompt) {
+        const entry = this.sessions.get(sessionId);
+        if (!entry) {
+            return;
+        }
+        entry.adapterSession.status = 'thinking';
+        this.emit('status-change', sessionId, 'thinking');
+        void entry.runtime.submit(initialPrompt).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');
+        });
+    }
+    forwardAcodeEvent(event) {
+        const entry = this.sessions.get(event.sessionId);
+        if (!entry) {
+            return;
+        }
+        if (event.type === 'assistant_delta') {
+            const text = typeof event.data.text === 'string' ? event.data.text : '';
+            entry.adapterSession.messages.push({
+                id: uuidv4(),
+                sessionId: event.sessionId,
+                role: 'assistant',
+                content: text,
+                timestamp: event.timestamp,
+            });
+            this.emitProviderEvent(event, 'text_delta', { text });
+            return;
+        }
+        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)) {
+                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);
+            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');
+            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');
+            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', {
+                toolName: actionDetail,
+                actionType: 'mcp',
+                actionLabel: 'Calling MCP',
+                actionDetail,
+            });
+            this.emit('status-change', event.sessionId, 'tool_using', {
+                actionType: 'mcp',
+                actionLabel: 'Calling MCP',
+                actionDetail,
+            });
+            return;
+        }
+        this.emitProviderEvent(event, 'thinking', {
+            text: JSON.stringify(event.data),
+        });
+    }
+    emitProviderEvent(event, type, data) {
+        this.emit('event', {
+            type,
+            sessionId: event.sessionId,
+            timestamp: event.timestamp,
+            data,
+        });
+    }
+    /**
+     * 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.
+     */
+    scheduleAutoPoll(sessionId) {
+        const entry = this.sessions.get(sessionId);
+        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)) {
+                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);
+    }
+    cancelScheduledAutoPoll(entry) {
+        if (!entry.autoPollTimer) {
+            return;
+        }
+        clearTimeout(entry.autoPollTimer);
+        entry.autoPollTimer = undefined;
+    }
+    isTerminalStatus(status) {
+        return status === 'completed' || status === 'terminated' || status === 'error';
+    }
+    emitRuntimeError(sessionId, 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');
+    }
+}

package/dist/adapter/AcodeSdkAdapter.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=AcodeSdkAdapter.test.d.ts.map

package/dist/adapter/AcodeSdkAdapter.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AcodeSdkAdapter.test.d.ts","sourceRoot":"","sources":["../../src/adapter/AcodeSdkAdapter.test.ts"],"names":[],"mappings":""}

package/dist/adapter/AcodeSdkAdapter.test.js

@@ -0,0 +1,273 @@
+import { EventEmitter } from 'node:events';
+import { describe, expect, it, vi } from 'vitest';
+import { AcodeSdkAdapter, isFailedAcodeTurnComplete } from './AcodeSdkAdapter.js';
+class FailedTurnRuntime extends EventEmitter {
+    constructor(config) {
+        super();
+        this.config = config;
+    }
+    async start() { }
+    async submit(_message) {
+        this.emit('event', {
+            type: 'error',
+            sessionId: this.config.sessionId,
+            timestamp: new Date(0).toISOString(),
+            data: { message: 'provider down' },
+        });
+        this.emit('event', {
+            type: 'turn_complete',
+            sessionId: this.config.sessionId,
+            timestamp: new Date(0).toISOString(),
+            data: { failed: true, usage: { inputTokens: 1, outputTokens: 0 } },
+        });
+    }
+    async abort() { }
+    async stop() { }
+}
+class McpStatusRuntime extends EventEmitter {
+    constructor(config) {
+        super();
+        this.config = config;
+    }
+    async start() { }
+    async submit(_message) {
+        this.emit('event', {
+            type: 'mcp_status',
+            sessionId: this.config.sessionId,
+            timestamp: new Date(0).toISOString(),
+            data: { action: 'call_tool', server: 'aws-mcp', tool: 'create_memory' },
+        });
+    }
+    async abort() { }
+    async stop() { }
+}
+class CommandStatusRuntime extends EventEmitter {
+    constructor(config) {
+        super();
+        this.config = config;
+    }
+    async start() { }
+    async submit(_message) {
+        this.emit('event', {
+            type: 'command_status',
+            sessionId: this.config.sessionId,
+            timestamp: new Date(0).toISOString(),
+            data: { action: 'slash_command', command: 'review' },
+        });
+    }
+    async abort() { }
+    async stop() { }
+}
+class McpThenSessionCompleteRuntime extends EventEmitter {
+    constructor(config) {
+        super();
+        this.config = config;
+    }
+    async start() { }
+    async submit(_message) {
+        this.emit('event', {
+            type: 'mcp_status',
+            sessionId: this.config.sessionId,
+            timestamp: new Date(0).toISOString(),
+            data: { action: 'call_tool', server: 'aws-mcp', tool: 'send_private' },
+        });
+        this.emit('event', {
+            type: 'session_complete',
+            sessionId: this.config.sessionId,
+            timestamp: new Date(0).toISOString(),
+            data: { exitCode: 0 },
+        });
+    }
+    async abort() { }
+    async stop() { }
+}
+class DeferredInitialPromptRuntime extends EventEmitter {
+    constructor(config) {
+        super();
+        DeferredInitialPromptRuntime.receivedInitialPrompt = config.initialPrompt;
+    }
+    async start() { }
+    async submit(_message) {
+        DeferredInitialPromptRuntime.submitCalls += 1;
+        await new Promise(() => undefined);
+    }
+    async abort() { }
+    async stop() { }
+}
+DeferredInitialPromptRuntime.submitCalls = 0;
+class AutoPollRuntime extends EventEmitter {
+    constructor(config) {
+        super();
+        this.config = config;
+    }
+    async start() { }
+    async submit(message) {
+        AutoPollRuntime.submitMessages.push(message);
+        if (AutoPollRuntime.submitMessages.length === 1) {
+            this.emit('event', {
+                type: 'turn_complete',
+                sessionId: this.config.sessionId,
+                timestamp: new Date(0).toISOString(),
+                data: { usage: { inputTokens: 1, outputTokens: 1 } },
+            });
+        }
+    }
+    async abort() { }
+    async stop() { }
+}
+AutoPollRuntime.submitMessages = [];
+describe('AcodeSdkAdapter turn completion state', () => {
+    it('keeps error status for failed turn_complete events', () => {
+        expect(isFailedAcodeTurnComplete({ failed: true })).toBe(true);
+        expect(isFailedAcodeTurnComplete({ failed: false })).toBe(false);
+        expect(isFailedAcodeTurnComplete({ usage: { inputTokens: 1, outputTokens: 2 } })).toBe(false);
+    });
+    it('does not forward failed turn_complete into waiting_input status updates', async () => {
+        const adapter = new AcodeSdkAdapter();
+        adapter.setRuntimeConstructorForTest(FailedTurnRuntime);
+        const events = [];
+        const statuses = [];
+        adapter.on('event', (event) => events.push(event));
+        adapter.on('status-change', (_sessionId, status) => statuses.push(status));
+        await adapter.startSession('session-failed', {
+            command: 'acode',
+            workingDirectory: process.cwd(),
+            autoAccept: true,
+            extraMcpServers: {},
+            envOverrides: {},
+        });
+        await adapter.sendMessage('session-failed', 'fail please');
+        expect(events.map((event) => event.type)).toEqual(['error']);
+        expect(statuses).toEqual(['starting', 'waiting_input', 'thinking', 'error']);
+        expect(adapter.getSessionStatus('session-failed')).toBe('error');
+    });
+    it('maps ACode MCP status events to tool_using instead of thinking', async () => {
+        const adapter = new AcodeSdkAdapter();
+        adapter.setRuntimeConstructorForTest(McpStatusRuntime);
+        const events = [];
+        const statuses = [];
+        adapter.on('event', (event) => events.push(event));
+        adapter.on('status-change', (_sessionId, status, actionInfo) => {
+            statuses.push({ status, actionType: actionInfo?.actionType, actionDetail: actionInfo?.actionDetail });
+        });
+        await adapter.startSession('session-mcp', {
+            command: 'acode',
+            workingDirectory: process.cwd(),
+            autoAccept: true,
+            extraMcpServers: {},
+            envOverrides: {},
+        });
+        await adapter.sendMessage('session-mcp', 'call mcp');
+        expect(events.map((event) => event.type)).toEqual(['tool_use_start']);
+        expect(events[0]?.data).toMatchObject({
+            actionType: 'mcp',
+            actionLabel: 'Calling MCP',
+            actionDetail: 'aws-mcp/create_memory',
+        });
+        expect(statuses.at(-1)).toEqual({
+            status: 'tool_using',
+            actionType: 'mcp',
+            actionDetail: 'aws-mcp/create_memory',
+        });
+        expect(adapter.getSessionStatus('session-mcp')).toBe('tool_using');
+    });
+    it('forwards ACode command status as thinking without changing session status', async () => {
+        const adapter = new AcodeSdkAdapter();
+        adapter.setRuntimeConstructorForTest(CommandStatusRuntime);
+        const events = [];
+        const statuses = [];
+        adapter.on('event', (event) => events.push(event));
+        adapter.on('status-change', (_sessionId, status) => statuses.push(status));
+        await adapter.startSession('session-command-status', {
+            command: 'acode',
+            workingDirectory: process.cwd(),
+            autoAccept: true,
+            extraMcpServers: {},
+            envOverrides: {},
+        });
+        await adapter.sendMessage('session-command-status', '/review src');
+        expect(events).toHaveLength(1);
+        expect(events[0]?.type).toBe('thinking');
+        expect(String(events[0]?.data.text)).toContain('slash_command');
+        expect(statuses).toEqual(['starting', 'waiting_input', 'thinking']);
+        expect(adapter.getSessionStatus('session-command-status')).toBe('thinking');
+    });
+    it('forwards session_complete status after MCP calls so UI can clear active tool state', async () => {
+        const adapter = new AcodeSdkAdapter();
+        adapter.setRuntimeConstructorForTest(McpThenSessionCompleteRuntime);
+        const events = [];
+        const statuses = [];
+        adapter.on('event', (event) => events.push(event));
+        adapter.on('status-change', (_sessionId, status, actionInfo) => {
+            statuses.push({ status, actionType: actionInfo?.actionType, actionDetail: actionInfo?.actionDetail });
+        });
+        await adapter.startSession('session-mcp-complete', {
+            command: 'acode',
+            workingDirectory: process.cwd(),
+            autoAccept: true,
+            extraMcpServers: {},
+            envOverrides: {},
+        });
+        await adapter.sendMessage('session-mcp-complete', 'send private');
+        expect(events.map((event) => event.type)).toEqual(['tool_use_start', 'session_complete']);
+        expect(statuses.at(-2)).toEqual({
+            status: 'tool_using',
+            actionType: 'mcp',
+            actionDetail: 'aws-mcp/send_private',
+        });
+        expect(statuses.at(-1)).toEqual({
+            status: 'completed',
+            actionType: undefined,
+            actionDetail: undefined,
+        });
+        expect(adapter.getSessionStatus('session-mcp-complete')).toBe('completed');
+    });
+    it('does not block launch completion while the initial prompt runs in the background', async () => {
+        DeferredInitialPromptRuntime.submitCalls = 0;
+        DeferredInitialPromptRuntime.receivedInitialPrompt = undefined;
+        const adapter = new AcodeSdkAdapter();
+        adapter.setRuntimeConstructorForTest(DeferredInitialPromptRuntime);
+        const statuses = [];
+        adapter.on('status-change', (_sessionId, status) => statuses.push(status));
+        await adapter.startSession('session-initial-prompt', {
+            command: 'acode',
+            workingDirectory: process.cwd(),
+            autoAccept: true,
+            initialPrompt: 'start working loop',
+            extraMcpServers: {},
+            envOverrides: {},
+        });
+        expect(DeferredInitialPromptRuntime.receivedInitialPrompt).toBeUndefined();
+        expect(DeferredInitialPromptRuntime.submitCalls).toBe(1);
+        expect(statuses).toEqual(['starting', 'waiting_input', 'thinking']);
+        expect(adapter.getSessionStatus('session-initial-prompt')).toBe('thinking');
+    });
+    it('continues the message loop by auto-submitting poll_message after a completed turn', async () => {
+        vi.useFakeTimers();
+        AutoPollRuntime.submitMessages = [];
+        const adapter = new AcodeSdkAdapter();
+        adapter.setRuntimeConstructorForTest(AutoPollRuntime);
+        const statuses = [];
+        adapter.on('status-change', (_sessionId, status) => statuses.push(status));
+        try {
+            await adapter.startSession('session-auto-poll', {
+                command: 'acode',
+                workingDirectory: process.cwd(),
+                autoAccept: true,
+                extraMcpServers: {},
+                envOverrides: {},
+            });
+            await adapter.sendMessage('session-auto-poll', 'handle current work');
+            await vi.advanceTimersByTimeAsync(250);
+            expect(AutoPollRuntime.submitMessages).toHaveLength(2);
+            expect(AutoPollRuntime.submitMessages[0]).toBe('handle current work');
+            expect(AutoPollRuntime.submitMessages[1]).toContain('poll_message');
+            expect(statuses).toEqual(['starting', 'waiting_input', 'thinking', 'waiting_input', 'thinking']);
+            expect(adapter.getSessionStatus('session-auto-poll')).toBe('thinking');
+        }
+        finally {
+            vi.useRealTimers();
+            adapter.cleanup();
+        }
+    });
+});