nolo-cli 0.153.2 → 0.154.0

package/{chunk-3WIXU4XO.js → chunk-QI2WVWXV.js}

@@ -15,7 +15,7 @@ import {
 } from "./chunk-PSCNXBYA.js";
 import {
   getModelConfig
-} from "./chunk-TRW43TSC.js";
+} from "./chunk-6EQD4AQL.js";
 import {
   asTrimmedString
 } from "./chunk-3EUW3WEO.js";
@@ -112,6 +112,17 @@ var PARALLEL_DISPATCH_DEFAULT_RULE = [
   "\u6D3E\u53D1\u65F6\u5728\u56DE\u590D\u91CC\u5199\u51FA\u300C\u5E76\u53D1\u7EC4 / \u4E32\u884C\u7406\u7531\u300D\uFF0C\u8BA9\u7528\u6237\u4E00\u773C\u770B\u51FA\u54EA\u6761\u7EBF\u88AB\u4E32\u884C\u5316\u3001\u4F9D\u636E\u662F\u4EC0\u4E48\u3002"
 ].join("\n");
 
+// packages/agent-runtime/dispatchBackendPolicy.ts
+var DISPATCH_BACKEND_POLICY = [
+  "\u3010\u6D3E\u53D1\u843D\u70B9 \xB7 \u6267\u884C\u540E\u7AEF\u3011",
+  "\u6D3E\u53D1\u5B50 run \u5148\u770B**\u80FD\u529B\u6761\u4EF6**\uFF0C\u522B\u4E00\u5F8B\u52A0 `local`\uFF1A",
+  '\u2460 \u6709\u5BBF\u4E3B\u6267\u884C\u5668\uFF08CLI / desktop\uFF09\u4E14\u8981\u6309\u7ED9\u5B9A `cwd` \u6539\u6307\u5B9A worktree / \u76EE\u5F55 \u2192 `runtimeKey: "local"` + `allowHostWrites: true`\uFF08\u7F3A\u4E00\u5373\u62D2\uFF09\u3002',
+  "\u2461 \u8981\u8BBF\u95EE\u7EBF\u4E0A\u670D\u52A1\u5668\u6216\u5BBF\u4E3B\u51ED\u636E \u2192 \u9009**\u6709\u8BE5\u80FD\u529B**\u7684\u6267\u884C\u9762\uFF1A\u6709\u5BBF\u4E3B\u6267\u884C\u5668\u65F6\u7528 `local`\uFF0C\u6CA1\u6709\u65F6\u7528\u5DF2\u8FDE\u63A5\u7684\u673A\u5668 `machine:<machineId>`\u3002",
+  "\u670D\u52A1\u7AEF\u7684 run \u6CA1\u6709\u5BBF\u4E3B\u6267\u884C\u5668\uFF0C\u5151\u73B0\u4E0D\u4E86\u8C03\u7528\u65B9\u7684\u672C\u5730 `cwd`\uFF1A`local` \u7ED5\u4E0D\u8FC7\u53BB\uFF08`local_target_unsupported`\uFF09\uFF0C\u8981\u4E48\u8D70 `machine:<machineId>`\uFF0C\u8981\u4E48\u7701\u7565\u843D\u70B9\u3002",
+  "\u6C99\u76D2\u7684\u7A33\u5B9A\u8FB9\u754C\uFF1A\u4E0D\u5151\u73B0\u5BBF\u4E3B\u7EDD\u5BF9 `cwd`\u3001\u4E0D\u81EA\u52A8\u7EE7\u627F\u5BBF\u4E3B\u51ED\u636E\uFF1B\u5DE5\u5177\u4E0E\u7F51\u7EDC\u80FD\u529B\u4EE5\u5C31\u7EEA\u73AF\u5883\u4E3A\u51C6\u3002",
+  "\u300C\u5199\u578B\u6D3E\u53D1\u9ED8\u8BA4\u843D docker \u6C99\u76D2\u300D\u53EA\u5C5E\u4E8E CLI \u672C\u5730\u6D3E\u53D1\u901A\u9053\u8FD9\u4E00\u8303\u56F4\uFF1B\u4E0D\u5E26\u5BBF\u4E3B\u72B6\u6001\u4E0E\u5BBF\u4E3B\u51ED\u636E\u7684\u72EC\u7ACB\u4EE3\u7801\u6539\u52A8 + \u8DD1\u6D4B\u8BD5\uFF0C\u6C99\u76D2\u4ECD\u662F\u9996\u9009\uFF08\u9694\u79BB\u662F\u4FDD\u9669\uFF0C\u4E0D\u662F\u8D1F\u62C5\uFF09\u3002"
+].join("\n");
+
 // packages/agent-runtime/platformRiskControl.ts
 var PLATFORM_RISK_CONTROL_RULE = [
   "\u3010\u5E73\u53F0\u98CE\u63A7\u7EAA\u5F8B \xB7 \u7B2C\u4E09\u65B9\u7AD9\u70B9\u81EA\u52A8\u5316\u3011",
@@ -776,6 +787,7 @@ export {
   DELETE_SAFETY_RED_LINE,
   CREDENTIAL_HYGIENE_RULE,
   PARALLEL_DISPATCH_DEFAULT_RULE,
+  DISPATCH_BACKEND_POLICY,
   PLATFORM_RISK_CONTROL_RULE,
   isGptProModel,
   shouldBlockForGptPro,

package/{chunk-VSJIIKGY.js → chunk-QXZH5UDF.js}

@@ -27,11 +27,11 @@ import {
   stablePromptCacheKey,
   toOpenAiCompatibleMessages,
   toResponsesTools
-} from "./chunk-SGJRNVYF.js";
+} from "./chunk-4L4K6YR7.js";
 import {
   isMeaningfulChatCompletionOutput,
   isMeaningfulResponsesOutput
-} from "./chunk-AAMWEIEP.js";
+} from "./chunk-QA2C5NKI.js";
 import {
   clipCompactText
 } from "./chunk-5MMAK75Q.js";
@@ -44,7 +44,7 @@ import {
   resolvePlatformAuthToken,
   resolvePlatformServerUrl,
   resolveProviderTransportDecision
-} from "./chunk-SUKSWFLP.js";
+} from "./chunk-PIG2IUVZ.js";
 import {
   isRecord
 } from "./chunk-KUG52IAP.js";

package/{chunk-SQ73U3BG.js → chunk-QZIOZDM6.js}

@@ -2,7 +2,7 @@ import {
   clipMultilineText,
   fetchAndSerializeTable,
   waitForAbortableDelay
-} from "./chunk-SOEJSA7I.js";
+} from "./chunk-FCUKCVKN.js";
 import {
   isGatewayHttpStatus
 } from "./chunk-NF64D32W.js";
@@ -15,30 +15,33 @@ import {
 import {
   resolvePageReadMarkdown,
   slateToSimplifiedMarkdown
-} from "./chunk-US6MKPE7.js";
+} from "./chunk-3L5MSPWX.js";
 import {
   extractCategorizedMentions
 } from "./chunk-AGIM7IMJ.js";
 import {
   fetchAndCacheMessages
-} from "./chunk-T64RZQBO.js";
+} from "./chunk-F5WASHQA.js";
 import {
   createSpaceKey
 } from "./chunk-UAD2WT54.js";
 import {
   read
-} from "./chunk-ZVQHBIWV.js";
+} from "./chunk-CDLP56BS.js";
 import {
   getRuntimeServerContext
-} from "./chunk-2SGAI64X.js";
+} from "./chunk-43OFVLWJ.js";
 import {
   extractRuntimePageCapabilities,
   resolveBuiltinSkillPage,
   resolveSkillGraphFromRoots
-} from "./chunk-DC3SZCRR.js";
+} from "./chunk-SH3XD4E2.js";
 import {
   isAbortError
 } from "./chunk-7DPNBQSV.js";
+import {
+  wrapHistoricalSummaryWithReplayGuard
+} from "./chunk-4VJAC32I.js";
 import {
   extractCustomId
 } from "./chunk-M2EJHDJP.js";
@@ -51,9 +54,6 @@ import {
 import {
   asTrimmedString
 } from "./chunk-3EUW3WEO.js";
-import {
-  wrapHistoricalSummaryWithReplayGuard
-} from "./chunk-4VJAC32I.js";
 
 // packages/ai/chat/errorDiagnostics.ts
 var record = (value) => value !== null && typeof value === "object" && !Array.isArray(value) ? value : {};

package/{chunk-MJ54WBLO.js → chunk-R2KWTENX.js}

@@ -7,7 +7,7 @@ import {
 import {
   patch,
   readAndWait
-} from "./chunk-ZVQHBIWV.js";
+} from "./chunk-CDLP56BS.js";
 import {
   toErrorMessage
 } from "./chunk-HNMXYYJR.js";
@@ -333,7 +333,7 @@ async function saveDocState(arg, { dispatch, getState }) {
     ).unwrap();
     if (dbSpaceId) {
       try {
-        const { updateContentTitle } = await import("./contentThunks-56AWRCC4.js");
+        const { updateContentTitle } = await import("./contentThunks-QBL5NK2W.js");
         await dispatch(
           updateContentTitle({
             spaceId: dbSpaceId,
@@ -372,7 +372,7 @@ async function saveDocState(arg, { dispatch, getState }) {
   }
 }
 async function createDocState(args, thunkApi) {
-  const { createPageAction } = await import("./createPageAction-T4WRPDOH.js");
+  const { createPageAction } = await import("./createPageAction-7T3RINS2.js");
   return createPageAction(args, thunkApi);
 }
 function subscribe(listener) {

package/{chunk-C3OK72G3.js → chunk-RIHQGFFA.js}

@@ -1,7 +1,7 @@
 import {
   readDbRecord,
   writeAgentRecord
-} from "./chunk-ZEY4NJRE.js";
+} from "./chunk-KABQ74UQ.js";
 import {
   buildSkillSummaryMarker
 } from "./chunk-VF4K2QE6.js";

package/{chunk-DC3SZCRR.js → chunk-SH3XD4E2.js}

@@ -6,11 +6,11 @@ import {
   buildBuiltinObjectSkillDbKey,
   buildBuiltinObjectSkillPageContent,
   buildCodeWorkDiscipline
-} from "./chunk-JZX2XLKC.js";
+} from "./chunk-YCRROBDY.js";
 import {
   buildSkillDocMarkdown,
   resolvePageSkillMetadata
-} from "./chunk-XETG4RIX.js";
+} from "./chunk-AETZ7AD6.js";
 import {
   nolotusId
 } from "./chunk-Y6ORVLSS.js";

package/{chunk-MM3662RS.js → chunk-SNAWGDXT.js}

@@ -2,13 +2,13 @@ import {
   isAgentRunTerminalStatus,
   normalizeRunTitle
 } from "./chunk-PJNFNEJE.js";
-import {
-  resolvePlatformAuthToken
-} from "./chunk-SUKSWFLP.js";
 import {
   isCompiledBinary,
   resolveCliEntrypointPath
 } from "./chunk-A7GB5UGH.js";
+import {
+  resolvePlatformAuthToken
+} from "./chunk-PIG2IUVZ.js";
 
 // packages/cli/client/originShellApprovalTransport.ts
 import { realpathSync } from "node:fs";
@@ -324,6 +324,233 @@ import { dirname, isAbsolute as isAbsolute2, join, resolve } from "node:path";
 import * as nodeFs from "node:fs";
 import { execFileSync as nodeExecFileSync, spawn as nodeSpawn } from "node:child_process";
 
+// packages/cli/client/hostMemory.ts
+import { readFileSync, existsSync } from "node:fs";
+import { freemem as osFreemem, totalmem as osTotalmem } from "node:os";
+var PROC_MEMINFO_PATH = "/proc/meminfo";
+var PROC_MOUNTS_PATH = "/proc/mounts";
+var DEFAULT_CGROUP2_MOUNT = "/sys/fs/cgroup";
+var SANDBOX_MARKER_PATHS = ["/.dockerenv", "/run/.containerenv"];
+var PROC_SELF_CGROUP_PATH = "/proc/self/cgroup";
+var SANDBOX_CGROUP_PATTERN = /(docker|kubepods|instabox|containerd)/;
+var MEMORY_AVAILABLE_RATIO_THRESHOLD = 0.15;
+var SWAP_USED_RATIO_THRESHOLD = 0.7;
+var HOST_MEMORY_PRESSURE_HINT = "\u26A0 \u5185\u5B58\u504F\u7D27\uFF0C\u5EFA\u8BAE\u91CD\u6D3B\u653E\u6C99\u76D2/\u8FDC\u7AEF\u6216\u51CF\u5C11\u5E76\u53D1";
+var BYTES_PER_MB = 1024 * 1024;
+function toMbFromBytes(bytes) {
+  return Math.round(bytes / BYTES_PER_MB);
+}
+function kbToMb(kb) {
+  return Math.round(kb / 1024);
+}
+function tryReadText(deps, path) {
+  try {
+    const reader = deps.readFile ?? ((p) => readFileSync(p, "utf8"));
+    const text = reader(path);
+    return typeof text === "string" ? text : null;
+  } catch {
+    return null;
+  }
+}
+function tryExists(deps, path) {
+  try {
+    const checker = deps.exists ?? ((p) => existsSync(p));
+    return checker(path) === true;
+  } catch {
+    return false;
+  }
+}
+function readKbValue(text, key) {
+  const match = new RegExp(`^${key}:\\s*(\\d+)`, "m").exec(text);
+  if (!match) return null;
+  const value = Number.parseInt(match[1], 10);
+  return Number.isFinite(value) ? value : null;
+}
+function parseProcMeminfo(text) {
+  if (typeof text !== "string" || text.length === 0) return null;
+  const totalKb = readKbValue(text, "MemTotal");
+  const availableKb = readKbValue(text, "MemAvailable");
+  if (totalKb === null || availableKb === null) return null;
+  if (!(totalKb > 0)) return null;
+  const swapTotalKb = readKbValue(text, "SwapTotal") ?? 0;
+  const swapFreeKb = readKbValue(text, "SwapFree") ?? 0;
+  return {
+    source: "proc-meminfo",
+    totalMb: kbToMb(totalKb),
+    availableMb: kbToMb(Math.max(0, availableKb)),
+    swapTotalMb: kbToMb(Math.max(0, swapTotalKb)),
+    swapUsedMb: kbToMb(Math.max(0, swapTotalKb - swapFreeKb)),
+    hostAvailableMb: null
+  };
+}
+function detectSandbox(deps = {}) {
+  const platform = deps.platform ?? process.platform;
+  if (platform !== "linux") return false;
+  for (const marker of SANDBOX_MARKER_PATHS) {
+    if (tryExists(deps, marker)) return true;
+  }
+  const selfCgroup = tryReadText(deps, PROC_SELF_CGROUP_PATH);
+  return selfCgroup !== null && SANDBOX_CGROUP_PATTERN.test(selfCgroup);
+}
+function readOsView(deps) {
+  const os = deps.os ?? { totalmem: osTotalmem, freemem: osFreemem };
+  try {
+    const totalMb = toMbFromBytes(os.totalmem());
+    const availableMb = toMbFromBytes(os.freemem());
+    if (!(totalMb > 0) || !Number.isFinite(availableMb)) return null;
+    return {
+      source: "os",
+      totalMb,
+      availableMb: Math.max(0, availableMb),
+      // os 没有可移植的 swap 口径：按契约显示 n/a，而不是编一个数字。
+      swapTotalMb: null,
+      swapUsedMb: null,
+      hostAvailableMb: null
+    };
+  } catch {
+    return null;
+  }
+}
+function readHostView(deps) {
+  const platform = deps.platform ?? process.platform;
+  if (platform === "linux") {
+    const text = tryReadText(deps, PROC_MEMINFO_PATH);
+    if (text !== null) {
+      const parsed = parseProcMeminfo(text);
+      if (parsed) return parsed;
+    }
+  }
+  return readOsView(deps);
+}
+function parseCgroup2RelativePath(text) {
+  for (const line of text.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    const parts = trimmed.split(":");
+    if (parts.length < 3 || parts[0] !== "0" || parts[1] !== "") continue;
+    const path = parts.slice(2).join(":").trim();
+    if (!path) continue;
+    return path.startsWith("/") ? path : `/${path}`;
+  }
+  return null;
+}
+function parseCgroup2MountPoint(mountsText) {
+  for (const line of mountsText.split("\n")) {
+    const fields = line.trim().split(/\s+/);
+    if (fields.length < 3) continue;
+    if (fields[2] !== "cgroup2") continue;
+    const mountPoint = fields[1].replace(/\\040/g, " ");
+    if (mountPoint.startsWith("/")) return mountPoint;
+  }
+  return null;
+}
+function cgroupAncestorDirs(mountPoint, relativePath) {
+  const base = mountPoint.length > 1 && mountPoint.endsWith("/") ? mountPoint.slice(0, -1) : mountPoint;
+  const dirs = [];
+  if (relativePath && relativePath !== "/") {
+    const rel = relativePath.startsWith("/") ? relativePath : `/${relativePath}`;
+    const segments = rel.split("/").filter(Boolean);
+    for (let depth = segments.length; depth >= 1; depth -= 1) {
+      dirs.push(`${base}/${segments.slice(0, depth).join("/")}`);
+    }
+  }
+  dirs.push(base);
+  return dirs;
+}
+function readCgroupMaxMb(deps, dir) {
+  const maxText = tryReadText(deps, `${dir}/memory.max`);
+  if (maxText === null) return null;
+  const maxRaw = maxText.trim();
+  if (maxRaw === "" || maxRaw === "max") return null;
+  const maxBytes = Number.parseInt(maxRaw, 10);
+  if (!Number.isFinite(maxBytes) || maxBytes <= 0) return null;
+  const totalMb = toMbFromBytes(maxBytes);
+  return totalMb > 0 ? totalMb : null;
+}
+function buildCgroupSnapshot(deps, dir, totalMb, hostView) {
+  const currentText = tryReadText(deps, `${dir}/memory.current`);
+  let usedMb = null;
+  if (currentText !== null) {
+    const currentBytes = Number.parseInt(currentText.trim(), 10);
+    if (Number.isFinite(currentBytes)) {
+      usedMb = Math.min(totalMb, Math.max(0, toMbFromBytes(currentBytes)));
+    }
+  }
+  return {
+    source: "cgroup",
+    totalMb,
+    availableMb: usedMb === null ? null : Math.max(0, totalMb - usedMb),
+    // swap 不是 cgroup 配额的一部分，只能借宿主视角（Linux 上就是 /proc/meminfo）。
+    swapTotalMb: hostView?.swapTotalMb ?? null,
+    swapUsedMb: hostView?.swapUsedMb ?? null,
+    hostAvailableMb: hostView?.availableMb ?? null
+  };
+}
+function readCgroupLimitView(deps, hostView) {
+  const selfCgroupText = tryReadText(deps, PROC_SELF_CGROUP_PATH) ?? "";
+  const relativePath = parseCgroup2RelativePath(selfCgroupText);
+  const mountsText = tryReadText(deps, PROC_MOUNTS_PATH) ?? "";
+  const mountPoint = parseCgroup2MountPoint(mountsText) ?? DEFAULT_CGROUP2_MOUNT;
+  let limitingDir = null;
+  let limitingMb = Number.POSITIVE_INFINITY;
+  for (const dir of cgroupAncestorDirs(mountPoint, relativePath)) {
+    const totalMb = readCgroupMaxMb(deps, dir);
+    if (totalMb === null) continue;
+    if (totalMb < limitingMb) {
+      limitingMb = totalMb;
+      limitingDir = dir;
+    }
+  }
+  if (limitingDir === null) return null;
+  return buildCgroupSnapshot(deps, limitingDir, limitingMb, hostView);
+}
+function readHostMemory(deps = {}) {
+  const platform = deps.platform ?? process.platform;
+  if (platform !== "linux") {
+    return readHostView(deps);
+  }
+  const hostView = readHostView(deps);
+  const cgroupView = readCgroupLimitView(deps, hostView);
+  if (!cgroupView) return hostView;
+  return {
+    ...cgroupView,
+    scope: detectSandbox(deps) ? "sandbox" : "cgroup-limit"
+  };
+}
+function isHostMemoryTight(mem) {
+  if (!(mem.totalMb > 0)) return false;
+  if (mem.availableMb !== null && mem.availableMb / mem.totalMb < MEMORY_AVAILABLE_RATIO_THRESHOLD) {
+    return true;
+  }
+  if (mem.swapTotalMb !== null && mem.swapUsedMb !== null && mem.swapTotalMb > 0 && mem.swapUsedMb / mem.swapTotalMb > SWAP_USED_RATIO_THRESHOLD) {
+    return true;
+  }
+  return false;
+}
+function formatHostMemoryMb(mb) {
+  const value = Math.max(0, Math.round(Number.isFinite(mb) ? mb : 0));
+  if (value >= 1024) return `${(value / 1024).toFixed(1)}G`;
+  return `${value}M`;
+}
+function formatSwapPart(mem) {
+  if (mem.swapTotalMb === null || mem.swapUsedMb === null) return "swap n/a";
+  return `swap ${formatHostMemoryMb(mem.swapUsedMb)}/${formatHostMemoryMb(mem.swapTotalMb)}`;
+}
+function formatHostMemoryLine(mem) {
+  const usedMb = mem.availableMb === null ? null : Math.max(0, mem.totalMb - mem.availableMb);
+  let line;
+  if (mem.source === "cgroup") {
+    const hostAvailable = mem.hostAvailableMb === null ? "n/a" : formatHostMemoryMb(mem.hostAvailableMb);
+    const prefix = (mem.scope ?? "sandbox") === "cgroup-limit" ? "[\u9650\u989D] \u672C\u8FDB\u7A0B\u5185\u5B58" : "[sandbox] \u5BB9\u5668\u5185\u5B58";
+    const usage = usedMb === null ? "\u5360\u7528\u672A\u77E5" : formatHostMemoryMb(usedMb);
+    line = `${prefix} ${usage}/${formatHostMemoryMb(mem.totalMb)} \xB7 \u5BBF\u4E3B\u53EF\u7528 ${hostAvailable}`;
+  } else {
+    const available = mem.availableMb === null ? "n/a" : formatHostMemoryMb(mem.availableMb);
+    line = `\u672C\u5730\u5185\u5B58 ${formatHostMemoryMb(usedMb ?? 0)}/${formatHostMemoryMb(mem.totalMb)}\uFF08\u53EF\u7528 ${available}\uFF09\xB7 ${formatSwapPart(mem)}`;
+  }
+  return isHostMemoryTight(mem) ? `${line} \xB7 ${HOST_MEMORY_PRESSURE_HINT}` : line;
+}
+
 // packages/cli/client/localRuntimeHelpers.ts
 var REMOTE_DIALOG_SYNC_TIMEOUT_MS = 1e4;
 var remoteDialogSyncTimeoutMsForTest;
@@ -1183,6 +1410,29 @@ function buildAgentRunChildCommand(options, deps = {}) {
   }
   return { execPath, childArgs: [entrypoint, ...commandParts, ...strippedArgs] };
 }
+function safeReadHostMemory(reader) {
+  try {
+    return reader();
+  } catch {
+    return null;
+  }
+}
+function emitHostMemoryNotice(mem, output) {
+  if (!mem || !output) return void 0;
+  let notice;
+  try {
+    notice = formatHostMemoryLine(mem);
+  } catch {
+    return void 0;
+  }
+  try {
+    output.write(`${notice}
+`);
+  } catch {
+    return notice;
+  }
+  return notice;
+}
 async function spawnLocalBackgroundRun(input, deps = {}) {
   const env = deps.env ?? process.env;
   const homedir = deps.homedir ?? nodeHomedir;
@@ -1266,6 +1516,7 @@ async function spawnLocalBackgroundRun(input, deps = {}) {
     NOLO_AGENT_RUN_CHILD: "1",
     NOLO_AGENT_RUN_ID: runId
   };
+  const hostMemory = safeReadHostMemory(deps.readHostMemory ?? readHostMemory);
   const logFd = fs.openSync(logPath, "a");
   const proc = spawn(execPath, childArgs, {
     cwd: input.cwd,
@@ -1283,6 +1534,7 @@ async function spawnLocalBackgroundRun(input, deps = {}) {
     proc.channel?.unref?.();
   }
   proc.unref();
+  const hostMemoryNotice = emitHostMemoryNotice(hostMemory, input.output);
   if (typeof proc.pid === "number") {
     const processStartedAt = (deps.getProcessStartTime ?? defaultGetProcessStartTime)(proc.pid);
     withRunRecordLock(runId, deps, () => {
@@ -1292,7 +1544,14 @@ async function spawnLocalBackgroundRun(input, deps = {}) {
       writeRunRecord(latest, deps);
     });
   }
-  return { runId, pid: proc.pid, logPath, queuePath, batchId };
+  return {
+    runId,
+    pid: proc.pid,
+    logPath,
+    queuePath,
+    batchId,
+    ...hostMemoryNotice ? { hostMemoryNotice } : {}
+  };
 }
 function ackRunRecord(runId, deps = {}) {
   withRunRecordLock(runId, deps, () => {

package/{chunk-JGRPBIZZ.js → chunk-SQX235S2.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-WWC7I6TA.js";
 import {
   trimTrailingSlash
-} from "./chunk-SUKSWFLP.js";
+} from "./chunk-PIG2IUVZ.js";
 import {
   toErrorMessage
 } from "./chunk-HNMXYYJR.js";

package/chunk-TT644UJD.js

@@ -0,0 +1,188 @@
+import {
+  shouldUseServerProxy
+} from "./chunk-F3SOW2EU.js";
+import {
+  ANTIGRAVITY_CLOUD_CODE_BASE_URL,
+  isAntigravityCloudCodeBaseUrl,
+  isAntigravityOAuthAgent
+} from "./chunk-SQX235S2.js";
+import {
+  isOpenAiResponsesModel,
+  resolvePlatformChatCompletionsEndpoint,
+  resolvePlatformResponsesEndpoint
+} from "./chunk-V7PCFWX3.js";
+import {
+  findModelConfig
+} from "./chunk-6EQD4AQL.js";
+import {
+  asOptionalTrimmedString
+} from "./chunk-G3SUCT4W.js";
+import {
+  asTrimmedLowercaseString
+} from "./chunk-QSJ3HFEF.js";
+
+// packages/agent-runtime/agentCallPlan.ts
+var CODEX_RESPONSES_URL = "https://chatgpt.com/backend-api/codex/responses";
+var CURSOR_AGENT_URL = "https://api2.cursor.sh/agent.v1.AgentService/Run";
+var DEVIN_CONNECT_URL = "https://server.codeium.com/exa.api_server_pb.ApiServerService/GetChatMessage";
+function resolveClientWire(plan) {
+  if (plan.upstreamWire === "gemini-cca") return "chat.completions";
+  if (plan.upstreamWire === "anthropic-messages") return "chat.completions";
+  if (plan.upstreamWire === "cursor-connect") return "chat.completions";
+  if (plan.upstreamWire === "devin-connect") return "chat.completions";
+  if (plan.upstreamWire === "custom-gemini") return "chat.completions";
+  if (plan.upstreamWire === "custom-openai-responses") return "chat.completions";
+  if (plan.upstreamWire === "custom-anthropic-messages") return "chat.completions";
+  if (plan.upstreamWire === "responses" && plan.authMethod.kind === "oauth" && plan.authMethod.ref === "chatgpt") {
+    return "chat.completions";
+  }
+  return plan.upstreamWire;
+}
+var XAI_CHAT_COMPLETIONS_URL = "https://api.x.ai/v1/chat/completions";
+var ANTHROPIC_MESSAGES_URL = "https://api.anthropic.com/v1/messages";
+var CODEX_REQUIRED_HEADERS = [
+  "chatgpt-account-id",
+  "OpenAI-Beta",
+  "originator",
+  "version"
+];
+var ANTIGRAVITY_REQUIRED_HEADERS = [
+  "User-Agent"
+  // antigravity-specific UA (matches getAntigravityUserAgent)
+];
+function agentShouldUseServerProxy(agentConfig) {
+  return shouldUseServerProxy(agentConfig);
+}
+function resolveCustomUpstreamWire(endpoint, nativeProtocol) {
+  const responsesEndpoint = endpoint.includes("/responses");
+  if (nativeProtocol === "openai-responses" && responsesEndpoint) return "responses";
+  if (nativeProtocol === "gemini") return "custom-gemini";
+  if (nativeProtocol === "openai-responses") return "custom-openai-responses";
+  if (nativeProtocol === "anthropic-messages") return "custom-anthropic-messages";
+  return responsesEndpoint ? "responses" : "chat.completions";
+}
+function hasOwnCustomProviderKey(agentConfig) {
+  const endpoint = asOptionalTrimmedString(agentConfig.customProviderUrl);
+  if (!endpoint) return false;
+  if (isAntigravityCloudCodeBaseUrl(endpoint)) return false;
+  return Boolean(asOptionalTrimmedString(agentConfig.apiKey));
+}
+function resolveAgentCallPlan(agentConfig, _env) {
+  const apiKeyRef = asTrimmedLowercaseString(agentConfig.apiKeyRef);
+  const provider = asTrimmedLowercaseString(
+    agentConfig.provider ?? agentConfig.apiSource
+  );
+  const ownCustomKeyWins = hasOwnCustomProviderKey(agentConfig);
+  const oauthApiKeyRef = ownCustomKeyWins ? "" : apiKeyRef;
+  if (!ownCustomKeyWins && isAntigravityOAuthAgent(agentConfig)) {
+    return {
+      authMethod: { kind: "oauth", ref: "antigravity" },
+      transport: "server-proxy",
+      upstreamWire: "gemini-cca",
+      endpoint: ANTIGRAVITY_CLOUD_CODE_BASE_URL,
+      requiredHeaders: [...ANTIGRAVITY_REQUIRED_HEADERS],
+      vendor: provider || "google-antigravity"
+    };
+  }
+  if (oauthApiKeyRef === "chatgpt") {
+    return {
+      authMethod: { kind: "oauth", ref: "chatgpt" },
+      transport: "server-proxy",
+      upstreamWire: "responses",
+      endpoint: CODEX_RESPONSES_URL,
+      requiredHeaders: [...CODEX_REQUIRED_HEADERS],
+      vendor: provider || "openai"
+    };
+  }
+  if (oauthApiKeyRef === "claude") {
+    return {
+      authMethod: { kind: "oauth", ref: "claude" },
+      transport: "server-proxy",
+      upstreamWire: "anthropic-messages",
+      endpoint: ANTHROPIC_MESSAGES_URL,
+      requiredHeaders: ["anthropic-version", "anthropic-beta"],
+      vendor: provider || "anthropic"
+    };
+  }
+  if (oauthApiKeyRef === "xai") {
+    return {
+      authMethod: { kind: "oauth", ref: "xai" },
+      transport: "server-proxy",
+      upstreamWire: "chat.completions",
+      endpoint: XAI_CHAT_COMPLETIONS_URL,
+      requiredHeaders: [],
+      vendor: provider || "xai"
+    };
+  }
+  if (oauthApiKeyRef === "cursor") {
+    return {
+      authMethod: { kind: "oauth", ref: "cursor" },
+      transport: "server-proxy",
+      upstreamWire: "cursor-connect",
+      endpoint: CURSOR_AGENT_URL,
+      requiredHeaders: [
+        "x-cursor-client-version",
+        "x-cursor-client-type",
+        "x-ghost-mode"
+      ],
+      vendor: provider || "cursor"
+    };
+  }
+  if (oauthApiKeyRef === "devin" || !ownCustomKeyWins && provider === "devin") {
+    return {
+      authMethod: { kind: "oauth", ref: "devin" },
+      transport: "server-proxy",
+      upstreamWire: "devin-connect",
+      endpoint: DEVIN_CONNECT_URL,
+      requiredHeaders: ["connect-protocol-version"],
+      vendor: provider || "devin"
+    };
+  }
+  if (agentConfig.cliProvider || agentConfig.apiSource === "cli" || provider === "cli") {
+    return {
+      authMethod: { kind: "cli", provider: agentConfig.cliProvider || provider || "codex" },
+      transport: "direct",
+      upstreamWire: "cli",
+      endpoint: "",
+      requiredHeaders: [],
+      vendor: provider || "cli"
+    };
+  }
+  if (agentConfig.customProviderUrl || agentConfig.apiSource === "custom") {
+    const transport2 = agentShouldUseServerProxy(agentConfig) ? "server-proxy" : "direct";
+    const endpoint2 = asOptionalTrimmedString(agentConfig.customProviderUrl) ?? "";
+    const upstreamWire2 = resolveCustomUpstreamWire(
+      endpoint2,
+      findModelConfig(provider, agentConfig.model ?? "")?.nativeProtocol
+    );
+    return {
+      authMethod: { kind: "custom-key" },
+      transport: transport2,
+      upstreamWire: upstreamWire2,
+      endpoint: endpoint2,
+      requiredHeaders: [],
+      vendor: provider || "custom"
+    };
+  }
+  const transport = agentShouldUseServerProxy(agentConfig) ? "server-proxy" : "direct";
+  const useResponses = isOpenAiResponsesModel({
+    provider,
+    model: agentConfig.model,
+    endpointKey: agentConfig.endpointKey
+  });
+  const upstreamWire = useResponses ? "responses" : "chat.completions";
+  const endpoint = upstreamWire === "responses" ? resolvePlatformResponsesEndpoint(provider, agentConfig.model) ?? "" : resolvePlatformChatCompletionsEndpoint(provider, agentConfig.model) ?? "";
+  return {
+    authMethod: { kind: "platform-key" },
+    transport,
+    upstreamWire,
+    endpoint,
+    requiredHeaders: [],
+    vendor: provider || "openai"
+  };
+}
+
+export {
+  resolveClientWire,
+  resolveAgentCallPlan
+};