@remnic/core 9.69.39 → 9.69.40

package/dist/{chunk-LQNRVPTV.js → chunk-THTF2W7M.js}

@@ -13,52 +13,32 @@ import {
 import {
   CODEX_SUBSCRIPTION_PROVIDER_ID,
   abortReason,
+  classifyThrownProviderError,
   codexSubscriptionBuiltinProviderConfig,
-  getCodexSubscriptionRunnerForOwner,
+  defaultOpenClawWorkspaceDir,
+  extractResponsesOutputText,
   isTerminalCodexSubscriptionError,
+  isTimeoutError,
+  isUnsupportedJsonSchemaError,
+  normalizeRuntimePath,
   raceFallbackLlmDeadline,
+  readGatewayWorkspaceDir,
   tryCodexSubscriptionProvider,
   withCodexRuntimeShutdown
-} from "./chunk-CWTCMZGE.js";
+} from "./chunk-KTOXQMW3.js";
 import {
   extractJsonCandidates
 } from "./chunk-RGMVMVMF.js";
-import {
-  expandTildePath
-} from "./chunk-6KH5NLQS.js";
-import {
-  resolveHomeDir
-} from "./chunk-P2QRMMVQ.js";
 import {
   log
 } from "./chunk-3WCASNQZ.js";
 
 // src/fallback-llm.ts
-import path from "path";
 function gatewayTaskChainOptions(config) {
   if (config.modelSource !== "gateway") return {};
   if (config.taskModelChain) return { modelChain: config.taskModelChain };
   return config.gatewayAgentId ? { agentId: config.gatewayAgentId } : {};
 }
