@remnic/plugin-openclaw 1.0.34 → 1.0.36

package/dist/{chunk-NDZNURDM.js → chunk-SEGEX7W4.js}

@@ -1,29 +1,42 @@
 import {
-  countRecallTokenOverlap,
-  normalizeRecallTokens
-} from "./chunk-WPINX4MF.js";
+  isSafeRouteNamespace
+} from "./chunk-TH5FF5SC.js";
 import {
-  StorageManager,
-  isSemanticConsolidationLlmOperator
-} from "./chunk-ZXLYEVOP.js";
+  StorageManager
+} from "./chunk-G3CZA4SD.js";
 import {
   log
 } from "./chunk-UFU5GGGA.js";
 import {
   readEnvVar,
   resolveHomeDir
-} from "./chunk-TDRJVMUP.js";
+} from "./chunk-EH4AXGRO.js";
 
 // ../remnic-core/src/connectors/codex-materialize-runner.ts
-import path2 from "path";
 import { existsSync } from "fs";
 
+// ../remnic-core/src/namespaces/path.ts
+import path from "path";
+function assertNamespacePathInsideRoot(root, candidate, namespace, label = "namespace path") {
+  const relative = path.relative(root, candidate);
+  if (relative === "" || !relative.startsWith("..") && !path.isAbsolute(relative)) {
+    return;
+  }
+  throw new Error(`invalid ${label}: ${namespace}`);
+}
+function resolveNamespaceChildRoot(memoryDir, namespace, label = "namespace path") {
+  const namespaceRoot = path.resolve(memoryDir, "namespaces");
+  const candidate = path.resolve(namespaceRoot, namespace);
+  assertNamespacePathInsideRoot(namespaceRoot, candidate, namespace, label);
+  return candidate;
+}
+
 // ../remnic-core/src/connectors/codex-materialize.ts
 import {
   createHash
 } from "crypto";
 import fs from "fs";
-import path from "path";
+import path2 from "path";
 var MATERIALIZE_VERSION = 1;
 var SENTINEL_FILE = ".remnic-managed";
 var TMP_DIR = ".remnic-tmp";
@@ -34,12 +47,11 @@ function materializeForNamespace(namespace, options) {
     warn: (msg) => log.warn(`[codex-materialize] ${msg}`),
     debug: (msg) => log.debug(`[codex-materialize] ${msg}`)
   };
-  const codexHome = resolveCodexHome(options.codexHome);
-  const memoriesDir = path.join(codexHome, "memories");
+  const memoriesDir = resolveCodexMemoriesDir(options.codexHome);
   const now = options.now ?? /* @__PURE__ */ new Date();
   const maxSummaryTokens = typeof options.maxSummaryTokens === "number" && options.maxSummaryTokens >= 0 ? options.maxSummaryTokens : 4500;
   const rolloutRetentionDays = typeof options.rolloutRetentionDays === "number" && options.rolloutRetentionDays >= 0 ? options.rolloutRetentionDays : 30;
