opencode-feishu 0.7.5 → 0.7.6

package/dist/index.js

@@ -99292,10 +99292,14 @@ async function forkOrCreateSession(client, oldSessionId, 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;
@@ -99318,6 +99322,12 @@ function setForkAttempts(sessionKey, count) {
   }, 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);
 }
@@ -99354,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) {
@@ -99409,39 +99426,47 @@ 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) {
           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 });
+            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,
+                sessionKey: maskKey(sessionKey),
                 forkAttempt: attempts + 1
               });
               migratePending(sessionId, newSession.id);
             } catch (recoverErr) {
               deps.log("error", "\u4F1A\u8BDD\u6062\u590D\u5931\u8D25", {
                 sessionId,
-                sessionKey,
+                sessionKey: maskKey(sessionKey),
                 error: recoverErr instanceof Error ? recoverErr.message : String(recoverErr)
               });
             }
@@ -99452,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}
@@ -99487,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", {
@@ -99527,10 +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) {