@remnic/core 9.69.39 → 9.69.41

package/dist/chunk-SK7D34OL.js

@@ -0,0 +1,68 @@
+import {
+  coerceBool,
+  coerceNumber
+} from "./chunk-PQVCH2AE.js";
+import {
+  log
+} from "./chunk-3WCASNQZ.js";
+
+// src/task-llm-config.ts
+var DEFAULT_TIMEOUT_MS = 18e4;
+var MIN_TIMEOUT_MS = 1;
+var MAX_TIMEOUT_MS = 864e5;
+var warnedLegacy = /* @__PURE__ */ new Set();
+function resetTaskLlmLegacyWarningsForTest() {
+  warnedLegacy.clear();
+}
+function warnLegacyOnce(legacyKey, currentKey, extra) {
+  if (warnedLegacy.has(legacyKey)) return;
+  warnedLegacy.add(legacyKey);
+  log.warn(
+    `config: ${legacyKey} is a legacy alias for ${currentKey}; set ${currentKey} instead. ${legacyKey} still works when ${currentKey} is absent. ${extra}`
+  );
+}
+function parseBoundedIntegerMs(value, fallback) {
+  const coerced = coerceNumber(value);
+  if (coerced === void 0) return fallback;
+  return Math.min(MAX_TIMEOUT_MS, Math.max(MIN_TIMEOUT_MS, Math.floor(coerced)));
+}
+function hasOwnKey(raw, key) {
+  return Object.hasOwn(raw, key);
+}
+function parseTaskLlmConfig(cfg) {
+  const localTimeoutMs = hasOwnKey(cfg, "localLlmTimeoutMs") ? parseBoundedIntegerMs(cfg.localLlmTimeoutMs, DEFAULT_TIMEOUT_MS) : DEFAULT_TIMEOUT_MS;
+  let timeoutMs;
+  if (hasOwnKey(cfg, "taskLlmTimeoutMs")) {
+    timeoutMs = parseBoundedIntegerMs(cfg.taskLlmTimeoutMs, DEFAULT_TIMEOUT_MS);
+  } else if (hasOwnKey(cfg, "localLlmTimeoutMs")) {
+    warnLegacyOnce(
+      "localLlmTimeoutMs",
+      "taskLlmTimeoutMs",
+      "localLlmTimeoutMs remains the local-endpoint timeout; without taskLlmTimeoutMs it also sizes the gateway/task chain."
+    );
+    timeoutMs = localTimeoutMs;
+  } else {
+    timeoutMs = DEFAULT_TIMEOUT_MS;
+  }
+  let fallback;
+  if (hasOwnKey(cfg, "taskLlmFallback")) {
+    const coerced = coerceBool(cfg.taskLlmFallback, "taskLlmFallback");
+    fallback = coerced !== void 0 ? coerced : true;
+  } else if (hasOwnKey(cfg, "localLlmFallback")) {
+    warnLegacyOnce(
+      "localLlmFallback",
+      "taskLlmFallback",
+      "taskLlmFallback is the current name for using the gateway/task chain when the local path fails."
+    );
+    fallback = cfg.localLlmFallback !== false;
+  } else {
+    fallback = true;
+  }
+  return { timeoutMs, localTimeoutMs, fallback };
+}
+
+export {
+  resetTaskLlmLegacyWarningsForTest,
+  parseTaskLlmConfig
+};
+//# sourceMappingURL=chunk-SK7D34OL.js.map

