abelworkflow 1.0.0 → 1.1.0

package/lib/providers/codex.mjs

@@ -25,6 +25,8 @@ import {
 import { defaultPaths, maskSecret, pathToLabel } from "../paths.mjs";
 import { normalizeOpenAiBaseUrl } from "./pi.mjs";
 
+const CODEX_ENV_KEY = "OPENAI_API_KEY";
+
 const publishedCodexDeveloperInstructionHashes = new Set([
   "957adb227dd3fc298985acca38db4c22b8e018d387dab91f1ea8287db35385db"
 ]);
@@ -249,13 +251,6 @@ async function deployBundledCodexAgents(paths = defaultPaths, previousManagedFil
   return result;
 }
 
-function getDefaultCodexEnvKey(providerId) {
-  if (providerId === "openai") return "OPENAI_API_KEY";
-  if (providerId === "abelworkflow") return "ABELWORKFLOW_API_KEY";
-  const digest = createHash("sha256").update(providerId).digest("hex").toUpperCase();
-  return `ABELWORKFLOW_PROVIDER_${digest}_API_KEY`;
-}
-
 function getCodexProviderSectionName(providerId) {
   return `model_providers.${formatTomlKeySegment(providerId)}`;
 }
@@ -275,8 +270,7 @@ function assertCodexAuthKeyAvailable(auth, envKey) {
 function resolveExistingCodexApiConfig(content, auth = {}) {
   const providerId = readTopLevelTomlString(content, "model_provider") || "abelworkflow";
   const provider = parseTomlSection(content, getCodexProviderSectionName(providerId));
-  const configuredEnvKey = provider.temp_env_key || "";
-  const envKey = configuredEnvKey || getDefaultCodexEnvKey(providerId);
+  const envKey = CODEX_ENV_KEY;
   assertCodexAuthKeyAvailable(auth, envKey);
   const apiKey = typeof auth[envKey] === "string" ? auth[envKey] : "";
 
@@ -331,7 +325,7 @@ async function configureCodexApi(paths = defaultPaths, promptApi, ownership = {}
   const shouldDeploySubagents = await confirmOrCancel({ message: "是否部署 Codex subagents 配置？", initialValue: true });
   let managedCodexAgentFiles = { ...(ownership.managedCodexAgentFiles ?? {}) };
 
-  const envKey = existing.envKey || "OPENAI_API_KEY";
+  const envKey = CODEX_ENV_KEY;
   const currentContent = await pathExists(paths.codexConfigPath) ? await readFile(paths.codexConfigPath, "utf8") : "";
   const templateContent = await loadBundledCodexConfigTemplate(paths);
   const content = buildCodexConfigContent(currentContent, {
@@ -340,8 +334,7 @@ async function configureCodexApi(paths = defaultPaths, promptApi, ownership = {}
     includeSubagentDefaults: shouldDeploySubagents,
     providerId,
     providerName,
-    baseUrl,
-    envKey
+    baseUrl
   });
 
   const auth = mergeCodexAuthData(
@@ -382,8 +375,7 @@ function buildCodexConfigContent(currentContent, {
   includeSubagentDefaults = true,
   providerId,
   providerName,
-  baseUrl,
-  envKey
+  baseUrl
 }) {
   const effectiveTemplateContent = includeSubagentDefaults
     ? templateContent
@@ -403,7 +395,7 @@ function buildCodexConfigContent(currentContent, {
     name: providerName,
     base_url: baseUrl,
     wire_api: "responses",
-    temp_env_key: envKey,
+    temp_env_key: CODEX_ENV_KEY,
     requires_openai_auth: true,
     supports_websockets: true
   });

package/lib/providers/skills.mjs

@@ -56,6 +56,15 @@ async function configureGrokSearchEnv(paths, ensureSkillPresent = async () => {}
     initialValue: Boolean(existing.TAVILY_API_KEY)
   });
 
+  const tavilyUrl = useTavily
+    ? await p.text({
+        message: "Tavily API URL",
+        initialValue: existing.TAVILY_API_URL || "https://api.tavily.com",
+        validate: required()
+      })
+    : null;
+  if (useTavily) assertNotCancelled(tavilyUrl);
+
   const tavilyKey = useTavily
     ? await p.password(passwordPromptOptions(
         "Tavily API Key",
@@ -70,6 +79,7 @@ async function configureGrokSearchEnv(paths, ensureSkillPresent = async () => {}
     GROK_API_URL: baseUrl,
     GROK_API_KEY: finalApiKey,
     GROK_MODEL: model,
+    TAVILY_API_URL: tavilyUrl,
     TAVILY_API_KEY: finalTavilyKey,
     TAVILY_ENABLED: useTavily ? "true" : null
   });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "abelworkflow",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "Install AbelWorkflow into ~/.agents and create Claude/Codex symlinks.",
   "type": "module",
   "scripts": {

package/skills/grok-search/scripts/groksearch_cli.py

@@ -216,7 +216,17 @@ def _emit_tavily_warning(message: str) -> None:
 RETRYABLE_STATUS_CODES = {408, 429, 500, 502, 503, 504}
 
 
+class StreamEmbeddedError(Exception):
+    """SSE 流内嵌错误事件（HTTP 200 + data: {"error": ...}）。"""
+
+
+class EmptyStreamError(Exception):
+    """流式响应解析完成但内容为空。"""
+
+
 def _is_retryable_exception(exc) -> bool:
+    if isinstance(exc, (StreamEmbeddedError, EmptyStreamError)):
+        return True
     if isinstance(exc, (httpx.TimeoutException, httpx.NetworkError, httpx.ConnectError, httpx.RemoteProtocolError)):
         return True
     if isinstance(exc, httpx.HTTPStatusError):
@@ -501,6 +511,7 @@ def _normalize_tavily_base_url(raw: str) -> str:
 
 _http_client: Optional[httpx.AsyncClient] = None
 _DEFAULT_TIMEOUT = httpx.Timeout(connect=6.0, read=60.0, write=10.0, pool=None)
+_NON_STREAM_TIMEOUT = httpx.Timeout(connect=6.0, read=10.0, write=10.0, pool=None)
 
 
 async def get_http_client() -> httpx.AsyncClient:
@@ -586,16 +597,23 @@ class GrokSearchProvider:
         return await self._execute(payload)
 
     async def _execute(self, payload: dict) -> str:
-        """执行请求：先尝试非流式，失败时回退到流式。"""
+        """执行请求：流式优先，失败时回退到非流式（10s 超时 fail-fast）。"""
         try:
+            return await self._execute_stream(payload)
+        except httpx.HTTPStatusError as e:
+            if e.response.status_code not in RETRYABLE_STATUS_CODES:
+                raise
+            if config.debug_enabled:
+                print(f"[DEBUG] 流式失败: {e}，回退到非流式", file=sys.stderr)
             return await self._execute_non_stream(payload)
-        except (httpx.HTTPStatusError, json.JSONDecodeError) as e:
+        except (httpx.TimeoutException, httpx.NetworkError, httpx.RemoteProtocolError,
+                StreamEmbeddedError, EmptyStreamError, json.JSONDecodeError) as e:
             if config.debug_enabled:
-                print(f"[DEBUG] 非流式失败: {e}，回退到流式", file=sys.stderr)
-            return await self._execute_stream(payload)
+                print(f"[DEBUG] 流式失败: {e}，回退到非流式", file=sys.stderr)
+            return await self._execute_non_stream(payload)
 
     async def _execute_non_stream(self, payload: dict) -> str:
-        """非流式请求（首选，对短响应更快）。"""
+        """非流式请求（流式失败后的回退方案，10s read 超时 fail-fast）。"""
         payload_copy = {**payload, "stream": False}
         client = await get_http_client()
 
@@ -610,6 +628,7 @@ class GrokSearchProvider:
                     f"{self.api_url}/chat/completions",
                     headers=self._headers,
                     json=payload_copy,
+                    timeout=_NON_STREAM_TIMEOUT,
                 )
                 response.raise_for_status()
                 data = response.json()
@@ -619,7 +638,7 @@ class GrokSearchProvider:
                 return ""
 
     async def _execute_stream(self, payload: dict) -> str:
-        """流式请求（大响应的回退方案）。"""
+        """流式请求（首选，chunk 保活避免网关超时）。"""
         payload_copy = {**payload, "stream": True}
         client = await get_http_client()
 
@@ -655,24 +674,30 @@ class GrokSearchProvider:
                 try:
                     json_str = line[5:].lstrip()
                     data = json.loads(json_str)
-                    choices = data.get("choices", [])
-                    if choices:
-                        delta = choices[0].get("delta", {})
-                        if "content" in delta:
-                            content += delta["content"]
                 except (json.JSONDecodeError, IndexError):
                     continue
+                if isinstance(data, dict) and "error" in data:
+                    raise StreamEmbeddedError(json.dumps(data["error"], ensure_ascii=False)[:300])
+                choices = data.get("choices", [])
+                if choices:
+                    delta = choices[0].get("delta", {})
+                    if "content" in delta:
+                        content += delta["content"]
 
         if not content and full_body_buffer:
             try:
                 full_text = "".join(full_body_buffer)
                 data = json.loads(full_text)
+                if isinstance(data, dict) and "error" in data:
+                    raise StreamEmbeddedError(json.dumps(data["error"], ensure_ascii=False)[:300])
                 if "choices" in data and data["choices"]:
                     message = data["choices"][0].get("message", {})
                     content = message.get("content", "")
             except json.JSONDecodeError:
                 pass
 
+        if not content.strip():
+            raise EmptyStreamError("流式响应内容为空")
         return content
 
 
@@ -935,8 +960,9 @@ async def cmd_web_search(args):
     except ValueError as e:
         print(json.dumps({"error": str(e)}, ensure_ascii=False), file=sys.stderr)
         sys.exit(1)
-    except httpx.HTTPStatusError as e:
-        print(json.dumps({"error": f"API错误: {e.response.status_code}"}, ensure_ascii=False), file=sys.stderr)
+    except httpx.HTTPError as e:
+        detail = str(e.response.status_code) if isinstance(e, httpx.HTTPStatusError) else (str(e) or type(e).__name__)
+        print(json.dumps({"error": f"API错误: {detail}"}, ensure_ascii=False), file=sys.stderr)
         sys.exit(1)
 
 
@@ -974,8 +1000,9 @@ async def cmd_web_fetch(args):
         except ValueError as e:
             print(f"错误: {e}", file=sys.stderr)
             sys.exit(1)
-        except httpx.HTTPStatusError as e:
-            print(f"API错误: {e.response.status_code}", file=sys.stderr)
+        except httpx.HTTPError as e:
+            detail = str(e.response.status_code) if isinstance(e, httpx.HTTPStatusError) else (str(e) or type(e).__name__)
+            print(f"API错误: {detail}", file=sys.stderr)
             sys.exit(1)
 
     if not result and tavily_error and not use_grok_fallback: