opencode-feishu 0.7.6 → 0.7.10

package/dist/index.js

@@ -99176,157 +99176,35 @@ async function updateMessage(client, messageId, text2) {
   }
 }
 
-// src/session.ts
-var SESSION_KEY_PREFIX = "feishu";
-var TITLE_PREFIX = "Feishu";
-var sessionCache = /* @__PURE__ */ new Map();
-var sessionIdToKeyCache = /* @__PURE__ */ new Map();
-function setCachedSession(sessionKey, session) {
-  const oldSession = sessionCache.get(sessionKey);
-  if (oldSession && oldSession.id !== session.id) {
-    sessionIdToKeyCache.delete(oldSession.id);
-  }
-  sessionCache.set(sessionKey, session);
-  sessionIdToKeyCache.set(session.id, sessionKey);
-}
-function invalidateCachedSession(sessionId) {
-  const sessionKey = sessionIdToKeyCache.get(sessionId);
-  if (sessionKey) {
-    sessionCache.delete(sessionKey);
-    sessionIdToKeyCache.delete(sessionId);
-  }
-  return sessionKey;
-}
-function buildSessionKey(chatType, id) {
-  return `${SESSION_KEY_PREFIX}-${chatType}-${id}`;
-}
-function generateSessionTitle(sessionKey) {
-  return `${TITLE_PREFIX}-${sessionKey}-${Date.now()}`;
-}
-async function getOrCreateSession(client, sessionKey, directory) {
-  const cached = sessionCache.get(sessionKey);
-  if (cached) return cached;
-  const titlePrefix = `${TITLE_PREFIX}-${sessionKey}-`;
-  const query = directory ? { directory } : void 0;
-  const { data: sessions } = await client.session.list({ query });
-  if (Array.isArray(sessions)) {
-    const candidates = sessions.filter(
-      (s) => s.title && s.title.startsWith(titlePrefix)
-    );
-    if (candidates.length > 0) {
-      candidates.sort((a, b) => {
-        const ca = a.time?.created ?? 0;
-        const cb = b.time?.created ?? 0;
-        return cb - ca;
-      });
-      const best = candidates[0];
-      if (best?.id) {
-        const session2 = { id: best.id, title: best.title };
-        setCachedSession(sessionKey, session2);
-        return session2;
-      }
-    }
-  }
-  const title = generateSessionTitle(sessionKey);
-  const createResp = await client.session.create({ query, body: { title } });
-  if (!createResp?.data?.id) {
-    const err = createResp?.error;
-    throw new Error(
-      `\u521B\u5EFA OpenCode \u4F1A\u8BDD\u5931\u8D25: ${err ? JSON.stringify(err) : "unknown"}`
-    );
-  }
-  const session = { id: createResp.data.id, title: createResp.data.title };
-  setCachedSession(sessionKey, session);
-  return session;
-}
-async function forkSession(client, oldSessionId, sessionKey, directory) {
-  const query = directory ? { directory } : void 0;
-  const resp = await client.session.fork({
-    path: { id: oldSessionId },
-    query,
-    body: {}
-  });
-  if (!resp?.data?.id) {
-    const err = resp?.error;
-    throw new Error(
-      `Fork \u4F1A\u8BDD\u5931\u8D25: ${err ? JSON.stringify(err) : "unknown"}`
-    );
-  }
-  const title = generateSessionTitle(sessionKey);
-  const updateResp = await client.session.update({
-    path: { id: resp.data.id },
-    query,
-    body: { title }
-  });
-  if (!updateResp?.data?.id) {
-    const err = updateResp?.error;
-    throw new Error(
-      `\u66F4\u65B0 forked session \u6807\u9898\u5931\u8D25: ${err ? JSON.stringify(err) : "unknown"}`
-    );
-  }
-  return { id: resp.data.id, title };
-}
-async function createFreshSession(client, sessionKey, directory) {
-  const query = directory ? { directory } : void 0;
-  const title = generateSessionTitle(sessionKey);
-  const resp = await client.session.create({ query, body: { title } });
-  if (!resp?.data?.id) {
-    const err = resp?.error;
-    throw new Error(
-      `\u521B\u5EFA\u65B0\u4F1A\u8BDD\u5931\u8D25: ${err ? JSON.stringify(err) : "unknown"}`
-    );
-  }
-  return { id: resp.data.id, title: resp.data.title };
-}
-async function forkOrCreateSession(client, oldSessionId, sessionKey, directory, log) {
-  try {
-    return await forkSession(client, oldSessionId, sessionKey, directory);
-  } catch (forkErr) {
-    log?.("warn", "Fork \u5931\u8D25\uFF0C\u56DE\u9000\u5230\u521B\u5EFA\u65B0\u4F1A\u8BDD", {
-      oldSessionId,
-      sessionKey,
-      error: forkErr instanceof Error ? forkErr.message : String(forkErr)
-    });
-    return await createFreshSession(client, sessionKey, directory);
-  }
-}
-
 // src/handler/event.ts
