opencode-feishu 0.7.8 → 0.7.10

package/dist/index.js

@@ -99181,30 +99181,30 @@ 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);
+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 getForkAttempts(sessionKey) {
-  return forkAttempts.get(sessionKey) ?? 0;
+function getRetryAttempts(sessionKey) {
+  return retryAttempts.get(sessionKey) ?? 0;
 }
-function setForkAttempts(sessionKey, count) {
-  forkAttempts.set(sessionKey, count);
-  const existing = forkAttemptTimeouts.get(sessionKey);
+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);
+    retryAttempts.delete(sessionKey);
+    retryAttemptTimeouts.delete(sessionKey);
+  }, RETRY_ATTEMPTS_TTL_MS);
+  retryAttemptTimeouts.set(sessionKey, timeoutId);
 }
 function getSessionError(sessionId) {
   return sessionErrors.get(sessionId);
@@ -99314,22 +99314,8 @@ function extractPartText(part) {
 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}`;
@@ -99373,57 +99359,6 @@ async function getOrCreateSession(client, sessionKey, directory) {
   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/chat.ts
 var SSE_RACE_WAIT_MS = 100;
@@ -99542,7 +99477,7 @@ async function handleChat(ctx, deps) {
       sessionId: session.id,
       output: finalText || "(empty)"
     });
-    clearForkAttempts(sessionKey);
+    clearRetryAttempts(sessionKey);
     await replyOrUpdate(feishuClient, chatId, placeholderId, finalText || "\u26A0\uFE0F \u54CD\u5E94\u8D85\u65F6");
     await runAutoPromptLoop(session.id);
   } catch (err) {
@@ -99557,61 +99492,46 @@ async function handleChat(ctx, deps) {
       }
     }
     if (sessionError && isModelError(sessionError.fields)) {
-      const attempts = getForkAttempts(sessionKey);
-      if (attempts < MAX_FORK_ATTEMPTS) {
-        setForkAttempts(sessionKey, attempts + 1);
+      const attempts = getRetryAttempts(sessionKey);
+      if (attempts < MAX_RETRY_ATTEMPTS) {
         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", {
+          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,
-              error: modelErr instanceof Error ? modelErr.message : String(modelErr)
+              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;
           }
-          unregisterPending(session.id);
-          if (placeholderId) {
-            registerPending(newSession.id, { chatId, placeholderId, feishuClient });
-          }
-          const retryBody = { ...baseBody, ...modelOverride ? { model: modelOverride } : {} };
-          await client.session.prompt({
-            path: { id: newSession.id },
-            query,
-            body: retryBody
-          });
-          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,
-            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: [] };
+          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,
@@ -99619,7 +99539,7 @@ async function handleChat(ctx, deps) {
           });
         }
       } else {
-        log("warn", "\u5DF2\u8FBE fork \u4E0A\u9650\uFF0C\u653E\u5F03\u6062\u590D", {
+        log("warn", "\u5DF2\u8FBE\u91CD\u8BD5\u4E0A\u9650\uFF0C\u653E\u5F03\u6062\u590D", {
           sessionKey,
           attempts
         });
@@ -99643,23 +99563,31 @@ async function handleChat(ctx, deps) {
   }
 }
 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 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 defaultModelID = data.default?.[providerID];
-  if (defaultModelID) {
-    return { providerID, modelID: defaultModelID };
+  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 };
+    }
   }
-  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 };
+  return void 0;
 }
 async function buildPromptParts(feishuClient, messageId, messageType, rawContent, textContent, chatType, senderId, log) {
   if (messageType === "text") {
@@ -99932,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;