@wu529778790/open-im 1.11.8-beta.8 → 1.11.8

package/dist/config-web-payload.d.ts

@@ -64,6 +64,7 @@ export interface WebConfigPayload {
         claudeBaseUrl: string;
         claudeModel: string;
         claudeProxy: string;
+        claudeSkipPermissions: boolean;
         codexCliPath: string;
         codebuddyCliPath: string;
         opencodeCliPath: string;

package/dist/config-web-payload.js

@@ -92,6 +92,7 @@ export function buildInitialPayload(file) {
             claudeBaseUrl: claudeEnv.ANTHROPIC_BASE_URL ?? "",
             claudeModel: claudeEnv.ANTHROPIC_MODEL ?? "",
             claudeProxy: file.tools?.claude?.proxy ?? "",
+            claudeSkipPermissions: file.tools?.claude?.skipPermissions ?? false,
             codexCliPath: file.tools?.codex?.cliPath ?? "codex",
             codebuddyCliPath: file.tools?.codebuddy?.cliPath ?? "codebuddy",
             opencodeCliPath: file.tools?.opencode?.cliPath ?? "opencode",
@@ -177,6 +178,7 @@ export function toFileConfig(payload, existing) {
                 ...existing.tools?.claude,
                 workDir: clean(payload.ai.claudeWorkDir) ?? process.cwd(),
                 proxy: clean(payload.ai.claudeProxy),
+                skipPermissions: payload.ai.claudeSkipPermissions,
                 // model is now saved to ~/.claude/settings.json as env var
             },
             codex: {

package/dist/config-web.js

@@ -355,7 +355,7 @@ export async function startWebConfigServer(options) {
             try {
                 const { startQRLogin } = await import("./clawbot/qr-login.js");
                 const session = await startQRLogin();
-                json(response, 200, { success: true, qrcodeUrl: session.qrcodeUrl, sessionKey: session.sessionKey }, request);
+                json(response, 200, { success: true, qrcodeUrl: session.qrcodeUrl, qrcodeImage: session.qrcodeImage, qrcode: session.qrcode, sessionKey: session.sessionKey }, request);
             }
             catch (error) {
                 json(response, 500, { success: false, error: toErrorMessage(error) }, request);
@@ -375,6 +375,33 @@ export async function startWebConfigServer(options) {
             }
             return;
         }
+        if (request.method === "POST" && requestUrl.pathname === "/api/workbuddy/qr-login/start") {
+            try {
+                const { WorkBuddyOAuth } = await import("./workbuddy/oauth.js");
+                const QRCode = (await import("qrcode")).default;
+                const oauth = new WorkBuddyOAuth();
+                const { authUrl, state } = await oauth.fetchAuthState();
+                const qrcodeImage = await QRCode.toDataURL(authUrl, { width: 280, margin: 1 });
+                json(response, 200, { success: true, qrcodeImage, state, authUrl }, request);
+            }
+            catch (error) {
+                json(response, 500, { success: false, error: toErrorMessage(error) }, request);
+            }
+            return;
+        }
+        if (request.method === "POST" && requestUrl.pathname === "/api/workbuddy/qr-login/wait") {
+            try {
+                const body = await readJson(request);
+                const { WorkBuddyOAuth } = await import("./workbuddy/oauth.js");
+                const oauth = new WorkBuddyOAuth();
+                const result = await oauth.pollToken(body.state);
+                json(response, 200, { success: true, accessToken: result.accessToken, refreshToken: result.refreshToken, userId: result.userId }, request);
+            }
+            catch (error) {
+                json(response, 500, { success: false, error: toErrorMessage(error) }, request);
+            }
+            return;
+        }
         if (request.method === "GET" && tryServeDashboardStatic(requestUrl, request, response, mergeCors)) {
             return;
         }

package/dist/config.js

@@ -246,9 +246,14 @@ export function loadConfig() {
     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
-        : (tc.skipPermissions ?? true);
+    const skipPermissions = (() => {
+        const raw = process.env.OPEN_IM_SKIP_PERMISSIONS?.trim().toLowerCase();
+        if (raw === 'true' || raw === '1' || raw === 'yes')
+            return true;
+        if (raw === 'false' || raw === '0' || raw === 'no')
+            return false;
+        return tc.skipPermissions;
+    })();
     const envIdleRaw = process.env.OPEN_IM_CLAUDE_SESSION_IDLE_TTL_MINUTES;
     const envIdleParsed = envIdleRaw !== undefined && envIdleRaw !== '' ? Number.parseInt(envIdleRaw, 10) : NaN;
     const fileIdle = tc.sessionIdleTtlMinutes;

package/dist/qq/client.js

@@ -1,6 +1,6 @@
 import WebSocket from "ws";
 import { createLogger } from "../logger.js";
-import { jitteredDelay, SLOW_PROBE_MS } from "../shared/reconnect.js";
+import { ReconnectManager, HeartbeatMonitor } from "../shared/connection-manager.js";
 const log = createLogger("QQ");
 const TOKEN_URL = "https://bots.qq.com/app/getAppAccessToken";
 const API_BASE = "https://api.sgroup.qq.com";
@@ -12,25 +12,23 @@ const INTENTS = {
 };
 let client = null;
 let ws = null;
-let heartbeatTimer = null;
-let reconnectTimer = null;
 let stopped = false;
 let seq = null;
 let sessionId = null;
-let reconnectAttempt = 0;
 let connecting = false; // 防止并发 connectWebSocket
 let currentConfig = null;
 let currentHandler = null;
 let tokenState = null;
-let lastServerResponseTime = 0;
-function clearTimers() {
-    if (heartbeatTimer) {
-        clearInterval(heartbeatTimer);
-        heartbeatTimer = null;
-    }
-    if (reconnectTimer) {
-        clearTimeout(reconnectTimer);
-        reconnectTimer = null;
+// Connection infrastructure (shared managers replace raw timers/counters)
+const heartbeatMonitor = new HeartbeatMonitor();
+const reconnectManager = new ReconnectManager({
+    name: 'QQ',
+    backoff: { mode: 'stepped', delays: RECONNECT_DELAYS_MS },
+    onReconnect: () => reconnectFn(),
+});
+async function reconnectFn() {
+    if (currentConfig && currentHandler) {
+        await connectWebSocket(currentConfig, currentHandler);
     }
 }
 function buildAuthHeaders(token) {
@@ -143,28 +141,28 @@ function normalizeInboundEvent(payload) {
     }
     return null;
 }
-function startHeartbeat(intervalMs) {
-    lastServerResponseTime = Date.now();
-    if (heartbeatTimer)
-        clearInterval(heartbeatTimer);
-    heartbeatTimer = setInterval(() => {
-        if (!ws || ws.readyState !== WebSocket.OPEN)
-            return;
-        const elapsed = Date.now() - lastServerResponseTime;
-        if (lastServerResponseTime > 0 && elapsed > intervalMs * 3) {
-            log.warn(`QQ dead connection: no response for ${Math.round(elapsed / 1000)}s, reconnecting`);
-            clearTimers();
-            ws?.terminate();
-            connectWebSocket(currentConfig, currentHandler);
-            return;
-        }
-        try {
-            ws.send(JSON.stringify({ op: 1, d: seq }));
-        }
-        catch (err) {
-            log.warn('QQ heartbeat send failed:', err);
-        }
-    }, intervalMs);
+/**
+ * Heartbeat tick: send ping and detect stale connections.
+ * The heartbeat interval is dynamic (from QQ gateway HELLO message).
+ */
+let heartbeatIntervalMs = 30000;
+function heartbeatTick() {
+    if (!ws || ws.readyState !== WebSocket.OPEN)
+        return;
+    if (heartbeatMonitor.isStale(heartbeatIntervalMs * 3)) {
+        const elapsed = Date.now() - heartbeatMonitor.lastResponseTime;
+        log.warn(`QQ dead connection: no response for ${Math.round(elapsed / 1000)}s, reconnecting`);
+        heartbeatMonitor.stop();
+        ws?.terminate();
+        reconnectFn().catch((err) => log.error('QQ reconnect from heartbeat failed:', err));
+        return;
+    }
+    try {
+        ws.send(JSON.stringify({ op: 1, d: seq }));
+    }
+    catch (err) {
+        log.warn('QQ heartbeat send failed:', err);
+    }
 }
 async function connectWebSocket(config, handler) {
     // 防止并发连接
@@ -196,17 +194,17 @@ async function connectWebSocket(config, handler) {
             };
             socket.on("open", () => {
                 log.info("QQ gateway connected");
-                reconnectAttempt = 0;
+                reconnectManager.reset();
             });
             socket.on("message", async (raw) => {
-                lastServerResponseTime = Date.now();
+                heartbeatMonitor.recordResponse();
                 try {
                     const payload = JSON.parse(raw.toString());
                     if (typeof payload.s === "number")
                         seq = payload.s;
                     if (payload.op === 10) {
-                        const heartbeatInterval = Number(payload.d?.heartbeat_interval ?? 30000);
-                        startHeartbeat(heartbeatInterval);
+                        heartbeatIntervalMs = Number(payload.d?.heartbeat_interval ?? 30000);
+                        heartbeatMonitor.start(heartbeatIntervalMs, heartbeatTick);
                         socket.send(JSON.stringify({
                             op: sessionId ? 6 : 2,
                             d: sessionId
@@ -253,7 +251,7 @@ async function connectWebSocket(config, handler) {
             });
             socket.on("close", (code, reason) => {
                 settle(() => { }); // 清理 ready timeout
-                clearTimers();
+                heartbeatMonitor.stop();
                 ws = null;
                 const reasonStr = reason.toString();
                 if (code === 4009) {
@@ -273,19 +271,11 @@ async function connectWebSocket(config, handler) {
                     seq = null;
                 }
                 const isFatalClose = code === 4004 || code === 4006 || code === 4007;
-                const baseDelay = RECONNECT_DELAYS_MS[Math.min(reconnectAttempt, RECONNECT_DELAYS_MS.length - 1)];
-                const delay = isFatalClose ? jitteredDelay(SLOW_PROBE_MS) : jitteredDelay(baseDelay);
                 if (isFatalClose) {
-                    log.warn(`QQ 致命关闭码 ${code}（鉴权失败），转慢探测（每 ${Math.round(SLOW_PROBE_MS / 1000)}s 一次）`);
+                    reconnectManager.setFatal(true);
+                    log.warn(`QQ 致命关闭码 ${code}（鉴权失败），转慢探测（每 ${Math.round(5 * 60)}s 一次）`);
                 }
-                reconnectAttempt += 1;
-                reconnectTimer = setTimeout(() => {
-                    if (currentConfig && currentHandler) {
-                        connectWebSocket(currentConfig, currentHandler).catch((err) => {
-                            log.error("QQ reconnect failed:", err);
-                        });
-                    }
-                }, delay);
+                reconnectManager.schedule();
             });
         });
     }
@@ -306,6 +296,8 @@ export async function initQQ(config, eventHandler) {
     stopped = false;
     currentConfig = config;
     currentHandler = eventHandler;
+    reconnectManager.reset();
+    reconnectManager.resume();
     client = {
         sendPrivateMessage: async (openid, content, replyToMessageId) => {
             const res = await apiRequest(config, "POST", `/v2/users/${openid}/messages`, buildMessageBody(content, replyToMessageId));
@@ -328,7 +320,8 @@ export async function initQQ(config, eventHandler) {
 }
 export async function stopQQ() {
     stopped = true;
-    clearTimers();
+    heartbeatMonitor.stop();
+    reconnectManager.stop();
     if (ws) {
         ws.close(1000);
         ws = null;
@@ -339,5 +332,4 @@ export async function stopQQ() {
     tokenState = null;
     sessionId = null;
     seq = null;
-    lastServerResponseTime = 0;
 }

package/dist/shared/ai-task.js

@@ -180,6 +180,22 @@ function buildCompletionNote(result, sessionManager, ctx) {
         parts.push(ctxWarning);
     return parts.join(' | ');
 }
+function buildRunOptions(config, sessionManager, ctx, aiCommand, toolAdapter) {
+    const defaultSkipPermissions = toolAdapter.interactionMode === 'native'
+        ? (config.skipPermissions ?? false)
+        : (config.skipPermissions ?? true);
+    return {
+        model: aiCommand === 'claude'
+            ? (sessionManager.getModel(ctx.userId, ctx.threadId) ?? config.claudeModel)
+            : aiCommand === 'opencode'
+                ? config.opencodeModel
+                : undefined,
+        chatId: ctx.chatId,
+        skipPermissions: defaultSkipPermissions,
+        skipAutoResume: sessionManager.isFreshSession(ctx.userId),
+        ...(aiCommand === 'codex' && config.codexProxy ? { proxy: config.codexProxy } : {}),
+    };
+}
 export function runAITask(deps, ctx, prompt, toolAdapter, platformAdapter) {
     const { config, sessionManager } = deps;
     return new Promise((resolve) => {
@@ -295,7 +311,9 @@ export function runAITask(deps, ctx, prompt, toolAdapter, platformAdapter) {
                     toolLines.push(notification);
                     if (toolLines.length > 5)
                         toolLines.shift();
-                    throttledUpdate(taskState.latestContent, true);
+                    // 不强制发送（force=false），让节流机制合并短时间内的多次工具调用，
+                    // 避免突发大量消息触发平台频率限制（如 ClawBot ret=-2）。
+                    throttledUpdate(taskState.latestContent, false);
                 },
                 onComplete: async (result) => {
                     log.info(`[AITask] onComplete fired: settled=${settled}, success=${result.success}, platform=${ctx.platform}, taskKey=${ctx.taskKey}`);
@@ -457,19 +475,7 @@ export function runAITask(deps, ctx, prompt, toolAdapter, platformAdapter) {
                     cleanup();
                     resolve();
                 },
-            }, {
-                model: aiCommand === 'claude'
-                    ? (sessionManager.getModel(ctx.userId, ctx.threadId) ?? config.claudeModel)
-                    : aiCommand === 'opencode'
-                        ? config.opencodeModel
-                        : undefined,
-                chatId: ctx.chatId,
-                // 默认跳过权限确认，保持全自动执行（可通过 config 或环境变量关闭）
-                skipPermissions: config.skipPermissions ?? true,
-                // /new 后跳过自动恢复 CLI session
-                skipAutoResume: sessionManager.isFreshSession(ctx.userId),
-                ...(aiCommand === 'codex' && config.codexProxy ? { proxy: config.codexProxy } : {}),
-            });
+            }, buildRunOptions(config, sessionManager, ctx, aiCommand, toolAdapter));
             return activeHandle;
         };
         taskState = {

package/dist/shared/connection-manager.d.ts

@@ -0,0 +1,111 @@
+/**
+ * Shared connection management infrastructure for self-managing platform clients.
+ *
+ * Encapsulates three cross-cutting concerns duplicated across wework, clawbot,
+ * qq, and workbuddy clients:
+ *
+ * - **ReconnectManager**: jittered backoff scheduling with fatal→slow-probe mode
+ * - **HeartbeatMonitor**: interval-based heartbeat / watchdog timer
+ * - **StateManager**: state variable with change-notification callback
+ */
+export interface ReconnectManagerConfig {
+    /** Platform name used in log messages. */
+    name: string;
+    /**
+     * Delay strategy:
+     * - `{ mode: 'exponential', baseMs, maxMs, cap }` — exponential backoff
+     *   `min(baseMs * 1.5^floor(attempt / cap), maxMs)`.
+     * - `{ mode: 'stepped', delays }` — stepped array; last entry repeats.
+     */
+    backoff: {
+        mode: 'exponential';
+        baseMs: number;
+        maxMs: number;
+        cap?: number;
+    } | {
+        mode: 'stepped';
+        delays: number[];
+    };
+    /**
+     * After this many attempts the counter resets and retries continue
+     * (avoids permanent disconnection). 0 = unlimited (no reset).
+     */
+    maxAttempts?: number;
+    /** Callback invoked after the computed delay. */
+    onReconnect: () => void | Promise<void>;
+}
+/**
+ * Manages reconnection scheduling with jittered backoff and fatal→slow-probe.
+ *
+ * Replaces the duplicated `scheduleReconnect()` pattern across 4 client files:
+ * timer cleanup, attempt counting, backoff computation, jitter, logging.
+ */
+export declare class ReconnectManager {
+    private timer;
+    private attempt;
+    private _fatal;
+    private _stopped;
+    private readonly log;
+    private readonly cfg;
+    constructor(cfg: ReconnectManagerConfig);
+    get attemptCount(): number;
+    get fatal(): boolean;
+    get stopped(): boolean;
+    /** Mark a fatal (auth) error — next scheduleReconnect uses slow-probe delay. */
+    setFatal(value: boolean): void;
+    /** Reset attempt counter and fatal flag after a successful connection. */
+    reset(): void;
+    /**
+     * Schedule a reconnect attempt.  Clears any pending timer, computes the
+     * backoff delay (with jitter), and invokes `onReconnect` after the delay.
+     */
+    schedule(): void;
+    /** Cancel any pending reconnect timer. */
+    stop(): void;
+    /** Allow scheduling again (undo `stop`). */
+    resume(): void;
+    private clearTimer;
+    private computeBaseDelay;
+}
+/**
+ * Manages a setInterval-based heartbeat or watchdog timer.
+ *
+ * Replaces duplicated `heartbeatTimer` / `watchdogTimer` patterns:
+ * timer cleanup on re-start, clearInterval on stop.
+ */
+export declare class HeartbeatMonitor {
+    private timer;
+    private _lastResponseTime;
+    get lastResponseTime(): number;
+    /** Record that a response was received (for watchdog stale detection). */
+    recordResponse(): void;
+    /**
+     * Start a periodic callback.  Clears any existing timer first.
+     * @param intervalMs  Interval in milliseconds.
+     * @param onTick      Callback invoked on each tick.
+     */
+    start(intervalMs: number, onTick: () => void | Promise<void>): void;
+    /** Clear the heartbeat timer. */
+    stop(): void;
+    /**
+     * Watchdog convenience: returns true if more than `staleMs` have elapsed
+     * since the last `recordResponse()` call.
+     */
+    isStale(staleMs: number): boolean;
+}
+/**
+ * Manages a connection state variable with change-notification callback.
+ *
+ * Replaces duplicated `connectionState` / `channelState` + `stateChangeHandler`
+ * patterns across wework, clawbot, and workbuddy clients.
+ */
+export declare class StateManager<T extends string> {
+    private _state;
+    private onChange?;
+    constructor(initialState: T);
+    get current(): T;
+    /** Register a callback invoked whenever the state changes. */
+    setOnChange(handler: ((state: T) => void) | undefined): void;
+    /** Transition to a new state and notify the callback if it changed. */
+    set(newState: T): void;
+}

package/dist/shared/connection-manager.js

@@ -0,0 +1,157 @@
+/**
+ * Shared connection management infrastructure for self-managing platform clients.
+ *
+ * Encapsulates three cross-cutting concerns duplicated across wework, clawbot,
+ * qq, and workbuddy clients:
+ *
+ * - **ReconnectManager**: jittered backoff scheduling with fatal→slow-probe mode
+ * - **HeartbeatMonitor**: interval-based heartbeat / watchdog timer
+ * - **StateManager**: state variable with change-notification callback
+ */
+import { createLogger } from '../logger.js';
+import { jitteredDelay, SLOW_PROBE_MS } from './reconnect.js';
+/**
+ * Manages reconnection scheduling with jittered backoff and fatal→slow-probe.
+ *
+ * Replaces the duplicated `scheduleReconnect()` pattern across 4 client files:
+ * timer cleanup, attempt counting, backoff computation, jitter, logging.
+ */
+export class ReconnectManager {
+    timer = null;
+    attempt = 0;
+    _fatal = false;
+    _stopped = false;
+    log;
+    cfg;
+    constructor(cfg) {
+        this.cfg = cfg;
+        this.log = createLogger(`${cfg.name}/Reconnect`);
+    }
+    get attemptCount() { return this.attempt; }
+    get fatal() { return this._fatal; }
+    get stopped() { return this._stopped; }
+    /** Mark a fatal (auth) error — next scheduleReconnect uses slow-probe delay. */
+    setFatal(value) { this._fatal = value; }
+    /** Reset attempt counter and fatal flag after a successful connection. */
+    reset() {
+        this.attempt = 0;
+        this._fatal = false;
+    }
+    /**
+     * Schedule a reconnect attempt.  Clears any pending timer, computes the
+     * backoff delay (with jitter), and invokes `onReconnect` after the delay.
+     */
+    schedule() {
+        this.clearTimer();
+        if (this._stopped)
+            return;
+        const max = this.cfg.maxAttempts;
+        if (max && max > 0 && this.attempt >= max) {
+            this.log.warn(`Max reconnect attempts (${max}) reached, resetting counter`);
+            this.attempt = 0;
+        }
+        const baseDelay = this.computeBaseDelay();
+        const delay = this._fatal ? jitteredDelay(SLOW_PROBE_MS) : jitteredDelay(baseDelay);
+        this.attempt++;
+        const fatalTag = this._fatal ? ' [slow-probe]' : '';
+        this.log.info(`Reconnecting in ${delay}ms (attempt ${this.attempt})${fatalTag}...`);
+        this.timer = setTimeout(async () => {
+            this.timer = null;
+            try {
+                await this.cfg.onReconnect();
+            }
+            catch (err) {
+                this.log.warn(`Reconnect callback failed: ${err instanceof Error ? err.message : String(err)}`);
+            }
+        }, delay);
+    }
+    /** Cancel any pending reconnect timer. */
+    stop() {
+        this._stopped = true;
+        this.clearTimer();
+    }
+    /** Allow scheduling again (undo `stop`). */
+    resume() {
+        this._stopped = false;
+    }
+    clearTimer() {
+        if (this.timer) {
+            clearTimeout(this.timer);
+            this.timer = null;
+        }
+    }
+    computeBaseDelay() {
+        const { backoff } = this.cfg;
+        if (backoff.mode === 'exponential') {
+            const cap = backoff.cap ?? 5;
+            return Math.min(backoff.baseMs * Math.pow(1.5, Math.floor(this.attempt / cap)), backoff.maxMs);
+        }
+        const { delays } = backoff;
+        return delays[Math.min(this.attempt, delays.length - 1)];
+    }
+}
+// ── HeartbeatMonitor ─────────────────────────────────────────────
+/**
+ * Manages a setInterval-based heartbeat or watchdog timer.
+ *
+ * Replaces duplicated `heartbeatTimer` / `watchdogTimer` patterns:
+ * timer cleanup on re-start, clearInterval on stop.
+ */
+export class HeartbeatMonitor {
+    timer = null;
+    _lastResponseTime = 0;
+    get lastResponseTime() { return this._lastResponseTime; }
+    /** Record that a response was received (for watchdog stale detection). */
+    recordResponse() { this._lastResponseTime = Date.now(); }
+    /**
+     * Start a periodic callback.  Clears any existing timer first.
+     * @param intervalMs  Interval in milliseconds.
+     * @param onTick      Callback invoked on each tick.
+     */
+    start(intervalMs, onTick) {
+        this.stop();
+        this.timer = setInterval(() => {
+            Promise.resolve(onTick()).catch(() => { });
+        }, intervalMs);
+    }
+    /** Clear the heartbeat timer. */
+    stop() {
+        if (this.timer) {
+            clearInterval(this.timer);
+            this.timer = null;
+        }
+    }
+    /**
+     * Watchdog convenience: returns true if more than `staleMs` have elapsed
+     * since the last `recordResponse()` call.
+     */
+    isStale(staleMs) {
+        return this._lastResponseTime > 0 && Date.now() - this._lastResponseTime > staleMs;
+    }
+}
+// ── StateManager ─────────────────────────────────────────────────
+/**
+ * Manages a connection state variable with change-notification callback.
+ *
+ * Replaces duplicated `connectionState` / `channelState` + `stateChangeHandler`
+ * patterns across wework, clawbot, and workbuddy clients.
+ */
+export class StateManager {
+    _state;
+    onChange;
+    constructor(initialState) {
+        this._state = initialState;
+    }
+    get current() { return this._state; }
+    /** Register a callback invoked whenever the state changes. */
+    setOnChange(handler) {
+        this.onChange = handler;
+    }
+    /** Transition to a new state and notify the callback if it changed. */
+    set(newState) {
+        if (this._state === newState)
+            return;
+        this._state = newState;
+        this.onChange?.(newState);
+    }
+}

package/dist/telegram/event-handler.js

@@ -61,14 +61,14 @@ async function downloadTelegramFile(bot, fileId, basenameHint, fallbackExtension
 }
 export function setupTelegramHandlers(bot, config, sessionManager) {
     // Create shared platform event context
-    const ctx = createPlatformEventContext({
+    const platformCtx = createPlatformEventContext({
         platform: 'telegram',
         allowedUserIds: config.telegramAllowedUserIds,
         config,
         sessionManager,
         sender: { sendTextReply, sendDirectorySelection },
     });
-    const { accessControl, requestQueue, runningTasks } = ctx;
+    const { accessControl, requestQueue, runningTasks } = platformCtx;
     // Telegram-specific sender callbacks for the factory
     const telegramSender = {
         sendThinkingMessage: async (chatId, replyToMessageId, toolId) => {
@@ -316,24 +316,14 @@ export function setupTelegramHandlers(bot, config, sessionManager) {
             if (parts.length >= 3) {
                 const choiceNum = parts[2];
                 const chatId = String(ctx.chat?.id ?? "");
-                // 将用户选择作为消息发送给 AI
-                const { handleTextFlow } = await import("../platform/handle-text-flow.js");
                 await handleTextFlow({
                     platform: "telegram",
                     userId,
                     chatId,
                     text: choiceNum,
-                    ctx: createPlatformEventContext({
-                        platform: "telegram",
-                        allowedUserIds: config.telegramAllowedUserIds,
-                        config,
-                        sessionManager,
-                        sender: { sendTextReply: async () => { } },
-                    }),
-                    handleAIRequest: async () => { },
-                    sendTextReply: async (c, t) => {
-                        await sendTextReply(c, t);
-                    },
+                    ctx: platformCtx,
+                    handleAIRequest,
+                    sendTextReply,
                     workDir: sessionManager.getWorkDir(userId),
                     convId: sessionManager.getConvId(userId),
                 });
@@ -352,7 +342,7 @@ export function setupTelegramHandlers(bot, config, sessionManager) {
                 userId,
                 chatId,
                 text,
-                ctx,
+                ctx: platformCtx,
                 handleAIRequest,
                 sendTextReply,
                 replyToMessageId: messageId,