opencode-feishu 0.7.4 → 0.7.6

package/dist/index.js

@@ -99266,12 +99266,68 @@ async function forkSession(client, oldSessionId, sessionKey, directory) {
   }
   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);
+  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 getModelOverride(sessionKey) {
+  return modelOverrides.get(sessionKey);
+}
+function clearModelOverride(sessionKey) {
+  modelOverrides.delete(sessionKey);
+}
 function getSessionError(sessionId) {
   return sessionErrors.get(sessionId);
 }
@@ -99308,19 +99364,26 @@ function migratePending(oldSessionId, newSessionId) {
     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;
+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.some((f) => f.includes("ModelNotFound") || f.includes("ProviderModelNotFound"));
+    return fields;
   }
+  return [String(error)];
+}
+function isModelError(errMsg, rawError) {
+  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;
 }
 async function handleEvent(event, deps) {
@@ -99363,35 +99426,50 @@ async function handleEvent(event, deps) {
       } 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
-      });
+      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) {
-          try {
-            const newSession = await forkSession(deps.client, sessionId, sessionKey, deps.directory);
-            setCachedSession(sessionKey, newSession);
-            deps.log("warn", "\u6A21\u578B\u4E0D\u517C\u5BB9\uFF0C\u5DF2\u4E3B\u52A8 fork \u4F1A\u8BDD", {
-              oldSessionId: sessionId,
-              newSessionId: newSession.id,
-              sessionKey
-            });
-            migratePending(sessionId, newSession.id);
-          } catch (forkErr) {
-            deps.log("error", "\u4E3B\u52A8 fork \u5931\u8D25", {
-              sessionId,
-              sessionKey,
-              error: forkErr instanceof Error ? forkErr.message : String(forkErr)
-            });
+          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)
+              });
+            }
           }
         }
       }
@@ -99399,6 +99477,26 @@ async function handleEvent(event, deps) {
     }
   }
 }
+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}
@@ -99434,12 +99532,14 @@ async function handleChat(ctx, deps) {
     shouldReply,
     parts
   });
+  const modelOverride = getModelOverride(sessionKey);
+  const baseBody = { parts, ...modelOverride ? { model: modelOverride } : {} };
   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", {
@@ -99474,9 +99574,11 @@ async function handleChat(ctx, deps) {
     await client.session.prompt({
       path: { id: session.id },
       query,
-      body: { parts }
+      body: baseBody
     });
     const finalText = await pollForResponse(client, session.id, { timeout, pollInterval, stablePolls, query });
+    clearForkAttempts(sessionKey);
+    clearModelOverride(sessionKey);
     await replyOrUpdate(feishuClient, chatId, placeholderId, finalText || "\u26A0\uFE0F \u54CD\u5E94\u8D85\u65F6");
     const { autoPrompt } = config;
     if (autoPrompt.enabled && shouldReply) {
@@ -99522,7 +99624,7 @@ async function handleChat(ctx, deps) {
       sessionKey: sessionKey.replace(/-[^-]+$/, "-***"),
       chatType,
       error: thrownError,
-      ...sessionError ? { sessionError } : {}
+      ...sessionError ? { sessionError } : { sseRaceMiss: true }
     });
     const msg = "\u274C " + errorMessage;
     await replyOrUpdate(feishuClient, chatId, placeholderId, msg);