-function maskKey(sessionKey) {
-  return sessionKey.replace(/-[^-]+$/, "-***");
-}
 var pendingBySession = /* @__PURE__ */ new Map();
 var sessionErrors = /* @__PURE__ */ new Map();
 var sessionErrorTimeouts = /* @__PURE__ */ new Map();
 var SESSION_ERROR_TTL_MS = 3e4;
-var modelOverrides = /* @__PURE__ */ new Map();
-var forkAttempts = /* @__PURE__ */ new Map();
-var forkAttemptTimeouts = /* @__PURE__ */ new Map();
-var MAX_FORK_ATTEMPTS = 2;
-var FORK_ATTEMPTS_TTL_MS = 36e5;
-function clearForkAttempts(sessionKey) {
-  forkAttempts.delete(sessionKey);
-  const timer = forkAttemptTimeouts.get(sessionKey);
+var retryAttempts = /* @__PURE__ */ new Map();
+var retryAttemptTimeouts = /* @__PURE__ */ new Map();
+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);
-    forkAttemptTimeouts.delete(sessionKey);
+    retryAttemptTimeouts.delete(sessionKey);
   }
 }
-function setForkAttempts(sessionKey, count) {
-  forkAttempts.set(sessionKey, count);
-  const existing = forkAttemptTimeouts.get(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(() => {
-    forkAttempts.delete(sessionKey);
-    forkAttemptTimeouts.delete(sessionKey);
-  }, FORK_ATTEMPTS_TTL_MS);
-  forkAttemptTimeouts.set(sessionKey, timeoutId);
-}
-function getModelOverride(sessionKey) {
-  return modelOverrides.get(sessionKey);
-}
-function clearModelOverride(sessionKey) {
-  modelOverrides.delete(sessionKey);
+    retryAttempts.delete(sessionKey);
+    retryAttemptTimeouts.delete(sessionKey);
+  }, RETRY_ATTEMPTS_TTL_MS);
+  retryAttemptTimeouts.set(sessionKey, timeoutId);
 }
 function getSessionError(sessionId) {
   return sessionErrors.get(sessionId);
@@ -99339,12 +99217,12 @@ function clearSessionError(sessionId) {
   }
   sessionErrors.delete(sessionId);
 }