package/dist/chunk-SK7D34OL.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/task-llm-config.ts"],"sourcesContent":["/**\n * Honest names for the gateway/task LLM chain (issue #2967).\n *\n * `FallbackLlmClient` is the primary configured path in gateway mode, not a\n * secondary recovery path. `taskLlmTimeoutMs` / `taskLlmFallback` are the\n * current keys. `localLlmTimeoutMs` / `localLlmFallback` remain documented\n * legacy aliases, read only when the corresponding new key is absent.\n */\nimport { coerceBool, coerceNumber } from \"./connectors/coerce.js\";\nimport { log } from \"./logger.js\";\n\nconst DEFAULT_TIMEOUT_MS = 180_000;\nconst MIN_TIMEOUT_MS = 1;\nconst MAX_TIMEOUT_MS = 86_400_000;\n\nconst warnedLegacy = new Set<string>();\n\nexport function resetTaskLlmLegacyWarningsForTest(): void {\n  warnedLegacy.clear();\n}\n\nfunction warnLegacyOnce(legacyKey: string, currentKey: string, extra: string): void {\n  if (warnedLegacy.has(legacyKey)) return;\n  warnedLegacy.add(legacyKey);\n  log.warn(\n    `config: ${legacyKey} is a legacy alias for ${currentKey}; set ${currentKey} instead. ${legacyKey} still works when ${currentKey} is absent. ${extra}`,\n  );\n}\n\nfunction parseBoundedIntegerMs(value: unknown, fallback: number): number {\n  const coerced = coerceNumber(value);\n  if (coerced === undefined) return fallback;\n  return Math.min(MAX_TIMEOUT_MS, Math.max(MIN_TIMEOUT_MS, Math.floor(coerced)));\n}\n\nfunction hasOwnKey(raw: Record<string, unknown>, key: string): boolean {\n  return Object.hasOwn(raw, key);\n}\n\nexport interface ParsedTaskLlmConfig {\n  timeoutMs: number;\n  localTimeoutMs: number;\n  fallback: boolean;\n}\n\n/**\n * Resolve task-LLM timeout and local→task fallback.\n *\n * New key wins when present (including present-with-`undefined`, which takes\n * the default rather than falling through to the legacy key). Legacy keys are\n * read only when the new key is absent, and warn once per process.\n */\nexport function parseTaskLlmConfig(cfg: Record<string, unknown>): ParsedTaskLlmConfig {\n  const localTimeoutMs = hasOwnKey(cfg, \"localLlmTimeoutMs\")\n    ? parseBoundedIntegerMs(cfg.localLlmTimeoutMs, DEFAULT_TIMEOUT_MS)\n    : DEFAULT_TIMEOUT_MS;\n\n  let timeoutMs: number;\n  if (hasOwnKey(cfg, \"taskLlmTimeoutMs\")) {\n    timeoutMs = parseBoundedIntegerMs(cfg.taskLlmTimeoutMs, DEFAULT_TIMEOUT_MS);\n  } else if (hasOwnKey(cfg, \"localLlmTimeoutMs\")) {\n    warnLegacyOnce(\n      \"localLlmTimeoutMs\",\n      \"taskLlmTimeoutMs\",\n      \"localLlmTimeoutMs remains the local-endpoint timeout; without taskLlmTimeoutMs it also sizes the gateway/task chain.\",\n    );\n    timeoutMs = localTimeoutMs;\n  } else {\n    timeoutMs = DEFAULT_TIMEOUT_MS;\n  }\n\n  let fallback: boolean;\n  if (hasOwnKey(cfg, \"taskLlmFallback\")) {\n    const coerced = coerceBool(cfg.taskLlmFallback, \"taskLlmFallback\");\n    fallback = coerced !== undefined ? coerced : true;\n  } else if (hasOwnKey(cfg, \"localLlmFallback\")) {\n    warnLegacyOnce(\n      \"localLlmFallback\",\n      \"taskLlmFallback\",\n      \"taskLlmFallback is the current name for using the gateway/task chain when the local path fails.\",\n    );\n    fallback = cfg.localLlmFallback !== false;\n  } else {\n    fallback = true;\n  }\n\n  return { timeoutMs, localTimeoutMs, fallback };\n}\n"],"mappings":";;;;;;;;;AAWA,IAAM,qBAAqB;AAC3B,IAAM,iBAAiB;AACvB,IAAM,iBAAiB;AAEvB,IAAM,eAAe,oBAAI,IAAY;AAE9B,SAAS,oCAA0C;AACxD,eAAa,MAAM;AACrB;AAEA,SAAS,eAAe,WAAmB,YAAoB,OAAqB;AAClF,MAAI,aAAa,IAAI,SAAS,EAAG;AACjC,eAAa,IAAI,SAAS;AAC1B,MAAI;AAAA,IACF,WAAW,SAAS,0BAA0B,UAAU,SAAS,UAAU,aAAa,SAAS,qBAAqB,UAAU,eAAe,KAAK;AAAA,EACtJ;AACF;AAEA,SAAS,sBAAsB,OAAgB,UAA0B;AACvE,QAAM,UAAU,aAAa,KAAK;AAClC,MAAI,YAAY,OAAW,QAAO;AAClC,SAAO,KAAK,IAAI,gBAAgB,KAAK,IAAI,gBAAgB,KAAK,MAAM,OAAO,CAAC,CAAC;AAC/E;AAEA,SAAS,UAAU,KAA8B,KAAsB;AACrE,SAAO,OAAO,OAAO,KAAK,GAAG;AAC/B;AAeO,SAAS,mBAAmB,KAAmD;AACpF,QAAM,iBAAiB,UAAU,KAAK,mBAAmB,IACrD,sBAAsB,IAAI,mBAAmB,kBAAkB,IAC/D;AAEJ,MAAI;AACJ,MAAI,UAAU,KAAK,kBAAkB,GAAG;AACtC,gBAAY,sBAAsB,IAAI,kBAAkB,kBAAkB;AAAA,EAC5E,WAAW,UAAU,KAAK,mBAAmB,GAAG;AAC9C;AAAA,MACE;AAAA,MACA;AAAA,MACA;AAAA,IACF;AACA,gBAAY;AAAA,EACd,OAAO;AACL,gBAAY;AAAA,EACd;AAEA,MAAI;AACJ,MAAI,UAAU,KAAK,iBAAiB,GAAG;AACrC,UAAM,UAAU,WAAW,IAAI,iBAAiB,iBAAiB;AACjE,eAAW,YAAY,SAAY,UAAU;AAAA,EAC/C,WAAW,UAAU,KAAK,kBAAkB,GAAG;AAC7C;AAAA,MACE;AAAA,MACA;AAAA,MACA;AAAA,IACF;AACA,eAAW,IAAI,qBAAqB;AAAA,EACtC,OAAO;AACL,eAAW;AAAA,EACb;AAEA,SAAO,EAAE,WAAW,gBAAgB,SAAS;AAC/C;","names":[]}

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

