@wu529778790/open-im 1.11.8-beta.2 → 1.11.8-beta.21

package/dist/config.js

@@ -8,7 +8,7 @@ import { accessSync, constants } from 'node:fs';
 import { execFileSync } from 'node:child_process';
 import { join, isAbsolute } from 'node:path';
 import { createLogger } from './logger.js';
-import { APP_HOME, } from './constants.js';
+import { APP_HOME, AUTOPILOT_ENABLED_DEFAULT, AUTOPILOT_MAX_RETRIES, AUTOPILOT_DEFAULT_INTERVAL_HOURS, AUTOPILOT_SHORT_RETRY_SECONDS, AUTOPILOT_DEFAULT_PROMPT, } from './constants.js';
 const log = createLogger('config');
 import { isAiCommand, AI_TOOL_BY_ID } from './adapters/tool-registry.js';
 /**
@@ -200,6 +200,24 @@ export function loadConfig() {
     const tc = file.tools?.claude ?? {};
     const tcod = file.tools?.codex ?? {};
     const tcb = file.tools?.codebuddy ?? {};
+    // Autopilot（限流自动恢复）配置
+    const autopilotFile = tc.autopilot ?? {};
+    const autopilot = {
+        enabled: process.env.OPEN_IM_AUTOPILOT !== 'false'
+            && (autopilotFile.enabled ?? AUTOPILOT_ENABLED_DEFAULT),
+        maxRetries: (() => {
+            const envVal = process.env.OPEN_IM_AUTOPILOT_MAX_RETRIES;
+            if (envVal !== undefined && envVal !== '') {
+                const n = Number.parseInt(envVal, 10);
+                if (Number.isFinite(n) && n >= 0)
+                    return n;
+            }
+            return autopilotFile.maxRetries ?? AUTOPILOT_MAX_RETRIES;
+        })(),
+        defaultIntervalHours: autopilotFile.defaultIntervalHours ?? AUTOPILOT_DEFAULT_INTERVAL_HOURS,
+        shortRetrySeconds: autopilotFile.shortRetrySeconds ?? AUTOPILOT_SHORT_RETRY_SECONDS,
+        autoResumePrompt: autopilotFile.autoResumePrompt ?? AUTOPILOT_DEFAULT_PROMPT,
+    };
     const claudeProxy = process.env.CLAUDE_PROXY ?? tc.proxy;
     const codexProxy = process.env.CODEX_PROXY ?? tcod.proxy;
     // Windows 下若 CLI 路径仍是默认名,尝试在 npm 全局目录定位 .cmd。
@@ -226,6 +244,7 @@ export function loadConfig() {
     const codebuddyCliPath = process.env.CODEBUDDY_CLI_PATH ?? tcb.cliPath ?? resolveWindowsCliPath(AI_TOOL_BY_ID.codebuddy.cliDefault ?? 'codebuddy');
     const topencode = file.tools?.opencode ?? {};
     const opencodeCliPath = process.env.OPENCODE_CLI_PATH ?? topencode.cliPath ?? resolveWindowsCliPath(AI_TOOL_BY_ID.opencode.cliDefault ?? 'opencode');
+    const opencodeModel = process.env.OPENCODE_MODEL ?? topencode.model;
     const claudeWorkDir = process.env.CLAUDE_WORK_DIR ?? tc.workDir ?? process.cwd();
     const skipPermissions = process.env.OPEN_IM_SKIP_PERMISSIONS === 'false'
         ? false
@@ -519,6 +538,7 @@ export function loadConfig() {
         codexCliPath,
         codebuddyCliPath,
         opencodeCliPath,
+        opencodeModel,
         claudeProxy,
         codexProxy,
         claudeWorkDir,
@@ -530,6 +550,7 @@ export function loadConfig() {
         telemetry: {
             enabled: telemetryEnabled,
         },
+        autopilot,
         platforms,
     };
 }

package/dist/constants.d.ts

@@ -71,5 +71,15 @@ export declare const MAX_WORKBUDDY_MESSAGE_LENGTH = 2000;
 export declare const MAX_CLAWBOT_MESSAGE_LENGTH = 2000;
 /** ClawBot 长轮询间隔 */
 export declare const CLAWBOT_POLL_INTERVAL_MS = 3000;