-function setSessionError(sessionId, errMsg) {
+function setSessionError(sessionId, message, fields) {
   const existing = sessionErrorTimeouts.get(sessionId);
   if (existing) {
     clearTimeout(existing);
   }
-  sessionErrors.set(sessionId, errMsg);
+  sessionErrors.set(sessionId, { message, fields });
   const timeoutId = setTimeout(() => {
     sessionErrors.delete(sessionId);
     sessionErrorTimeouts.delete(sessionId);
@@ -99357,13 +99235,6 @@ function registerPending(sessionId, payload) {
 function unregisterPending(sessionId) {
   pendingBySession.delete(sessionId);
 }
-function migratePending(oldSessionId, newSessionId) {
-  const payload = pendingBySession.get(oldSessionId);
-  if (payload) {
-    pendingBySession.delete(oldSessionId);
-    pendingBySession.set(newSessionId, payload);
-  }
-}
 function extractErrorFields(error) {
   if (typeof error === "string") return [error];
   if (error && typeof error === "object") {
@@ -99377,14 +99248,12 @@ function extractErrorFields(error) {
   }
   return [String(error)];
 }
-function isModelError(errMsg, rawError) {
+function isModelError(fields) {
   const check = (s) => {
     const l = s.toLowerCase();
     return l.includes("model not found") || l.includes("modelnotfound");
   };
-  if (check(errMsg)) return true;
-  if (rawError) return extractErrorFields(rawError).some(check);
-  return false;
+  return fields.some(check);
 }
 async function handleEvent(event, deps) {
   switch (event.type) {
@@ -99426,77 +99295,13 @@ async function handleEvent(event, deps) {
       } else {
         errMsg = String(error);
       }
+      const fields = extractErrorFields(error);
       deps.log("warn", "\u6536\u5230 session.error \u4E8B\u4EF6", { sessionId, errMsg });
-      setSessionError(sessionId, errMsg);
-      if (isModelError(errMsg, props.error)) {
-        const sessionKey = invalidateCachedSession(sessionId);
-        if (sessionKey) {
-          const attempts = forkAttempts.get(sessionKey) ?? 0;
-          if (attempts >= MAX_FORK_ATTEMPTS) {
-            deps.log("warn", "\u5DF2\u8FBE fork \u4E0A\u9650\uFF0C\u653E\u5F03\u6062\u590D", { sessionKey: maskKey(sessionKey), attempts });
-          } else {
-            setForkAttempts(sessionKey, attempts + 1);
-            try {
-              const newSession = await forkOrCreateSession(deps.client, sessionId, sessionKey, deps.directory, deps.log);
-              setCachedSession(sessionKey, newSession);
-              modelOverrides.delete(sessionKey);
-              try {
-                const fallbackModel = await resolveLatestModel(deps.client, props.error ?? errMsg, deps.directory);
-                if (fallbackModel) {
-                  modelOverrides.set(sessionKey, fallbackModel);
-                  deps.log("info", "\u5DF2\u89E3\u6790\u964D\u7EA7\u6A21\u578B", {
-                    sessionKey: maskKey(sessionKey),
-                    providerID: fallbackModel.providerID,
-                    modelID: fallbackModel.modelID
-                  });
-                }
-              } catch (modelErr) {
-                deps.log("warn", "\u89E3\u6790\u964D\u7EA7\u6A21\u578B\u5931\u8D25\uFF0C\u5C06\u4F7F\u7528\u9ED8\u8BA4\u6A21\u578B", {
-                  sessionKey: maskKey(sessionKey),
-                  error: modelErr instanceof Error ? modelErr.message : String(modelErr)
-                });
-              }
-              deps.log("warn", "\u6A21\u578B\u4E0D\u517C\u5BB9\uFF0C\u5DF2\u6062\u590D\u4F1A\u8BDD", {
-                oldSessionId: sessionId,
-                newSessionId: newSession.id,
-                sessionKey: maskKey(sessionKey),
-                forkAttempt: attempts + 1
-              });
-              migratePending(sessionId, newSession.id);
-            } catch (recoverErr) {
-              deps.log("error", "\u4F1A\u8BDD\u6062\u590D\u5931\u8D25", {
-                sessionId,
-                sessionKey: maskKey(sessionKey),
-                error: recoverErr instanceof Error ? recoverErr.message : String(recoverErr)
-              });
-            }
-          }
-        }
-      }
+      setSessionError(sessionId, errMsg, fields);
       break;
     }
   }
 }
-async function resolveLatestModel(client, rawError, directory) {
-  const pattern = /model not found:?\s*(\w[\w-]*)\//i;
-  const fields = extractErrorFields(rawError);
-  const rawProviderID = fields.map((f) => pattern.exec(f)?.[1]).find(Boolean);
-  if (!rawProviderID) return void 0;
-  const providerID = rawProviderID.toLowerCase();
-  const query = directory ? { directory } : void 0;
-  const { data } = await client.provider.list({ query });
-  if (!data) return void 0;
-  const defaultModelID = data.default?.[providerID];
-  if (defaultModelID) {
-    return { providerID, modelID: defaultModelID };
-  }
-  const provider = data.all?.find((p) => p.id === providerID);
-  if (!provider?.models) return void 0;
-  const sortedModels = Object.values(provider.models).filter((m) => m.status !== "deprecated").sort((a, b) => b.release_date.localeCompare(a.release_date));
-  if (sortedModels.length === 0) return void 0;
-  const best = sortedModels.find((m) => m.tool_call) ?? sortedModels[0];
-  return { providerID, modelID: best.id };
-}
 function extractPartText(part) {
   if (part.type === "text") return part.text ?? "";
   if (part.type === "reasoning" && part.text) return `\u{1F914} \u601D\u8003: ${part.text}
@@ -99505,6 +99310,56 @@ function extractPartText(part) {
   return "";
 }
 
+// src/session.ts
+var SESSION_KEY_PREFIX = "feishu";
+var TITLE_PREFIX = "Feishu";
+var sessionCache = /* @__PURE__ */ new Map();
+function setCachedSession(sessionKey, session) {
+  sessionCache.set(sessionKey, session);
+}
+function buildSessionKey(chatType, id) {
+  return `${SESSION_KEY_PREFIX}-${chatType}-${id}`;
+}
+function generateSessionTitle(sessionKey) {
+  return `${TITLE_PREFIX}-${sessionKey}-${Date.now()}`;
+}
+async function getOrCreateSession(client, sessionKey, directory) {
+  const cached = sessionCache.get(sessionKey);
+  if (cached) return cached;
+  const titlePrefix = `${TITLE_PREFIX}-${sessionKey}-`;
+  const query = directory ? { directory } : void 0;
+  const { data: sessions } = await client.session.list({ query });
+  if (Array.isArray(sessions)) {
+    const candidates = sessions.filter(
+      (s) => s.title && s.title.startsWith(titlePrefix)
+    );
+    if (candidates.length > 0) {
+      candidates.sort((a, b) => {
+        const ca = a.time?.created ?? 0;
+        const cb = b.time?.created ?? 0;
+        return cb - ca;
+      });
+      const best = candidates[0];
+      if (best?.id) {
+        const session2 = { id: best.id, title: best.title };
+        setCachedSession(sessionKey, session2);
+        return session2;
+      }
+    }
+  }
+  const title = generateSessionTitle(sessionKey);
+  const createResp = await client.session.create({ query, body: { title } });
+  if (!createResp?.data?.id) {
+    const err = createResp?.error;
+    throw new Error(
+      `\u521B\u5EFA OpenCode \u4F1A\u8BDD\u5931\u8D25: ${err ? JSON.stringify(err) : "unknown"}`
+    );
+  }
+  const session = { id: createResp.data.id, title: createResp.data.title };
+  setCachedSession(sessionKey, session);
+  return session;
+}
+
 // src/handler/chat.ts
 var SSE_RACE_WAIT_MS = 100;
 var activeAutoPrompts = /* @__PURE__ */ new Map();
@@ -99530,10 +99385,10 @@ async function handleChat(ctx, deps) {
     senderId,
     messageType,
     shouldReply,
+    content,
     parts
   });
-  const modelOverride = getModelOverride(sessionKey);
-  const baseBody = { parts, ...modelOverride ? { model: modelOverride } : {} };
+  const baseBody = { parts };
   if (!shouldReply) {
     try {
       await client.session.prompt({
@@ -99554,6 +99409,7 @@ async function handleChat(ctx, deps) {
   const stablePolls = config.stablePolls;
   let placeholderId = "";
   let done = false;
+  let activeSessionId = session.id;
   const timer = thinkingDelay > 0 ? setTimeout(async () => {
     if (done) return;
     try {
@@ -99561,7 +99417,7 @@ async function handleChat(ctx, deps) {
       if (done) return;
       if (res.ok && res.messageId) {
         placeholderId = res.messageId;
-        registerPending(session.id, { chatId, placeholderId, feishuClient });
+        registerPending(activeSessionId, { chatId, placeholderId, feishuClient });
       }
     } catch (err) {
       log("warn", "\u53D1\u9001\u5360\u4F4D\u6D88\u606F\u5931\u8D25", {
@@ -99570,6 +99426,45 @@ async function handleChat(ctx, deps) {
       });
     }
   }, thinkingDelay) : null;
+  async function runAutoPromptLoop(activeId) {
+    const { autoPrompt } = config;
+    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 });
+        await client.session.prompt({
+          path: { id: activeId },
+          query,
+          body: { parts: [{ type: "text", text: autoPrompt.message }] }
+        });
+        const text2 = await pollForResponse(client, activeId, { timeout, pollInterval, stablePolls, query, signal: ac.signal });
+        if (text2) {
+          log("info", "\u81EA\u52A8\u63D0\u793A\u54CD\u5E94", {
+            sessionKey,
+            iteration: i + 1,
+            output: text2
+          });
+          await sendTextMessage(feishuClient, chatId, text2);
+        }
+      }
+      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);
+    }
+  }
   try {
     await client.session.prompt({
       path: { id: session.id },
@@ -99577,62 +99472,122 @@ async function handleChat(ctx, deps) {
       body: baseBody
     });
     const finalText = await pollForResponse(client, session.id, { timeout, pollInterval, stablePolls, query });
-    clearForkAttempts(sessionKey);
-    clearModelOverride(sessionKey);
+    log("info", "\u6A21\u578B\u54CD\u5E94\u5B8C\u6210", {
+      sessionKey,
+      sessionId: session.id,
+      output: finalText || "(empty)"
+    });
+    clearRetryAttempts(sessionKey);
     await replyOrUpdate(feishuClient, chatId, placeholderId, finalText || "\u26A0\uFE0F \u54CD\u5E94\u8D85\u65F6");
-    const { autoPrompt } = config;
-    if (autoPrompt.enabled && shouldReply) {
-      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 });
-          await client.session.prompt({
-            path: { id: session.id },
-            query,
-            body: { parts: [{ type: "text", text: autoPrompt.message }] }
-          });
-          const text2 = await pollForResponse(client, session.id, { timeout, pollInterval, stablePolls, query, signal: ac.signal });
-          if (text2) {
-            await sendTextMessage(feishuClient, chatId, text2);
+    await runAutoPromptLoop(session.id);
+  } catch (err) {
+    await new Promise((r) => setTimeout(r, SSE_RACE_WAIT_MS));
+    let sessionError = getSessionError(session.id);
+    clearSessionError(session.id);
+    if (!sessionError) {
+      const thrownFields = extractErrorFields(err);
+      if (isModelError(thrownFields)) {
+        const thrownMsg = err instanceof Error ? err.message : String(err);
+        sessionError = { message: thrownMsg, fields: thrownFields };
+      }
+    }
+    if (sessionError && isModelError(sessionError.fields)) {
+      const attempts = getRetryAttempts(sessionKey);
+      if (attempts < MAX_RETRY_ATTEMPTS) {
+        try {
+          const modelOverride = await resolveLatestModel(client, sessionError.fields, directory);
+          if (!modelOverride) {
+            log("warn", "\u65E0\u4EFB\u4F55\u5DF2\u8FDE\u63A5 provider \u6709\u53EF\u7528\u6A21\u578B\uFF0C\u653E\u5F03\u6062\u590D", { sessionKey });
+          } else {
+            setRetryAttempts(sessionKey, attempts + 1);
+            log("info", "\u5DF2\u89E3\u6790\u53EF\u7528\u6A21\u578B\uFF0C\u5728\u540C\u4E00 session \u4E0A\u91CD\u8BD5", {
+              sessionKey,
+              providerID: modelOverride.providerID,
+              modelID: modelOverride.modelID
+            });
+            await client.session.prompt({
+              path: { id: session.id },
+              query,
+              body: { ...baseBody, model: modelOverride }
+            });
+            const finalText = await pollForResponse(client, session.id, { timeout, pollInterval, stablePolls, query });
+            log("info", "\u6A21\u578B\u6062\u590D\u540E\u54CD\u5E94\u5B8C\u6210", {
+              sessionKey,
+              sessionId: session.id,
+              output: finalText || "(empty)"
+            });
+            clearRetryAttempts(sessionKey);
+            await replyOrUpdate(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;
           }
-        }
-        log("info", "\u81EA\u52A8\u63D0\u793A\u5FAA\u73AF\u7ED3\u675F\uFF08\u8FBE\u5230\u6700\u5927\u6B21\u6570\uFF09", { sessionKey });
-      } catch (err) {
-        if (err.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", {
+        } catch (recoveryErr) {
+          const recoveryErrMsg = recoveryErr instanceof Error ? recoveryErr.message : String(recoveryErr);
+          const retryError = getSessionError(session.id);
+          if (retryError) clearSessionError(session.id);
+          sessionError = retryError ?? { message: recoveryErrMsg, fields: [] };
+          log("error", "\u6A21\u578B\u6062\u590D\u5931\u8D25", {
+            sessionId: session.id,
             sessionKey,
-            error: err instanceof Error ? err.message : String(err)
+            error: recoveryErrMsg
           });
         }
-      } finally {
-        activeAutoPrompts.delete(sessionKey);
+      } else {
+        log("warn", "\u5DF2\u8FBE\u91CD\u8BD5\u4E0A\u9650\uFF0C\u653E\u5F03\u6062\u590D", {
+          sessionKey,
+          attempts
+        });
       }
     }
-  } catch (err) {
-    await new Promise((r) => setTimeout(r, SSE_RACE_WAIT_MS));
-    const sessionError = getSessionError(session.id);
-    clearSessionError(session.id);
     const thrownError = err instanceof Error ? err.message : String(err);
-    const errorMessage = sessionError || thrownError;
+    const errorMessage = sessionError?.message || thrownError;
     log("error", "\u5BF9\u8BDD\u5904\u7406\u5931\u8D25", {
       sessionId: session.id,
-      sessionKey: sessionKey.replace(/-[^-]+$/, "-***"),
+      sessionKey,
       chatType,
       error: thrownError,
-      ...sessionError ? { sessionError } : { sseRaceMiss: true }
+      ...sessionError ? { sessionError: sessionError.message } : { sseRaceMiss: true }
     });
     const msg = "\u274C " + errorMessage;
     await replyOrUpdate(feishuClient, chatId, placeholderId, msg);
   } finally {
     done = true;
     if (timer) clearTimeout(timer);
-    unregisterPending(session.id);
+    unregisterPending(activeSessionId);
+  }
+}
+async function resolveLatestModel(client, errorFields, directory) {
+  const pattern = /model\s*not\s*found:?\s*(\w[\w-]*)\/(\S+)/i;
+  const match = errorFields.map((f) => pattern.exec(f)).find(Boolean);
+  const failedProviderID = match?.[1]?.toLowerCase();
+  const failedModelID = match?.[2]?.replace(/\.$/, "");
+  const query = directory ? { directory } : void 0;
+  const { data } = await client.provider.list({ query });
+  if (!data) return void 0;
+  const connectedProviders = data.connected ?? [];
+  if (connectedProviders.length === 0) return void 0;
+  for (const pid of connectedProviders) {
+    const defaultModelID = data.default?.[pid];
+    if (defaultModelID && !(pid === failedProviderID && defaultModelID === failedModelID)) {
+      return { providerID: pid, modelID: defaultModelID };
+    }
+  }
+  for (const pid of connectedProviders) {
+    const provider = data.all?.find((p) => p.id === pid);
+    if (!provider?.models) continue;
+    const candidates = Object.values(provider.models).filter((m) => m.status !== "deprecated" && !(pid === failedProviderID && m.id === failedModelID)).sort((a, b) => b.release_date.localeCompare(a.release_date));
+    if (candidates.length > 0) {
+      const best = candidates.find((m) => m.tool_call) ?? candidates[0];
+      return { providerID: pid, modelID: best.id };
+    }
   }
+  return void 0;
 }
 async function buildPromptParts(feishuClient, messageId, messageType, rawContent, textContent, chatType, senderId, log) {
   if (messageType === "text") {
@@ -99905,7 +99860,7 @@ var FeishuPlugin = async (ctx) => {
   const hooks = {
     event: async ({ event }) => {
       if (!gateway) return;
-      await handleEvent(event, { client, log, directory: resolvedConfig.directory });
+      await handleEvent(event, { log, directory: resolvedConfig.directory });
     }
   };
   return hooks;