lark-remote 0.1.6 → 0.1.7

package/dist/config/index.js

@@ -9,6 +9,20 @@ export { getConfigDir } from './dir.js';
 import { KIMI_THINKING_EFFORTS } from './kimi-config.js';
 /** Valid effort values for Claude */
 export const CLAUDE_EFFORTS = ['low', 'medium', 'high', 'xhigh', 'max'];
+/**
+ * Claude 官方 --permission-mode 枚举（claude --help 输出，2026-08 实测）。
+ * 额外支持 'default'：Claude settings.json 的官方未设置值，等价于不传
+ * --permission-mode（交互式默认：高风险工具逐个询问）。
+ */
+export const CLAUDE_PERMISSION_MODES = [
+    'default',
+    'acceptEdits',
+    'auto',
+    'bypassPermissions',
+    'manual',
+    'dontAsk',
+    'plan',
+];
 /** Valid thinking levels for Pi */
 export const PI_THINKING_LEVELS = ['off', 'minimal', 'low', 'medium', 'high', 'xhigh'];
 /** 默认值常量：schema 与 template 共享，避免双源不一致（G25 Magic Numbers）。 */
@@ -17,6 +31,10 @@ const DEFAULTS = {
     STOP_GRACE_MS: 5000,
     IDLE_WATCHDOG_MINUTES: 15,
     TURN_IDLE_TIMEOUT_MINUTES: 10,
+    /** 审批超时默认 5 分钟（对齐 codex 红线：勿随意改短）。 */
+    APPROVAL_TIMEOUT_MS: 5 * 60 * 1000,
+    /** Claude 会话级空闲回收默认 30 分钟（对齐 codex appServer.idleTtlMs）。 */
+    CLAUDE_IDLE_TTL_MINUTES: 30,
 };
 /**
  * Default SIGTERM→SIGKILL grace period (ms). Exported so runners (SpawningRunner)
@@ -26,6 +44,9 @@ const DEFAULTS = {
 export const DEFAULT_STOP_GRACE_MS = DEFAULTS.STOP_GRACE_MS;
 /** Codex app-server turn idle timeout default (minutes). */
 export const DEFAULT_TURN_IDLE_TIMEOUT_MINUTES = DEFAULTS.TURN_IDLE_TIMEOUT_MINUTES;