+/** Autopilot 默认开启 */
+export declare const AUTOPILOT_ENABLED_DEFAULT = true;
+/** 最大连续自动重试次数 */
+export declare const AUTOPILOT_MAX_RETRIES = 5;
+/** 无法从错误消息提取重置时间时的默认等待小时数 */
+export declare const AUTOPILOT_DEFAULT_INTERVAL_HOURS = 5;
+/** 529/临时限流的短延迟秒数 */
+export declare const AUTOPILOT_SHORT_RETRY_SECONDS = 60;
+/** 自动恢复时发送的提示词 */
+export declare const AUTOPILOT_DEFAULT_PROMPT = "\u7EE7\u7EED";
 export declare const DEFAULT_OPEN_IM_COAUTHOR_ADDR = "529778790@qq.com";
 export declare const TERMINAL_ONLY_COMMANDS: Set<string>;

package/dist/constants.js

@@ -90,6 +90,17 @@ export const MAX_CLAWBOT_MESSAGE_LENGTH = 2000;
 // ─── 轮询间隔 ───
 /** ClawBot 长轮询间隔 */
 export const CLAWBOT_POLL_INTERVAL_MS = 3000;
+// ─── Autopilot（限流自动恢复） ───
+/** Autopilot 默认开启 */
+export const AUTOPILOT_ENABLED_DEFAULT = true;
+/** 最大连续自动重试次数 */
+export const AUTOPILOT_MAX_RETRIES = 5;
+/** 无法从错误消息提取重置时间时的默认等待小时数 */
+export const AUTOPILOT_DEFAULT_INTERVAL_HOURS = 5;
+/** 529/临时限流的短延迟秒数 */
+export const AUTOPILOT_SHORT_RETRY_SECONDS = 60;
+/** 自动恢复时发送的提示词 */
+export const AUTOPILOT_DEFAULT_PROMPT = "继续";
 // ─── Git 共同作者 ───
 export const DEFAULT_OPEN_IM_COAUTHOR_ADDR = "529778790@qq.com";
 // ─── 终端独占命令 ───

package/dist/opencode/cli-runner.d.ts

@@ -3,30 +3,10 @@
  *
  * OpenCode outputs plain text to stdout. Session continuation uses `-s <id>`.
  */
-export interface OpenCodeRunCallbacks {
-    onText: (accumulated: string) => void;
-    onThinking?: (accumulated: string) => void;
-    onToolUse?: (toolName: string, toolInput?: Record<string, unknown>) => void;
-    onComplete: (result: {
-        success: boolean;
-        result: string;
-        accumulated: string;
-        cost: number;
-        durationMs: number;
-        model?: string;
-        numTurns: number;
-        toolStats: Record<string, number>;
-    }) => void;
-    onError: (error: string) => void;
-    onSessionId?: (sessionId: string) => void;
-    onSessionInvalid?: () => void;
-}
+import type { RunCallbacks, RunHandle } from '../adapters/tool-adapter.interface.js';
 export interface OpenCodeRunOptions {
     skipPermissions?: boolean;
     model?: string;
 }
-export interface OpenCodeRunHandle {
-    abort: () => void;
-}
 export declare function buildOpenCodeArgs(prompt: string, sessionId: string | undefined, workDir: string, options?: OpenCodeRunOptions): string[];
-export declare function runOpenCode(cliPath: string, prompt: string, sessionId: string | undefined, workDir: string, callbacks: OpenCodeRunCallbacks, options?: OpenCodeRunOptions): OpenCodeRunHandle;
+export declare function runOpenCode(cliPath: string, prompt: string, sessionId: string | undefined, workDir: string, callbacks: RunCallbacks, options?: OpenCodeRunOptions): RunHandle;