-function fallbackLlmRuntimeContextFromConfig(config, overrides = {}) {
-  return {
-    workspaceDir: config.workspaceDir,
-    resolveApiKeyForProvider: config.providerApiKeyResolver,
-    getRuntimeAuthForModel: config.runtimeAuthForModelResolver,
-    codexSubscriptionRunner: getCodexSubscriptionRunnerForOwner(config),
-    ...overrides
-  };
-}
-function isUnsupportedJsonSchemaError(error) {
-  const message = error instanceof Error ? error.message : String(error);
-  if (!/\b(?:400|404|422)\b/.test(message)) {
-    return false;
-  }
-  if (/(?:response[_ ]?format|json[_ ]?schema|structured[_ ]?output)/i.test(message)) {
-    return true;
-  }
-  return /\bunsupported\b[\s\S]{0,40}\b(?:schema|format)\b/i.test(message);
-}
 var PROVIDER_ALIASES = {
   "openai-codex": ["codex"],
   codex: ["openai-codex"],
@@ -109,6 +89,14 @@ var FallbackLlmClient = class {
    * When agentId is provided, uses that agent persona's model chain instead of defaults.
    */
   async chatCompletion(messages, options = {}) {
+    const outcome = await this.completeChat(messages, options);
+    return outcome.ok ? outcome.response : null;
+  }
+  /**
+   * Same transport walk as chatCompletion, but tagged so structured parse can
+   * tell timeout / empty / HTTP error apart instead of collapsing them to null.
+   */
+  async completeChat(messages, options = {}) {
     const models = this.getModelChain(
       options.agentId,
       options.model,
@@ -116,23 +104,41 @@ var FallbackLlmClient = class {
       options.includeDefaultModelFallback
     );
     if (models.length === 0) {
-      log.warn("fallback LLM: no models configured in gateway");
-      return null;
+      log.warn("task LLM: no models configured in gateway");
+      return { ok: false, failure: { failureReason: "no_models", errorClass: "no_models" } };
     }
     options = withCodexRuntimeShutdown(options, this.runtimeContext.codexSubscriptionRunner);
+    let lastFailure = {
+      failureReason: "http_error",
+      errorClass: "network"
+    };
+    const recordFailure = (failure, attemptedModel) => {
+      lastFailure = attemptedModel ? { ...failure, attemptedModel } : failure;
+    };
+    const throwIfCallerAborted = (signal) => {
+      if (!signal?.aborted) return;
+      const reason = abortReason(signal);
+      if (isTimeoutError(reason) && !options.signal?.aborted) {
+        recordFailure({ failureReason: "timeout", errorClass: "timeout" });
+        return;
+      }
+      throw reason;
+    };
     const runChain = async (initialOptions) => {
       let runOptions = initialOptions;
       let lastRejectedResponse = null;
+      let lastError;
       let terminalError;
       for (let i = 0; i < models.length; i++) {
         if (runOptions.signal?.aborted) {
-          throw abortReason(runOptions.signal);
+          throwIfCallerAborted(runOptions.signal);
+          if (lastFailure.failureReason === "timeout") return null;
         }
         const model = models[i];
         const isFallback = i > 0;
         try {
           const result = await this.tryModel(model, messages, runOptions);
-          if (result) {
+          if (result?.content) {
             const response = {
               content: result.content,
               modelUsed: model.modelString,
@@ -140,23 +146,26 @@ var FallbackLlmClient = class {
             };
             if (runOptions.acceptResponse && !runOptions.acceptResponse(response)) {
               lastRejectedResponse = response;
-              log.debug(`fallback LLM: ${model.modelString} returned rejected output, trying next...`);
+              log.debug(`task LLM: ${model.modelString} returned rejected output, trying next...`);
               continue;
             }
             if (isFallback) {
-              log.debug(`fallback LLM: succeeded using ${model.modelString} (fallback ${i})`);
+              log.debug(`task LLM: succeeded using ${model.modelString} (fallback ${i})`);
             }
             return response;
           }
+          recordFailure({ failureReason: "empty", errorClass: "empty" }, model.modelString);
         } catch (err) {
           if (isTerminalCodexSubscriptionError(err) && runOptions.signal?.aborted) {
             throw err;
           }
           if (runOptions.signal?.aborted) {
-            throw abortReason(runOptions.signal);
+            throwIfCallerAborted(runOptions.signal);
+            if (lastFailure.failureReason === "timeout") return null;
           }
+          lastError = err;
           if ((runOptions.jsonSchema || runOptions.responsesJsonSchema) && isUnsupportedJsonSchemaError(err)) {
-            log.debug(`fallback LLM: ${model.modelString} rejected native JSON schema; retrying without it`);
+            log.debug(`task LLM: ${model.modelString} rejected native JSON schema; retrying without it`);
             runOptions = {
               ...runOptions,
               jsonSchema: void 0,
@@ -164,7 +173,7 @@ var FallbackLlmClient = class {
             };
             try {
               const result = await this.tryModel(model, messages, runOptions);
-              if (result) {
+              if (result?.content) {
                 const response = {
                   content: result.content,
                   modelUsed: model.modelString,
@@ -174,17 +183,24 @@ var FallbackLlmClient = class {
                   return response;
                 }
                 lastRejectedResponse = response;
-                log.debug(`fallback LLM: ${model.modelString} unstructured retry output rejected by acceptResponse, trying next model...`);
+                log.debug(`task LLM: ${model.modelString} unstructured retry output rejected by acceptResponse, trying next model...`);
                 continue;
               }
+              recordFailure({ failureReason: "empty", errorClass: "empty" }, model.modelString);
             } catch (retryError) {
               if (isTerminalCodexSubscriptionError(retryError) && runOptions.signal?.aborted) {
                 throw retryError;
               }
-              if (runOptions.signal?.aborted) throw abortReason(runOptions.signal);
+              if (runOptions.signal?.aborted) {
+                throwIfCallerAborted(runOptions.signal);
+                if (lastFailure.failureReason === "timeout") return null;
+              }
+              lastError = retryError;
+              const retryClassified = classifyThrownProviderError(retryError);
+              recordFailure(retryClassified, model.modelString);
               const retryErrorMsg = runOptions.redactProviderErrors ? "provider error details redacted" : retryError instanceof Error ? retryError.message : String(retryError);
               log.debug(
-                `fallback LLM: ${model.modelString} unstructured retry failed (${retryErrorMsg})`
+                `task LLM: ${model.modelString} unstructured retry failed (${retryErrorMsg})`
               );
               if (isTerminalCodexSubscriptionError(retryError)) {
                 terminalError = retryError;
@@ -192,23 +208,32 @@ var FallbackLlmClient = class {
             }
             continue;
           }
+          const classified = classifyThrownProviderError(err);
+          recordFailure(classified, model.modelString);
           const errorMsg = runOptions.redactProviderErrors ? "provider error details redacted" : err instanceof Error ? err.message : String(err);
-          log.debug(`fallback LLM: ${model.modelString} failed (${errorMsg}), trying next...`);
+          log.debug(`task LLM: ${model.modelString} failed (${errorMsg}), trying next...`);
           if (isTerminalCodexSubscriptionError(err)) {
             terminalError = err;
           }
         }
       }
-      log.warn(`fallback LLM: all ${models.length} models in chain failed`);
+      log.warn(`task LLM: all ${models.length} models in chain failed`);
+      if (options.failureDiag && lastError !== void 0 && !lastRejectedResponse) {
+        options.failureDiag.lastError = lastError;
+      }
       if (terminalError !== void 0) {
         throw terminalError;
       }
       return lastRejectedResponse;
     };
+    const toOutcome = (response) => {
+      if (response) return { ok: true, response };
+      return { ok: false, failure: lastFailure };
+    };
     if (typeof options.timeoutMs === "number") {
       if (options.timeoutMs <= 0) {
-        log.warn("fallback LLM: timed out before request started");
-        return null;
+        log.warn("task LLM: timed out before request started");
+        return { ok: false, failure: { failureReason: "timeout", errorClass: "timeout" } };
       }
       const controller = new AbortController();
       const onCallerAbort = () => {
@@ -228,18 +253,25 @@ var FallbackLlmClient = class {
         }
       );
       try {
+        const timeoutError = Object.assign(
+          new Error(`task LLM timed out after ${options.timeoutMs}ms`),
+          { name: "TimeoutError" }
+        );
         const outcome = await raceFallbackLlmDeadline(guarded, options.timeoutMs, () => {
-          log.warn(`fallback LLM: timed out after ${options.timeoutMs}ms`);
-          controller.abort(
-            new Error(`fallback LLM timed out after ${options.timeoutMs}ms`)
-          );
+          log.warn(`task LLM: timed out after ${options.timeoutMs}ms`);
+          recordFailure({ failureReason: "timeout", errorClass: "timeout" });
+          controller.abort(timeoutError);
+          if (options.failureDiag) options.failureDiag.lastError = timeoutError;
         });
-        return outcome.timedOut ? null : outcome.value;
+        if (outcome.timedOut) {
+          return { ok: false, failure: { failureReason: "timeout", errorClass: "timeout" } };
+        }
+        return toOutcome(outcome.value);
       } finally {
         options.signal?.removeEventListener("abort", onCallerAbort);
       }
     }
-    return await runChain(options);
+    return toOutcome(await runChain(options));
   }
   /**
    * Make a request with structured output (Zod schema).
@@ -254,36 +286,69 @@ var FallbackLlmClient = class {
    * so callers can emit accurate trace events.
    */
   async parseWithSchemaDetailed(messages, schema, options = {}) {
-    let response;
+    let outcome;
     try {
-      response = await this.chatCompletion(messages, options);
+      outcome = await this.completeChat(messages, options);
     } catch (err) {
       if (options.signal?.aborted || isTerminalCodexSubscriptionError(err)) throw err;
-      log.warn("fallback LLM: chatCompletion threw during structured parse:", err);
-      return { result: null, failureReason: "http_error" };
-    }
-    if (!response?.content) {
-      const hasModels = this.getModelChain(
-        options.agentId,
-        options.model,
-        options.modelChain,
-        options.includeDefaultModelFallback
-      ).length > 0;
-      return { result: null, failureReason: hasModels ? "http_error" : "no_models" };
+      if (isTimeoutError(err)) {
+        return { result: null, failureReason: "timeout", errorClass: "timeout" };
+      }
+      log.warn("task LLM: chatCompletion threw during structured parse:", err);
+      return { result: null, ...classifyThrownProviderError(err) };
+    }
+    if (!outcome.ok) {
+      return { result: null, ...outcome.failure };
+    }
+    const response = outcome.response;
+    if (!response.content) {
+      return {
+        result: null,
+        failureReason: "empty",
+        attemptedModel: response.modelUsed,
+        errorClass: "empty"
+      };
     }
     try {
       const candidates = extractJsonCandidates(response.content);
+      let sawJson = false;
+      let sawSchemaReject = false;
       for (const c of candidates) {
+        let parsed;
+        try {
+          parsed = JSON.parse(c);
+          sawJson = true;
+        } catch {
+          continue;
+        }
         try {
-          const parsed = JSON.parse(c);
           return { result: schema.parse(parsed), modelUsed: response.modelUsed };
         } catch {
+          sawSchemaReject = true;
         }
       }
-      return { result: null, failureReason: "empty" };
+      if (sawSchemaReject) {
+        return {
+          result: null,
+          failureReason: "schema_rejection",
+          attemptedModel: response.modelUsed,
+          errorClass: "schema_rejection"
+        };
+      }
+      return {
+        result: null,
+        failureReason: "empty",
+        attemptedModel: response.modelUsed,
+        errorClass: "empty"
+      };
     } catch (err) {
-      log.warn("fallback LLM: failed to parse structured output:", err);
-      return { result: null, failureReason: "empty" };
+      log.warn("task LLM: failed to parse structured output:", err);
+      return {
+        result: null,
+        failureReason: "empty",
+        attemptedModel: response.modelUsed,
+        errorClass: "empty"
+      };
     }
   }
   /**
@@ -301,9 +366,9 @@ var FallbackLlmClient = class {
     let modelConfig;
     if (modelChainOverride?.primary) {
       modelConfig = modelChainOverride;
-      log.debug("fallback LLM: using explicit model chain override");
+      log.debug("task LLM: using explicit model chain override");
     } else if (modelChainOverride) {
-      log.warn("fallback LLM: ignoring explicit model chain override without primary model");
+      log.warn("task LLM: ignoring explicit model chain override without primary model");
     }
     if (!modelConfig && agentId) {
       const persona = this.gatewayConfig?.agents?.list?.find(
@@ -311,10 +376,10 @@ var FallbackLlmClient = class {
       );
       if (persona?.model) {
         modelConfig = persona.model;
-        log.debug(`fallback LLM: using agent persona "${agentId}" model chain`);
+        log.debug(`task LLM: using agent persona "${agentId}" model chain`);
       } else {
         log.warn(
-          `fallback LLM: agent persona "${agentId}" not found or has no model config, falling back to defaults`
+          `task LLM: agent persona "${agentId}" not found or has no model config, falling back to defaults`
         );
       }
     }
@@ -357,7 +422,7 @@ var FallbackLlmClient = class {
           chain.push(defaultRef);
           modelStrings.push(trimmed);
           log.debug(
-            `fallback LLM: appended gateway default model "${trimmed}" as implicit last resort`
+            `task LLM: appended gateway default model "${trimmed}" as implicit last resort`
           );
         }
       }
@@ -370,7 +435,7 @@ var FallbackLlmClient = class {
   parseModelString(modelString, providers) {
     const parts = modelString.split("/");
     if (parts.length < 2) {
-      log.warn(`fallback LLM: invalid model format: ${modelString}`);
+      log.warn(`task LLM: invalid model format: ${modelString}`);
       return null;
     }
     const requestedProviderId = parts[0];
@@ -379,7 +444,7 @@ var FallbackLlmClient = class {
     const providerConfig = resolvedProvider?.config;
     if (!providerConfig) {
       log.warn(
-        `fallback LLM: provider not found: ${requestedProviderId} (tried: ${this.providerResolutionCandidates(requestedProviderId).join(", ")})`
+        `task LLM: provider not found: ${requestedProviderId} (tried: ${this.providerResolutionCandidates(requestedProviderId).join(", ")})`
       );
       return null;
     }
@@ -398,7 +463,7 @@ var FallbackLlmClient = class {
       const config = providers[candidate];
       if (config) {
         if (candidate !== providerId) {
-          log.debug(`fallback LLM: provider "${providerId}" resolved via alias "${candidate}"`);
+          log.debug(`task LLM: provider "${providerId}" resolved via alias "${candidate}"`);
         }
         return { providerId: candidate, config };
       }
@@ -407,17 +472,17 @@ var FallbackLlmClient = class {
       const config = this.resolveFromModelsJson(candidate);
       if (config) {
         if (candidate !== providerId) {
-          log.debug(`fallback LLM: provider "${providerId}" resolved via models.json alias "${candidate}"`);
+          log.debug(`task LLM: provider "${providerId}" resolved via models.json alias "${candidate}"`);
         }
         return { providerId: candidate, config };
       }
       const builtInConfig = BUILT_IN_PROVIDER_FALLBACKS[candidate];
       if (builtInConfig) {
         if (candidate === providerId) {
-          log.debug(`fallback LLM: provider "${providerId}" resolved from built-in defaults`);
+          log.debug(`task LLM: provider "${providerId}" resolved from built-in defaults`);
           return { providerId, config: builtInConfig };
         }
-        log.debug(`fallback LLM: provider "${providerId}" resolved via built-in alias "${candidate}"`);
+        log.debug(`task LLM: provider "${providerId}" resolved via built-in alias "${candidate}"`);
         return { providerId: candidate, config: builtInConfig };
       }
     }
@@ -437,7 +502,7 @@ var FallbackLlmClient = class {
     const allProviders = loadModelsJsonProviders();
     const config = allProviders[providerId];
     if (config) {
-      log.debug(`fallback LLM: resolved provider "${providerId}" from models.json (api: ${config.api ?? "default"})`);
+      log.debug(`task LLM: resolved provider "${providerId}" from models.json (api: ${config.api ?? "default"})`);
       return config;
     }
     return null;
@@ -518,13 +583,13 @@ var FallbackLlmClient = class {
       });
       if (result?.apiKey || result?.baseUrl) {
         log.debug(
-          `fallback LLM: resolved runtime auth for "${model.modelString}" (source: ${result.source ?? "unknown"}, mode: ${result.mode ?? "unknown"})`
+          `task LLM: resolved runtime auth for "${model.modelString}" (source: ${result.source ?? "unknown"}, mode: ${result.mode ?? "unknown"})`
         );
         return { apiKey: result.apiKey, baseUrl: result.baseUrl };
       }
     } catch (err) {
       log.debug(
-        `fallback LLM: gateway runtime auth failed for "${model.modelString}": ${err instanceof Error ? err.message : String(err)}`
+        `task LLM: gateway runtime auth failed for "${model.modelString}": ${err instanceof Error ? err.message : String(err)}`
       );
     }
     return null;
@@ -587,7 +652,7 @@ var FallbackLlmClient = class {
     });
     if (!response.ok) {
       const error = await response.text();
-      throw new Error(`OpenAI API error: ${response.status} ${error}`);
+      throw Object.assign(new Error(`OpenAI API error: ${response.status} ${error}`), { status: response.status });
     }
     const data = await response.json();
     const content = data.choices?.[0]?.message?.content;
@@ -635,7 +700,7 @@ var FallbackLlmClient = class {
     });
     if (!response.ok) {
       const error = await response.text();
-      throw new Error(`Ollama API error: ${response.status} ${error}`);
+      throw Object.assign(new Error(`Ollama API error: ${response.status} ${error}`), { status: response.status });
     }
     const data = await response.json();
     const content = data.message?.content ?? data.response;
@@ -704,7 +769,7 @@ var FallbackLlmClient = class {
     });
     if (!response.ok) {
       const error = await response.text();
-      throw new Error(`OpenAI Responses API error: ${response.status} ${error}`);
+      throw Object.assign(new Error(`OpenAI Responses API error: ${response.status} ${error}`), { status: response.status });
     }
     const data = await response.json();
     const outputText = extractResponsesOutputText(data);
@@ -757,7 +822,7 @@ var FallbackLlmClient = class {
     });
     if (!response.ok) {
       const error = await response.text();
-      throw new Error(`Anthropic API error: ${response.status} ${error}`);
+      throw Object.assign(new Error(`Anthropic API error: ${response.status} ${error}`), { status: response.status });
     }
     const data = await response.json();
     const content = data.content?.[0]?.text;
@@ -774,41 +839,9 @@ var FallbackLlmClient = class {
     };
   }
 };
-function normalizeRuntimePath(value) {
-  if (typeof value !== "string") return void 0;
-  const trimmed = value.trim();
-  return trimmed.length > 0 ? expandTildePath(trimmed) : void 0;
-}
-function readGatewayWorkspaceDir(gatewayConfig) {
-  if (!gatewayConfig || typeof gatewayConfig !== "object") return void 0;
-  const raw = gatewayConfig;
-  return normalizeRuntimePath(raw.workspaceDir) ?? normalizeRuntimePath(raw.workspacePath) ?? normalizeRuntimePath(raw.workspace);
-}
-function defaultOpenClawWorkspaceDir() {
-  return path.join(resolveHomeDir(), ".openclaw", "workspace");
-}
-function extractResponsesOutputText(data) {
-  if (typeof data.output_text === "string" && data.output_text.trim().length > 0) {
-    return data.output_text;
-  }
-  const chunks = [];
-  for (const item of data.output ?? []) {
-    if (typeof item.text === "string" && item.text.trim().length > 0) {
-      chunks.push(item.text);
-    }
-    for (const part of item.content ?? []) {
-      if ((part.type === "output_text" || part.type === "text") && typeof part.text === "string" && part.text.trim().length > 0) {
-        chunks.push(part.text);
-      }
-    }
-  }
-  const joined = chunks.join("\n").trim();
-  return joined.length > 0 ? joined : null;
-}
 
 export {
   gatewayTaskChainOptions,
-  fallbackLlmRuntimeContextFromConfig,
   FallbackLlmClient
 };
-//# sourceMappingURL=chunk-LQNRVPTV.js.map
+//# sourceMappingURL=chunk-THTF2W7M.js.map