opencode-feishu 0.7.10 → 0.7.11

package/dist/index.js

@@ -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) {
@@ -99436,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,
@@ -99466,6 +99467,7 @@ async function handleChat(ctx, deps) {
     }
   }
   try {
+    clearSessionError(session.id);
     await client.session.prompt({
       path: { id: session.id },
       query,
@@ -99481,30 +99483,45 @@ async function handleChat(ctx, deps) {
     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 = getRetryAttempts(sessionKey);
       if (attempts < MAX_RETRY_ATTEMPTS) {
         try {
-          const modelOverride = await resolveLatestModel(client, sessionError.fields, directory);
+          let modelOverride;
+          try {
+            modelOverride = await getGlobalDefaultModel(client, directory);
+          } catch (configErr) {
+            log("warn", "\u8BFB\u53D6\u5168\u5C40\u6A21\u578B\u914D\u7F6E\u5931\u8D25", {
+              sessionKey,
+              error: configErr instanceof Error ? configErr.message : String(configErr)
+            });
+          }
           if (!modelOverride) {
-            log("warn", "\u65E0\u4EFB\u4F55\u5DF2\u8FDE\u63A5 provider \u6709\u53EF\u7528\u6A21\u578B\uFF0C\u653E\u5F03\u6062\u590D", { sessionKey });
+            log("warn", "\u5168\u5C40\u9ED8\u8BA4\u6A21\u578B\u672A\u914D\u7F6E\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", {
+            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,
@@ -99528,14 +99545,25 @@ async function handleChat(ctx, deps) {
             return;
           }
         } catch (recoveryErr) {
-          const recoveryErrMsg = recoveryErr instanceof Error ? recoveryErr.message : String(recoveryErr);
-          const retryError = getSessionError(session.id);
-          if (retryError) clearSessionError(session.id);
-          sessionError = retryError ?? { 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 {
@@ -99562,32 +99590,16 @@ async function handleChat(ctx, deps) {
     unregisterPending(activeSessionId);
   }
 }
-async function resolveLatestModel(client, errorFields, directory) {
-  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(/\.$/, "");
+async function getGlobalDefaultModel(client, directory) {
   const query = directory ? { directory } : void 0;
-  const { data } = await client.provider.list({ query });
-  if (!data) return void 0;
-  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 };
-    }
-  }
-  return void 0;
+  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") {
@@ -99603,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();
@@ -99614,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) {
@@ -99624,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;
 }