-  const sentinelPath = path.join(memoriesDir, SENTINEL_FILE);
+  const sentinelPath = path2.join(memoriesDir, SENTINEL_FILE);
   const existingSentinel = readSentinel(sentinelPath);
   if (!existingSentinel) {
     if (fs.existsSync(memoriesDir)) {
@@ -117,10 +129,10 @@ function materializeForNamespace(namespace, options) {
   });
   if (existingSentinel.content_hash === hash) {
     const requiredFiles = [
-      path.join(memoriesDir, "memory_summary.md"),
-      path.join(memoriesDir, "MEMORY.md"),
-      path.join(memoriesDir, "raw_memories.md"),
-      ...rolloutFiles.map((r) => path.join(memoriesDir, ROLLOUT_SUBDIR, r.name))
+      path2.join(memoriesDir, "memory_summary.md"),
+      path2.join(memoriesDir, "MEMORY.md"),
+      path2.join(memoriesDir, "raw_memories.md"),
+      ...rolloutFiles.map((r) => path2.join(memoriesDir, ROLLOUT_SUBDIR, r.name))
     ];
     const allPresent = requiredFiles.every((f) => fs.existsSync(f));
     if (allPresent) {
@@ -140,14 +152,14 @@ function materializeForNamespace(namespace, options) {
     );
   }
   const runTag = `${process.pid}-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
-  const tmpDir = path.join(memoriesDir, `${TMP_DIR}-${runTag}`);
+  const tmpDir = path2.join(memoriesDir, `${TMP_DIR}-${runTag}`);
   const TMP_STALE_MS = 60 * 60 * 1e3;
   const wallClockMs = Date.now();
   try {
     for (const entry of fs.readdirSync(memoriesDir, { withFileTypes: true })) {
       if (!entry.isDirectory()) continue;
       if (!entry.name.startsWith(TMP_DIR)) continue;
-      const stalePath = path.join(memoriesDir, entry.name);
+      const stalePath = path2.join(memoriesDir, entry.name);
       try {
         const stat = fs.statSync(stalePath);
         if (wallClockMs - stat.mtimeMs < TMP_STALE_MS) continue;
@@ -158,24 +170,24 @@ function materializeForNamespace(namespace, options) {
   } catch {
   }
   fs.mkdirSync(tmpDir, { recursive: true });
-  fs.mkdirSync(path.join(tmpDir, ROLLOUT_SUBDIR), { recursive: true });
+  fs.mkdirSync(path2.join(tmpDir, ROLLOUT_SUBDIR), { recursive: true });
   const filesWritten = [];
-  fs.writeFileSync(path.join(tmpDir, "memory_summary.md"), memorySummary);
+  fs.writeFileSync(path2.join(tmpDir, "memory_summary.md"), memorySummary);
   filesWritten.push("memory_summary.md");
-  fs.writeFileSync(path.join(tmpDir, "MEMORY.md"), memoryMd);
+  fs.writeFileSync(path2.join(tmpDir, "MEMORY.md"), memoryMd);
   filesWritten.push("MEMORY.md");
-  fs.writeFileSync(path.join(tmpDir, "raw_memories.md"), rawMemories);
+  fs.writeFileSync(path2.join(tmpDir, "raw_memories.md"), rawMemories);
   filesWritten.push("raw_memories.md");
   for (const rollout of rolloutFiles) {
-    fs.writeFileSync(path.join(tmpDir, ROLLOUT_SUBDIR, rollout.name), rollout.body);
-    filesWritten.push(path.join(ROLLOUT_SUBDIR, rollout.name));
+    fs.writeFileSync(path2.join(tmpDir, ROLLOUT_SUBDIR, rollout.name), rollout.body);
+    filesWritten.push(path2.join(ROLLOUT_SUBDIR, rollout.name));
   }
   for (const rel of ["memory_summary.md", "MEMORY.md", "raw_memories.md"]) {
-    const src = path.join(tmpDir, rel);
-    const dest = path.join(memoriesDir, rel);
+    const src = path2.join(tmpDir, rel);
+    const dest = path2.join(memoriesDir, rel);
     fs.renameSync(src, dest);
   }
-  const destRolloutsDir = path.join(memoriesDir, ROLLOUT_SUBDIR);
+  const destRolloutsDir = path2.join(memoriesDir, ROLLOUT_SUBDIR);
   fs.mkdirSync(destRolloutsDir, { recursive: true });
   if (rolloutsSupplied) {
     const retainedRolloutNames = new Set(rolloutFiles.map((r) => r.name));
@@ -185,7 +197,7 @@ function materializeForNamespace(namespace, options) {
         if (!entry.name.endsWith(".md")) continue;
         if (retainedRolloutNames.has(entry.name)) continue;
         try {
-          fs.unlinkSync(path.join(destRolloutsDir, entry.name));
+          fs.unlinkSync(path2.join(destRolloutsDir, entry.name));
         } catch {
         }
       }
@@ -193,8 +205,8 @@ function materializeForNamespace(namespace, options) {
     }
   }
   for (const rollout of rolloutFiles) {
-    const src = path.join(tmpDir, ROLLOUT_SUBDIR, rollout.name);
-    const dest = path.join(destRolloutsDir, rollout.name);
+    const src = path2.join(tmpDir, ROLLOUT_SUBDIR, rollout.name);
+    const dest = path2.join(destRolloutsDir, rollout.name);
     fs.renameSync(src, dest);
   }
   const sentinel = {
@@ -419,7 +431,13 @@ function resolveCodexHome(override) {
   if (override && override.trim().length > 0) return override;
   const fromEnv = readEnvVar("CODEX_HOME");
   if (fromEnv && fromEnv.trim().length > 0) return fromEnv;
-  return path.join(resolveHomeDir(), ".codex");
+  return path2.join(resolveHomeDir(), ".codex");
+}
+function resolveCodexMemoriesDir(codexHome) {
+  return path2.join(resolveCodexHome(codexHome), "memories");
+}
+function hasCodexMaterializeSentinel(codexHome) {
+  return readSentinel(path2.join(resolveCodexMemoriesDir(codexHome), SENTINEL_FILE)) !== null;
 }
 function readSentinel(sentinelPath) {
   if (!fs.existsSync(sentinelPath)) return null;
@@ -567,16 +585,19 @@ async function runCodexMaterialize(options) {
   if (options.memories) {
     memories = options.memories;
   } else {
+    if (!hasCodexMaterializeSentinel(options.codexHome)) {
+      return materializeForNamespace(namespace, {
+        memories: [],
+        codexHome: options.codexHome,
+        maxSummaryTokens: cfg.codexMaterializeMaxSummaryTokens,
+        rolloutRetentionDays: cfg.codexMaterializeRolloutRetentionDays,
+        rolloutSummaries: options.rolloutSummaries,
+        now: options.now
+      });
+    }
     const nsDir = resolveNamespaceDir(memoryDir, namespace, cfg);
     const storage = new StorageManager(nsDir);
-    try {
-      memories = await storage.readAllMemories();
-    } catch (error) {
-      log.warn(
-        `[codex-materialize] skipped \u2014 failed to read memories from ${nsDir}: ${error instanceof Error ? error.message : String(error)}`
-      );
-      return null;
-    }
+    memories = await storage.readAllMemories();
   }
   const result = materializeForNamespace(namespace, {
     memories,
@@ -616,16 +637,22 @@ async function runPostConsolidationMaterialize(logPrefix, options) {
 }
 function resolveNamespace(override, cfg) {
   const requested = (override ?? cfg.codexMaterializeNamespace ?? "auto").trim();
-  if (requested.length === 0 || requested === "auto") {
-    return cfg.defaultNamespace && cfg.defaultNamespace.length > 0 ? cfg.defaultNamespace : "default";
+  const defaultNamespace = (cfg.defaultNamespace ?? "").trim();
+  const namespace = requested.length === 0 || requested === "auto" ? defaultNamespace.length > 0 ? defaultNamespace : "default" : requested;
+  if (!isSafeRouteNamespace(namespace)) {
+    throw new Error(`invalid materialize namespace: ${namespace}`);
   }
-  return requested;
+  return namespace;
 }
 function resolveNamespaceDir(memoryDir, namespace, cfg) {
   if (!cfg.namespacesEnabled) return memoryDir;
-  const ns = namespace || cfg.defaultNamespace || "default";
-  const namespacedRoot = path2.join(memoryDir, "namespaces", ns);
-  if (ns === cfg.defaultNamespace) {
+  const defaultNamespace = (cfg.defaultNamespace ?? "").trim();
+  const ns = (namespace || defaultNamespace || "default").trim();
+  if (!isSafeRouteNamespace(ns)) {
+    throw new Error(`invalid materialize namespace: ${ns}`);
+  }
+  const namespacedRoot = resolveNamespaceChildRoot(memoryDir, ns, "materialize namespace path");
+  if (ns === defaultNamespace) {
     return existsSync(namespacedRoot) ? namespacedRoot : memoryDir;
   }
   return namespacedRoot;
@@ -853,190 +880,8 @@ ${ext.instructions}
   }
   return result;
 }
-function renderExtensionsFooter(extensions) {
-  if (extensions.length === 0) return "";
-  const names = extensions.map((ext) => ext.name).join(", ");
-  return `Active extensions: ${names}`;
-}
 
 // ../remnic-core/src/semantic-consolidation.ts
-function findSimilarClusters(memories, config) {
-  const excluded = new Set(config.excludeCategories);
-  const byCategory = /* @__PURE__ */ new Map();
-  for (const m of memories) {
-    const cat = m.frontmatter.category;
-    if (excluded.has(cat)) continue;
-    if (m.frontmatter.status && m.frontmatter.status !== "active") continue;
-    const list = byCategory.get(cat) ?? [];
-    list.push(m);
-    byCategory.set(cat, list);
-  }
-  const clusters = [];
-  let totalCandidates = 0;
-  for (const [category, mems] of byCategory) {
-    if (totalCandidates >= config.maxPerRun) break;
-    const tokenized = mems.map((m) => ({
-      memory: m,
-      tokens: new Set(normalizeRecallTokens(m.content, []))
-    }));
-    const clustered = /* @__PURE__ */ new Set();
-    for (let i = 0; i < tokenized.length && totalCandidates < config.maxPerRun; i++) {
-      if (clustered.has(tokenized[i].memory.frontmatter.id)) continue;
-      const cluster = [tokenized[i].memory];
-      let totalOverlap = 0;
-      let comparisons = 0;
-      for (let j = i + 1; j < tokenized.length; j++) {
-        if (clustered.has(tokenized[j].memory.frontmatter.id)) continue;
-        const aTokens = tokenized[i].tokens;
-        const bTokens = tokenized[j].tokens;
-        if (aTokens.size === 0 || bTokens.size === 0) continue;
-        const overlap = countRecallTokenOverlap(aTokens, [...bTokens].join(" "));
-        const maxTokens = Math.max(aTokens.size, bTokens.size);
-        const score = maxTokens > 0 ? overlap / maxTokens : 0;
-        if (score >= config.threshold) {
-          cluster.push(tokenized[j].memory);
-          totalOverlap += score;
-          comparisons++;
-          if (totalCandidates + cluster.length >= config.maxPerRun) break;
-        }
-      }
-      if (cluster.length >= config.minClusterSize) {
-        for (const m of cluster) clustered.add(m.frontmatter.id);
-        clusters.push({
-          category,
-          memories: cluster,
-          overlapScore: comparisons > 0 ? totalOverlap / comparisons : 0
-        });
-        totalCandidates += cluster.length;
-      }
-    }
-  }
-  return clusters;
-}
-function buildConsolidationPrompt(cluster) {
-  const memoryTexts = cluster.memories.map(
-    (m, i) => `Memory ${i + 1} (${m.frontmatter.id}, created ${m.frontmatter.created}):
-${m.content}`
-  ).join("\n\n");
-  return `You are a memory consolidation system. The following ${cluster.memories.length} memories in the "${cluster.category}" category contain overlapping information.
-
-Synthesize them into ONE canonical memory that:
-1. Preserves ALL unique information from every source memory
-2. Removes redundancy and repetition
-3. Uses clear, concise language
-4. Maintains the same category and tone
-5. Does NOT add information that isn't in the sources
-
-${memoryTexts}
-
-Write ONLY the consolidated memory content (no metadata, no explanation, no preamble):`;
-}
-function parseConsolidationResponse(response) {
-  return response.trim();
-}
-function chooseConsolidationOperator(cluster) {
-  if (cluster.memories.length <= 1) return "update";
-  return "merge";
-}
-function buildOperatorAwareConsolidationPrompt(cluster) {
-  const memoryTexts = cluster.memories.map(
-    (m, i) => `Memory ${i + 1} (${m.frontmatter.id}, created ${m.frontmatter.created}):
-${m.content}`
-  ).join("\n\n");
-  return `You are a memory consolidation system.  The following ${cluster.memories.length} memories in the "${cluster.category}" category contain overlapping information.
-
-Pick exactly ONE consolidation operator for this cluster and return a JSON object.
-
-Operator vocabulary:
-  - "merge"  \u2014 multiple distinct source memories overlap and should be collapsed into one canonical memory (most common).
-  - "update" \u2014 one source memory carries a stale value that a newer source supersedes within the same logical fact.
-  - "split"  \u2014 a single logical source really encodes multiple distinct facts that should be separated (rare; if you pick split, still emit ONE canonical body \u2014 the write path will chunk it later).
-
-Output JSON ONLY, no prose before or after.  The "operator" key MUST be set to exactly one of the three strings "merge", "update", or "split" \u2014 never a pipe-separated placeholder like "merge|update|split".  Example shape:
-  {
-    "operator": "merge",
-    "output": "<the canonical memory text>"
-  }
-
-The "output" value must:
-1. Preserve ALL unique information from every source memory
-2. Remove redundancy and repetition
-3. Use clear, concise language
-4. Match the "${cluster.category}" category and tone
-5. NOT add information that isn't in the sources
-
-${memoryTexts}
-
-Return ONLY the JSON object:`;
-}
-function parseOperatorAwareConsolidationResponse(response, cluster) {
-  const fallback = {
-    operator: chooseConsolidationOperator(cluster),
-    output: response.trim()
-  };
-  const trimmed = response.trim();
-  if (trimmed.length === 0) return fallback;
-  const fenced = /^```(?:json)?\s*([\s\S]*?)```\s*$/u.exec(trimmed);
-  const payload = fenced ? fenced[1].trim() : trimmed;
-  const parsed = findLastJsonObjectWithOperator(payload);
-  if (parsed === void 0) return fallback;
-  if (typeof parsed !== "object" || parsed === null) return fallback;
-  const obj = parsed;
-  const rawOperator = typeof obj.operator === "string" ? obj.operator.trim().toLowerCase() : "";
-  const rawOutput = typeof obj.output === "string" ? obj.output : "";
-  const operator = isSemanticConsolidationLlmOperator(rawOperator) ? rawOperator : chooseConsolidationOperator(cluster);
-  const output = rawOutput.trim().length > 0 ? rawOutput.trim() : response.trim();
-  return { operator, output };
-}
-function findLastJsonObjectWithOperator(text) {
-  let searchFrom = 0;
-  let last = void 0;
-  while (searchFrom < text.length) {
-    const start = text.indexOf("{", searchFrom);
-    if (start < 0) return last;
-    let depth = 0;
-    let inString = false;
-    let escape = false;
-    let closed = false;
-    let endIdx = -1;
-    for (let i = start; i < text.length; i++) {
-      const ch = text[i];
-      if (inString) {
-        if (escape) {
-          escape = false;
-        } else if (ch === "\\") {
-          escape = true;
-        } else if (ch === '"') {
-          inString = false;
-        }
-        continue;
-      }
-      if (ch === '"') {
-        inString = true;
-      } else if (ch === "{") {
-        depth += 1;
-      } else if (ch === "}") {
-        depth -= 1;
-        if (depth === 0) {
-          closed = true;
-          endIdx = i;
-          break;
-        }
-      }
-    }
-    if (!closed) return last;
-    const slice = text.slice(start, endIdx + 1);
-    try {
-      const parsed = JSON.parse(slice);
-      if (typeof parsed === "object" && parsed !== null && "operator" in parsed) {
-        last = parsed;
-      }
-    } catch {
-    }
-    searchFrom = endIdx + 1;
-  }
-  return last;
-}
 async function buildExtensionsBlockForConsolidation(config) {
   if (!config.memoryExtensionsEnabled) return "";
   const root = resolveExtensionsRoot(config);
@@ -1044,21 +889,8 @@ async function buildExtensionsBlockForConsolidation(config) {
   if (extensions.length === 0) return "";
   return renderExtensionsBlock(extensions);
 }
-async function materializeAfterSemanticConsolidation(options) {
-  return runPostConsolidationMaterialize("[semantic-consolidation]", options);
-}
 
 export {
-  discoverMemoryExtensions,
-  resolveExtensionsRoot,
-  renderExtensionsFooter,
   runPostConsolidationMaterialize,
-  findSimilarClusters,
-  buildConsolidationPrompt,
-  parseConsolidationResponse,
-  chooseConsolidationOperator,
-  buildOperatorAwareConsolidationPrompt,
-  parseOperatorAwareConsolidationResponse,
-  buildExtensionsBlockForConsolidation,
-  materializeAfterSemanticConsolidation
+  buildExtensionsBlockForConsolidation
 };

package/dist/{chunk-7NUFIRM3.js → chunk-SWOYEQN2.js}

@@ -8,7 +8,7 @@ import {
   expandTildePath,
   readEnvVar,
   resolveHomeDir
-} from "./chunk-TDRJVMUP.js";
+} from "./chunk-EH4AXGRO.js";
 
 // ../remnic-core/src/fallback-llm.ts
 import path2 from "path";
@@ -66,6 +66,13 @@ var _resolverLoaded = false;
 var _resolverNextRetryAt = 0;
 var RESOLVER_RETRY_BACKOFF_MS = 6e4;
 var resolvedCache = /* @__PURE__ */ new Map();
+var cacheObjectIds = /* @__PURE__ */ new WeakMap();
+var nextCacheObjectId = 1;
+var NON_LITERAL_AUTH_MARKERS = /* @__PURE__ */ new Set([
+  "secretref-managed",
+  "lm-studio"
+]);
+var ENV_VAR_MARKER_RE = /^[A-Z][A-Z0-9_]*(?:_API_KEY|_ACCESS_TOKEN|_TOKEN|_SECRET|_CREDENTIALS|_CREDENTIALS_JSON)$/;
 async function getGatewayResolver() {
   if (_resolverLoaded) {
     return _resolveCredentialForProvider;
@@ -178,23 +185,59 @@ function findExecutableOnPath(executableName, access, stat, executableMode) {
   }
   return void 0;
 }
+function isNonLiteralAuthMarker(value) {
+  return NON_LITERAL_AUTH_MARKERS.has(value) || value.endsWith("-oauth") || value.endsWith("-local") || value.startsWith("gcp-") || ENV_VAR_MARKER_RE.test(value);
+}
+function resolveFromNamedEnvVar(marker) {
+  if (!ENV_VAR_MARKER_RE.test(marker)) return void 0;
+  const value = readEnvVar(marker);
+  return value && value.trim().length > 0 ? value.trim() : void 0;
+}
+function cacheIdentity(value) {
+  if (value === null) return "null";
+  if (value === void 0) return "undefined";
+  if (typeof value === "string") return `string:${value}`;
+  if (typeof value === "number") return `number:${String(value)}`;
+  if (typeof value === "boolean") return `boolean:${String(value)}`;
+  if (typeof value === "bigint") return `bigint:${String(value)}`;
+  if (typeof value === "symbol" || typeof value === "function") return typeof value;
+  if (typeof value === "object") {
+    const existingId = cacheObjectIds.get(value);
+    if (existingId !== void 0) return `object:${existingId}`;
+    const newId = nextCacheObjectId++;
+    cacheObjectIds.set(value, newId);
+    return `object:${newId}`;
+  }
+  return String(value);
+}
+function providerSecretCacheKey(providerId, resolvedAgentDir, credentialValue, gatewayConfig) {
+  return [
+    `provider:${providerId}`,
+    `agentDir:${resolvedAgentDir}`,
+    `apiKey:${cacheIdentity(credentialValue)}`,
+    `cfg:${cacheIdentity(gatewayConfig)}`
+  ].join(":");
+}
 async function resolveProviderCredential(providerId, credentialValue, gatewayConfig, agentDir) {
   const resolvedAgentDir = path.resolve(
     agentDir ?? path.join(os.homedir(), ".openclaw", "agents", "main", "agent")
   );
-  const cacheKey = `provider:${providerId}:agentDir:${resolvedAgentDir}`;
-  if (resolvedCache.has(cacheKey)) {
-    return resolvedCache.get(cacheKey);
-  }
   let resolved;
   if (typeof credentialValue === "string" && credentialValue.trim().length > 0) {
-    if (credentialValue === "secretref-managed" || credentialValue.endsWith("-oauth") || credentialValue.endsWith("-local") || credentialValue === "lm-studio" || credentialValue.startsWith("gcp-")) {
+    const trimmedCredentialValue = credentialValue.trim();
+    if (isNonLiteralAuthMarker(trimmedCredentialValue)) {
+      const markerEnvValue = resolveFromNamedEnvVar(trimmedCredentialValue);
+      if (markerEnvValue) {
+        return markerEnvValue;
+      }
     } else {
-      resolved = credentialValue;
-      resolvedCache.set(cacheKey, resolved);
-      return resolved;
+      return trimmedCredentialValue;
     }
   }
+  const cacheKey = providerSecretCacheKey(providerId, resolvedAgentDir, credentialValue, gatewayConfig);
+  if (resolvedCache.has(cacheKey)) {
+    return resolvedCache.get(cacheKey);
+  }
   const resolver = await getGatewayResolver();
   if (resolver) {
     try {
@@ -307,7 +350,8 @@ function normalizeCodexCliFallbackConfig(config) {
 }
 function normalizeCodexCliFallbackOptions(options) {
   return {
-    ...options.timeoutMs !== void 0 ? { timeoutMs: normalizeCodexCliTimeoutMs(options.timeoutMs) } : {}
+    ...options.timeoutMs !== void 0 ? { timeoutMs: normalizeCodexCliTimeoutMs(options.timeoutMs) } : {},
+    ...options.signal ? { signal: options.signal } : {}
   };
 }
 function normalizeOptionalString(value, label) {
@@ -381,17 +425,20 @@ var FallbackLlmClient = class {
    * When agentId is provided, uses that agent persona's model chain instead of defaults.
    */
   async chatCompletion(messages, options = {}) {
-    const models = this.getModelChain(options.agentId);
+    const models = this.getModelChain(options.agentId, options.model);
     if (models.length === 0) {
       log.warn("fallback LLM: no models configured in gateway");
       return null;
     }
-    const runChain = async () => {
+    const runChain = async (runOptions) => {
       for (let i = 0; i < models.length; i++) {
+        if (runOptions.signal?.aborted) {
+          throw abortReason(runOptions.signal);
+        }
         const model = models[i];
         const isFallback = i > 0;
         try {
-          const result = await this.tryModel(model, messages, options);
+          const result = await this.tryModel(model, messages, runOptions);
           if (result) {
             if (isFallback) {
               log.debug(`fallback LLM: succeeded using ${model.modelString} (fallback ${i})`);
@@ -403,6 +450,9 @@ var FallbackLlmClient = class {
             };
           }
         } catch (err) {
+          if (runOptions.signal?.aborted) {
+            throw abortReason(runOptions.signal);
+          }
           const errorMsg = err instanceof Error ? err.message : String(err);
           log.debug(`fallback LLM: ${model.modelString} failed (${errorMsg}), trying next...`);
         }
@@ -416,21 +466,37 @@ var FallbackLlmClient = class {
         return null;
       }
       let timeoutHandle;
+      const controller = new AbortController();
+      const onCallerAbort = () => {
+        controller.abort(abortReason(options.signal));
+      };
+      options.signal?.addEventListener("abort", onCallerAbort, { once: true });
+      if (options.signal?.aborted) {
+        onCallerAbort();
+      }
+      const timedOptions = { ...options, signal: controller.signal };
+      const chain = runChain(timedOptions);
+      chain.catch(() => {
+      });
       try {
         return await Promise.race([
-          runChain(),
+          chain,
           new Promise((resolve) => {
             timeoutHandle = setTimeout(() => {
               log.warn(`fallback LLM: timed out after ${options.timeoutMs}ms`);
+              controller.abort(
+                new Error(`fallback LLM timed out after ${options.timeoutMs}ms`)
+              );
               resolve(null);
             }, options.timeoutMs);
           })
         ]);
       } finally {
         if (timeoutHandle) clearTimeout(timeoutHandle);
+        options.signal?.removeEventListener("abort", onCallerAbort);
       }
     }
-    return await runChain();
+    return await runChain(options);
   }
   /**
    * Make a request with structured output (Zod schema).
@@ -470,7 +536,7 @@ var FallbackLlmClient = class {
    * and uses that persona's model chain. Falls back to agents.defaults.model
    * if agentId is not found or not provided.
    */
-  getModelChain(agentId) {
+  getModelChain(agentId, modelOverride) {
     const chain = [];
     const providers = this.gatewayConfig?.models?.providers ?? {};
     let modelConfig;
@@ -491,8 +557,13 @@ var FallbackLlmClient = class {
       modelConfig = this.gatewayConfig?.agents?.defaults?.model;
     }
     const modelStrings = [];
+    if (typeof modelOverride === "string" && modelOverride.trim().length > 0) {
+      modelStrings.push(modelOverride.trim());
+    }
     if (modelConfig?.primary) {
-      modelStrings.push(modelConfig.primary);
+      if (!modelStrings.includes(modelConfig.primary)) {
+        modelStrings.push(modelConfig.primary);
+      }
     }
     if (Array.isArray(modelConfig?.fallbacks)) {
       for (const fb of modelConfig.fallbacks) {
@@ -618,7 +689,7 @@ var FallbackLlmClient = class {
         effectiveConfig,
         model.modelId,
         messages,
-        { timeoutMs: options.timeoutMs }
+        { timeoutMs: options.timeoutMs, signal: options.signal }
       );
     }
     if (model.providerConfig.api === "ollama-chat") {
@@ -712,6 +783,7 @@ var FallbackLlmClient = class {
     const response = await fetch(url, {
       method: "POST",
       headers,
+      signal: options.signal,
       body: JSON.stringify(body)
     });
     if (!response.ok) {
@@ -750,6 +822,7 @@ var FallbackLlmClient = class {
     const response = await fetch(url, {
       method: "POST",
       headers,
+      signal: options.signal,
       body: JSON.stringify({
         model: modelId,
         messages,
@@ -816,6 +889,7 @@ var FallbackLlmClient = class {
     const response = await fetch(url, {
       method: "POST",
       headers,
+      signal: options.signal,
       body: JSON.stringify(body)
     });
     if (!response.ok) {
@@ -868,6 +942,7 @@ var FallbackLlmClient = class {
     const response = await fetch(url, {
       method: "POST",
       headers,
+      signal: options.signal,
       body: JSON.stringify(body)
     });
     if (!response.ok) {
@@ -889,6 +964,10 @@ var FallbackLlmClient = class {
     };
   }
 };
+function abortReason(signal) {
+  const reason = signal?.reason;
+  return reason instanceof Error ? reason : new Error("fallback LLM request aborted");
+}
 function normalizeRuntimePath(value) {
   if (typeof value !== "string") return void 0;
   const trimmed = value.trim();
@@ -922,8 +1001,5 @@ function extractResponsesOutputText(data) {
 }
 
 export {
-  shouldAssumeOpenAiChatCompletions,
-  buildChatCompletionTokenLimit,
-  findGatewayRuntimeModules,
   FallbackLlmClient
 };