opencode-feishu 1.0.2 → 1.2.0

package/dist/index.js

@@ -11587,7 +11587,7 @@ var require_object_inspect = __commonJS({
       "double": /(["\\])/g,
       single: /(['\\])/g
     };
-    module2.exports = function inspect_(obj, options, depth, seen2) {
+    module2.exports = function inspect_(obj, options, depth, seen) {
       var opts = options || {};
       if (has(opts, "quoteStyle") && !has(quotes, opts.quoteStyle)) {
         throw new TypeError('option "quoteStyle" must be "single" or "double"');
@@ -11637,15 +11637,15 @@ var require_object_inspect = __commonJS({
         return isArray2(obj) ? "[Array]" : "[Object]";
       }
       var indent = getIndent(opts, depth);
-      if (typeof seen2 === "undefined") {
-        seen2 = [];
-      } else if (indexOf(seen2, obj) >= 0) {
+      if (typeof seen === "undefined") {
+        seen = [];
+      } else if (indexOf(seen, obj) >= 0) {
         return "[Circular]";
       }
       function inspect(value, from, noIndent) {
         if (from) {
-          seen2 = $arrSlice.call(seen2);
-          seen2.push(from);
+          seen = $arrSlice.call(seen);
+          seen.push(from);
         }
         if (noIndent) {
           var newOpts = {
@@ -11654,9 +11654,9 @@ var require_object_inspect = __commonJS({
           if (has(opts, "quoteStyle")) {
             newOpts.quoteStyle = opts.quoteStyle;
           }
-          return inspect_(value, newOpts, depth + 1, seen2);
+          return inspect_(value, newOpts, depth + 1, seen);
         }
-        return inspect_(value, opts, depth + 1, seen2);
+        return inspect_(value, opts, depth + 1, seen);
       }
       if (typeof obj === "function" && !isRegExp2(obj)) {
         var name = nameOf(obj);
@@ -13718,7 +13718,7 @@ var require_lodash2 = __commonJS({
       if (stacked && stack.get(other)) {
         return stacked == other;
       }
-      var index = -1, result = true, seen2 = bitmask & UNORDERED_COMPARE_FLAG ? new SetCache() : void 0;
+      var index = -1, result = true, seen = bitmask & UNORDERED_COMPARE_FLAG ? new SetCache() : void 0;
       stack.set(array2, other);
       stack.set(other, array2);
       while (++index < arrLength) {
@@ -13733,10 +13733,10 @@ var require_lodash2 = __commonJS({
           result = false;
           break;
         }
-        if (seen2) {
+        if (seen) {
           if (!arraySome(other, function(othValue2, othIndex) {
-            if (!seen2.has(othIndex) && (arrValue === othValue2 || equalFunc(arrValue, othValue2, customizer, bitmask, stack))) {
-              return seen2.add(othIndex);
+            if (!seen.has(othIndex) && (arrValue === othValue2 || equalFunc(arrValue, othValue2, customizer, bitmask, stack))) {
+              return seen.add(othIndex);
             }
           })) {
             result = false;
@@ -109648,14 +109648,14 @@ function initializeContext(params) {
 function process2(schema, ctx, _params = { path: [], schemaPath: [] }) {
   var _a2;
   const def = schema._zod.def;
-  const seen2 = ctx.seen.get(schema);
-  if (seen2) {
-    seen2.count++;
+  const seen = ctx.seen.get(schema);
+  if (seen) {
+    seen.count++;
     const isCycle = _params.schemaPath.includes(schema);
     if (isCycle) {
-      seen2.cycle = _params.path;
+      seen.cycle = _params.path;
     }
-    return seen2.schema;
+    return seen.schema;
   }
   const result = { schema: {}, count: 1, cycle: void 0, path: _params.path };
   ctx.seen.set(schema, result);
@@ -109738,12 +109738,12 @@ function extractDefs(ctx, schema) {
     if (entry[1].schema.$ref) {
       return;
     }
-    const seen2 = entry[1];
+    const seen = entry[1];
     const { ref, defId } = makeURI(entry);
-    seen2.def = { ...seen2.schema };
+    seen.def = { ...seen.schema };
     if (defId)
-      seen2.defId = defId;
-    const schema2 = seen2.schema;
+      seen.defId = defId;
+    const schema2 = seen.schema;
     for (const key in schema2) {
       delete schema2[key];
     }
@@ -109751,16 +109751,16 @@ function extractDefs(ctx, schema) {
   };
   if (ctx.cycles === "throw") {
     for (const entry of ctx.seen.entries()) {
-      const seen2 = entry[1];
-      if (seen2.cycle) {
-        throw new Error(`Cycle detected: #/${seen2.cycle?.join("/")}/<root>
+      const seen = entry[1];
+      if (seen.cycle) {
+        throw new Error(`Cycle detected: #/${seen.cycle?.join("/")}/<root>
 
 Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.`);
       }
     }
   }
   for (const entry of ctx.seen.entries()) {
-    const seen2 = entry[1];
+    const seen = entry[1];
     if (schema === entry[0]) {
       extractToDef(entry);
       continue;
@@ -109777,11 +109777,11 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       extractToDef(entry);
       continue;
     }
-    if (seen2.cycle) {
+    if (seen.cycle) {
       extractToDef(entry);
       continue;
     }
-    if (seen2.count > 1) {
+    if (seen.count > 1) {
       if (ctx.reused === "ref") {
         extractToDef(entry);
         continue;
@@ -109794,13 +109794,13 @@ function finalize(ctx, schema) {
   if (!root)
     throw new Error("Unprocessed schema. This is a bug in Zod.");
   const flattenRef = (zodSchema) => {
-    const seen2 = ctx.seen.get(zodSchema);
-    if (seen2.ref === null)
+    const seen = ctx.seen.get(zodSchema);
+    if (seen.ref === null)
       return;
-    const schema2 = seen2.def ?? seen2.schema;
+    const schema2 = seen.def ?? seen.schema;
     const _cached = { ...schema2 };
-    const ref = seen2.ref;
-    seen2.ref = null;
+    const ref = seen.ref;
+    seen.ref = null;
     if (ref) {
       flattenRef(ref);
       const refSeen = ctx.seen.get(ref);
@@ -109852,7 +109852,7 @@ function finalize(ctx, schema) {
     ctx.override({
       zodSchema,
       jsonSchema: schema2,
-      path: seen2.path ?? []
+      path: seen.path ?? []
     });
   };
   for (const entry of [...ctx.seen.entries()].reverse()) {
@@ -109875,9 +109875,9 @@ function finalize(ctx, schema) {
   Object.assign(result, root.def ?? root.schema);
   const defs = ctx.external?.defs ?? {};
   for (const entry of ctx.seen.entries()) {
-    const seen2 = entry[1];
-    if (seen2.def && seen2.defId) {
-      defs[seen2.defId] = seen2.def;
+    const seen = entry[1];
+    if (seen.def && seen.defId) {
+      defs[seen.defId] = seen.def;
     }
   }
   if (ctx.external) ; else {
@@ -110371,9 +110371,9 @@ var recordProcessor = (schema, ctx, _json, params) => {
 var nullableProcessor = (schema, ctx, json2, params) => {
   const def = schema._zod.def;
   const inner = process2(def.innerType, ctx, params);
-  const seen2 = ctx.seen.get(schema);
+  const seen = ctx.seen.get(schema);
   if (ctx.target === "openapi-3.0") {
-    seen2.ref = def.innerType;
+    seen.ref = def.innerType;
     json2.nullable = true;
   } else {
     json2.anyOf = [inner, { type: "null" }];
@@ -110382,29 +110382,29 @@ var nullableProcessor = (schema, ctx, json2, params) => {
 var nonoptionalProcessor = (schema, ctx, _json, params) => {
   const def = schema._zod.def;
   process2(def.innerType, ctx, params);
-  const seen2 = ctx.seen.get(schema);
-  seen2.ref = def.innerType;
+  const seen = ctx.seen.get(schema);
+  seen.ref = def.innerType;
 };
 var defaultProcessor = (schema, ctx, json2, params) => {
   const def = schema._zod.def;
   process2(def.innerType, ctx, params);
-  const seen2 = ctx.seen.get(schema);
-  seen2.ref = def.innerType;
+  const seen = ctx.seen.get(schema);
+  seen.ref = def.innerType;
   json2.default = JSON.parse(JSON.stringify(def.defaultValue));
 };
 var prefaultProcessor = (schema, ctx, json2, params) => {
   const def = schema._zod.def;
   process2(def.innerType, ctx, params);
-  const seen2 = ctx.seen.get(schema);
-  seen2.ref = def.innerType;
+  const seen = ctx.seen.get(schema);
+  seen.ref = def.innerType;
   if (ctx.io === "input")
     json2._prefault = JSON.parse(JSON.stringify(def.defaultValue));
 };
 var catchProcessor = (schema, ctx, json2, params) => {
   const def = schema._zod.def;
   process2(def.innerType, ctx, params);
-  const seen2 = ctx.seen.get(schema);
-  seen2.ref = def.innerType;
+  const seen = ctx.seen.get(schema);
+  seen.ref = def.innerType;
   let catchValue;
   try {
     catchValue = def.catchValue(void 0);
@@ -110417,33 +110417,33 @@ var pipeProcessor = (schema, ctx, _json, params) => {
   const def = schema._zod.def;
   const innerType = ctx.io === "input" ? def.in._zod.def.type === "transform" ? def.out : def.in : def.out;
   process2(innerType, ctx, params);
-  const seen2 = ctx.seen.get(schema);
-  seen2.ref = innerType;
+  const seen = ctx.seen.get(schema);
+  seen.ref = innerType;
 };
 var readonlyProcessor = (schema, ctx, json2, params) => {
   const def = schema._zod.def;
   process2(def.innerType, ctx, params);
-  const seen2 = ctx.seen.get(schema);
-  seen2.ref = def.innerType;
+  const seen = ctx.seen.get(schema);
+  seen.ref = def.innerType;
   json2.readOnly = true;
 };
 var promiseProcessor = (schema, ctx, _json, params) => {
   const def = schema._zod.def;
   process2(def.innerType, ctx, params);
-  const seen2 = ctx.seen.get(schema);
-  seen2.ref = def.innerType;
+  const seen = ctx.seen.get(schema);
+  seen.ref = def.innerType;
 };
 var optionalProcessor = (schema, ctx, _json, params) => {
   const def = schema._zod.def;
   process2(def.innerType, ctx, params);
-  const seen2 = ctx.seen.get(schema);
-  seen2.ref = def.innerType;
+  const seen = ctx.seen.get(schema);
+  seen.ref = def.innerType;
 };
 var lazyProcessor = (schema, ctx, _json, params) => {
   const innerType = schema._zod.innerType;
   process2(innerType, ctx, params);
-  const seen2 = ctx.seen.get(schema);
-  seen2.ref = innerType;
+  const seen = ctx.seen.get(schema);
+  seen.ref = innerType;
 };
 var allProcessors = {
   string: stringProcessor,
@@ -112507,17 +112507,19 @@ config(en_default());
 // src/types.ts
 var AutoPromptSchema = external_exports.object({
   enabled: external_exports.boolean().default(false),
-  intervalSeconds: external_exports.number().int().positive().default(30),
-  maxIterations: external_exports.number().int().positive().default(10),
-  message: external_exports.string().min(1).default("\u8BF7\u540C\u6B65\u5F53\u524D\u8FDB\u5EA6\uFF0C\u5982\u9700\u5E2E\u52A9\u8BF7\u8BF4\u660E")
+  intervalSeconds: external_exports.number().int().positive().max(300).default(30),
+  maxIterations: external_exports.number().int().positive().max(100).default(10),
+  message: external_exports.string().min(1).default("\u8BF7\u540C\u6B65\u5F53\u524D\u8FDB\u5EA6\uFF0C\u5982\u9700\u5E2E\u52A9\u8BF7\u8BF4\u660E"),
+  idleThreshold: external_exports.number().int().min(1).default(2),
+  idleMaxLength: external_exports.number().int().min(10).default(50)
 });
 var FeishuConfigSchema = external_exports.object({
   appId: external_exports.string().min(1, "appId \u4E0D\u80FD\u4E3A\u7A7A"),
   appSecret: external_exports.string().min(1, "appSecret \u4E0D\u80FD\u4E3A\u7A7A"),
-  timeout: external_exports.number().int().positive().default(12e4),
+  timeout: external_exports.number().int().positive().max(6e5).default(12e4),
   thinkingDelay: external_exports.number().int().nonnegative().default(2500),
   logLevel: external_exports.enum(["fatal", "error", "warn", "info", "debug", "trace"]).default("info"),
-  maxHistoryMessages: external_exports.number().int().positive().default(200),
+  maxHistoryMessages: external_exports.number().int().positive().max(500).default(200),
   pollInterval: external_exports.number().int().positive().default(1e3),
   stablePolls: external_exports.number().int().positive().default(3),
   dedupTtl: external_exports.number().int().positive().default(10 * 60 * 1e3),
@@ -112712,37 +112714,40 @@ function buildQuestionCard(request) {
 }
 
 // src/feishu/sender.ts
+async function wrapSendCall(fn, idExtractor = (res) => res?.data?.message_id ?? "") {
+  try {
+    const res = await fn();
+    return { ok: true, messageId: idExtractor(res) };
+  } catch (err) {
+    return { ok: false, error: err instanceof Error ? err.message : String(err) };
+  }
+}
 async function sendTextMessage(client, chatId, text) {
   if (!chatId?.trim()) {
     return { ok: false, error: "No chat_id provided" };
   }
-  try {
-    const res = await client.im.message.create({
+  return wrapSendCall(
+    () => client.im.message.create({
       params: { receive_id_type: "chat_id" },
       data: {
         receive_id: chatId.trim(),
         msg_type: "text",
         content: JSON.stringify({ text })
       }
-    });
-    return { ok: true, messageId: res?.data?.message_id ?? "" };
-  } catch (err) {
-    return { ok: false, error: err instanceof Error ? err.message : String(err) };
-  }
+    })
+  );
 }
 async function updateMessage(client, messageId, text) {
-  try {
-    await client.im.message.update({
+  return wrapSendCall(
+    () => client.im.message.update({
       path: { message_id: messageId },
       data: {
         msg_type: "text",
         content: JSON.stringify({ text })
       }
-    });
-    return { ok: true, messageId };
-  } catch (err) {
-    return { ok: false, error: err instanceof Error ? err.message : String(err) };
-  }
+    }),
+    () => messageId
+  );
 }
 async function deleteMessage(client, messageId) {
   try {
@@ -112754,49 +112759,71 @@ async function sendInteractiveCard(client, chatId, card) {
   if (!chatId?.trim()) {
     return { ok: false, error: "No chat_id provided" };
   }
-  try {
-    const res = await client.im.message.create({
+  return wrapSendCall(
+    () => client.im.message.create({
       params: { receive_id_type: "chat_id" },
       data: {
         receive_id: chatId.trim(),
         msg_type: "interactive",
         content: JSON.stringify(card)
       }
-    });
-    return { ok: true, messageId: res?.data?.message_id ?? "" };
-  } catch (err) {
-    return { ok: false, error: err instanceof Error ? err.message : String(err) };
-  }
+    })
+  );
 }
 async function sendCardMessage(client, chatId, cardId) {
   if (!chatId?.trim()) {
     return { ok: false, error: "No chat_id provided" };
   }
-  try {
-    const res = await client.im.message.create({
+  return wrapSendCall(
+    () => client.im.message.create({
       params: { receive_id_type: "chat_id" },
       data: {
         receive_id: chatId.trim(),
         msg_type: "interactive",
         content: JSON.stringify({ type: "card_kit", data: { card_id: cardId } })
       }
-    });
-    return { ok: true, messageId: res?.data?.message_id ?? "" };
-  } catch (err) {
-    return { ok: false, error: err instanceof Error ? err.message : String(err) };
-  }
+    })
+  );
 }
 
+// src/utils/ttl-map.ts
+var TtlMap = class {
+  constructor(defaultTtlMs) {
+    this.defaultTtlMs = defaultTtlMs;
+  }
+  data = /* @__PURE__ */ new Map();
+  timers = /* @__PURE__ */ new Map();
+  get(key) {
+    return this.data.get(key);
+  }
+  has(key) {
+    return this.data.has(key);
+  }
+  set(key, value, ttlMs) {
+    this.delete(key);
+    this.data.set(key, value);
+    const timer = setTimeout(() => {
+      this.data.delete(key);
+      this.timers.delete(key);
+    }, ttlMs ?? this.defaultTtlMs);
+    timer.unref();
+    this.timers.set(key, timer);
+  }
+  delete(key) {
+    const timer = this.timers.get(key);
+    if (timer) {
+      clearTimeout(timer);
+      this.timers.delete(key);
+    }
+    this.data.delete(key);
+  }
+};
+
 // src/handler/interactive.ts
-var SEEN_TTL_MS = 10 * 60 * 1e3;
-var seenRequestIds = /* @__PURE__ */ new Map();
+var seenIds = new TtlMap(10 * 60 * 1e3);
 function markSeen(requestId) {
-  const now = Date.now();
-  for (const [id, ts] of seenRequestIds) {
-    if (now - ts > SEEN_TTL_MS) seenRequestIds.delete(id);
-  }
-  if (seenRequestIds.has(requestId)) return false;
-  seenRequestIds.set(requestId, now);
+  if (seenIds.has(requestId)) return false;
+  seenIds.set(requestId, true);
   return true;
 }
 function handlePermissionRequested(request, chatId, deps) {
@@ -112864,19 +112891,14 @@ function buildCallbackResponse(action) {
 }
 
 // src/feishu/dedup.ts
-var seenTtlMs = 10 * 60 * 1e3;
-var seen = /* @__PURE__ */ new Map();
+var dedup = new TtlMap(10 * 60 * 1e3);
 function initDedup(ttl) {
-  seenTtlMs = ttl;
+  dedup = new TtlMap(ttl);
 }
 function isDuplicate(messageId) {
-  const now = Date.now();
-  for (const [k, ts] of seen) {
-    if (now - ts > seenTtlMs) seen.delete(k);
-  }
   if (!messageId) return false;
-  if (seen.has(messageId)) return true;
-  seen.set(messageId, now);
+  if (dedup.has(messageId)) return true;
+  dedup.set(messageId, true);
   return false;
 }
 
@@ -113314,57 +113336,24 @@ function emit(sessionId, action) {
 
 // src/handler/event.ts
 var pendingBySession = /* @__PURE__ */ new Map();
-var sessionErrors = /* @__PURE__ */ new Map();
-var sessionErrorTimeouts = /* @__PURE__ */ new Map();
-var SESSION_ERROR_TTL_MS = 3e4;
-var retryAttempts = /* @__PURE__ */ new Map();
-var retryAttemptTimeouts = /* @__PURE__ */ new Map();
+var sessionErrors = new TtlMap(3e4);
+var retryAttempts = new TtlMap(36e5);
 var MAX_RETRY_ATTEMPTS = 2;
-var RETRY_ATTEMPTS_TTL_MS = 36e5;
 function clearRetryAttempts(sessionKey) {
   retryAttempts.delete(sessionKey);
-  const timer = retryAttemptTimeouts.get(sessionKey);
-  if (timer) {
-    clearTimeout(timer);
-    retryAttemptTimeouts.delete(sessionKey);
-  }
 }
 function getRetryAttempts(sessionKey) {
   return retryAttempts.get(sessionKey) ?? 0;
 }
 function setRetryAttempts(sessionKey, count) {
   retryAttempts.set(sessionKey, count);
-  const existing = retryAttemptTimeouts.get(sessionKey);
-  if (existing) clearTimeout(existing);
-  const timeoutId = setTimeout(() => {
-    retryAttempts.delete(sessionKey);
-    retryAttemptTimeouts.delete(sessionKey);
-  }, RETRY_ATTEMPTS_TTL_MS);
-  retryAttemptTimeouts.set(sessionKey, timeoutId);
 }
 function getSessionError(sessionId) {
   return sessionErrors.get(sessionId);
 }
 function clearSessionError(sessionId) {
-  const timer = sessionErrorTimeouts.get(sessionId);
-  if (timer) {
-    clearTimeout(timer);
-    sessionErrorTimeouts.delete(sessionId);
-  }
   sessionErrors.delete(sessionId);
 }
-function setSessionError(sessionId, message, fields) {
-  const existing = sessionErrorTimeouts.get(sessionId);
-  if (existing) {
-    clearTimeout(existing);
-  }
-  sessionErrors.set(sessionId, { message, fields });
-  const timeoutId = setTimeout(() => {
-    sessionErrors.delete(sessionId);
-    sessionErrorTimeouts.delete(sessionId);
-  }, SESSION_ERROR_TTL_MS);
-  sessionErrorTimeouts.set(sessionId, timeoutId);
-}
 function registerPending(sessionId, payload) {
   pendingBySession.set(sessionId, { ...payload, textBuffer: "", expectedMessageId: void 0 });
 }
@@ -113415,111 +113404,115 @@ async function handleEvent(event, deps) {
   switch (event.type) {
     case "message.part.updated": {
       const part = event.properties.part;
-      if (!part) break;
-      const sessionId = part.sessionID;
-      if (!sessionId) break;
-      const payload = pendingBySession.get(sessionId);
+      if (!part?.sessionID) break;
+      const payload = pendingBySession.get(part.sessionID);
       if (!payload) break;
-      const messageId = part.messageID;
-      if (messageId) {
-        if (!payload.expectedMessageId) {
-          payload.expectedMessageId = messageId;
-        } else if (payload.expectedMessageId !== messageId) {
-          break;
-        }
-      } else if (payload.expectedMessageId) {
-        break;
-      }
-      const partSessionId = part.sessionID;
-      if (part.type === "tool") {
-        const p = part;
-        const toolName = String(p.toolName ?? p.name ?? "unknown");
-        const callID = String(p.toolCallID ?? p.id ?? "");
-        const hasError = p.error !== void 0 && p.error !== null;
-        const rawState = p.state != null ? String(p.state) : hasError ? "error" : "running";
-        const toolState = rawState === "completed" || rawState === "error" ? rawState : "running";
-        if (partSessionId) {
-          emit(partSessionId, {
-            type: "tool-state-changed",
-            sessionId: partSessionId,
-            callID,
-            tool: toolName,
-            state: toolState
-          });
-        }
-        break;
-      }
-      const delta = event.properties.delta;
-      if (delta) {
-        payload.textBuffer += delta;
-      } else {
-        const fullText = extractPartText(part);
-        if (fullText) {
-          payload.textBuffer = fullText;
-        }
-      }
-      if (payload.textBuffer) {
-        const res = await updateMessage(payload.feishuClient, payload.placeholderId, payload.textBuffer.trim());
-        if (!res.ok) ;
-      }
-      if (partSessionId) {
-        emit(partSessionId, {
-          type: "text-updated",
-          sessionId: partSessionId,
-          messageId: part.messageID,
-          delta: delta ?? void 0,
-          fullText: payload.textBuffer
-        });
-      }
+      await handleMessagePartUpdated(event, part, payload);
       break;
     }
-    case "session.error": {
-      const props = event.properties;
-      const sessionId = props.sessionID;
-      if (!sessionId) break;
-      const error48 = props.error;
-      let errMsg;
-      if (typeof error48 === "string") {
-        errMsg = error48;
-      } else if (error48 && typeof error48 === "object") {
-        const e = error48;
-        const rawDataMsg = e.data && typeof e.data === "object" && "message" in e.data ? e.data.message : void 0;
-        const dataMsg = rawDataMsg != null ? String(rawDataMsg) : void 0;
-        errMsg = String(e.message ?? dataMsg ?? e.type ?? e.name ?? "An unexpected error occurred");
-      } else {
-        errMsg = String(error48);
-      }
-      const fields = extractErrorFields(error48);
-      deps.log("warn", "\u6536\u5230 session.error \u4E8B\u4EF6", { sessionId, errMsg });
-      setSessionError(sessionId, errMsg, fields);
+    case "session.error":
+      handleSessionErrorEvent(event, deps);
       break;
-    }
-    default: {
-      const evtType = event.type;
-      const evtProps = event.properties ?? {};
-      const evtSessionId = evtProps.sessionID;
-      if (evtType === "permission.asked" && evtSessionId) {
-        emit(evtSessionId, {
-          type: "permission-requested",
-          sessionId: evtSessionId,
-          request: evtProps
-        });
-        deps.log("info", "permission.asked \u4E8B\u4EF6\u5DF2\u5206\u53D1", { sessionId: evtSessionId });
-      } else if (evtType === "question.asked" && evtSessionId) {
-        emit(evtSessionId, {
-          type: "question-requested",
-          sessionId: evtSessionId,
-          request: evtProps
-        });
-        deps.log("info", "question.asked \u4E8B\u4EF6\u5DF2\u5206\u53D1", { sessionId: evtSessionId });
-      } else if (evtType === "session.idle" && evtSessionId) {
-        emit(evtSessionId, {
-          type: "session-idle",
-          sessionId: evtSessionId
-        });
-      }
+    default:
+      handleV2Event(event, deps);
       break;
+  }
+}
+async function handleMessagePartUpdated(event, part, payload) {
+  const messageId = part.messageID;
+  if (messageId) {
+    if (!payload.expectedMessageId) {
+      payload.expectedMessageId = messageId;
+    } else if (payload.expectedMessageId !== messageId) {
+      return;
+    }
+  } else if (payload.expectedMessageId) {
+    return;
+  }
+  const partSessionId = part.sessionID;
+  if (part.type === "tool") {
+    const p = part;
+    const toolName = String(p.toolName ?? p.name ?? "unknown");
+    const callID = String(p.toolCallID ?? p.id ?? "");
+    const hasError = p.error !== void 0 && p.error !== null;
+    const rawState = p.state != null ? String(p.state) : hasError ? "error" : "running";
+    const toolState = rawState === "completed" || rawState === "error" ? rawState : "running";
+    if (partSessionId) {
+      emit(partSessionId, {
+        type: "tool-state-changed",
+        sessionId: partSessionId,
+        callID,
+        tool: toolName,
+        state: toolState
+      });
     }
+    return;
+  }
+  const delta = event.properties.delta;
+  if (delta) {
+    payload.textBuffer += delta;
+  } else {
+    const fullText = extractPartText(part);
+    if (fullText) {
+      payload.textBuffer = fullText;
+    }
+  }
+  if (payload.textBuffer) {
+    await updateMessage(payload.feishuClient, payload.placeholderId, payload.textBuffer.trim());
+  }
+  if (partSessionId) {
+    emit(partSessionId, {
+      type: "text-updated",
+      sessionId: partSessionId,
+      messageId: part.messageID,
+      delta: delta ?? void 0,
+      fullText: payload.textBuffer
+    });
+  }
+}
+function handleSessionErrorEvent(event, deps) {
+  const props = event.properties;
+  const sessionId = props.sessionID;
+  if (!sessionId) return;
+  const error48 = props.error;
+  let errMsg;
+  if (typeof error48 === "string") {
+    errMsg = error48;
+  } else if (error48 && typeof error48 === "object") {
+    const e = error48;
+    const asStr = (v) => typeof v === "string" && v.trim().length > 0 ? v : void 0;
+    const rawDataMsg = e.data && typeof e.data === "object" && "message" in e.data ? e.data.message : void 0;
+    errMsg = asStr(e.message) ?? asStr(rawDataMsg) ?? asStr(e.type) ?? asStr(e.name) ?? "An unexpected error occurred";
+  } else {
+    errMsg = String(error48);
+  }
+  const fields = extractErrorFields(error48);
+  deps.log("warn", "\u6536\u5230 session.error \u4E8B\u4EF6", { sessionId, errMsg });
+  sessionErrors.set(sessionId, { message: errMsg, fields });
+}
+function handleV2Event(event, deps) {
+  const evtType = event.type;
+  const evtProps = event.properties ?? {};
+  const evtSessionId = evtProps.sessionID;
+  if (evtType === "permission.asked" && evtSessionId) {
+    emit(evtSessionId, {
+      type: "permission-requested",
+      sessionId: evtSessionId,
+      request: evtProps
+    });
+    deps.log("info", "permission.asked \u4E8B\u4EF6\u5DF2\u5206\u53D1", { sessionId: evtSessionId });
+  } else if (evtType === "question.asked" && evtSessionId) {
+    emit(evtSessionId, {
+      type: "question-requested",
+      sessionId: evtSessionId,
+      request: evtProps
+    });
+    deps.log("info", "question.asked \u4E8B\u4EF6\u5DF2\u5206\u53D1", { sessionId: evtSessionId });
+  } else if (evtType === "session.idle" && evtSessionId) {
+    emit(evtSessionId, {
+      type: "session-idle",
+      sessionId: evtSessionId
+    });
   }
 }
 function extractPartText(part) {
@@ -113530,6 +113523,128 @@ function extractPartText(part) {
   return "";
 }
 
+// src/handler/error-recovery.ts
+var SessionErrorDetected = class extends Error {
+  constructor(sessionError) {
+    super(sessionError.message);
+    this.sessionError = sessionError;
+    this.name = "SessionErrorDetected";
+  }
+};
+async function getGlobalDefaultModel(client, directory) {
+  const query = directory ? { directory } : void 0;
+  const { data: config2 } = await client.config.get({ query });
+  const model = config2?.model;
+  if (!model || !model.includes("/")) return void 0;
+  const slash = model.indexOf("/");
+  const providerID = model.slice(0, slash).trim();
+  const modelID = model.slice(slash + 1).trim();
+  if (!providerID || !modelID) return void 0;
+  return { providerID, modelID };
+}
+function extractSessionError(err, sessionId) {
+  const result = err instanceof SessionErrorDetected ? err.sessionError : getSessionError(sessionId);
+  clearSessionError(sessionId);
+  return result;
+}
+async function tryModelRecovery(params) {
+  const {
+    sessionError,
+    sessionId,
+    sessionKey,
+    client,
+    directory,
+    parts,
+    timeout,
+    pollInterval,
+    stablePolls,
+    query,
+    signal,
+    log,
+    poll
+  } = params;
+  log("info", "\u9519\u8BEF\u5B57\u6BB5\u68C0\u67E5", {
+    sessionKey,
+    fields: sessionError.fields,
+    isModel: isModelError(sessionError.fields)
+  });
+  if (!isModelError(sessionError.fields)) {
+    return { recovered: false, sessionError };
+  }
+  const attempts = getRetryAttempts(sessionKey);
+  if (attempts >= MAX_RETRY_ATTEMPTS) {
+    log("warn", "\u5DF2\u8FBE\u91CD\u8BD5\u4E0A\u9650\uFF0C\u653E\u5F03\u6062\u590D", { sessionKey, attempts });
+    return { recovered: false, sessionError };
+  }
+  try {
+    let modelOverride;
+    try {
+      modelOverride = await getGlobalDefaultModel(client, directory);
+    } catch (configErr) {
+      log("warn", "\u8BFB\u53D6\u5168\u5C40\u6A21\u578B\u914D\u7F6E\u5931\u8D25", {
+        sessionKey,
+        error: configErr instanceof Error ? configErr.message : String(configErr)
+      });
+    }
+    if (!modelOverride) {
+      log("warn", "\u5168\u5C40\u9ED8\u8BA4\u6A21\u578B\u672A\u914D\u7F6E\uFF0C\u653E\u5F03\u6062\u590D", { sessionKey });
+      return { recovered: false, sessionError };
+    }
+    setRetryAttempts(sessionKey, attempts + 1);
+    log("info", "\u4F7F\u7528\u5168\u5C40\u9ED8\u8BA4\u6A21\u578B\u6062\u590D", {
+      sessionKey,
+      providerID: modelOverride.providerID,
+      modelID: modelOverride.modelID
+    });
+    clearSessionError(sessionId);
+    await client.session.promptAsync({
+      path: { id: sessionId },
+      query,
+      body: { parts: [...parts], model: modelOverride }
+    });
+    const finalText = await poll(client, sessionId, {
+      timeout,
+      pollInterval,
+      stablePolls,
+      query,
+      signal
+    });
+    log("info", "\u6A21\u578B\u6062\u590D\u540E\u54CD\u5E94\u5B8C\u6210", {
+      sessionKey,
+      sessionId,
+      output: finalText || "(empty)"
+    });
+    clearRetryAttempts(sessionKey);
+    log("info", "\u6A21\u578B\u4E0D\u517C\u5BB9\u6062\u590D\u6210\u529F", {
+      sessionId,
+      sessionKey,
+      model: `${modelOverride.providerID}/${modelOverride.modelID}`,
+      attempt: attempts + 1
+    });
+    return { recovered: true, text: finalText };
+  } catch (recoveryErr) {
+    if (recoveryErr instanceof Error && recoveryErr.name === "AbortError") {
+      throw recoveryErr;
+    }
+    const errMsg = recoveryErr instanceof Error ? recoveryErr.message : String(recoveryErr);
+    let updatedError;
+    if (recoveryErr instanceof SessionErrorDetected) {
+      updatedError = recoveryErr.sessionError;
+      clearSessionError(sessionId);
+    } else {
+      const sseError = getSessionError(sessionId);
+      if (sseError) {
+        updatedError = sseError;
+        clearSessionError(sessionId);
+      } else {
+        updatedError = { message: errMsg, fields: [] };
+      }
+    }
+    log("error", "\u6A21\u578B\u6062\u590D\u5931\u8D25", { sessionId, sessionKey, error: errMsg });
+    return { recovered: false, sessionError: updatedError };
+  }
+}
+
 // src/session.ts
 var SESSION_KEY_PREFIX = "feishu";
 var TITLE_PREFIX = "Feishu";
@@ -113762,7 +113877,6 @@ var StreamingCard = class {
 };
 
 // src/handler/chat.ts
-var activeAutoPrompts = /* @__PURE__ */ new Map();
 async function finalizeReply(streamingCard, feishuClient, chatId, placeholderId, text) {
   if (streamingCard) {
     await streamingCard.close(text);
@@ -113780,19 +113894,13 @@ async function abortCleanup(streamingCard, feishuClient, placeholderId) {
 }
 async function handleChat(ctx, deps, signal) {
   const { content, chatId, chatType, senderId, shouldReply, messageType, rawContent, messageId } = ctx;
-  if (!content.trim() && messageType === "text") return;
+  if (!content.trim() && messageType === "text") return void 0;
   const { config: config2, client, feishuClient, log, directory } = deps;
   const query = directory ? { directory } : void 0;
   const sessionKey = buildSessionKey(chatType, chatType === "p2p" ? senderId : chatId);
-  const existing = activeAutoPrompts.get(sessionKey);
-  if (existing) {
-    existing.abort();
-    activeAutoPrompts.delete(sessionKey);
-    log("info", "\u7528\u6237\u4ECB\u5165\uFF0C\u81EA\u52A8\u63D0\u793A\u5DF2\u4E2D\u65AD", { sessionKey });
-  }
   const session = await getOrCreateSession(client, sessionKey, directory);
   const parts = await buildPromptParts(feishuClient, messageId, messageType, rawContent, content, chatType, senderId, log);
-  if (!parts.length) return;
+  if (!parts.length) return void 0;
   log("info", "\u6536\u5230\u7528\u6237\u6D88\u606F", {
     sessionKey,
     sessionId: session.id,
@@ -113816,7 +113924,7 @@ async function handleChat(ctx, deps, signal) {
         error: err instanceof Error ? err.message : String(err)
       });
     }
-    return;
+    return void 0;
   }
   const timeout = config2.timeout;
   const thinkingDelay = config2.thinkingDelay;
@@ -113857,46 +113965,6 @@ async function handleChat(ctx, deps, signal) {
       });
     }
   }, thinkingDelay) : null;
-  async function runAutoPromptLoop(activeId) {
-    const { autoPrompt } = config2;
-    if (!autoPrompt.enabled || !shouldReply) return;
-    const ac = new AbortController();
-    activeAutoPrompts.set(sessionKey, ac);
-    log("info", "\u542F\u52A8\u81EA\u52A8\u63D0\u793A\u5FAA\u73AF", { sessionKey, maxIterations: autoPrompt.maxIterations });
-    try {
-      for (let i = 0; i < autoPrompt.maxIterations; i++) {
-        await abortableSleep(autoPrompt.intervalSeconds * 1e3, ac.signal);
-        log("info", "\u53D1\u9001\u81EA\u52A8\u63D0\u793A", { sessionKey, iteration: i + 1 });
-        clearSessionError(activeId);
-        await client.session.prompt({
-          path: { id: activeId },
-          query,
-          body: { parts: [{ type: "text", text: autoPrompt.message }] }
-        });
-        const text = await pollForResponse(client, activeId, { timeout, pollInterval, stablePolls, query, signal: ac.signal });
-        if (text) {
-          log("info", "\u81EA\u52A8\u63D0\u793A\u54CD\u5E94", {
-            sessionKey,
-            iteration: i + 1,
-            output: text
-          });
-          await sendTextMessage(feishuClient, chatId, text);
-        }
-      }
-      log("info", "\u81EA\u52A8\u63D0\u793A\u5FAA\u73AF\u7ED3\u675F\uFF08\u8FBE\u5230\u6700\u5927\u6B21\u6570\uFF09", { sessionKey });
-    } catch (loopErr) {
-      if (loopErr.name === "AbortError") {
-        log("info", "\u81EA\u52A8\u63D0\u793A\u5FAA\u73AF\u88AB\u4E2D\u65AD", { sessionKey });
-      } else {
-        log("error", "\u81EA\u52A8\u63D0\u793A\u5FAA\u73AF\u5F02\u5E38", {
-          sessionKey,
-          error: loopErr instanceof Error ? loopErr.message : String(loopErr)
-        });
-      }
-    } finally {
-      activeAutoPrompts.delete(sessionKey);
-    }
-  }
   let cardUnsub;
   {
     const card = streamingCard;
@@ -113942,113 +114010,60 @@ async function handleChat(ctx, deps, signal) {
     });
     clearRetryAttempts(sessionKey);
     await finalizeReply(streamingCard, feishuClient, chatId, placeholderId, finalText || "\u26A0\uFE0F \u54CD\u5E94\u8D85\u65F6");
-    await runAutoPromptLoop(session.id);
+    if (config2.autoPrompt.enabled && shouldReply) {
+      return { sessionId: session.id, sessionKey, chatId, deps };
+    }
+    return void 0;
   } catch (err) {
     if (err instanceof Error && err.name === "AbortError") {
       log("info", "\u5904\u7406\u88AB\u4E2D\u65AD", { sessionKey, sessionId: session.id });
       await abortCleanup(streamingCard, feishuClient, placeholderId);
-      return;
-    }
-    let sessionError;
-    if (err instanceof SessionErrorDetected) {
-      sessionError = err.sessionError;
-      clearSessionError(session.id);
-    } else {
-      sessionError = getSessionError(session.id);
-      clearSessionError(session.id);
+      return void 0;
     }
+    const sessionError = extractSessionError(err, session.id);
+    let displayError = sessionError;
     if (sessionError) {
-      log("info", "\u9519\u8BEF\u5B57\u6BB5\u68C0\u67E5", {
-        sessionKey,
-        fields: sessionError.fields,
-        isModel: isModelError(sessionError.fields)
-      });
-    }
-    if (sessionError && isModelError(sessionError.fields)) {
-      const attempts = getRetryAttempts(sessionKey);
-      if (attempts < MAX_RETRY_ATTEMPTS) {
-        try {
-          let modelOverride;
-          try {
-            modelOverride = await getGlobalDefaultModel(client, directory);
-          } catch (configErr) {
-            log("warn", "\u8BFB\u53D6\u5168\u5C40\u6A21\u578B\u914D\u7F6E\u5931\u8D25", {
-              sessionKey,
-              error: configErr instanceof Error ? configErr.message : String(configErr)
-            });
-          }
-          if (!modelOverride) {
-            log("warn", "\u5168\u5C40\u9ED8\u8BA4\u6A21\u578B\u672A\u914D\u7F6E\uFF0C\u653E\u5F03\u6062\u590D", { sessionKey });
-          } else {
-            setRetryAttempts(sessionKey, attempts + 1);
-            log("info", "\u4F7F\u7528\u5168\u5C40\u9ED8\u8BA4\u6A21\u578B\u6062\u590D", {
-              sessionKey,
-              providerID: modelOverride.providerID,
-              modelID: modelOverride.modelID
-            });
-            clearSessionError(session.id);
-            await client.session.promptAsync({
-              path: { id: session.id },
-              query,
-              body: { ...baseBody, model: modelOverride }
-            });
-            const finalText = await pollForResponse(client, session.id, { timeout, pollInterval, stablePolls, query, signal });
-            log("info", "\u6A21\u578B\u6062\u590D\u540E\u54CD\u5E94\u5B8C\u6210", {
-              sessionKey,
-              sessionId: session.id,
-              output: finalText || "(empty)"
-            });
-            clearRetryAttempts(sessionKey);
-            await finalizeReply(streamingCard, feishuClient, chatId, placeholderId, finalText || "\u26A0\uFE0F \u54CD\u5E94\u8D85\u65F6");
-            log("info", "\u6A21\u578B\u4E0D\u517C\u5BB9\u6062\u590D\u6210\u529F", {
-              sessionId: session.id,
-              sessionKey,
-              model: `${modelOverride.providerID}/${modelOverride.modelID}`,
-              attempt: attempts + 1
-            });
-            await runAutoPromptLoop(session.id);
-            return;
-          }
-        } catch (recoveryErr) {
-          if (recoveryErr instanceof Error && recoveryErr.name === "AbortError") {
-            log("info", "\u6A21\u578B\u6062\u590D\u88AB\u4E2D\u65AD", { sessionKey });
-            await abortCleanup(streamingCard, feishuClient, placeholderId);
-            return;
-          }
-          const errMsg = recoveryErr instanceof Error ? recoveryErr.message : String(recoveryErr);
-          if (recoveryErr instanceof SessionErrorDetected) {
-            sessionError = recoveryErr.sessionError;
-            clearSessionError(session.id);
-          } else {
-            const sseError = getSessionError(session.id);
-            if (sseError) {
-              sessionError = sseError;
-              clearSessionError(session.id);
-            } else {
-              sessionError = { message: errMsg, fields: [] };
-            }
-          }
-          log("error", "\u6A21\u578B\u6062\u590D\u5931\u8D25", {
-            sessionId: session.id,
-            sessionKey,
-            error: errMsg
-          });
-        }
-      } else {
-        log("warn", "\u5DF2\u8FBE\u91CD\u8BD5\u4E0A\u9650\uFF0C\u653E\u5F03\u6062\u590D", {
+      try {
+        const recovery = await tryModelRecovery({
+          sessionError,
+          sessionId: session.id,
           sessionKey,
-          attempts
+          client,
+          directory,
+          parts,
+          timeout,
+          pollInterval,
+          stablePolls,
+          query,
+          signal,
+          log,
+          poll: pollForResponse
         });
+        if (recovery.recovered) {
+          await finalizeReply(streamingCard, feishuClient, chatId, placeholderId, recovery.text || "\u26A0\uFE0F \u54CD\u5E94\u8D85\u65F6");
+          if (config2.autoPrompt.enabled && shouldReply) {
+            return { sessionId: session.id, sessionKey, chatId, deps };
+          }
+          return void 0;
+        }
+        displayError = recovery.sessionError;
+      } catch (abortErr) {
+        if (abortErr instanceof Error && abortErr.name === "AbortError") {
+          log("info", "\u6A21\u578B\u6062\u590D\u88AB\u4E2D\u65AD", { sessionKey });
+          await abortCleanup(streamingCard, feishuClient, placeholderId);
+          return void 0;
+        }
+        throw abortErr;
       }
     }
     const thrownError = err instanceof Error ? err.message : String(err);
-    const errorMessage = sessionError?.message || thrownError;
+    const errorMessage = displayError?.message || thrownError;
     log("error", "\u5BF9\u8BDD\u5904\u7406\u5931\u8D25", {
       sessionId: session.id,
       sessionKey,
       chatType,
       error: thrownError,
-      ...sessionError ? { sessionError: sessionError.message } : {}
+      ...displayError ? { sessionError: displayError.message } : {}
     });
     await finalizeReply(streamingCard, feishuClient, chatId, placeholderId, "\u274C " + errorMessage);
   } finally {
@@ -114058,17 +114073,6 @@ async function handleChat(ctx, deps, signal) {
     unregisterPending(activeSessionId);
   }
 }
-async function getGlobalDefaultModel(client, directory) {
-  const query = directory ? { directory } : void 0;
-  const { data: config2 } = await client.config.get({ query });
-  const model = config2?.model;
-  if (!model || !model.includes("/")) return void 0;
-  const slash = model.indexOf("/");
-  const providerID = model.slice(0, slash).trim();
-  const modelID = model.slice(slash + 1).trim();
-  if (!providerID || !modelID) return void 0;
-  return { providerID, modelID };
-}
 async function buildPromptParts(feishuClient, messageId, messageType, rawContent, textContent, chatType, senderId, log) {
   if (messageType === "text") {
     let promptText = textContent;
@@ -114083,13 +114087,6 @@ async function buildPromptParts(feishuClient, messageId, messageType, rawContent
   }
   return parts;
 }
-var SessionErrorDetected = class extends Error {
-  constructor(sessionError) {
-    super(sessionError.message);
-    this.sessionError = sessionError;
-    this.name = "SessionErrorDetected";
-  }
-};
 async function pollForResponse(client, sessionId, opts) {
   const { timeout, pollInterval, stablePolls, query, signal } = opts;
   const start = Date.now();
@@ -114145,6 +114142,43 @@ async function replyOrUpdate(feishuClient, chatId, placeholderId, text) {
     await sendTextMessage(feishuClient, chatId, text);
   }
 }
+var idlePatterns = [
+  /^(无|没有)(任务|变化|进行中)/,
+  /空闲|闲置|等待(指令|中|新|你)/,
+  /随时可(开始|开始新)/,
+  /等你指令/
+];
+function isIdleResponse(text, maxLength = 50) {
+  if (text.length >= maxLength) return false;
+  return idlePatterns.some((p) => p.test(text));
+}
+async function runOneAutoPromptIteration(apCtx, iteration, signal) {
+  const { sessionId, chatId, deps } = apCtx;
+  const { config: config2, client, feishuClient, log, directory } = deps;
+  const query = directory ? { directory } : void 0;
+  const { autoPrompt, timeout, pollInterval, stablePolls } = config2;
+  log("info", "\u53D1\u9001\u81EA\u52A8\u63D0\u793A", { sessionKey: apCtx.sessionKey, iteration });
+  clearSessionError(sessionId);
+  await client.session.promptAsync({
+    path: { id: sessionId },
+    query,
+    body: { parts: [{ type: "text", text: autoPrompt.message }] }
+  });
+  const text = await pollForResponse(client, sessionId, {
+    timeout,
+    pollInterval,
+    stablePolls,
+    query,
+    signal
+  });
+  if (!text) return { text: null, isIdle: false };
+  const idle = isIdleResponse(text, autoPrompt.idleMaxLength);
+  if (!idle) {
+    log("info", "\u81EA\u52A8\u63D0\u793A\u54CD\u5E94", { sessionKey: apCtx.sessionKey, iteration, output: text });
+    await sendTextMessage(feishuClient, chatId, text);
+  }
+  return { text, isIdle: idle };
+}
 function abortableSleep(ms, signal) {
   return new Promise((resolve, reject) => {
     if (signal.aborted) {
@@ -114173,6 +114207,7 @@ function extractLastAssistantText(messages) {
 }
 
 // src/handler/session-queue.ts
+var QUEUE_MONITOR_INTERVAL_MS = 200;
 var states = /* @__PURE__ */ new Map();
 function getOrCreateState(sessionKey) {
   const existing = states.get(sessionKey);
@@ -114191,6 +114226,9 @@ function cleanupStateIfIdle(sessionKey, state) {
     states.delete(sessionKey);
   }
 }
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
 async function enqueueMessage(ctx, deps) {
   if (!ctx.shouldReply) {
     await handleChat(ctx, deps);
@@ -114221,7 +114259,18 @@ async function handleP2PMessage(sessionKey, ctx, deps) {
   const controller = new AbortController();
   state.controller = controller;
   state.processing = true;
-  const task = processMessage(ctx, deps, controller.signal).finally(() => {
+  const task = (async () => {
+    const apCtx = await processMessage(ctx, deps, controller.signal);
+    if (apCtx) {
+      await runP2PAutoPrompt(apCtx, controller.signal);
+    }
+  })().catch((err) => {
+    if (err instanceof Error && err.name === "AbortError") return;
+    deps.log("error", "P2P \u6D88\u606F\u6216\u81EA\u52A8\u63D0\u793A\u5904\u7406\u5931\u8D25", {
+      sessionKey,
+      error: err instanceof Error ? err.message : String(err)
+    });
+  }).finally(() => {
     state.processing = false;
     state.controller = null;
     state.currentTask = null;
@@ -114230,6 +114279,31 @@ async function handleP2PMessage(sessionKey, ctx, deps) {
   state.currentTask = task;
   await task;
 }
+async function runP2PAutoPrompt(apCtx, signal) {
+  const { autoPrompt } = apCtx.deps.config;
+  if (!autoPrompt.enabled) return;
+  let idleCount = 0;
+  for (let i = 0; i < autoPrompt.maxIterations; i++) {
+    await abortableSleep(autoPrompt.intervalSeconds * 1e3, signal);
+    const result = await runOneAutoPromptIteration(apCtx, i + 1, signal);
+    if (result.isIdle) {
+      idleCount++;
+      if (idleCount >= autoPrompt.idleThreshold) {
+        apCtx.deps.log("info", "P2P \u81EA\u52A8\u63D0\u793A\u5FAA\u73AF\u7ED3\u675F\uFF08\u68C0\u6D4B\u5230\u7A7A\u95F2\uFF09", {
+          sessionKey: apCtx.sessionKey,
+          iteration: i + 1,
+          idleCount
+        });
+        return;
+      }
+    } else {
+      idleCount = 0;
+    }
+  }
+  apCtx.deps.log("info", "P2P \u81EA\u52A8\u63D0\u793A\u5FAA\u73AF\u7ED3\u675F\uFF08\u8FBE\u5230\u6700\u5927\u6B21\u6570\uFF09", {
+    sessionKey: apCtx.sessionKey
+  });
+}
 async function handleGroupMessage(sessionKey, ctx, deps) {
   const state = getOrCreateState(sessionKey);
   state.queue.push({ ctx, deps });
@@ -114238,21 +114312,81 @@ async function handleGroupMessage(sessionKey, ctx, deps) {
 }
 async function drainLoop(sessionKey, state) {
   state.processing = true;
+  let autoPromptCtx;
+  let idleCount = 0;
+  let autoPromptIteration = 0;
   try {
-    while (state.queue.length > 0) {
-      const item = state.queue.shift();
-      if (!item) break;
-      const controller = new AbortController();
-      state.controller = controller;
+    while (true) {
+      if (state.queue.length > 0) {
+        const item = state.queue.shift();
+        const controller = new AbortController();
+        state.controller = controller;
+        try {
+          autoPromptCtx = await processMessage(item.ctx, item.deps, controller.signal);
+          idleCount = 0;
+          autoPromptIteration = 0;
+        } catch (err) {
+          item.deps.log("error", "\u7FA4\u804A\u961F\u5217\u6D88\u606F\u5904\u7406\u5931\u8D25", {
+            sessionKey,
+            error: err instanceof Error ? err.message : String(err)
+          });
+        } finally {
+          state.controller = null;
+        }
+        continue;
+      }
+      if (!autoPromptCtx) break;
+      const { autoPrompt } = autoPromptCtx.deps.config;
+      if (!autoPrompt.enabled) break;
+      if (autoPromptIteration >= autoPrompt.maxIterations) {
+        autoPromptCtx.deps.log("info", "\u81EA\u52A8\u63D0\u793A\u5FAA\u73AF\u7ED3\u675F\uFF08\u8FBE\u5230\u6700\u5927\u6B21\u6570\uFF09", { sessionKey });
+        break;
+      }
+      const intervalSeconds = autoPrompt.intervalSeconds;
+      let interrupted = false;
+      for (let s = 0; s < intervalSeconds; s++) {
+        await sleep(1e3);
+        if (state.queue.length > 0) {
+          interrupted = true;
+          break;
+        }
+      }
+      if (interrupted) continue;
+      const autoPromptController = new AbortController();
+      const monitor = setInterval(() => {
+        if (state.queue.length > 0) autoPromptController.abort();
+      }, QUEUE_MONITOR_INTERVAL_MS);
       try {
-        await processMessage(item.ctx, item.deps, controller.signal);
+        const result = await runOneAutoPromptIteration(
+          autoPromptCtx,
+          autoPromptIteration + 1,
+          autoPromptController.signal
+        );
+        autoPromptIteration++;
+        if (result.isIdle) {
+          idleCount++;
+          if (idleCount >= autoPrompt.idleThreshold) {
+            autoPromptCtx.deps.log("info", "\u81EA\u52A8\u63D0\u793A\u5FAA\u73AF\u7ED3\u675F\uFF08\u68C0\u6D4B\u5230\u7A7A\u95F2\uFF09", {
+              sessionKey,
+              iteration: autoPromptIteration,
+              idleCount
+            });
+            break;
+          }
+        } else {
+          idleCount = 0;
+        }
       } catch (err) {
-        item.deps.log("error", "\u7FA4\u804A\u961F\u5217\u6D88\u606F\u5904\u7406\u5931\u8D25", {
+        if (err instanceof Error && err.name === "AbortError") {
+          continue;
+        }
+        autoPromptCtx.deps.log("error", "\u81EA\u52A8\u63D0\u793A\u8FED\u4EE3\u5F02\u5E38", {
           sessionKey,
           error: err instanceof Error ? err.message : String(err)
         });
+        break;
       } finally {
-        state.controller = null;
+        clearInterval(monitor);
       }
     }
   } finally {
@@ -114261,7 +114395,7 @@ async function drainLoop(sessionKey, state) {
   }
 }
 async function processMessage(ctx, deps, signal) {
-  await handleChat(ctx, deps, signal);
+  return handleChat(ctx, deps, signal);
 }
 async function abortServerSession(sessionKey, deps) {
   const { client, log, directory } = deps;
@@ -114384,21 +114518,9 @@ var FeishuPlugin = async (ctx) => {
     });
   };
   const configPath = join(homedir(), ".config", "opencode", "plugins", "feishu.json");
-  if (!existsSync(configPath)) {
-    throw new Error(
-      `\u7F3A\u5C11\u98DE\u4E66\u914D\u7F6E\u6587\u4EF6\uFF1A\u8BF7\u521B\u5EFA ${configPath}\uFF0C\u5185\u5BB9\u4E3A {"appId":"cli_xxx","appSecret":"xxx"}`
-    );
-  }
   let resolvedConfig;
   try {
-    const raw = resolveEnvPlaceholders(
-      JSON.parse(readFileSync(configPath, "utf-8"))
-    );
-    const parsed = FeishuConfigSchema.parse(raw);
-    resolvedConfig = {
-      ...parsed,
-      directory: expandDirectoryPath(parsed.directory ?? ctx.directory ?? "")
-    };
+    resolvedConfig = loadAndValidateConfig(configPath, ctx.directory ?? "");
   } catch (e) {
     if (e instanceof external_exports.ZodError) {
       const details = e.issues.map((i) => `  - ${i.path.join(".")}: ${i.message}`).join("\n");
@@ -114477,6 +114599,14 @@ ${details}`);
   };
   return hooks;
 };
+function loadAndValidateConfig(configPath, ctxDirectory) {
+  if (!existsSync(configPath)) {
+    throw new Error(`\u7F3A\u5C11\u98DE\u4E66\u914D\u7F6E\u6587\u4EF6\uFF1A\u8BF7\u521B\u5EFA ${configPath}\uFF0C\u5185\u5BB9\u4E3A {"appId":"cli_xxx","appSecret":"xxx"}`);
+  }
+  const raw = resolveEnvPlaceholders(JSON.parse(readFileSync(configPath, "utf-8")));
+  const parsed = FeishuConfigSchema.parse(raw);
+  return { ...parsed, directory: expandDirectoryPath(parsed.directory ?? ctxDirectory ?? "") };
+}
 function expandDirectoryPath(dir) {
   if (!dir) return dir;
   if (dir.startsWith("~")) {