opencode-feishu 0.7.5 → 0.7.8

package/dist/index.js

@@ -99176,6 +99176,140 @@ async function updateMessage(client, messageId, text2) {
   }
 }
 
+// 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 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);
+  if (timer) {
+    clearTimeout(timer);
+    forkAttemptTimeouts.delete(sessionKey);
+  }
+}
+function getForkAttempts(sessionKey) {
+  return forkAttempts.get(sessionKey) ?? 0;
+}
+function setForkAttempts(sessionKey, count) {
+  forkAttempts.set(sessionKey, count);
+  const existing = forkAttemptTimeouts.get(sessionKey);
+  if (existing) clearTimeout(existing);
+  const timeoutId = setTimeout(() => {
+    forkAttempts.delete(sessionKey);
+    forkAttemptTimeouts.delete(sessionKey);
+  }, FORK_ATTEMPTS_TTL_MS);
+  forkAttemptTimeouts.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: "" });
+}
+function unregisterPending(sessionId) {
+  pendingBySession.delete(sessionId);
+}
+function extractErrorFields(error) {
+  if (typeof error === "string") return [error];
+  if (error && typeof error === "object") {
+    const e = error;
+    const fields = [e.type, e.name, e.message].filter(Boolean).map(String);
+    if (e.data && typeof e.data === "object" && "message" in e.data) {
+      const dataMsg = e.data.message;
+      if (dataMsg) fields.push(String(dataMsg));
+    }
+    return fields;
+  }
+  return [String(error)];
+}
+function isModelError(fields) {
+  const check = (s) => {
+    const l = s.toLowerCase();
+    return l.includes("model not found") || l.includes("modelnotfound");
+  };
+  return fields.some(check);
+}
+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 (!payload) 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) ;
+      }
+      break;
+    }
+    case "session.error": {
+      const props = event.properties;
+      const sessionId = props.sessionID;
+      if (!sessionId) break;
+      const error = props.error;
+      let errMsg;
+      if (typeof error === "string") {
+        errMsg = error;
+      } else if (error && typeof error === "object") {
+        const e = error;
+        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(error);
+      }
+      const fields = extractErrorFields(error);
+      deps.log("warn", "\u6536\u5230 session.error \u4E8B\u4EF6", { sessionId, errMsg });
+      setSessionError(sessionId, errMsg, fields);
+      break;
+    }
+  }
+}
+function extractPartText(part) {
+  if (part.type === "text") return part.text ?? "";
+  if (part.type === "reasoning" && part.text) return `\u{1F914} \u601D\u8003: ${part.text}
+
+`;
+  return "";
+}
+
 // src/session.ts
 var SESSION_KEY_PREFIX = "feishu";
 var TITLE_PREFIX = "Feishu";
@@ -99291,175 +99425,6 @@ async function forkOrCreateSession(client, oldSessionId, sessionKey, directory,
   }
 }
 
-// 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 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);
-  if (timer) {
-    clearTimeout(timer);
-    forkAttemptTimeouts.delete(sessionKey);
-  }
-}
-function setForkAttempts(sessionKey, count) {
-  forkAttempts.set(sessionKey, count);
-  const existing = forkAttemptTimeouts.get(sessionKey);
-  if (existing) clearTimeout(existing);
-  const timeoutId = setTimeout(() => {
-    forkAttempts.delete(sessionKey);
-    forkAttemptTimeouts.delete(sessionKey);
-  }, FORK_ATTEMPTS_TTL_MS);
-  forkAttemptTimeouts.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, errMsg) {
-  const existing = sessionErrorTimeouts.get(sessionId);
-  if (existing) {
-    clearTimeout(existing);
-  }
-  sessionErrors.set(sessionId, errMsg);
-  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: "" });
-}
-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 isModelError(errMsg, rawError) {
-  if (errMsg.includes("ModelNotFound") || errMsg.includes("ProviderModelNotFound")) {
-    return true;
-  }
-  if (rawError && typeof rawError === "object") {
-    const e = rawError;
-    const fields = [e.type, e.name, e.message].filter(Boolean).map(String);
-    if (e.data && typeof e.data === "object" && "message" in e.data) {
-      const dataMsg = e.data.message;
-      if (dataMsg) fields.push(String(dataMsg));
-    }
-    return fields.some((f) => f.includes("ModelNotFound") || f.includes("ProviderModelNotFound"));
-  }
-  return false;
-}
-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 (!payload) 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) ;
-      }
-      break;
-    }
-    case "session.error": {
-      const props = event.properties;
-      const sessionId = props.sessionID;
-      if (!sessionId) break;
-      const error = props.error;
-      let errMsg;
-      if (typeof error === "string") {
-        errMsg = error;
-      } else if (error && typeof error === "object") {
-        const e = error;
-        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(error);
-      }
-      const safeErrorFields = error && typeof error === "object" ? {
-        type: error.type,
-        name: error.name,
-        dataMessage: error.data?.message
-      } : { raw: String(error) };
-      deps.log("warn", "\u6536\u5230 session.error \u4E8B\u4EF6", {
-        sessionId,
-        error: safeErrorFields,
-        extractedMsg: 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, attempts });
-          } else {
-            setForkAttempts(sessionKey, attempts + 1);
-            try {
-              const newSession = await forkOrCreateSession(deps.client, sessionId, sessionKey, deps.directory, deps.log);
-              setCachedSession(sessionKey, newSession);
-              deps.log("warn", "\u6A21\u578B\u4E0D\u517C\u5BB9\uFF0C\u5DF2\u6062\u590D\u4F1A\u8BDD", {
-                oldSessionId: sessionId,
-                newSessionId: newSession.id,
-                sessionKey,
-                forkAttempt: attempts + 1
-              });
-              migratePending(sessionId, newSession.id);
-            } catch (recoverErr) {
-              deps.log("error", "\u4F1A\u8BDD\u6062\u590D\u5931\u8D25", {
-                sessionId,
-                sessionKey,
-                error: recoverErr instanceof Error ? recoverErr.message : String(recoverErr)
-              });
-            }
-          }
-        }
-      }
-      break;
-    }
-  }
-}
-function extractPartText(part) {
-  if (part.type === "text") return part.text ?? "";
-  if (part.type === "reasoning" && part.text) return `\u{1F914} \u601D\u8003: ${part.text}
-
-`;
-  return "";
-}
-
 // src/handler/chat.ts
 var SSE_RACE_WAIT_MS = 100;
 var activeAutoPrompts = /* @__PURE__ */ new Map();
