opencode-feishu 0.7.8 → 0.7.11

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);
@@ -99249,11 +99249,11 @@ function extractErrorFields(error) {
   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);
+  const patterns = ["model not found", "modelnotfound", "model not supported", "model_not_supported"];
+  return fields.some((f) => {
+    const l = f.toLowerCase();
+    return patterns.some((p) => l.includes(p));
+  });
 }
 async function handleEvent(event, deps) {
   switch (event.type) {
@@ -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;
@@ -99501,6 +99436,7 @@ async function handleChat(ctx, deps) {
       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,
@@ -99531,6 +99467,7 @@ async function handleChat(ctx, deps) {
     }
   }
   try {
+    clearSessionError(session.id);
     await client.session.prompt({
       path: { id: session.id },
       query,
@@ -99542,84 +99479,95 @@ 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) {
-    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 };
+    let sessionError;
+    if (err instanceof SessionErrorDetected) {
+      sessionError = err.sessionError;
+      clearSessionError(session.id);
+    } else {
+      await new Promise((r) => setTimeout(r, SSE_RACE_WAIT_MS));
+      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);
+      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", {
+            modelOverride = await getGlobalDefaultModel(client, directory);
+          } catch (configErr) {
+            log("warn", "\u8BFB\u53D6\u5168\u5C40\u6A21\u578B\u914D\u7F6E\u5931\u8D25", {
               sessionKey,
-              error: modelErr instanceof Error ? modelErr.message : String(modelErr)
+              error: configErr instanceof Error ? configErr.message : String(configErr)
             });
           }
-          unregisterPending(session.id);
-          if (placeholderId) {
-            registerPending(newSession.id, { chatId, placeholderId, feishuClient });
+          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.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;
           }
-          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 errMsg = recoveryErr instanceof Error ? recoveryErr.message : String(recoveryErr);
+          if (recoveryErr instanceof SessionErrorDetected) {
+            sessionError = recoveryErr.sessionError;
+            clearSessionError(session.id);
+          } else {
+            await new Promise((r) => setTimeout(r, SSE_RACE_WAIT_MS));
+            const sseError = getSessionError(session.id);
+            if (sseError) {
+              sessionError = sseError;
+              clearSessionError(session.id);
+            } else {
+              const thrownFields = extractErrorFields(recoveryErr);
+              sessionError = { message: errMsg, fields: thrownFields };
+            }
+          }
           log("error", "\u6A21\u578B\u6062\u590D\u5931\u8D25", {
             sessionId: session.id,
             sessionKey,
-            error: recoveryErrMsg
+            error: errMsg
           });
         }
       } 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
         });
@@ -99642,24 +99590,16 @@ async function handleChat(ctx, deps) {
     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();
+async function getGlobalDefaultModel(client, directory) {
   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 };
+  const { data: config } = await client.config.get({ query });
+  const model = config?.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") {
@@ -99675,6 +99615,13 @@ 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();
@@ -99686,6 +99633,10 @@ async function pollForResponse(client, sessionId, opts) {
     } else {
       await new Promise((r) => setTimeout(r, pollInterval));
     }
+    const sseError = getSessionError(sessionId);
+    if (sseError) {
+      throw new SessionErrorDetected(sseError);
+    }
     const { data: messages } = await client.session.messages({ path: { id: sessionId }, query });
     const text2 = extractLastAssistantText(messages ?? []);
     if (text2 && text2 !== lastText) {
@@ -99696,6 +99647,10 @@ async function pollForResponse(client, sessionId, opts) {
       if (sameCount >= stablePolls) break;
     }
   }
+  const finalSseError = getSessionError(sessionId);
+  if (finalSseError) {
+    throw new SessionErrorDetected(finalSseError);
+  }
   const { data: finalMessages } = await client.session.messages({ path: { id: sessionId }, query });
   return extractLastAssistantText(finalMessages ?? []) || lastText;
 }
@@ -99932,7 +99887,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;