+/** 入站媒体默认配置（schema 默认与 connector 兜底共用，避免双源漂移）。 */
+export const DEFAULT_INBOUND_MEDIA_DIR_NAME = '.lark-remote-temp';
+export const DEFAULT_INBOUND_MEDIA_MAX_SIZE_MB = 50;
 /** 模型 ID → alias 映射。 */
 export const MODEL_ID_TO_ALIAS = {
     'claude-opus-4-8': 'opus',
@@ -47,7 +68,17 @@ const FeishuConfigSchema = z.object({
 const ClaudeConfigSchema = z.object({
     model: z.string().default(DEFAULTS.CLAUDE_MODEL),
     effort: z.enum(CLAUDE_EFFORTS).default('medium'),
-    // permissionMode 硬编码为 bypassPermissions（runner 内部），不通过 config 配置
+    /**
+     * Claude 权限模式（官方 --permission-mode 枚举 + 'default'=省略该参数）。
+     * 默认 bypassPermissions 保持现有行为（无审批卡）；配置为其他值后激活
+     * 交互式审批（control_request → run 卡审批区）。
+     */
+    permissionMode: z.enum(CLAUDE_PERMISSION_MODES).default('bypassPermissions'),
+    /** 审批请求超时（ms），默认 5 分钟；超时自动发送 cancel 并中断 turn。
+     *  0 = 立即过期（fail-fast，避免审批永久挂起），不推荐；勿随意改短。 */
+    approvalTimeoutMs: z.number().int().min(0).default(DEFAULTS.APPROVAL_TIMEOUT_MS),
+    /** 会话级空闲回收（分钟）：turn 之间无新消息超过该窗口则停止长驻进程。 */
+    idleTtlMinutes: z.number().int().min(0).default(DEFAULTS.CLAUDE_IDLE_TTL_MINUTES),
     stopGraceMs: z.number().int().min(0).default(DEFAULTS.STOP_GRACE_MS),
 });
 /** Codex app-server connection configuration. */
@@ -75,14 +106,12 @@ export const CodexConfigSchema = z.object({
      */
     // codex 拒绝空串档位（ReasoningEffort::from_str "" → Err，P3-3）
     reasoningEffort: z.string().min(1).optional(),
-    /** Stop grace period in milliseconds. */
-    stopGraceMs: z.number().int().min(0).default(5000),
-    /** Service mode: 'exec' (spawn-per-message) or 'app-server' (persistent connection). */
-    serviceMode: z.enum(['exec', 'app-server']).optional(),
-    /** Approval policy (Codex 官方 AskForApproval 标准值). 仅 app-server 模式有效（exec 固定 approval_policy="never"）。 */
-    approvalPolicy: z.enum(['untrusted', 'on-request', 'never']).optional(),
-    /** Sandbox mode (Codex 官方 SandboxMode 标准值). 仅 app-server 模式有效（exec 固定 --sandbox danger-full-access）。 */
-    sandbox: z.enum(['read-only', 'workspace-write', 'danger-full-access']).optional(),
+    /** Approval policy (Codex 官方 AskForApproval 标准值). 默认 on-request。 */
+    approvalPolicy: z.enum(['untrusted', 'on-request', 'never']).default('on-request'),
+    /** Sandbox mode (Codex 官方 SandboxMode 标准值). 默认 workspace-write。 */
+    sandbox: z
+        .enum(['read-only', 'workspace-write', 'danger-full-access'])
+        .default('workspace-write'),
     /** App-server connection configuration. */
     appServer: CodexAppServerConfigSchema.optional(),
 });
@@ -92,6 +121,8 @@ const OpencodeConfigSchema = z.object({
     providerID: z.string().default('anthropic'),
     /** Model ID for the LLM backend (e.g. 'claude-sonnet-4-20250514'). */
     modelID: z.string().default('claude-sonnet-4-20250514'),
+    /** Session mode (opencode agent name): 'build' (default) or 'plan'. */
+    mode: z.enum(['build', 'plan']).default('build'),
 });
 /** Pi-specific configuration. pi is a spawn-per-message CLI like Claude. */
 const PiConfigSchema = z.object({
@@ -104,16 +135,35 @@ const PiConfigSchema = z.object({
     /** Comma-separated tool whitelist. */
     tools: z.string().default('read,bash,edit,write,grep,find,ls'),
 });
-/** Kimi-specific configuration. kimi is a spawn-per-message CLI. */
+/** Kimi-specific configuration. Pure ACP mode (persistent `kimi acp` connection). */
 const KimiConfigSchema = z.object({
     /** Model ID or alias, e.g. 'kimi-code/k3'. */
     model: z.string().default('kimi-code/k3'),
     /** Thinking effort: 'on', 'max'. */
     thinkingEffort: z.enum(KIMI_THINKING_EFFORTS).default('max'),
+    /** Permission mode: 'manual' (approve each), 'auto' (engine decides), 'yolo' (allow all). */
+    permissionMode: z.enum(['manual', 'auto', 'yolo']).default('manual'),
+    /** ACP sub-configuration. */
+    acp: z
+        .object({
+        /** Path to kimi binary for ACP mode. */
+        binary: z.string().default('kimi'),
+        /** Request timeout in milliseconds. */
+        requestTimeoutMs: z.number().int().min(0).default(60000),
+        /** Idle TTL for ACP connection in milliseconds. */
+        idleTtlMs: z.number().int().min(0).default(1800000),
+        /** Turn idle timeout in minutes (0 disables). */
+        turnIdleTimeoutMinutes: z.number().int().min(0).default(DEFAULT_TURN_IDLE_TIMEOUT_MINUTES),
+    })
+        .optional(),
 });
+/** 首次启动的默认 agents 配置：codex 默认 app-server / on-request / workspace-write。 */
+const DEFAULT_AGENTS_CONFIG = {
+    codex: CodexConfigSchema.parse({}),
+};
 /** Agents configuration: per-agent settings keyed by agent kind. */
 const AgentsConfigSchema = z.object({
-    codex: CodexConfigSchema.optional(),
+    codex: CodexConfigSchema.default(DEFAULT_AGENTS_CONFIG.codex),
     opencode: OpencodeConfigSchema.optional(),
     pi: PiConfigSchema.optional(),
     kimi: KimiConfigSchema.optional(),
@@ -134,6 +184,15 @@ const OutputConfigSchema = z.object({
 const LoggingConfigSchema = z.object({
     level: z.enum(['debug', 'info', 'warn', 'error']).default('info'),
 });
+/** 入站媒体落盘配置（预留可配置，默认即可用）。 */
+const InboundMediaConfigSchema = z.object({
+    /** 是否启用图片/文件落盘。 */
+    enabled: z.boolean().default(true),
+    /** 落盘根目录名（位于当前 cwd 下）。 */
+    dirName: z.string().min(1).default(DEFAULT_INBOUND_MEDIA_DIR_NAME),
+    /** 单文件大小上限（MiB）。 */
+    maxFileSizeMb: z.number().int().min(1).default(DEFAULT_INBOUND_MEDIA_MAX_SIZE_MB),
+});
 /** Agent-specific saved choices for quick switching. */
 const AgentChoicesSchema = z.object({
     codex: z
@@ -166,13 +225,15 @@ export const AppConfigSchema = z.object({
     feishu: FeishuConfigSchema,
     /** Claude config (top-level; other agents live under `agents`). */
     claude: ClaudeConfigSchema.default(ClaudeConfigSchema.parse({})),
-    /** Per-agent configuration for non-claude agents. */
-    agents: AgentsConfigSchema.optional(),
+    /** Per-agent configuration for non-claude agents. 首次启动默认含 codex（app-server / workspace-write / on-request）。 */
+    agents: AgentsConfigSchema.default(DEFAULT_AGENTS_CONFIG),
     /** Agent-specific saved choices for quick switching. */
     agentChoices: AgentChoicesSchema.optional(),
     idle: IdleConfigSchema.default(IdleConfigSchema.parse({})),
     output: OutputConfigSchema.default(OutputConfigSchema.parse({})),
     logging: LoggingConfigSchema.default(LoggingConfigSchema.parse({})),
+    /** 入站媒体（图片/文件）落盘配置。 */
+    inboundMedia: InboundMediaConfigSchema.default(InboundMediaConfigSchema.parse({})),
     /** Default agent for new runs. */
     defaultAgent: z.enum(['claude', 'codex', 'opencode', 'pi', 'kimi']).default('claude'),
     /** Check for updates on bridge startup (default: false). */
@@ -185,6 +246,9 @@ const TEMPLATE = `feishu:
 claude:
   model: ${DEFAULTS.CLAUDE_MODEL}
   effort: medium
+  permissionMode: bypassPermissions
+  approvalTimeoutMs: ${DEFAULTS.APPROVAL_TIMEOUT_MS}
+  idleTtlMinutes: ${DEFAULTS.CLAUDE_IDLE_TTL_MINUTES}
   stopGraceMs: ${DEFAULTS.STOP_GRACE_MS}
 
 idle:
@@ -272,33 +336,45 @@ export function assertSafeKeyPart(part) {
         throw new Error(`[lark-remote] invalid config key segment: '${part}'`);
     }
 }
-/** 在对象上按 dot-separated key 设置嵌套值（仅修改内存对象，不写盘）。 */
-function setNestedValue(target, key, value) {
-    const parts = key.split('.');
+/**
+ * 按 dot-separated key 下钻到目标键的父容器（不含最后一段）。
+ *
+ * - create=true：中间缺失/非对象段自动补 `{}`（set 语义）
+ * - create=false：中间缺失/非对象段返回 undefined（get/delete 语义）
+ *
+ * 危险段（__proto__/prototype/constructor）在每段统一拒绝。
+ */
+export function walkNestedContainer(target, parts, create) {
     let current = target;
     for (let i = 0; i < parts.length - 1; i++) {
         assertSafeKeyPart(parts[i]);
         const next = current[parts[i]];
         if (next == null || typeof next !== 'object') {
+            if (!create)
+                return undefined;
             current[parts[i]] = {};
         }
         current = current[parts[i]];
     }
+    return current;
+}
+/** 在对象上按 dot-separated key 设置嵌套值（仅修改内存对象，不写盘）。 */
+function setNestedValue(target, key, value) {
+    const parts = key.split('.');
+    const container = walkNestedContainer(target, parts, true);
     const lastPart = parts[parts.length - 1];
     assertSafeKeyPart(lastPart);
-    current[lastPart] = value;
+    container[lastPart] = value;
 }
 /** Get a nested value from config by dot-separated key, e.g. "feishu.appId" */
 export function getConfigValue(config, key) {
     const parts = key.split('.');
-    let current = config;
-    for (const part of parts) {
-        assertSafeKeyPart(part);
-        if (current == null || typeof current !== 'object')
-            return undefined;
-        current = current[part];
-    }
-    return current;
+    const container = walkNestedContainer(config, parts, false);
+    if (!container)
+        return undefined;
+    const lastPart = parts[parts.length - 1];
+    assertSafeKeyPart(lastPart);
+    return container[lastPart];
 }
 /** Set a nested value in config by dot-separated key, write back to YAML file */
 export function setConfigValue(configPath, config, key, value) {
@@ -337,17 +413,12 @@ export function setConfigValues(configPath, config, updates) {
  */
 function deleteNestedValue(target, key) {
     const parts = key.split('.');
-    let current = target;
-    for (let i = 0; i < parts.length - 1; i++) {
-        assertSafeKeyPart(parts[i]);
-        const next = current[parts[i]];
-        if (next == null || typeof next !== 'object')
-            return;
-        current = next;
-    }
+    const container = walkNestedContainer(target, parts, false);
+    if (!container)
+        return;
     const lastPart = parts[parts.length - 1];
     assertSafeKeyPart(lastPart);
-    delete current[lastPart];
+    delete container[lastPart];
 }
 export function getAgentConfig(config, kind) {
     if (kind === 'claude') {

package/dist/connector/index.d.ts

@@ -1,4 +1,4 @@
-import { type CardActionEvent, type CardActionResponse, type CardStreamProducer } from '@larksuite/channel';
+import { type CardActionEvent, type CardActionResponse, type CardStreamProducer, type LarkChannel } from '@larksuite/channel';
 import type { AppConfig } from '../config/index.js';
 /**
  * dedup 缓存 TTL（毫秒）。控制飞书事件去重窗口，全局作用于 message + cardAction。
@@ -26,6 +26,54 @@ interface FeishuMessage {
     content: string;
 }
 type MessageHandler = (msg: FeishuMessage) => void;
+/**
+ * 入站媒体（image/file 消息的 resource）下载结果，交给 bridge 落盘。
+ * media 为通过大小限制、可落盘的项；failures 为下载失败或超限的项
+ * （bridge 负责把这些失败提示回用户）。
+ */
+export interface InboundMediaItem {
+    /** 资源类型：image 消息按 MIME 生成 image_<HHmmss>_<n>.<ext>，file 保留文件名。 */
+    type: 'image' | 'file';
+    /** 原始文件名（file 消息有；image 消息无，由 bridge 按 MIME 生成）。 */
+    fileName?: string;
+    /** 服务端 content-type（参数已剥离；可能缺失，bridge 有兜底）。 */
+    mimeType?: string;
+    /**
+     * 下载内容所在临时文件（流式落盘，避免大文件全量进堆内存）。
+     * 由 bridge 移动到最终位置；任何未移动路径都必须清理该文件。
+     */
+    tempPath: string;
+}
+export interface InboundMediaFailure {
+    fileName?: string;
+    reason: string;
+}
+export interface InboundMediaPayload {
+    userId: string;
+    chatId: string;
+    messageId: string;
+    /** 引用上下文：不同 replyTo 强制拆批。 */
+    replyToMessageId?: string;
+    media: InboundMediaItem[];
+    failures: InboundMediaFailure[];
+}
+/**
+ * 媒体消息到达的轻量描述（未下载）：供上层先做 owner/配置闸门，
+ * 通过后再调 downloadInboundMedia —— 下载发生在认证之后（P1 review 修复）。
+ */
+export interface InboundMediaMessage {
+    userId: string;
+    chatId: string;
+    messageId: string;
+    /** 引用上下文：不同 replyTo 强制拆批。 */
+    replyToMessageId?: string;
+    resources: Array<{
+        type: 'image' | 'file';
+        fileKey: string;
+        fileName?: string;
+    }>;
+}
+type InboundMediaDetectedHandler = (msg: InboundMediaMessage) => void | Promise<void>;
 /**
  * CardAction handler may return a CardActionResponse (e.g. `{ toast: {...} }`)
  * to give the clicking user native immediate feedback. The SDK passes the
@@ -34,9 +82,11 @@ type MessageHandler = (msg: FeishuMessage) => void;
  */
 type CardActionHandler = (action: CardActionEvent) => void | CardActionResponse | Promise<void | CardActionResponse>;
 export declare class FeishuConnector {
-    private channel;
+    /** 飞书 channel 实例（public：测试直接访问/注入 mock，替代 as unknown as）。 */
+    channel: LarkChannel;
     private onMessage?;
     private onCardAction?;
+    private onInboundMediaDetected?;
     private isConnected;
     private appId;
     private appSecret;
@@ -44,6 +94,23 @@ export declare class FeishuConnector {
     get connected(): boolean;
     setMessageHandler(handler: MessageHandler): void;
     setCardActionHandler(handler: CardActionHandler): void;
+    setInboundMediaDetectedHandler(handler: InboundMediaDetectedHandler): void;
+    /**
+     * 上报媒体消息到达（轻量，不含下载内容）。上层认证/配置闸门通过后
+     * 再调 downloadInboundMedia。
+     */
+    private handleInboundMediaDetected;
+    /**
+     * 下载消息里的全部资源（流式写临时文件，避免大文件全量进堆内存）。
+     * 逐资源 try/catch：单个失败不影响其他资源；超限项不进入 media（不落盘）。
+     * 下载失败/超限都随 failures 交给 bridge 提示用户（对齐"发送文件失败"文案风格）。
+     * 调用方必须已通过 owner/配置闸门（index.ts）；maxFileSizeMb 由调用方从
+     * 当前配置传入（避免 connector 持有过期的 config 快照）。
+     */
+    downloadInboundMedia(msg: InboundMediaMessage, opts?: {
+        maxFileSizeMb?: number;
+        downloadTimeoutMs?: number;
+    }): Promise<InboundMediaPayload>;
     connect(): Promise<void>;
     disconnect(): Promise<void>;
     reconnect(): Promise<void>;

package/dist/connector/index.js

@@ -1,9 +1,15 @@
 import { createLarkChannel, } from '@larksuite/channel';
 import { getLogger } from '../logger/index.js';
 import { MAX_FILE_UPLOAD_SIZE } from './file-limits.js';
+import { DEFAULT_INBOUND_MEDIA_MAX_SIZE_MB } from '../config/index.js';
+import { sleep } from '../common/sleep.js';
 import axios from 'axios';
 import fs from 'node:fs';
+import { silentlyUnlink } from '../common/fs.js';
 import https from 'node:https';
+import os from 'node:os';
+import path from 'node:path';
+import { randomUUID } from 'node:crypto';
 import FormData from 'form-data';
 /**
  * Dedicated https.Agent with keepAlive disabled for sendFile's three axios
@@ -36,6 +42,20 @@ const noKeepAliveAgent = new https.Agent({ keepAlive: false });
  * 详见 design.md §9.8。原地更新逻辑新增按钮时参考该节去重风险分类。
  */
 export const DEDUP_TTL_MS = 300;
+/** 单资源下载超时（毫秒）：SDK 无内置超时，挂起会导致提示丢失 + 残留临时文件。 */
+const RESOURCE_DOWNLOAD_TIMEOUT_MS = 5 * 60 * 1000;
+function withTimeout(promise, ms, label) {
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => reject(new Error(`${label} timed out after ${ms}ms`)), ms);
+        promise.then((value) => {
+            clearTimeout(timer);
+            resolve(value);
+        }, (err) => {
+            clearTimeout(timer);
+            reject(err);
+        });
+    });
+}
 /**
  * 判断 send 失败是否值得重试一次（§9.5 限流重试口径，§P1-3 修正）。
  *
@@ -75,9 +95,11 @@ function tryGetPatchService(channel) {
     return c?.im?.v1?.message;
 }
 export class FeishuConnector {
+    /** 飞书 channel 实例（public：测试直接访问/注入 mock，替代 as unknown as）。 */
     channel;
     onMessage;
     onCardAction;
+    onInboundMediaDetected;
     isConnected = false;
     appId;
     appSecret;
@@ -125,6 +147,15 @@ export class FeishuConnector {
         this.channel.on('message', (msg) => {
             if (msg.chatType !== 'p2p')
                 return;
+            // 入站图片/文件：不转发文本内容（图片消息的 content 只是占位文案），
+            // 而是下载资源后交给 bridge 落盘（runner 零改动）。
+            if ((msg.rawContentType === 'image' || msg.rawContentType === 'file') &&
+                msg.resources.length > 0) {
+                // 只上报"媒体到达"，不在此下载：owner/配置闸门在 index.ts 里先执行，
+                // 通过后才调用 downloadInboundMedia（避免未认证大文件下载打爆内存）。
+                void this.handleInboundMediaDetected(msg);
+                return;
+            }
             this.onMessage?.({
                 userId: msg.senderId,
                 messageId: msg.messageId,
@@ -158,6 +189,81 @@ export class FeishuConnector {
     setCardActionHandler(handler) {
         this.onCardAction = handler;
     }
+    setInboundMediaDetectedHandler(handler) {
+        this.onInboundMediaDetected = handler;
+    }
+    /**
+     * 上报媒体消息到达（轻量，不含下载内容）。上层认证/配置闸门通过后
+     * 再调 downloadInboundMedia。
+     */
+    async handleInboundMediaDetected(msg) {
+        if (!this.onInboundMediaDetected) {
+            getLogger().warn('[feishu] inbound media received but no detected handler registered');
+            return;
+        }
+        try {
+            await this.onInboundMediaDetected({
+                userId: msg.senderId,
+                chatId: msg.chatId,
+                messageId: msg.messageId,
+                replyToMessageId: msg.replyToMessageId,
+                resources: msg.resources.map((r) => ({
+                    type: r.type === 'image' ? 'image' : 'file',
+                    fileKey: r.fileKey,
+                    fileName: r.fileName,
+                })),
+            });
+        }
+        catch (err) {
+            getLogger().error('[feishu] inbound media detected handler failed:', err.message);
+        }
+    }
+    /**
+     * 下载消息里的全部资源（流式写临时文件，避免大文件全量进堆内存）。
+     * 逐资源 try/catch：单个失败不影响其他资源；超限项不进入 media（不落盘）。
+     * 下载失败/超限都随 failures 交给 bridge 提示用户（对齐"发送文件失败"文案风格）。
+     * 调用方必须已通过 owner/配置闸门（index.ts）；maxFileSizeMb 由调用方从
+     * 当前配置传入（避免 connector 持有过期的 config 快照）。
+     */
+    async downloadInboundMedia(msg, opts) {
+        const maxBytes = (opts?.maxFileSizeMb ?? DEFAULT_INBOUND_MEDIA_MAX_SIZE_MB) * 1024 * 1024;
+        const timeoutMs = opts?.downloadTimeoutMs ?? RESOURCE_DOWNLOAD_TIMEOUT_MS;
+        const media = [];
+        const failures = [];
+        for (const res of msg.resources) {
+            const tmpPath = path.join(os.tmpdir(), `lark-remote-inbound-${randomUUID()}`);
+            try {
+                const { contentType, bytesWritten } = await withTimeout(this.channel.downloadResourceToFile(msg.messageId, res.fileKey, res.type, tmpPath), timeoutMs, `downloadResource fileKey=${res.fileKey}`);
+                if (bytesWritten > maxBytes) {
+                    silentlyUnlink(tmpPath);
+                    failures.push({
+                        fileName: res.fileName,
+                        reason: `超过 ${maxBytes / (1024 * 1024)}MB 大小限制`,
+                    });
+                    continue;
+                }
+                media.push({
+                    type: res.type,
+                    fileName: res.fileName,
+                    mimeType: contentType,
+                    tempPath: tmpPath,
+                });
+            }
+            catch (err) {
+                silentlyUnlink(tmpPath);
+                getLogger().warn(`[feishu] downloadResource failed fileKey=${res.fileKey} type=${res.type}:`, err.message);
+                failures.push({ fileName: res.fileName, reason: `下载失败: ${err.message}` });
+            }
+        }
+        return {
+            userId: msg.userId,
+            chatId: msg.chatId,
+            messageId: msg.messageId,
+            replyToMessageId: msg.replyToMessageId,
+            media,
+            failures,
+        };
+    }
     async connect() {
         try {
             await this.channel.connect();
@@ -200,7 +306,7 @@ export class FeishuConnector {
         catch (err) {
             if (shouldRetrySendError(err)) {
                 getLogger().warn('[feishu] rate limited, retrying in 200ms...');
-                await new Promise((r) => setTimeout(r, 200));
+                await sleep(200);
                 try {
                     const result = await this.channel.send(chatId, input, { replyTo: opts?.replyTo });
                     return result.messageId;