@@ -99485,14 +99450,16 @@ async function handleChat(ctx, deps) {
     senderId,
     messageType,
     shouldReply,
+    content,
     parts
   });
+  const baseBody = { parts };
   if (!shouldReply) {
     try {
       await client.session.prompt({
         path: { id: session.id },
         query,
-        body: { parts, noReply: true }
+        body: { ...baseBody, noReply: true }
       });
     } catch (err) {
       log("warn", "\u9759\u9ED8\u8F6C\u53D1\u5931\u8D25", {
@@ -99507,6 +99474,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 {
@@ -99514,7 +99482,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", {
@@ -99523,68 +99491,175 @@ 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 },
       query,
-      body: { parts }
+      body: baseBody
     });
     const finalText = await pollForResponse(client, session.id, { timeout, pollInterval, stablePolls, query });
+    log("info", "\u6A21\u578B\u54CD\u5E94\u5B8C\u6210", {
+      sessionKey,
+      sessionId: session.id,
+      output: finalText || "(empty)"
+    });
     clearForkAttempts(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 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 = getForkAttempts(sessionKey);
+      if (attempts < MAX_FORK_ATTEMPTS) {
+        setForkAttempts(sessionKey, attempts + 1);
+        try {
+          invalidateCachedSession(session.id);
+          const newSession = await forkOrCreateSession(client, session.id, sessionKey, directory, log);
+          setCachedSession(sessionKey, newSession);
+          activeSessionId = newSession.id;
+          let modelOverride;
+          try {
+            modelOverride = await resolveLatestModel(client, sessionError.fields, directory);
+            if (modelOverride) {
+              log("info", "\u5DF2\u89E3\u6790\u964D\u7EA7\u6A21\u578B", {
+                sessionKey,
+                providerID: modelOverride.providerID,
+                modelID: modelOverride.modelID
+              });
+            }
+          } catch (modelErr) {
+            log("warn", "\u89E3\u6790\u964D\u7EA7\u6A21\u578B\u5931\u8D25\uFF0C\u5C06\u4F7F\u7528\u9ED8\u8BA4\u6A21\u578B", {
+              sessionKey,
+              error: modelErr instanceof Error ? modelErr.message : String(modelErr)
+            });
+          }
+          unregisterPending(session.id);
+          if (placeholderId) {
+            registerPending(newSession.id, { chatId, placeholderId, feishuClient });
+          }
+          const retryBody = { ...baseBody, ...modelOverride ? { model: modelOverride } : {} };
           await client.session.prompt({
-            path: { id: session.id },
+            path: { id: newSession.id },
             query,
-            body: { parts: [{ type: "text", text: autoPrompt.message }] }
+            body: retryBody
           });
-          const text2 = await pollForResponse(client, session.id, { timeout, pollInterval, stablePolls, query, signal: ac.signal });
-          if (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 (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", {
+          const finalText = await pollForResponse(client, newSession.id, { timeout, pollInterval, stablePolls, query });
+          log("info", "\u6062\u590D\u540E\u6A21\u578B\u54CD\u5E94\u5B8C\u6210", {
+            sessionKey,
+            newSessionId: newSession.id,
+            output: finalText || "(empty)"
+          });
+          clearForkAttempts(sessionKey);
+          await replyOrUpdate(feishuClient, chatId, placeholderId, finalText || "\u26A0\uFE0F \u54CD\u5E94\u8D85\u65F6");
+          log("info", "\u6A21\u578B\u4E0D\u517C\u5BB9\u6062\u590D\u6210\u529F", {
+            oldSessionId: session.id,
+            newSessionId: newSession.id,
             sessionKey,
-            error: err instanceof Error ? err.message : String(err)
+            forkAttempt: attempts + 1
+          });
+          await runAutoPromptLoop(newSession.id);
+          return;
+        } catch (recoveryErr) {
+          const recoveryErrMsg = recoveryErr instanceof Error ? recoveryErr.message : String(recoveryErr);
+          const newSessionError = activeSessionId !== session.id ? getSessionError(activeSessionId) : void 0;
+          if (newSessionError) clearSessionError(activeSessionId);
+          sessionError = newSessionError ?? { message: recoveryErrMsg, fields: [] };
+          log("error", "\u6A21\u578B\u6062\u590D\u5931\u8D25", {
+            sessionId: session.id,
+            sessionKey,
+            error: recoveryErrMsg
           });
         }
-      } finally {
-        activeAutoPrompts.delete(sessionKey);
+      } else {
+        log("warn", "\u5DF2\u8FBE fork \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 not found:?\s*(\w[\w-]*)\//i;
+  const rawProviderID = errorFields.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 };
 }
 async function buildPromptParts(feishuClient, messageId, messageType, rawContent, textContent, chatType, senderId, log) {
   if (messageType === "text") {