package/dist/opencode/cli-runner.js

@@ -3,11 +3,11 @@
  *
  * OpenCode outputs plain text to stdout. Session continuation uses `-s <id>`.
  */
-import { spawn } from 'node:child_process';
 import { createInterface } from 'node:readline';
 import { createLogger } from '../logger.js';
-import { processEnvForNonClaudeCliChild } from '../config/file-io.js';
-import { killProcessTree, trackChild } from '../shared/process-kill.js';
+import { killProcessTree } from '../shared/process-kill.js';
+import { isSessionInvalidMessage } from '../shared/session-invalid-detector.js';
+import { createStderrBuffer, appendStderr, reconstructStderr, createFinalizeGate, isFinalizeReady, clearWallClockTimeout, spawnCliProcess, } from '../shared/cli-runner-base.js';
 const log = createLogger('OpenCodeCli');
 export function buildOpenCodeArgs(prompt, sessionId, workDir, options) {
     const args = ['run'];
@@ -31,16 +31,8 @@ export function buildOpenCodeArgs(prompt, sessionId, workDir, options) {
 }
 export function runOpenCode(cliPath, prompt, sessionId, workDir, callbacks, options) {
     const args = buildOpenCodeArgs(prompt, sessionId, workDir, options);
-    const env = processEnvForNonClaudeCliChild();
     log.info(`Spawning OpenCode: path=${cliPath}, cwd=${workDir}, session=${sessionId ?? 'new'}`);
-    const child = spawn(cliPath, args, {
-        cwd: workDir,
-        detached: process.platform !== 'win32',
-        stdio: ['pipe', 'pipe', 'pipe'],
-        env,
-        windowsHide: process.platform === 'win32',
-    });
-    trackChild(child);
+    const child = spawnCliProcess(cliPath, args, workDir);
     // Close stdin — prompt is passed as argument
     child.stdin?.end();
     let accumulated = '';
@@ -48,27 +40,10 @@ export function runOpenCode(cliPath, prompt, sessionId, workDir, callbacks, opti
     const toolStats = {};
     const startTime = Date.now();
     const rl = createInterface({ input: child.stdout });
-    const MAX_STDERR_HEAD = 4 * 1024;
-    const MAX_STDERR_TAIL = 6 * 1024;
-    let stderrHead = '';
-    let stderrTail = '';
-    let stderrTotal = 0;
-    let stderrHeadFull = false;
+    const stderrBuf = createStderrBuffer();
     child.stderr?.on('data', (chunk) => {
         const text = chunk.toString();
-        stderrTotal += text.length;
-        if (!stderrHeadFull) {
-            const room = MAX_STDERR_HEAD - stderrHead.length;
-            if (room > 0) {
-                stderrHead += text.slice(0, room);
-                if (stderrHead.length >= MAX_STDERR_HEAD)
-                    stderrHeadFull = true;
-            }
-        }
-        stderrTail += text;
-        if (stderrTail.length > MAX_STDERR_TAIL) {
-            stderrTail = stderrTail.slice(-MAX_STDERR_TAIL);
-        }
+        appendStderr(stderrBuf, text);
         log.debug(`[stderr] ${text.trimEnd()}`);
     });
     rl.on('line', (line) => {
@@ -94,67 +69,71 @@ export function runOpenCode(cliPath, prompt, sessionId, workDir, callbacks, opti
         }
     });
     let exitCode = null;
-    let rlClosed = false;
-    let childClosed = false;
+    const gate = createFinalizeGate();
+    let cliTimeoutHandle = null;
     const finalize = () => {
-        if (!rlClosed || !childClosed)
+        clearWallClockTimeout(cliTimeoutHandle);
+        cliTimeoutHandle = null;
+        if (!isFinalizeReady(gate))
             return;
         if (completed)
             return;
         if (exitCode !== null && exitCode !== 0) {
-            let errMsg = '';
-            if (stderrTotal > 0) {
-                if (!stderrHeadFull) {
-                    errMsg = stderrHead;
-                }
-                else if (stderrTotal <= MAX_STDERR_HEAD + MAX_STDERR_TAIL) {
-                    errMsg = stderrHead + stderrTail.slice(stderrTail.length - (stderrTotal - MAX_STDERR_HEAD));
-                }
-                else {
-                    errMsg =
-                        stderrHead +
-                            `\n\n... (omitted ${stderrTotal - MAX_STDERR_HEAD - MAX_STDERR_TAIL} bytes) ...\n\n` +
-                            stderrTail;
-                }
-            }
-            if (sessionId &&
-                (errMsg.includes('session not found') ||
-                    errMsg.includes('Session not found') ||
-                    errMsg.includes('no sessions found'))) {
+            const errMsg = reconstructStderr(stderrBuf);
+            if (sessionId && isSessionInvalidMessage(errMsg)) {
                 callbacks.onSessionInvalid?.();
             }
             callbacks.onError(errMsg || `OpenCode exited with code ${exitCode}`);
             return;
         }
         // Exit code 0 but no onComplete fired yet — treat accumulated text as result
-        if (!completed) {
-            completed = true;
-            callbacks.onComplete({
-                success: true,
-                result: accumulated,
-                accumulated,
-                cost: 0,
-                durationMs: Date.now() - startTime,
-                numTurns: 1,
-                toolStats,
-            });
-        }
+        completed = true;
+        callbacks.onComplete({
+            success: true,
+            result: accumulated,
+            accumulated,
+            cost: 0,
+            durationMs: Date.now() - startTime,
+            numTurns: 1,
+            toolStats,
+        });
     };
     rl.on('close', () => {
-        rlClosed = true;
+        gate.rlClosed = true;
         finalize();
     });
     child.on('close', (code) => {
         exitCode = code;
-        childClosed = true;
+        gate.childClosed = true;
         finalize();
     });
     child.on('error', (err) => {
         log.error('OpenCode spawn error:', err);
-        callbacks.onError(`Failed to start OpenCode: ${err.message}`);
+        if (!completed) {
+            completed = true;
+            callbacks.onError(`Failed to start OpenCode: ${err.message}`);
+        }
+        gate.childClosed = true;
+        finalize();
     });
+    // 墙钟超时：防止 CLI 挂死永久占用用户队列槽
+    const cliTimeoutMs = Number(process.env.OPEN_IM_CLI_TIMEOUT_MS) || 30 * 60 * 1000;
+    cliTimeoutHandle = setTimeout(() => {
+        if (completed)
+            return;
+        completed = true;
+        rl.close();
+        killProcessTree(child);
+        callbacks.onError(`OpenCode CLI 运行超时（${Math.round(cliTimeoutMs / 1000)}s），已终止。请重试。`);
+    }, cliTimeoutMs);
+    cliTimeoutHandle.unref();
     return {
         abort: () => {
+            if (completed)
+                return;
+            completed = true;
+            clearWallClockTimeout(cliTimeoutHandle);
+            rl.close();
             killProcessTree(child);
         },
     };

package/dist/opencode/sdk-manager.d.ts

@@ -0,0 +1,11 @@
+import type { OpencodeClient } from '@opencode-ai/sdk/v2/client';
+export declare function startOpencode(options?: {
+    hostname?: string;
+    port?: number;
+    signal?: AbortSignal;
+    timeout?: number;
+}): Promise<OpencodeClient>;
+export declare function stopOpencode(): void;
+export declare function getOpencodeClient(): OpencodeClient;
+export declare function isOpencodeRunning(): boolean;
+export declare function connectToOpencode(baseUrl?: string): Promise<OpencodeClient>;

package/dist/opencode/sdk-manager.js

@@ -0,0 +1,46 @@
+import { createOpencode, createOpencodeClient } from '@opencode-ai/sdk/v2';
+import { createLogger } from '../logger.js';
+const log = createLogger('OpenCodeSDK');
+let instance = null;
+export async function startOpencode(options) {
+    if (instance) {
+        log.info('OpenCode SDK already running');
+        return instance.client;
+    }
+    log.info('Starting OpenCode SDK server...');
+    const result = await createOpencode({
+        hostname: options?.hostname ?? '127.0.0.1',
+        port: options?.port ?? 0,
+        signal: options?.signal,
+        timeout: options?.timeout ?? 15000,
+    });
+    log.info(`OpenCode server started at ${result.server.url}`);
+    instance = result;
+    return instance.client;
+}
+export function stopOpencode() {
+    if (instance) {
+        log.info('Stopping OpenCode SDK server...');
+        instance.server.close();
+        instance = null;
+        log.info('OpenCode SDK server stopped');
+    }
+}
+export function getOpencodeClient() {
+    if (!instance) {
+        throw new Error('OpenCode SDK not started');
+    }
+    return instance.client;
+}
+export function isOpencodeRunning() {
+    return instance !== null;
+}
+export async function connectToOpencode(baseUrl) {
+    if (instance)
+        return instance.client;
+    const url = baseUrl ?? 'http://127.0.0.1:4096';
+    log.info(`Connecting to existing OpenCode server at ${url}`);
+    const client = createOpencodeClient({ baseUrl: url });
+    instance = { client, server: { url, close() { } } };
+    return client;
+}

package/dist/opencode/sdk-runner.d.ts

@@ -0,0 +1,7 @@
+import type { RunCallbacks, RunHandle } from '../adapters/tool-adapter.interface.js';
+export interface OpenCodeSdkRunOptions {
+    skipPermissions?: boolean;
+    model?: string;
+}
+export declare function runOpenCodeSdk(prompt: string, sessionId: string | undefined, workDir: string, callbacks: RunCallbacks, options?: OpenCodeSdkRunOptions): Promise<RunHandle>;
+export declare function clearSessionCache(workDir?: string): void;

package/dist/opencode/sdk-runner.js

@@ -0,0 +1,225 @@
+import { startOpencode } from './sdk-manager.js';
+import { createLogger } from '../logger.js';
+import { isSessionInvalidMessage } from '../shared/session-invalid-detector.js';
+const log = createLogger('OpenCodeSDKRunner');
+const sessionCache = new Map();
+function parseModel(modelStr) {
+    const slashIdx = modelStr.indexOf('/');
+    if (slashIdx > 0) {
+        return { providerID: modelStr.slice(0, slashIdx), modelID: modelStr.slice(slashIdx + 1) };
+    }
+    return { providerID: 'anthropic', modelID: modelStr };
+}
+export async function runOpenCodeSdk(prompt, sessionId, workDir, callbacks, options) {
+    const client = await startOpencode();
+    const abortController = new AbortController();
+    const startTime = Date.now();
+    let currentSessionId = sessionId;
+    if (!currentSessionId) {
+        currentSessionId = sessionCache.get(workDir);
+    }
+    if (!currentSessionId) {
+        try {
+            const projectName = workDir.split('/').filter(Boolean).pop() || 'project';
+            const result = await client.session.create({
+                directory: workDir,
+                title: `open-im: ${projectName}`,
+            });
+            currentSessionId = result.data?.id;
+            if (!currentSessionId) {
+                throw new Error('Session creation returned no ID');
+            }
+            sessionCache.set(workDir, currentSessionId);
+            callbacks.onSessionId?.(currentSessionId);
+            log.info(`Created session ${currentSessionId} for ${workDir}`);
+        }
+        catch (err) {
+            const msg = (err instanceof Error ? err.message : String(err));
+            log.error('Failed to create session:', msg);
+            callbacks.onError(msg);
+            return { abort: () => { } };
+        }
+    }
+    else {
+        log.info(`Using ${sessionId ? 'provided' : 'cached'} session ${currentSessionId}`);
+    }
+    let accumulatedText = '';
+    let accumulatedThinking = '';
+    const toolStats = {};
+    let runSettled = false;
+    let sseConnected = false;
+    // 用于等待 SSE 连接就绪后再发 prompt，避免竞态
+    const sseReadyResolve = () => { sseConnected = true; };
+    const subscribeEvents = async () => {
+        try {
+            const sse = await client.global.event({ signal: abortController.signal });
+            // SSE 连接已建立，通知主流程可以开始 prompt
+            sseReadyResolve();
+            log.debug('SSE stream connected');
+            for await (const raw of sse.stream) {
+                const ev = raw;
+                const payload = ev?.payload;
+                if (!payload?.properties)
+                    continue;
+                if (payload.properties.sessionID !== currentSessionId)
+                    continue;
+                switch (payload.type) {
+                    case 'session.next.text.delta': {
+                        const delta = payload.properties.delta;
+                        if (delta) {
+                            accumulatedText += delta;
+                            callbacks.onText(accumulatedText);
+                        }
+                        break;
+                    }
+                    case 'session.next.text.ended': {
+                        // text.ended 携带完整文本，作为 SSE 流的兜底
+                        const fullText = payload.properties.text;
+                        if (fullText && !accumulatedText) {
+                            accumulatedText = fullText;
+                            callbacks.onText(accumulatedText);
+                            log.debug(`SSE text.ended fallback: got ${fullText.length} chars`);
+                        }
+                        break;
+                    }
+                    case 'session.next.reasoning.delta': {
+                        const delta = payload.properties.delta;
+                        if (delta) {
+                            accumulatedThinking += delta;
+                            callbacks.onThinking?.(accumulatedThinking);
+                        }
+                        break;
+                    }
+                    case 'session.next.reasoning.ended': {
+                        // reasoning.ended 携带完整推理文本
+                        const fullReasoning = payload.properties.text;
+                        if (fullReasoning && !accumulatedThinking) {
+                            accumulatedThinking = fullReasoning;
+                            callbacks.onThinking?.(accumulatedThinking);
+                        }
+                        break;
+                    }
+                    case 'session.next.tool.called': {
+                        const tool = payload.properties.tool;
+                        if (tool) {
+                            toolStats[tool] = (toolStats[tool] || 0) + 1;
+                            callbacks.onToolUse?.(tool, payload.properties.input);
+                        }
+                        break;
+                    }
+                    default:
+                        log.debug(`SSE unhandled event: ${payload.type}`);
+                        break;
+                }
+            }
+        }
+        catch (err) {
+            if (!abortController.signal.aborted) {
+                log.debug('SSE stream ended:', err?.message);
+            }
+        }
+    };
+    const background = subscribeEvents();
+    // 等待 SSE 连接就绪（最多 3 秒），避免 prompt 在 SSE 未连接时就开始
+    // 如果 3 秒内 SSE 未连接，仍然继续执行（SSE 可能后续连接并补收事件）
+    const sseReady = new Promise((resolve) => {
+        const check = setInterval(() => {
+            if (sseConnected) {
+                clearInterval(check);
+                resolve();
+            }
+        }, 100);
+        // 3 秒超时：SSE 可能需要重试连接，不等太久
+        setTimeout(() => {
+            clearInterval(check);
+            if (!sseConnected)
+                log.warn('SSE not connected within 3s, proceeding with prompt anyway');
+            resolve();
+        }, 3000);
+    });
+    await sseReady;
+    try {
+        const result = await client.session.prompt({
+            sessionID: currentSessionId,
+            directory: workDir,
+            parts: [{ type: 'text', text: prompt }],
+            ...(options?.model ? { model: parseModel(options.model) } : {}),
+        });
+        // 调试：dump SDK 返回值结构
+        log.info(`SDK prompt raw result: hasData=${!!result.data}, hasError=${!!result.error}, keys=${Object.keys(result).join(',')}`);
+        if (result.error) {
+            const errStr = result.error instanceof Error ? result.error.message : JSON.stringify(result.error).substring(0, 500);
+            log.info(`SDK prompt error detail: ${errStr}`);
+        }
+        if (result.data) {
+            const d = result.data;
+            log.info(`SDK prompt data keys: ${Object.keys(d).join(',')}, parts count: ${Array.isArray(d.parts) ? d.parts.length : 'N/A'}, info keys: ${d.info && typeof d.info === 'object' ? Object.keys(d.info).join(',') : 'N/A'}`);
+        }
+        abortController.abort();
+        await background.catch(() => { });
+        runSettled = true;
+        // SDK 返回 { data, error } 二元组；error 存在时 data 为 undefined
+        const sdkError = result.error;
+        if (sdkError) {
+            const errMsg = sdkError instanceof Error ? sdkError.message : JSON.stringify(sdkError);
+            log.error(`SDK prompt returned error: ${errMsg}`);
+            callbacks.onError(errMsg);
+            return { abort: () => { } };
+        }
+        const data = result.data;
+        if (!data) {
+            log.error(`SDK prompt returned no data and no error — result keys: ${Object.keys(result).join(',')}`);
+            callbacks.onError('SDK 返回空数据');
+            return { abort: () => { } };
+        }
+        const parts = data?.parts ?? [];
+        const finalText = parts
+            .filter((p) => p.type === 'text' && typeof p.text === 'string')
+            .map(p => p.text)
+            .join('\n');
+        const cost = data?.info?.cost ?? 0;
+        log.info(`SDK prompt completed: accumulatedText=${accumulatedText.length}, finalText=${finalText.length}, parts=${parts.length}, cost=${cost}`);
+        if (!accumulatedText && !finalText) {
+            log.warn(`SDK prompt returned empty output — data keys: ${data ? Object.keys(data).join(',') : 'null'}, parts types: ${parts.map(p => p.type).join(',')}`);
+        }
+        callbacks.onComplete({
+            success: true,
+            result: finalText,
+            accumulated: accumulatedText || finalText,
+            cost,
+            durationMs: Date.now() - startTime,
+            numTurns: 1,
+            toolStats,
+        });
+    }
+    catch (err) {
+        abortController.abort();
+        await background.catch(() => { });
+        if (runSettled)
+            return { abort: () => { } };
+        const msg = (err instanceof Error ? err.message : String(err));
+        log.error('OpenCode SDK error:', msg);
+        if (isSessionInvalidMessage(msg)) {
+            sessionCache.delete(workDir);
+            callbacks.onSessionInvalid?.();
+        }
+        runSettled = true;
+        callbacks.onError(msg);
+    }
+    return {
+        abort: () => {
+            if (!abortController.signal.aborted) {
+                abortController.abort();
+                client.session.abort({ sessionID: currentSessionId }).catch(() => { });
+            }
+        },
+    };
+}
+export function clearSessionCache(workDir) {
+    if (workDir) {
+        sessionCache.delete(workDir);
+    }
+    else {
+        sessionCache.clear();
+    }
+}

package/dist/platform/handle-ai-request.js

@@ -133,7 +133,24 @@ export function createPlatformAIRequestHandler(deps) {
         };
         // 7. Run AI task
         try {
-            await runAITask({ config, sessionManager }, {
+            await runAITask({
+                config,
+                sessionManager,
+                autopilot: {
+                    onAutoPilotContinue: (continuePrompt) => {
+                        log.info(`[${platform}] Autopilot: re-enqueuing "${continuePrompt}" for user ${userId}`);
+                        handleAIRequest({
+                            userId,
+                            chatId,
+                            prompt: continuePrompt,
+                            workDir,
+                            convId,
+                        }).catch((err) => {
+                            log.error(`[${platform}] Autopilot re-enqueue failed:`, err);
+                        });
+                    },
+                },
+            }, {
                 userId,
                 chatId,
                 workDir,