@@ -13,52 +13,33 @@ import {
 import {
   CODEX_SUBSCRIPTION_PROVIDER_ID,
   abortReason,
+  classifyThrownProviderError,
+  codexDeadlineHeadroomMs,
   codexSubscriptionBuiltinProviderConfig,
-  getCodexSubscriptionRunnerForOwner,
+  defaultOpenClawWorkspaceDir,
+  extractResponsesOutputText,
   isTerminalCodexSubscriptionError,
+  isTimeoutError,
+  isUnsupportedJsonSchemaError,
+  normalizeRuntimePath,
   raceFallbackLlmDeadline,
+  readGatewayWorkspaceDir,
   tryCodexSubscriptionProvider,
   withCodexRuntimeShutdown
-} from "./chunk-CWTCMZGE.js";
+} from "./chunk-UHSOPTNB.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 +90,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 +105,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 +147,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 +174,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 +184,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,54 +209,70 @@ 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 = () => {
         controller.abort(abortReason(options.signal));
       };
       options.signal?.addEventListener("abort", onCallerAbort, { once: true });
-      if (options.signal?.aborted) {
-        onCallerAbort();
-      }
+      if (options.signal?.aborted) onCallerAbort();
       const timedOptions = { ...options, signal: controller.signal };
       const chain = runChain(timedOptions);
-      const guarded = chain.then(
-        (value) => value,
-        (err) => {
-          if (isTerminalCodexSubscriptionError(err)) throw err;
-          return null;
-        }
-      );
+      const guarded = chain.catch((err) => {
+        if (isTerminalCodexSubscriptionError(err)) throw err;
+        return null;
+      });
       try {
-        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`)
-          );
-        });
-        return outcome.timedOut ? null : outcome.value;
+        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(`task LLM: timed out after ${options.timeoutMs}ms`);
+            recordFailure({ failureReason: "timeout", errorClass: "timeout" });
+            controller.abort(timeoutError);
+            if (options.failureDiag) options.failureDiag.lastError = timeoutError;
+          },
+          models.some((m) => m.providerConfig.api === "codex-cli") ? codexDeadlineHeadroomMs(options.timeoutMs) : 0
+        );
+        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 +287,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 +367,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 +377,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 +423,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 +436,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 +445,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 +464,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 +473,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 +503,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 +584,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 +653,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 +701,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 +770,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 +823,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 +840,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-TRTLWUDD.js.map