nolo-cli 0.32.0 → 0.33.0-alpha.10

package/chunk-BFPSVRCQ.js

@@ -0,0 +1,1799 @@
+import {
+  buildCurrentTimeBlock,
+  buildIdentityBlock,
+  buildRuntimeGuidanceBlocks,
+  resolveToolGuidedSections
+} from "./chunk-ZWS6DUHX.js";
+import {
+  getModelContextWindow,
+  resolveBuiltinPlatformAgentConfig
+} from "./chunk-GJXRIOLS.js";
+import {
+  COMPACTION_SUMMARY_SYSTEM_PROMPT,
+  buildCompactionMetricsFromPlan,
+  buildCompactionUserContent,
+  clipCompactText,
+  estimateTokenCount,
+  formatCompactionMetricsLog,
+  formatFileOperationsFromMessages,
+  formatMessagesForSummaryWithTruncation,
+  planCompression,
+  planContextUsage
+} from "./chunk-DKMOY3QI.js";
+import {
+  findModelConfig,
+  getProviderByModelName
+} from "./chunk-DFUPZE6V.js";
+import {
+  buildDialogSummaryLayer
+} from "./chunk-2UECQ7RE.js";
+import {
+  buildUserResponseLanguageContext
+} from "./chunk-FMEVI5TG.js";
+import {
+  canonicalizeToolName,
+  canonicalizeToolNames
+} from "./chunk-ZZ2MH7LE.js";
+import {
+  toErrorMessage
+} from "./chunk-HNMXYYJR.js";
+import {
+  PLATFORM_HOSTED_QWEN_37_FLASH_MODEL
+} from "./chunk-OR2HNLVO.js";
+import {
+  asRecordOrEmpty
+} from "./chunk-KX6YBIHG.js";
+import {
+  asTrimmedLowercaseString
+} from "./chunk-QSJ3HFEF.js";
+import {
+  PUBLIC_QWEN_37_FLASH_AGENT_KEY
+} from "./chunk-IR6W62Q6.js";
+import {
+  isRecord
+} from "./chunk-KUG52IAP.js";
+import {
+  asOptionalTrimmedString
+} from "./chunk-G3SUCT4W.js";
+
+// packages/agent-runtime/actionGate.ts
+function readCommandActionGatePayload(payload) {
+  if (!isRecord(payload)) return null;
+  if (!Array.isArray(payload.command)) return null;
+  const command = payload.command.flatMap((item) => {
+    const value = asOptionalTrimmedString(item);
+    return value ? [value] : [];
+  });
+  if (command.length === 0) return null;
+  const displayCommand = asOptionalTrimmedString(payload.displayCommand);
+  return {
+    command,
+    ...displayCommand ? { displayCommand } : {}
+  };
+}
+function readActionGate(value) {
+  if (!isRecord(value)) return null;
+  if (typeof value.id !== "string" || !value.id.trim()) return null;
+  if (value.kind !== "confirm" && value.kind !== "handoff" && value.kind !== "input") return null;
+  if (typeof value.title !== "string" || !value.title.trim()) return null;
+  const titleParams = readTitleParams(value.titleParams);
+  return {
+    id: value.id.trim(),
+    kind: value.kind,
+    title: value.title.trim(),
+    ...titleParams ? { titleParams } : {},
+    ...asOptionalTrimmedString(value.body) ? { body: asOptionalTrimmedString(value.body) } : {},
+    ...Object.prototype.hasOwnProperty.call(value, "payload") ? { payload: value.payload } : {}
+  };
+}
+function readTitleParams(value) {
+  if (!isRecord(value)) return void 0;
+  const entries = Object.entries(value).flatMap(([key, raw]) => {
+    if (typeof raw === "string" || typeof raw === "number") {
+      return [[key, raw]];
+    }
+    return [];
+  });
+  if (entries.length === 0) return void 0;
+  return Object.fromEntries(entries);
+}
+
+// packages/ai/llm/agentCapabilities.ts
+var ANTIGRAVITY_EFFORT_SUFFIXES = [
+  "-tiered",
+  "-extra-low",
+  "-low",
+  "-medium",
+  "-high"
+];
+function stripEffortSuffix(model) {
+  for (const suffix of ANTIGRAVITY_EFFORT_SUFFIXES) {
+    if (model.endsWith(suffix) && model.length > suffix.length) {
+      return model.slice(0, -suffix.length);
+    }
+  }
+  return model;
+}
+function stripPreviewSuffix(model) {
+  const suffix = "-preview";
+  if (model.endsWith(suffix) && model.length > suffix.length) {
+    return model.slice(0, -suffix.length);
+  }
+  return model;
+}
+var lookupKnownModelVision = (provider, model) => {
+  if (!model) return void 0;
+  const candidates = [model];
+  const strippedEffort = stripEffortSuffix(model);
+  if (strippedEffort !== model) candidates.push(strippedEffort);
+  const strippedPreview = stripPreviewSuffix(model);
+  if (strippedPreview !== model) candidates.push(strippedPreview);
+  for (const candidate of candidates) {
+    if (provider && provider !== "custom") {
+      const direct = findModelConfig(provider, candidate);
+      if (direct && typeof direct.hasVision === "boolean") return direct.hasVision;
+    }
+    const detected = getProviderByModelName(candidate);
+    if (detected) {
+      const found = findModelConfig(detected, candidate)?.hasVision;
+      if (found !== void 0) return found;
+    }
+    if (candidate.includes("/")) {
+      const slash = candidate.indexOf("/");
+      const modelProvider = candidate.slice(0, slash).toLowerCase();
+      const modelName = candidate.slice(slash + 1);
+      const nested = findModelConfig(modelProvider, modelName);
+      if (nested && typeof nested.hasVision === "boolean") return nested.hasVision;
+    }
+  }
+  return void 0;
+};
+var resolveAgentImageInputSupport = (agent) => {
+  if (!agent) return true;
+  const provider = asTrimmedLowercaseString(agent.provider) || null;
+  const model = asOptionalTrimmedString(agent.model) ?? "";
+  const catalogHasVision = lookupKnownModelVision(
+    provider,
+    model
+  );
+  if (catalogHasVision !== void 0) {
+    return catalogHasVision;
+  }
+  if (typeof agent.hasVision === "boolean") {
+    return agent.hasVision;
+  }
+  return true;
+};
+
+// packages/ai/agent/imagePreprocessing.ts
+var DEFAULT_IMAGE_PREPROCESSOR_AGENT_KEY = PUBLIC_QWEN_37_FLASH_AGENT_KEY;
+var DESCRIBE_IMAGE_PROMPT = `\u4F60\u662F\u4E00\u4E2A\u4E13\u4E1A\u7684\u56FE\u7247\u63CF\u8FF0\u52A9\u624B\u3002\u8BF7\u6781\u5176\u8BE6\u7EC6\u5730\u63CF\u8FF0\u8FD9\u5F20\u56FE\u7247\uFF0C\u76EE\u6807\u662F\u8BA9\u4E00\u4E2A\u770B\u4E0D\u5230\u56FE\u7247\u7684 AI \u52A9\u624B\u80FD\u5B8C\u5168\u7406\u89E3\u56FE\u7247\u5185\u5BB9\u3002
+
+\u8BF7\u6309\u4EE5\u4E0B\u7ED3\u6784\u63CF\u8FF0\uFF1A
+
+1. **\u56FE\u7247\u7C7B\u578B**\uFF1A\u8FD9\u662F\u754C\u9762\u622A\u56FE\u3001\u7167\u7247\u3001\u56FE\u8868\u3001\u6587\u6863\u3001\u8FD8\u662F\u5176\u4ED6\u7C7B\u578B\uFF1F
+
+2. **\u5982\u679C\u662F\u754C\u9762\u622A\u56FE**\uFF1A
+   - \u5217\u51FA\u6240\u6709\u53EF\u89C1\u7684 UI \u5143\u7D20\uFF1A\u6807\u9898\u680F\u3001\u5BFC\u822A\u83DC\u5355\u3001\u6309\u94AE\u3001\u8F93\u5165\u6846\u3001\u5217\u8868\u9879\u7B49
+   - \u9010\u4E2A\u63CF\u8FF0\u6BCF\u4E2A\u5143\u7D20\u7684\u6587\u5B57\u5185\u5BB9\u548C\u4F4D\u7F6E\uFF08\u5982"\u5DE6\u4E0A\u89D2"\u3001"\u53F3\u4FA7\u680F"\uFF09
+   - \u63CF\u8FF0\u989C\u8272\u4E3B\u9898\u3001\u5E03\u5C40\u7ED3\u6784\u3001\u5F53\u524D\u72B6\u6001\uFF08\u5982\u9009\u4E2D\u3001hover\u3001loading\uFF09
+   - \u5982\u679C\u6709\u5F39\u7A97/\u5BF9\u8BDD\u6846/\u901A\u77E5\uFF0C\u5B8C\u6574\u8BB0\u5F55\u5176\u6587\u5B57\u5185\u5BB9
+
+3. **\u5982\u679C\u662F\u751F\u6D3B\u7167\u7247**\uFF1A
+   - \u573A\u666F/\u73AF\u5883\uFF1A\u5BA4\u5185/\u5BA4\u5916\u3001\u5730\u70B9\u7C7B\u578B\u3001\u65F6\u95F4\u611F\uFF08\u767D\u5929/\u591C\u665A\uFF09
+   - \u4EBA\u7269\uFF1A\u4EBA\u6570\u3001\u59FF\u52BF\u3001\u8868\u60C5\u3001\u7A7F\u7740\u3001\u52A8\u4F5C
+   - \u7269\u4F53\uFF1A\u524D\u666F/\u80CC\u666F\u4E2D\u7684\u6240\u6709\u663E\u8457\u7269\u4F53
+   - \u5149\u7EBF\u3001\u5929\u6C14\u3001\u6C1B\u56F4
+
+4. **\u5982\u679C\u662F\u56FE\u8868/\u6570\u636E\u56FE**\uFF1A
+   - \u56FE\u8868\u7C7B\u578B\uFF08\u67F1\u72B6\u56FE/\u6298\u7EBF\u56FE/\u997C\u56FE\u7B49\uFF09
+   - \u5750\u6807\u8F74\u6807\u7B7E\u3001\u6570\u503C\u8303\u56F4\u3001\u5355\u4F4D
+   - \u5173\u952E\u6570\u636E\u70B9\u548C\u8D8B\u52BF
+   - \u56FE\u4F8B\u3001\u6807\u9898
+
+5. **\u6240\u6709\u53EF\u89C1\u6587\u5B57**\uFF1A\u9010\u5B57\u8BB0\u5F55\u56FE\u7247\u4E2D\u51FA\u73B0\u7684\u6240\u6709\u6587\u5B57\uFF08UI \u6587\u5B57\u3001\u8DEF\u724C\u3001\u6807\u7B7E\u3001\u6C34\u5370\u7B49\uFF09\uFF0C\u4FDD\u7559\u539F\u6587\u3002
+
+6. **\u989C\u8272\u548C\u5E03\u5C40**\uFF1A\u4E3B\u8272\u8C03\u3001\u5E03\u5C40\u7ED3\u6784\u3001\u7A7A\u95F4\u5173\u7CFB\u3002
+
+\u8BF7\u5C3D\u53EF\u80FD\u8BE6\u7EC6\uFF0C\u4E0D\u8981\u9057\u6F0F\u4EFB\u4F55\u53EF\u89C1\u4FE1\u606F\u3002`;
+function extractImageUrlsFromMessages(messages) {
+  const urls = [];
+  for (const msg of messages) {
+    if (!Array.isArray(msg.content)) continue;
+    for (const part of msg.content) {
+      if (part && typeof part === "object" && part.type === "image_url" && part.image_url && typeof part.image_url.url === "string" && part.image_url.url.trim()) {
+        urls.push(part.image_url.url);
+      }
+    }
+  }
+  return urls;
+}
+function hasImageInRuntimeMessages(messages) {
+  return extractImageUrlsFromMessages(messages).length > 0;
+}
+var IMAGE_DESCRIPTION_CACHE = /* @__PURE__ */ new Map();
+function cacheKeyForUrls(urls) {
+  return urls.slice().sort().join("||");
+}
+async function preprocessImagesForTextOnlyAgent(messages, describeImage) {
+  const imageUrls = extractImageUrlsFromMessages(messages);
+  if (imageUrls.length === 0) return messages;
+  const key = cacheKeyForUrls(imageUrls);
+  let description = IMAGE_DESCRIPTION_CACHE.get(key);
+  if (!description) {
+    const rawDesc = await describeImage(imageUrls);
+    if (rawDesc === null || !rawDesc.trim()) return messages;
+    description = rawDesc.trim();
+    IMAGE_DESCRIPTION_CACHE.set(key, description);
+  }
+  const descriptionText = `[\u56FE\u7247\u63CF\u8FF0] ${description}`;
+  return messages.map((msg) => {
+    if (!Array.isArray(msg.content)) return msg;
+    const hasImage = msg.content.some((p) => p?.type === "image_url");
+    if (!hasImage) return msg;
+    const newContent = msg.content.map((part) => {
+      if (part && typeof part === "object" && part.type === "image_url") {
+        return { type: "text", text: descriptionText };
+      }
+      return part;
+    }).filter((p) => p !== null && p !== void 0);
+    return { ...msg, content: newContent };
+  });
+}
+async function describeImageWithLocalProvider(adapter, imageUrls, visionAgentConfig) {
+  if (imageUrls.length === 0) return null;
+  try {
+    const config = visionAgentConfig ?? resolveBuiltinPlatformAgentConfig(DEFAULT_IMAGE_PREPROCESSOR_AGENT_KEY);
+    if (!config) {
+      console.warn("[imagePreprocessing] vision agent config not found, skipping");
+      return null;
+    }
+    const visionProvider = await adapter.resolveProvider(config);
+    const result = await visionProvider.complete(
+      [{ role: "user", content: buildDescribeContentParts(imageUrls) }],
+      { timeoutMs: 3e4 }
+    );
+    const text = result.content?.trim();
+    if (!text) return null;
+    return text;
+  } catch (error) {
+    console.warn("[imagePreprocessing] vision describe failed, will fallback:", error);
+    return null;
+  }
+}
+async function describeImageViaServerProxy(serverUrl, authToken, imageUrls, visionAgentKey) {
+  if (imageUrls.length === 0) return null;
+  const agentKey = visionAgentKey ?? DEFAULT_IMAGE_PREPROCESSOR_AGENT_KEY;
+  const { model: visionModel, provider: visionProvider } = resolveDefaultVisionModelConfig(agentKey);
+  try {
+    const payload = {
+      model: visionModel,
+      messages: [{ role: "user", content: buildDescribeContentParts(imageUrls) }],
+      stream: false,
+      provider: visionProvider,
+      agentKey,
+      // server proxy 需要 url 字段，但 nolo 平台 agent 的上游由 server 端路由，
+      // 这里放一个占位 url，server 端会根据 provider/model 覆盖。
+      url: "https://api.ollama.com/v1/chat/completions"
+    };
+    const response = await fetch(`${serverUrl}/api/chat`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${authToken}`
+      },
+      body: JSON.stringify(payload),
+      signal: AbortSignal.timeout(3e4)
+    });
+    if (!response.ok) {
+      console.warn(`[imagePreprocessing] server proxy vision call failed: ${response.status}`);
+      return null;
+    }
+    const data = await response.json();
+    const text = data?.choices?.[0]?.message?.content;
+    if (typeof text === "string" && text.trim()) {
+      return text.trim();
+    }
+    return null;
+  } catch (error) {
+    console.warn("[imagePreprocessing] server proxy vision describe failed:", error);
+    return null;
+  }
+}
+function buildDescribeContentParts(imageUrls) {
+  const parts = [{ type: "text", text: DESCRIBE_IMAGE_PROMPT }];
+  for (const url of imageUrls) {
+    parts.push({ type: "image_url", image_url: { url } });
+  }
+  return parts;
+}
+function resolveDefaultVisionModelConfig(agentKey) {
+  const key = agentKey ?? DEFAULT_IMAGE_PREPROCESSOR_AGENT_KEY;
+  const config = resolveBuiltinPlatformAgentConfig(key);
+  return {
+    model: config?.model ?? PLATFORM_HOSTED_QWEN_37_FLASH_MODEL,
+    provider: config?.provider ?? "nolo",
+    config
+  };
+}
+var IMAGE_OMITTED_PLACEHOLDER = "[Image content omitted: model does not support image input]";
+function stripImagePartsFromContent(content) {
+  if (!Array.isArray(content)) return content;
+  const filtered = content.filter((part) => part?.type !== "image_url");
+  if (filtered.length === 0) return IMAGE_OMITTED_PLACEHOLDER;
+  return filtered;
+}
+function stripImagePartsFromMessages(messages) {
+  return messages.map((msg) => ({
+    ...msg,
+    content: stripImagePartsFromContent(msg.content)
+  }));
+}
+async function tryPreprocessWebImageOrReject(messages, agentConfig, initialHistoryIds, serverUrl, authToken) {
+  const supportsVision = resolveAgentImageInputSupport(agentConfig);
+  const hasImages = hasImageInRuntimeMessages(messages);
+  const needsPreprocessing = !supportsVision && hasImages;
+  if (!needsPreprocessing) {
+    const firstDynamicIdx = messages.findIndex((m) => m.id && !initialHistoryIds.has(m.id));
+    const splitIdx2 = firstDynamicIdx === -1 ? messages.length : firstDynamicIdx;
+    return {
+      kind: "ok",
+      messages,
+      stableMessages: messages.slice(0, splitIdx2),
+      dynamicMessages: messages.slice(splitIdx2)
+    };
+  }
+  let finalMessages = messages;
+  if (serverUrl && authToken) {
+    try {
+      const preprocessed = await preprocessImagesForTextOnlyAgent(
+        messages,
+        (urls) => describeImageViaServerProxy(serverUrl, authToken, urls)
+      );
+      if (preprocessed !== messages) {
+        finalMessages = preprocessed;
+      }
+    } catch (e) {
+      console.warn("[imagePreprocessing] web vision describe error:", e);
+    }
+  }
+  if (finalMessages === messages) {
+    finalMessages = stripImagePartsFromMessages(messages);
+  }
+  const newFirstDynamicIdx = finalMessages.findIndex((m) => m.id && !initialHistoryIds.has(m.id));
+  const splitIdx = newFirstDynamicIdx === -1 ? finalMessages.length : newFirstDynamicIdx;
+  return {
+    kind: "ok",
+    messages: finalMessages,
+    stableMessages: finalMessages.slice(0, splitIdx),
+    dynamicMessages: finalMessages.slice(splitIdx)
+  };
+}
+
+// packages/agent-runtime/toolCallPairing.ts
+function readToolCallId(message) {
+  if (typeof message.tool_call_id === "string" && message.tool_call_id) {
+    return message.tool_call_id;
+  }
+  if (typeof message.toolCallId === "string" && message.toolCallId) {
+    return message.toolCallId;
+  }
+  return void 0;
+}
+function isContentBlank(content) {
+  if (content == null) return true;
+  if (typeof content === "string") return content.trim().length === 0;
+  if (Array.isArray(content)) {
+    if (content.length === 0) return true;
+    return !content.some((part) => {
+      if (part == null || typeof part !== "object") return false;
+      const p = part;
+      if (p.type === "text") return typeof p.text === "string" && p.text.trim().length > 0;
+      if (p.type === "image_url") {
+        const url = p.image_url?.url;
+        return typeof url === "string" && url.trim().length > 0;
+      }
+      return true;
+    });
+  }
+  return false;
+}
+function sanitizeToolCallPairing(messages) {
+  const assistantIndexByCallId = /* @__PURE__ */ new Map();
+  for (let i = 0; i < messages.length; i += 1) {
+    const m = messages[i];
+    if (m == null) continue;
+    if (m.role !== "assistant") continue;
+    const toolCalls = m.tool_calls;
+    if (!Array.isArray(toolCalls)) continue;
+    for (const call of toolCalls) {
+      const id = call?.id;
+      if (typeof id !== "string" || !id) continue;
+      if (!assistantIndexByCallId.has(id)) {
+        assistantIndexByCallId.set(id, i);
+      }
+    }
+  }
+  const toolByCallId = /* @__PURE__ */ new Map();
+  for (let i = 0; i < messages.length; i += 1) {
+    const m = messages[i];
+    if (m == null) continue;
+    if (m.role !== "tool") continue;
+    const id = readToolCallId(m);
+    if (typeof id !== "string" || !id) continue;
+    if (!toolByCallId.has(id)) {
+      toolByCallId.set(id, m);
+    }
+  }
+  const output = [];
+  const consumedToolCallIds = /* @__PURE__ */ new Set();
+  for (let i = 0; i < messages.length; i += 1) {
+    const m = messages[i];
+    if (m == null) continue;
+    if (m.role === "tool") continue;
+    if (m.role !== "assistant") {
+      output.push(m);
+      continue;
+    }
+    const toolCalls = m.tool_calls;
+    if (!Array.isArray(toolCalls) || toolCalls.length === 0) {
+      output.push(m);
+      continue;
+    }
+    const matchedToolCalls = [];
+    const matchedToolMessages = [];
+    for (const call of toolCalls) {
+      const id = call?.id;
+      if (typeof id !== "string" || !id) continue;
+      const toolMessage = toolByCallId.get(id);
+      if (!toolMessage) continue;
+      if (assistantIndexByCallId.get(id) !== i) continue;
+      if (consumedToolCallIds.has(id)) continue;
+      matchedToolCalls.push(call);
+      matchedToolMessages.push(toolMessage);
+      consumedToolCallIds.add(id);
+    }
+    if (matchedToolCalls.length === 0) {
+      const { tool_calls: _drop, ...rest } = m;
+      const stripped = rest;
+      if (isContentBlank(stripped.content)) {
+        continue;
+      }
+      output.push(stripped);
+      continue;
+    }
+    const normalizedAssistant = { ...m, tool_calls: matchedToolCalls };
+    output.push(normalizedAssistant);
+    for (const toolMessage of matchedToolMessages) {
+      output.push(toolMessage);
+    }
+  }
+  return output;
+}
+
+// packages/agent-runtime/parseToolArguments.ts
+function parseToolArgumentsJson(raw) {
+  if (!raw?.trim()) return {};
+  try {
+    return asRecordOrEmpty(JSON.parse(raw));
+  } catch {
+    return {};
+  }
+}
+
+// packages/agent-runtime/summarizeToolArguments.ts
+function clip(value, max = 240) {
+  return clipCompactText(value, max);
+}
+function summarizeToolArguments(toolName, rawArgs) {
+  const args = parseToolArgumentsJson(rawArgs);
+  const pick = (...keys2) => {
+    for (const key of keys2) {
+      const value = asOptionalTrimmedString(args[key]);
+      if (value) return value;
+    }
+    return "";
+  };
+  const command = pick("command", "cmd", "runCommand", "executeCommand", "bash");
+  if (command) return clip(command);
+  const query = pick("query", "pattern", "search", "q");
+  if (query) return clip(query);
+  const filePath = pick("filePath", "file_path", "path", "filename", "file");
+  if (filePath) return clip(filePath);
+  const keys = Object.keys(args);
+  if (keys.length === 0) return "";
+  return clip(
+    keys.slice(0, 6).map((key) => {
+      const value = args[key];
+      if (typeof value === "string") return `${key}=${clip(value, 80)}`;
+      if (typeof value === "number" || typeof value === "boolean") {
+        return `${key}=${String(value)}`;
+      }
+      if (Array.isArray(value)) return `${key}[${value.length}]`;
+      return `${key}=${value === null ? "null" : typeof value}`;
+    }).join(" ")
+  );
+}
+
+// packages/agent-runtime/contextBlockScope.ts
+var isContextBlockScope = (value) => {
+  if (typeof value !== "object" || value === null) return false;
+  const candidate = value;
+  return typeof candidate.content === "string" && (candidate.cacheScope === "session" || candidate.cacheScope === "turn");
+};
+var normalizeContextBlockScopes = (legacyBlocks = void 0, scopes = void 0) => {
+  const trimmedScopes = (Array.isArray(scopes) ? scopes : []).filter(isContextBlockScope).map((scope) => ({ content: scope.content.trim(), cacheScope: scope.cacheScope })).filter((scope) => scope.content.length > 0);
+  if (trimmedScopes.length > 0) {
+    return trimmedScopes;
+  }
+  return (Array.isArray(legacyBlocks) ? legacyBlocks : []).filter((block) => typeof block === "string").map((block) => block.trim()).filter((block) => block.length > 0).map((block) => ({ content: block, cacheScope: "turn" }));
+};
+
+// packages/ai/agent/toolOutputPolicy.ts
+var MAX_HISTORICAL_TOOL_CONTENT_CHARS = 1600;
+var MAX_IN_TURN_TOOL_CONTENT_CHARS = 4e3;
+var FRESH_TOOL_OUTPUT_MAX_CHARS = 32e3;
+var DEFAULT_TOOL_OUTPUT_PROFILE = {
+  maxChars: MAX_IN_TURN_TOOL_CONTENT_CHARS,
+  headRatio: 0.5
+};
+var TOOL_OUTPUT_PROFILES = {
+  readFile: { maxChars: 4800, headRatio: 0.68, historicalMaxChars: 4800 },
+  read_file: { maxChars: 4800, headRatio: 0.68, historicalMaxChars: 4800 },
+  readWorkspaceFile: { maxChars: 4800, headRatio: 0.68, historicalMaxChars: 4800 },
+  searchFiles: { maxChars: 3600, headRatio: 0.78 },
+  search_files: { maxChars: 3600, headRatio: 0.78 },
+  listFiles: { maxChars: 2800, headRatio: 0.85 },
+  globFiles: { maxChars: 2800, headRatio: 0.85 },
+  execShell: { maxChars: 4e3, headRatio: 0.35 },
+  runCommand: { maxChars: 4e3, headRatio: 0.35 },
+  launchProcess: { maxChars: 2800, headRatio: 0.35 },
+  editFile: { maxChars: 2800, headRatio: 0.62 },
+  writeFile: { maxChars: 2400, headRatio: 0.62 },
+  readPastedText: { maxChars: 4800, headRatio: 0.5, historicalMaxChars: 4800 }
+};
+function resolveToolOutputProfile(toolName) {
+  return (toolName ? TOOL_OUTPUT_PROFILES[toolName] : void 0) ?? DEFAULT_TOOL_OUTPUT_PROFILE;
+}
+function resolveHistoricalToolContentCap(toolName, historicalMaxChars) {
+  const profile = toolName ? TOOL_OUTPUT_PROFILES[toolName] : void 0;
+  return profile?.historicalMaxChars !== void 0 ? Math.max(historicalMaxChars, profile.historicalMaxChars) : historicalMaxChars;
+}
+function projectToolMessageContent(input) {
+  const { content, isFresh, toolName, historicalMaxChars } = input;
+  if (isFresh) {
+    if (content.length <= FRESH_TOOL_OUTPUT_MAX_CHARS) return content;
+    return clipToolText(
+      content,
+      FRESH_TOOL_OUTPUT_MAX_CHARS,
+      resolveToolOutputProfile(toolName).headRatio,
+      `
+\u2026[\u622A\u65AD\uFF0C\u539F\u59CB\u957F\u5EA6 ${content.length} \u5B57\u7B26]`
+    );
+  }
+  const cap = resolveHistoricalToolContentCap(toolName, historicalMaxChars);
+  if (content.length <= cap) return content;
+  return content.slice(0, cap) + `
+\u2026[\u622A\u65AD\uFF0C\u539F\u59CB\u957F\u5EA6 ${content.length} \u5B57\u7B26]`;
+}
+function clipToolText(content, maxChars, headRatio, marker = "\n\n[... tool output middle omitted; head/tail preserved ...]\n\n") {
+  const normalized = content.replace(/\r\n/g, "\n").trim();
+  if (normalized.length <= maxChars) return normalized;
+  if (maxChars <= marker.length + 2) return normalized.slice(0, maxChars);
+  const available = maxChars - marker.length;
+  const headChars = Math.max(1, Math.floor(available * headRatio));
+  const tailChars = Math.max(1, available - headChars);
+  return `${normalized.slice(0, headChars)}${marker}${normalized.slice(-tailChars)}`;
+}
+
+// packages/agent-runtime/localAutoCompaction.ts
+function toPlanCompressionMessages(history) {
+  return history.map((message, index) => ({
+    id: `local-${index}`,
+    role: message.role,
+    content: message.content,
+    ...Array.isArray(message.tool_calls) ? { tool_calls: message.tool_calls } : {}
+  }));
+}
+function buildLocalSummaryHistoryMessage(summary) {
+  const layer = buildDialogSummaryLayer({ summary });
+  return {
+    role: "user",
+    content: layer?.content ?? `--- \u5386\u53F2\u5BF9\u8BDD\u6458\u8981 ---
+${summary.trim()}`
+  };
+}
+function projectHistoryWithSummary(args) {
+  const bridged = toPlanCompressionMessages(args.history);
+  let startIndex = 0;
+  if (args.summarizedBeforeId) {
+    const found = bridged.findIndex((m) => m.id === args.summarizedBeforeId);
+    if (found !== -1) startIndex = found + 1;
+  }
+  return [
+    buildLocalSummaryHistoryMessage(args.summary),
+    ...args.history.slice(startIndex)
+  ];
+}
+var COLD_RESUME_IDLE_MS = 60 * 60 * 1e3;
+function isColdResume(history, nowMs) {
+  for (let i = history.length - 1; i >= 0; i -= 1) {
+    const at = history[i]?.createdAt;
+    if (typeof at === "number" && Number.isFinite(at)) {
+      return nowMs - at > COLD_RESUME_IDLE_MS;
+    }
+  }
+  return false;
+}
+async function maybeAutoCompactLocalHistory(args) {
+  const { adapter, dialogId, history } = args;
+  const unchanged = () => ({
+    history,
+    compressed: false,
+    summaryGenerated: false
+  });
+  if (!dialogId || history.length === 0 || typeof adapter.loadDialogSummary !== "function" || typeof adapter.saveDialogSummary !== "function") {
+    return unchanged();
+  }
+  let stored = null;
+  try {
+    stored = await adapter.loadDialogSummary(dialogId);
+  } catch (error) {
+    console.warn("[localLoop] loadDialogSummary failed:", error);
+    return unchanged();
+  }
+  const existingSummary = typeof stored?.summary === "string" ? stored.summary : "";
+  const summarizedBeforeId = typeof stored?.summarizedBeforeId === "string" ? stored.summarizedBeforeId : void 0;
+  const contextWindow = typeof args.contextWindow === "number" && Number.isFinite(args.contextWindow) && args.contextWindow > 0 ? args.contextWindow : getModelContextWindow(args.model ?? "");
+  const allMsgs = toPlanCompressionMessages(history);
+  const coldResume = isColdResume(history, args.now?.() ?? Date.now());
+  const plan = planCompression({
+    allMsgs,
+    summarizedBeforeId,
+    summary: existingSummary,
+    contextWindow,
+    // 防死亡螺旋：用 summary 长度作为上次压缩后的基线。如果新内容没让
+    // totalUsed 比 summary 本身增长超过 minNewTokens，不重复触发。
+    lastCompactedTokenCount: existingSummary ? estimateTokenCount(existingSummary) : void 0,
+    ...coldResume ? { force: true, reason: "context_budget" } : {}
+  });
+  const projectExisting = () => {
+    if (!existingSummary.trim()) return unchanged();
+    return {
+      history: projectHistoryWithSummary({
+        history,
+        summary: existingSummary,
+        summarizedBeforeId
+      }),
+      compressed: true,
+      summaryGenerated: false
+    };
+  };
+  if (!plan.shouldCompress) {
+    return projectExisting();
+  }
+  try {
+    const provider = await args.resolveProvider();
+    const msgsToCompress = plan.msgsToCompress;
+    const messagesText = formatMessagesForSummaryWithTruncation(msgsToCompress);
+    const fileOpsText = formatFileOperationsFromMessages(
+      msgsToCompress,
+      canonicalizeToolName
+    );
+    const promptContent = buildCompactionUserContent({
+      previousSummary: existingSummary,
+      messagesText,
+      fileOpsText
+    });
+    const result = await provider.complete([
+      { role: "system", content: COMPACTION_SUMMARY_SYSTEM_PROMPT },
+      { role: "user", content: promptContent }
+    ]);
+    const newSummary = typeof result.content === "string" ? result.content.trim() : "";
+    if (!newSummary) {
+      console.warn(
+        "[localLoop] auto-compaction produced empty summary; keeping prior projection"
+      );
+      return projectExisting();
+    }
+    await adapter.saveDialogSummary({
+      dialogId,
+      summary: newSummary,
+      summarizedBeforeId: plan.newSummarizedBeforeId
+    });
+    const metrics = buildCompactionMetricsFromPlan({
+      reason: coldResume ? "cold_resume" : "context_budget",
+      previousSummary: existingSummary,
+      plan,
+      newSummary,
+      summaryUsage: result.usage
+    });
+    console.log(formatCompactionMetricsLog(metrics));
+    return {
+      history: projectHistoryWithSummary({
+        history,
+        summary: newSummary,
+        summarizedBeforeId: plan.newSummarizedBeforeId
+      }),
+      compressed: true,
+      summaryGenerated: true,
+      ...result.usage ? { usage: result.usage } : {},
+      metrics
+    };
+  } catch (error) {
+    console.warn("[localLoop] auto-compaction failed:", error);
+    return projectExisting();
+  }
+}
+
+// packages/agent-runtime/localLoop.ts
+var LOCAL_AGENT_CONFIG_MISSING_CODE = "LOCAL_AGENT_CONFIG_MISSING";
+var EMPTY_ASSISTANT_REPAIR_PROMPT = "\u8BF7\u7ED9\u51FA\u660E\u786E\u7684\u6587\u5B57\u56DE\u7B54\u6216\u6267\u884C\u4E0B\u4E00\u6B65\uFF1A\u5982\u679C\u4EFB\u52A1\u5DF2\u5B8C\u6210\uFF0C\u8BF7\u76F4\u63A5\u603B\u7ED3\u7ED3\u679C\uFF1B\u5982\u679C\u9700\u8981\u8C03\u7528\u5DE5\u5177\uFF0C\u8BF7\u76F4\u63A5\u8F93\u51FA tool_calls\u3002\u8BF7\u5207\u52FF\u8FD4\u56DE\u7A7A\u5185\u5BB9\u3002";
+var EMPTY_ASSISTANT_FALLBACK_MESSAGE = "\u6A21\u578B\u8FDE\u7EED\u8FD4\u56DE\u7A7A\u6D88\u606F\uFF0C\u5F53\u524D\u4EFB\u52A1\u672A\u5B8C\u6210\u3002\u8BF7\u91CD\u8BD5\u5F53\u524D\u6B65\u9AA4\uFF0C\u6216\u7ED9\u51FA\u66F4\u5177\u4F53\u7684\u4FEE\u6539\u8303\u56F4\u3002";
+var LENGTH_TRUNCATED_FALLBACK_MESSAGE = "\u8F93\u51FA\u8FBE\u5230\u957F\u5EA6\u4E0A\u9650\u88AB\u622A\u65AD\uFF0C\u5EFA\u8BAE\u7F29\u77ED\u4EFB\u52A1\u6216\u63D0\u9AD8\u8F93\u51FA\u4E0A\u9650\u3002";
+var STREAM_TRUNCATED_FALLBACK_MESSAGE = "\u4E0A\u6E38\u54CD\u5E94\u6D41\u5728\u6536\u5C3E\u524D\u88AB\u4E2D\u65AD\uFF08\u672A\u6536\u5230\u7ED3\u675F\u6807\u8BB0\uFF09\uFF0C\u672C\u8F6E\u8F93\u51FA\u4E0D\u5B8C\u6574\u3002\u8BF7\u91CD\u8BD5\u5F53\u524D\u6B65\u9AA4\u3002";
+function resolveEmptyAssistantOutcome(args) {
+  if (args.hasToolCalls || args.hasVisibleOutput) return { kind: "ok" };
+  if (args.finishReason === "length") return { kind: "fallback", reason: "length_truncated" };
+  if (!args.repairUsed) return { kind: "repair" };
+  if (!args.finishReason && !args.streamComplete) {
+    return { kind: "fallback", reason: "stream_truncated" };
+  }
+  return { kind: "fallback", reason: "empty_completion" };
+}
+function resolveEmptyAssistantFallbackMessage(reason) {
+  if (reason === "length_truncated") return LENGTH_TRUNCATED_FALLBACK_MESSAGE;
+  if (reason === "stream_truncated") return STREAM_TRUNCATED_FALLBACK_MESSAGE;
+  return EMPTY_ASSISTANT_FALLBACK_MESSAGE;
+}
+function hasAssistantVisibleOutput(content) {
+  if (typeof content === "string") return content.trim().length > 0;
+  if (!Array.isArray(content)) return false;
+  return content.some((part) => {
+    if (part?.type === "text" && String(part.text ?? "").trim()) return true;
+    if (part?.type === "image_url") {
+      const url = part?.image_url?.url;
+      return typeof url === "string" && url.trim().length > 0;
+    }
+    return false;
+  });
+}
+function formatToolExecutionError(args) {
+  const message = toErrorMessage(args.error);
+  return `${args.toolName} failed: ${message}`;
+}
+function formatStructuredToolExecutionError(args) {
+  if (!args.error || typeof args.error !== "object") return null;
+  const error = args.error;
+  if (typeof error.code !== "string") return null;
+  return JSON.stringify({
+    error: error.code,
+    message: typeof error.message === "string" ? error.message : formatToolExecutionError(args),
+    ...error.policy && typeof error.policy === "object" ? { policy: error.policy } : {},
+    ...error.permissionRequest && typeof error.permissionRequest === "object" ? { permissionRequest: error.permissionRequest } : {}
+  });
+}
+function shouldReturnToolExecutionErrors(adapter) {
+  return adapter.capabilities.includes("local-tools");
+}
+function emitToolEvent(input, event) {
+  input.onToolEvent?.(event);
+}
+function emitLoopEvent(input, event) {
+  if (!input.onLoopEvent) return;
+  try {
+    input.onLoopEvent(event);
+  } catch {
+  }
+}
+var LLM_REQUEST_TIMEOUT = "LLM_REQUEST_TIMEOUT";
+var LOCAL_TURN_ABORTED_CODE = "LOCAL_TURN_ABORTED";
+function buildAbortedError() {
+  const error = new Error("local agent turn aborted by user");
+  error.code = LOCAL_TURN_ABORTED_CODE;
+  return error;
+}
+function throwIfAborted(input) {
+  if (input.abortSignal?.aborted) throw buildAbortedError();
+}
+async function raceWithAbort(input, promise, pendingToolName) {
+  const signal = input.abortSignal;
+  if (!signal) return promise;
+  let abortListener;
+  const abortPromise = new Promise((_resolve, reject) => {
+    abortListener = () => {
+      const error = buildAbortedError();
+      if (pendingToolName) error.pendingToolName = pendingToolName;
+      promise.catch(() => {
+      });
+      reject(error);
+    };
+    if (signal.aborted) {
+      abortListener();
+      return;
+    }
+    signal.addEventListener("abort", abortListener, { once: true });
+  });
+  try {
+    return await Promise.race([promise, abortPromise]);
+  } finally {
+    if (signal && abortListener) signal.removeEventListener("abort", abortListener);
+  }
+}
+function resolveLlmRequestTimeoutMs(input) {
+  const raw = input.llmRequestTimeoutMs ?? input.timeoutMs;
+  if (typeof raw !== "number" || !Number.isFinite(raw) || raw <= 0) return void 0;
+  return raw;
+}
+async function runCompleteWithTimeout(args) {
+  const { provider, messages, options, timeoutMs, round, input, context } = args;
+  emitLoopEvent(input, {
+    kind: "llm-start",
+    round,
+    atMs: Date.now(),
+    ...context ? { context } : {}
+  });
+  const complete = provider.complete(messages, options);
+  let ok = false;
+  const signal = input.abortSignal;
+  let abortListener;
+  const racers = [];
+  if (signal) {
+    racers.push(
+      new Promise((_resolve, reject) => {
+        abortListener = () => reject(buildAbortedError());
+        if (signal.aborted) {
+          abortListener();
+          return;
+        }
+        signal.addEventListener("abort", abortListener, { once: true });
+      })
+    );
+  }
+  let timer;
+  if (typeof timeoutMs === "number") {
+    racers.push(
+      new Promise((_resolve, reject) => {
+        timer = setTimeout(() => {
+          reject(new Error(`__llm_timeout__:${timeoutMs}`));
+        }, timeoutMs);
+      })
+    );
+  }
+  let result;
+  try {
+    result = racers.length === 0 ? await complete : await Promise.race([complete, ...racers]);
+    ok = true;
+    return result;
+  } catch (error) {
+    const isTimeout = error instanceof Error && error.message.startsWith("__llm_timeout__:");
+    if (!isTimeout) throw error;
+    const timeoutError = new Error(
+      `LLM request timed out after ${timeoutMs}ms (round ${round})`
+    );
+    timeoutError.code = LLM_REQUEST_TIMEOUT;
+    throw timeoutError;
+  } finally {
+    if (timer) clearTimeout(timer);
+    if (signal && abortListener) signal.removeEventListener("abort", abortListener);
+    const usage = result?.usage;
+    const cacheHit = Number(usage?.cache_read_input_tokens ?? usage?.prompt_cache_hit_tokens ?? 0);
+    const cacheMiss = Number(usage?.cache_creation_input_tokens ?? usage?.prompt_cache_miss_tokens ?? 0);
+    const inputTokens = Number(usage?.input_tokens ?? usage?.prompt_tokens ?? 0);
+    const outputTokens = Number(usage?.output_tokens ?? usage?.completion_tokens ?? 0);
+    emitLoopEvent(input, {
+      kind: "llm-end",
+      round,
+      atMs: Date.now(),
+      ok,
+      ...inputTokens > 0 || cacheHit > 0 || cacheMiss > 0 ? {
+        cache: {
+          inputTokens,
+          outputTokens,
+          cacheHitTokens: cacheHit,
+          cacheMissTokens: cacheMiss,
+          hitRatio: inputTokens > 0 ? Math.round(cacheHit / inputTokens * 1e4) / 1e4 : 0
+        }
+      } : {}
+    });
+  }
+}
+function clip2(value, max = 240) {
+  return clipCompactText(value, max);
+}
+function summarizeToolResult(content, metadata) {
+  const parts = [];
+  const exitCode = metadata?.exitCode;
+  if (typeof exitCode === "number") parts.push(`exit=${exitCode}`);
+  if (typeof content === "string") {
+    const trimmed = content.trim();
+    if (trimmed) {
+      const lines = trimmed.split(/\r?\n/).length;
+      parts.push(`${lines} line${lines === 1 ? "" : "s"}`);
+      parts.push(`${trimmed.length} chars`);
+      const tail = clip2(trimmed.slice(-160), 160);
+      if (tail) parts.push(`tail="${tail}"`);
+    } else {
+      parts.push("empty");
+    }
+  }
+  return parts.join(" ");
+}
+function formatToolMessageContent(args) {
+  if (args.toolName !== "listFiles" && args.toolName !== "globFiles" && args.toolName !== "searchFiles" && args.toolName !== "readFile" || !args.metadata || Object.keys(args.metadata).length === 0) {
+    return args.content;
+  }
+  return `${args.content}
+
+[tool metadata]
+${JSON.stringify(args.metadata)}`;
+}
+function blocksToOpenAiMessages(blocks) {
+  const out = [];
+  let text = "";
+  let reasoning = "";
+  let pendingToolCalls = [];
+  let pendingToolResults = [];
+  const flushSegment = () => {
+    if (text === "" && pendingToolCalls.length === 0 && reasoning === "") return;
+    out.push({
+      role: "assistant",
+      content: text || null,
+      ...reasoning ? { reasoning_content: reasoning } : {},
+      ...pendingToolCalls.length > 0 ? { tool_calls: pendingToolCalls } : {}
+    });
+    for (let i = 0; i < pendingToolCalls.length; i += 1) {
+      const tc = pendingToolCalls[i];
+      const res = pendingToolResults[i];
+      out.push({
+        role: "tool",
+        content: formatToolMessageContent({
+          toolName: tc.function.name,
+          content: res?.content ?? "",
+          ...res?.metadata ? { metadata: res.metadata } : {}
+        }),
+        tool_call_id: tc.id,
+        toolName: tc.function.name,
+        ...res?.metadata ? { tool_result_metadata: res.metadata } : {}
+      });
+    }
+    text = "";
+    reasoning = "";
+    pendingToolCalls = [];
+    pendingToolResults = [];
+  };
+  for (const block of blocks) {
+    if (block.type === "text") {
+      if (pendingToolCalls.length > 0) {
+        flushSegment();
+      }
+      text += block.text;
+      continue;
+    }
+    if (block.type === "thinking") {
+      reasoning += block.thinking;
+      continue;
+    }
+    if (block.type === "toolCall") {
+      pendingToolCalls.push(block.toolCall);
+      pendingToolResults.push({
+        content: block.result?.content ?? "",
+        ...block.result?.metadata ? { metadata: block.result.metadata } : {}
+      });
+    }
+  }
+  flushSegment();
+  return out;
+}
+function buildActionGate(args) {
+  const gate = readActionGate(args.metadata?.actionGate);
+  if (!gate) return null;
+  if (gate.kind === "handoff" && !readCommandActionGatePayload(gate.payload)) return null;
+  return {
+    ...gate,
+    toolName: args.toolName,
+    toolCallId: args.toolCallId
+  };
+}
+var TOOL_METADATA_KEYS = [
+  "path",
+  "query",
+  "effectivePattern",
+  "startLine",
+  "endLine",
+  "totalLines",
+  "totalBytes",
+  "bytes",
+  "totalChars",
+  "count",
+  "matchCount",
+  "matchedFiles",
+  "truncated",
+  "limitedByMaxResults",
+  "limitedByMaxDepth",
+  "visitedEntries",
+  "maxResults",
+  "exitCode",
+  "status",
+  "timedOut",
+  "aborted",
+  "replacements",
+  "code",
+  "error",
+  "message",
+  "warnings",
+  "pasteId",
+  "source"
+];
+function trimHistoryToContextBudget(history, model) {
+  if (history.length === 0) return { history, droppedCount: 0 };
+  const { rawMessageBudget } = planContextUsage({
+    contextWindow: getModelContextWindow(model ?? ""),
+    summaryTokens: 0,
+    // localLoop 没有 web 端的负载分档器；medium 是中性默认值，
+    // 不为了省几个 token 在这里复制一份分类逻辑。
+    recentLoad: "medium"
+  });
+  const messageTokens = (message) => {
+    const toolCalls = message.tool_calls;
+    return estimateTokenCount(contentAsText(message.content)) + (Array.isArray(toolCalls) ? estimateTokenCount(JSON.stringify(toolCalls)) : 0);
+  };
+  let used = 0;
+  let start = history.length;
+  for (let i = history.length - 1; i >= 0; i -= 1) {
+    const cost = messageTokens(history[i]);
+    if (used + cost > rawMessageBudget && start < history.length) break;
+    used += cost;
+    start = i;
+  }
+  if (start === 0) return { history, droppedCount: 0 };
+  return {
+    history: sanitizeToolCallPairing(history.slice(start)),
+    droppedCount: start
+  };
+}
+function contentAsText(content) {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  return content.map((part) => {
+    if (part?.type === "text") return part.text;
+    if (part?.type === "image_url") return part.image_url.url;
+    return "";
+  }).join("\n");
+}
+function contentCharCount(content) {
+  if (typeof content === "string") return content.length;
+  if (!Array.isArray(content)) return 0;
+  return content.reduce((total, part) => {
+    if (part?.type === "text") return total + part.text.length;
+    if (part?.type === "image_url") return total + part.image_url.url.length;
+    return total;
+  }, 0);
+}
+function compactToolMetadata(metadata) {
+  if (!metadata) return "";
+  const selected = {};
+  for (const key of TOOL_METADATA_KEYS) {
+    const value = metadata[key];
+    if (value === void 0) continue;
+    if (typeof value === "string") {
+      selected[key] = clipCompactText(value, 240);
+      continue;
+    }
+    if (Array.isArray(value)) {
+      selected[key] = value.slice(0, 20).map(
+        (item) => typeof item === "string" ? clipCompactText(item, 180) : clipCompactText(JSON.stringify(item), 180)
+      );
+      continue;
+    }
+    selected[key] = value;
+  }
+  return Object.keys(selected).length > 0 ? clipCompactText(JSON.stringify(selected), 1200) : "";
+}
+function projectToolContentForProvider(args) {
+  const content = args.content;
+  if (typeof content !== "string") return content;
+  const metadataText = compactToolMetadata(args.metadata);
+  const embeddedMetadataIndex = metadataText ? content.indexOf("\n\n[tool metadata]\n") : -1;
+  const contentForProjection = embeddedMetadataIndex >= 0 ? content.slice(0, embeddedMetadataIndex) : content;
+  const metadataSuffix = metadataText ? `
+
+[tool metadata]
+${metadataText}` : "";
+  if (embeddedMetadataIndex >= 0 && content.length <= args.maxChars) {
+    return content;
+  }
+  const headRatio = resolveToolOutputProfile(args.toolName).headRatio;
+  const diagnostic = (clippedLength) => `[${args.label}; originalChars=${content.length}; omittedChars=${Math.max(
+    0,
+    content.length - clippedLength
+  )}]`;
+  const suffix = (clippedLength) => [diagnostic(clippedLength), metadataSuffix.trimStart()].filter(Boolean).join("\n\n");
+  const initialBudget = Math.max(
+    1,
+    args.maxChars - suffix(contentForProjection.length).length - 2
+  );
+  let clipped = clipToolText(contentForProjection, initialBudget, headRatio);
+  const wasClipped = clipped.length < contentForProjection.trim().length;
+  const needsProjection = wasClipped || Boolean(metadataSuffix) || embeddedMetadataIndex >= 0;
+  if (!needsProjection) return args.content;
+  let projected = wasClipped || metadataSuffix ? `${clipped}
+
+${suffix(clipped.length)}` : clipped;
+  if (projected.length > args.maxChars) {
+    const boundedBudget = Math.max(
+      1,
+      args.maxChars - suffix(clipped.length).length - 2
+    );
+    clipped = clipToolText(contentForProjection, boundedBudget, headRatio);
+    projected = `${clipped}
+
+${suffix(clipped.length)}`;
+  }
+  return projected.length <= args.maxChars ? projected : projected.slice(0, args.maxChars);
+}
+function summarizeHistoricalToolContent(content, toolName, metadata) {
+  return projectToolContentForProvider({
+    content,
+    toolName,
+    metadata,
+    // Same single source of truth as the server path and the read ledgers:
+    // read-family tools keep their profile historical cap (4800) cross-turn,
+    // unprofiled tools fall back to the flat historical budget.
+    maxChars: resolveHistoricalToolContentCap(toolName, MAX_HISTORICAL_TOOL_CONTENT_CHARS),
+    label: "historical tool result truncated for the next turn"
+  });
+}
+function prepareMessagesForProviderCall(messages) {
+  const paired = sanitizeToolCallPairing(messages);
+  let freshRunStart = paired.length;
+  while (freshRunStart > 0 && paired[freshRunStart - 1].role === "tool") {
+    freshRunStart -= 1;
+  }
+  let toolMessageCount = 0;
+  let rawToolContentChars = 0;
+  let projectedToolContentChars = 0;
+  let truncatedToolResults = 0;
+  const projected = paired.map((message, index) => {
+    const { context_reference: _contextReference, ...providerMessage } = message;
+    const sanitizedContent = providerMessage.content == null ? "" : typeof providerMessage.content === "string" ? providerMessage.content : providerMessage.content;
+    if (providerMessage.role !== "tool") {
+      return {
+        ...providerMessage,
+        content: sanitizedContent
+      };
+    }
+    toolMessageCount += 1;
+    rawToolContentChars += contentCharCount(sanitizedContent);
+    const isFresh = index >= freshRunStart;
+    const maxChars = isFresh ? FRESH_TOOL_OUTPUT_MAX_CHARS : resolveToolOutputProfile(providerMessage.toolName).maxChars;
+    const projectedContent = projectToolContentForProvider({
+      content: sanitizedContent,
+      toolName: providerMessage.toolName,
+      metadata: providerMessage.tool_result_metadata,
+      maxChars,
+      label: "in-turn tool result truncated/projected before next provider call"
+    });
+    projectedToolContentChars += contentCharCount(projectedContent);
+    if (contentCharCount(projectedContent) < contentCharCount(sanitizedContent)) {
+      truncatedToolResults += 1;
+    }
+    return {
+      ...providerMessage,
+      content: projectedContent
+    };
+  });
+  return {
+    messages: projected,
+    metrics: {
+      messageCount: projected.length,
+      contentChars: projected.reduce((total, message) => total + contentCharCount(message.content), 0),
+      toolMessageCount,
+      rawToolContentChars,
+      projectedToolContentChars,
+      truncatedToolResults,
+      stableContextChars: 0,
+      dynamicContextChars: 0
+    }
+  };
+}
+function prepareHistoryForNextTurn(history, contextReferenceResolver) {
+  return history.map((message) => {
+    if (message.role === "user" && message.context_reference !== void 0 && contextReferenceResolver?.(message.context_reference)) {
+      return { ...message, content: message.context_reference };
+    }
+    if (message.role !== "tool") return message;
+    return {
+      ...message,
+      content: summarizeHistoricalToolContent(
+        message.content,
+        message.toolName,
+        message.tool_result_metadata
+      )
+    };
+  });
+}
+var IMAGE_OMITTED_PLACEHOLDER2 = "[Image content omitted: model does not support image input]";
+function stripImagePartsFromContent2(content) {
+  if (!Array.isArray(content)) return content;
+  const filtered = content.filter((part) => part?.type !== "image_url");
+  if (filtered.length === 0) return IMAGE_OMITTED_PLACEHOLDER2;
+  return filtered;
+}
+function filterImagePartsFromMessages(messages, supportsImages) {
+  if (supportsImages) return messages;
+  return messages.map((msg) => ({
+    ...msg,
+    content: stripImagePartsFromContent2(msg.content)
+  }));
+}
+function buildMessages(args) {
+  if (args.contextBlockScopes?.length) {
+    const blocks2 = args.contextBlockScopes.filter((b) => b.content.trim());
+    const stableParts = [args.prompt?.trim(), ...blocks2.filter((b) => b.cacheScope === "session").map((b) => b.content)].filter(Boolean);
+    const dynamicParts = blocks2.filter((b) => b.cacheScope === "turn").map((b) => b.content).map((block) => block.trim()).filter(Boolean);
+    const stableContent = stableParts.join("\n\n");
+    const dynamicContent = dynamicParts.join("\n\n");
+    const systemContent2 = dynamicContent ? `${stableContent}
+
+${dynamicContent}` : stableContent;
+    return {
+      messages: [
+        ...systemContent2 ? [{
+          role: "system",
+          content: systemContent2,
+          ...stableContent ? { stable_prefix_chars: stableContent.length } : {}
+        }] : [],
+        ...prepareHistoryForNextTurn(args.history, args.contextReferenceResolver),
+        { role: "user", content: args.input }
+      ],
+      stableContextChars: stableContent.length,
+      dynamicContextChars: dynamicContent.length
+    };
+  }
+  const blocks = (args.contextBlocks ?? []).map((block) => block.trim()).filter(Boolean);
+  const systemContent = [args.prompt?.trim(), ...blocks].filter(Boolean).join("\n\n");
+  return {
+    messages: [
+      ...systemContent ? [{ role: "system", content: systemContent }] : [],
+      ...prepareHistoryForNextTurn(args.history, args.contextReferenceResolver),
+      { role: "user", content: args.input }
+    ],
+    stableContextChars: (args.prompt?.trim() ?? "").length,
+    dynamicContextChars: blocks.join("\n\n").length
+  };
+}
+function mergeTurnUsage(current, next) {
+  if (!next) return current;
+  const read = (usage) => ({
+    input: Number(usage.input_tokens ?? usage.prompt_tokens ?? 0),
+    output: Number(usage.output_tokens ?? usage.completion_tokens ?? 0),
+    cacheHit: Number(
+      usage.cache_read_input_tokens ?? usage.prompt_cache_hit_tokens ?? 0
+    ),
+    cacheMiss: Number(
+      usage.cache_creation_input_tokens ?? usage.prompt_cache_miss_tokens ?? 0
+    )
+  });
+  const right = read(next);
+  const left = current ? read(current) : { input: 0, output: 0, cacheHit: 0, cacheMiss: 0 };
+  return {
+    input_tokens: left.input + right.input,
+    output_tokens: left.output + right.output,
+    cache_read_input_tokens: left.cacheHit + right.cacheHit,
+    cache_creation_input_tokens: left.cacheMiss + right.cacheMiss
+  };
+}
+function addOutOfBandUsage(turn, extra) {
+  if (!extra) return turn;
+  const num = (u, ...keys) => {
+    if (!u) return 0;
+    for (const k of keys) {
+      const v = Number(u[k]);
+      if (Number.isFinite(v) && v !== 0) return v;
+    }
+    return 0;
+  };
+  return {
+    ...turn ?? {},
+    input_tokens: num(turn, "input_tokens", "prompt_tokens") + num(extra, "input_tokens", "prompt_tokens"),
+    output_tokens: num(turn, "output_tokens", "completion_tokens") + num(extra, "output_tokens", "completion_tokens"),
+    cache_read_input_tokens: num(turn, "cache_read_input_tokens", "prompt_cache_hit_tokens") + num(extra, "cache_read_input_tokens", "prompt_cache_hit_tokens"),
+    cache_creation_input_tokens: num(turn, "cache_creation_input_tokens", "prompt_cache_miss_tokens") + num(extra, "cache_creation_input_tokens", "prompt_cache_miss_tokens")
+  };
+}
+function extractUserInputText(content) {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  return content.flatMap((part) => part?.type === "text" && part.text ? [part.text] : []).join("\n").trim();
+}
+function attachDialogIdToError(error, dialogId) {
+  if (!dialogId) return;
+  if (typeof error === "object" && error !== null) {
+    error.dialogId = dialogId;
+  }
+}
+async function persistFailedLocalTurn(args) {
+  const errorMessage = toErrorMessage(args.error);
+  try {
+    const saved = await args.adapter.saveTurn({
+      agentKey: args.agentKey,
+      messages: args.messages,
+      result: {
+        content: args.partialContent || `[nolo] Agent run failed: ${errorMessage}`,
+        model: args.model ?? "unknown",
+        toolCallCount: args.toolCallCount ?? 0,
+        error: true,
+        errorMessage,
+        ...args.usage ? { usage: args.usage } : {}
+      },
+      ...args.accountingUsage ? { accountingUsage: args.accountingUsage } : {},
+      ...args.usageRecords?.length ? { usageRecords: args.usageRecords } : {},
+      ...args.billingConfig ? { billingConfig: args.billingConfig } : {},
+      ...args.input.runtimeContext ? { runtimeContext: args.input.runtimeContext } : {},
+      ...args.input.continueDialogId ? { continueDialogId: args.input.continueDialogId } : {},
+      ...args.input.spaceId ? { spaceId: args.input.spaceId } : {},
+      ...args.input.category ? { category: args.input.category } : {},
+      ...args.input.inheritedFromDialogKey ? { inheritedFromDialogKey: args.input.inheritedFromDialogKey } : {},
+      ...args.input.parentDialogId ? { parentDialogId: args.input.parentDialogId } : {}
+    });
+    return saved?.dialogId;
+  } catch {
+    return args.input.continueDialogId;
+  }
+}
+function applyPersistedTurnInput(messages, persistedInput, persistedInputReference) {
+  if (persistedInput === void 0 && persistedInputReference === void 0) {
+    return messages;
+  }
+  let replaced = false;
+  return messages.map((message) => {
+    if (replaced || message.role !== "user") return message;
+    replaced = true;
+    return {
+      ...message,
+      ...persistedInput !== void 0 ? { content: persistedInput } : {},
+      ...persistedInputReference !== void 0 ? { context_reference: persistedInputReference } : {}
+    };
+  });
+}
+async function runLocalAgentTurn(input) {
+  const agentConfig = await input.adapter.loadAgentConfig(input.agentRef);
+  if (!agentConfig) {
+    const error = new Error(
+      `agentRef "${input.agentRef}" \u672A\u5339\u914D\u5230\u672C\u5730 agent\u3002\u8FD9\u4E0D\u662F\u914D\u7F6E\u7F3A\u5931\uFF0C\u8BF7\u7528 listAgents \u67E5\u770B\u53EF\u7528 agent\uFF0C\u518D\u7528 readAgent \u89E3\u6790 agentKey\uFF0C\u52FF\u624B\u5DE5\u62FC key\u3002`
+    );
+    error.code = LOCAL_AGENT_CONFIG_MISSING_CODE;
+    error.agentRef = input.agentRef;
+    throw error;
+  }
+  const rawBillingConfig = agentConfig.rawRecord ?? {};
+  const billingConfig = {
+    model: agentConfig.model || "unknown",
+    ...agentConfig.provider ? { provider: agentConfig.provider } : {},
+    ...agentConfig.apiSource ? { apiSource: agentConfig.apiSource } : {},
+    ...agentConfig.apiKeyRef !== void 0 ? { apiKeyRef: agentConfig.apiKeyRef } : {},
+    ...typeof rawBillingConfig.inputPrice === "number" ? { inputPrice: rawBillingConfig.inputPrice } : {},
+    ...typeof rawBillingConfig.outputPrice === "number" ? { outputPrice: rawBillingConfig.outputPrice } : {},
+    ...rawBillingConfig.sharingLevel ? { sharingLevel: rawBillingConfig.sharingLevel } : {},
+    id: agentConfig.key,
+    ...typeof rawBillingConfig.userId === "string" ? { userId: rawBillingConfig.userId } : {}
+  };
+  let history = [];
+  try {
+    history = input.continueDialogId ? await input.adapter.loadDialogHistory(input.continueDialogId) : [];
+  } catch (error) {
+    const dialogId = await persistFailedLocalTurn({
+      adapter: input.adapter,
+      agentKey: agentConfig.key,
+      messages: [{ role: "user", content: input.input }],
+      error,
+      model: agentConfig.model,
+      input
+    });
+    attachDialogIdToError(error, dialogId);
+    throw error;
+  }
+  const identityBlock = buildIdentityBlock({
+    agentName: agentConfig.name,
+    agentId: agentConfig.key,
+    model: agentConfig.model
+  });
+  const agentTools = canonicalizeToolNames(
+    agentConfig.exposedToolNames ?? agentConfig.toolNames ?? []
+  );
+  const guidanceBlocks = buildRuntimeGuidanceBlocks(agentTools);
+  const toolGuidedSections = resolveToolGuidedSections(agentTools);
+  const guidanceScopes = [
+    ...input.userLanguage?.trim() ? [buildUserResponseLanguageContext({ language: input.userLanguage })] : [],
+    guidanceBlocks.startupProtocol,
+    guidanceBlocks.contextLayerContract,
+    guidanceBlocks.emailRegistrationWorkflow,
+    guidanceBlocks.webResearchToolPolicy,
+    ...Object.values(toolGuidedSections)
+  ].map((content) => content.trim()).filter((content) => content.length > 0).map((content) => ({ content, cacheScope: "session" }));
+  const currentTimeScope = [
+    { content: buildCurrentTimeBlock(/* @__PURE__ */ new Date(), void 0), cacheScope: "turn" }
+  ];
+  const callerScopes = normalizeContextBlockScopes(
+    input.contextBlocks,
+    input.contextBlockScopes
+  );
+  const mergedContextBlockScopes = [
+    { content: identityBlock, cacheScope: "session" },
+    ...guidanceScopes,
+    ...currentTimeScope,
+    ...callerScopes
+  ];
+  let resolvedProvider;
+  const resolveProviderOnce = async () => {
+    if (!resolvedProvider) {
+      resolvedProvider = await input.adapter.resolveProvider(agentConfig);
+    }
+    return resolvedProvider;
+  };
+  let compactionUsage;
+  try {
+    const compacted = await maybeAutoCompactLocalHistory({
+      adapter: input.adapter,
+      dialogId: input.continueDialogId,
+      history,
+      model: agentConfig.model,
+      resolveProvider: resolveProviderOnce
+    });
+    history = compacted.history;
+    compactionUsage = compacted.usage;
+  } catch (error) {
+    console.warn("[localLoop] auto-compaction unexpected error:", error);
+  }
+  const trimmedHistory = trimHistoryToContextBudget(history, agentConfig.model);
+  if (trimmedHistory.droppedCount > 0) {
+    history = trimmedHistory.history;
+  }
+  const hasContextBlocks = callerScopes.some((block) => block.content.trim()) || mergedContextBlockScopes.some((block) => block.content.trim());
+  const promptMessageCount = agentConfig.prompt?.trim() || hasContextBlocks ? 1 : 0;
+  const turnStartIndex = promptMessageCount + history.length;
+  const builtMessages = buildMessages({
+    prompt: agentConfig.prompt,
+    contextBlockScopes: mergedContextBlockScopes,
+    history,
+    input: input.input,
+    contextReferenceResolver: input.adapter.host === "cli" ? input.contextReferenceResolver : void 0
+  });
+  let messages = builtMessages.messages;
+  const supportsImages = resolveAgentImageInputSupport({
+    apiSource: agentConfig.apiSource,
+    provider: agentConfig.provider,
+    model: agentConfig.model,
+    hasVision: agentConfig.hasVision
+  });
+  if (!supportsImages && hasImageInRuntimeMessages(messages)) {
+    const imageUrls = extractImageUrlsFromMessages(messages);
+    const preprocessed = await preprocessImagesForTextOnlyAgent(
+      messages,
+      (urls) => describeImageWithLocalProvider(input.adapter, urls)
+    );
+    if (preprocessed !== messages) {
+      messages = preprocessed;
+      emitLoopEvent(input, {
+        kind: "image-preprocessed",
+        atMs: Date.now(),
+        imageCount: imageUrls.length
+      });
+    } else {
+      messages = filterImagePartsFromMessages(messages, false);
+      emitLoopEvent(input, {
+        kind: "image-downgraded",
+        reason: "no-vision",
+        atMs: Date.now()
+      });
+    }
+  }
+  const userInputText = extractUserInputText(input.input);
+  let toolCallCount = 0;
+  let result;
+  let turnUsage;
+  let contextUsage;
+  const usageRecords = [];
+  let loopError;
+  let round = 0;
+  let emptyAssistantRepairPending = false;
+  let emptyAssistantRepairUsed = false;
+  let skipFinalAppend = false;
+  let partialContent = "";
+  try {
+    const provider = await resolveProviderOnce();
+    while (true) {
+      partialContent = "";
+      throwIfAborted(input);
+      const preparedMessages = prepareMessagesForProviderCall(messages);
+      const baseRequestMessages = filterImagePartsFromMessages(
+        preparedMessages.messages,
+        supportsImages
+      );
+      const requestMessages = emptyAssistantRepairPending ? [...baseRequestMessages, { role: "user", content: EMPTY_ASSISTANT_REPAIR_PROMPT }] : baseRequestMessages;
+      const contextMetrics = {
+        ...preparedMessages.metrics,
+        messageCount: requestMessages.length,
+        contentChars: requestMessages.reduce(
+          (total, message) => total + contentCharCount(message.content),
+          0
+        ),
+        stableContextChars: builtMessages.stableContextChars,
+        dynamicContextChars: builtMessages.dynamicContextChars
+      };
+      emptyAssistantRepairPending = false;
+      result = await runCompleteWithTimeout({
+        provider,
+        messages: requestMessages,
+        options: {
+          ...typeof input.timeoutMs === "number" ? { timeoutMs: input.timeoutMs } : {},
+          // 计费归因：续聊轮次带上 dialogId，platform proxy 才能把 token 记录
+          // 归到具体对话而不是 chat-proxy 兜底桶。新对话首轮 id 尚未分配。
+          ...input.continueDialogId ? { dialogId: input.continueDialogId } : {},
+          ...input.onTextDelta ? { onTextDelta: (chunk) => {
+            partialContent += chunk;
+            input.onTextDelta(chunk);
+          } } : {},
+          ...input.onReasoningDelta ? { onReasoningDelta: input.onReasoningDelta } : {},
+          ...input.onToolEvent ? { onToolEvent: input.onToolEvent } : {},
+          ...input.onToolEvent ? { toolEventRound: round } : {}
+        },
+        timeoutMs: resolveLlmRequestTimeoutMs(input),
+        round,
+        input,
+        context: contextMetrics
+      });
+      turnUsage = mergeTurnUsage(turnUsage, result.usage);
+      contextUsage = result.usage;
+      if (result.usage && Object.keys(result.usage).length > 0) {
+        usageRecords.push({
+          callId: typeof result.usage.provider_call_id === "string" && result.usage.provider_call_id.trim() ? result.usage.provider_call_id.trim() : crypto.randomUUID(),
+          usage: result.usage,
+          model: result.model || agentConfig.model || "unknown",
+          ...result.provider || agentConfig.provider ? { provider: result.provider || agentConfig.provider } : {}
+        });
+      }
+      const toolCalls = result.tool_calls ?? [];
+      const rawToolCallsCount = (result.tool_calls?.length ?? 0) || (Array.isArray(result.raw_tool_calls) ? result.raw_tool_calls.length : 0);
+      if (toolCalls.length === 0 && rawToolCallsCount === 0) {
+        const outcome = resolveEmptyAssistantOutcome({
+          hasToolCalls: rawToolCallsCount > 0,
+          hasVisibleOutput: hasAssistantVisibleOutput(result.content),
+          repairUsed: emptyAssistantRepairUsed,
+          finishReason: result.finish_reason,
+          streamComplete: result.stream_complete
+        });
+        if (outcome.kind === "repair") {
+          emptyAssistantRepairPending = true;
+          emptyAssistantRepairUsed = true;
+          continue;
+        }
+        if (outcome.kind === "fallback") {
+          result = {
+            ...result,
+            content: resolveEmptyAssistantFallbackMessage(outcome.reason)
+          };
+          break;
+        }
+        break;
+      }
+      const outputBlocks = result.output ?? [];
+      if (outputBlocks.length > 0) {
+        let hasInlineExecutedTools = false;
+        for (const block of outputBlocks) {
+          if (block.type !== "toolCall") continue;
+          toolCallCount += 1;
+          const toolName = block.toolCall.function.name;
+          if (block.result) {
+            hasInlineExecutedTools = true;
+          } else {
+            throw new Error(
+              `provider returned output block with unexecuted toolCall "${toolName}" (id=${block.toolCall.id}); no provider currently emits this shape. Either the provider must fill block.result (like Cursor's exec channel) or it must not set result.output at all.`
+            );
+          }
+        }
+        if (hasInlineExecutedTools) {
+          messages.push(...blocksToOpenAiMessages(outputBlocks));
+          skipFinalAppend = true;
+          break;
+        }
+        round += 1;
+        continue;
+      }
+      toolCallCount += toolCalls.length;
+      messages.push({
+        role: "assistant",
+        content: result.content || null,
+        ...result.reasoning_content ? { reasoning_content: result.reasoning_content } : {},
+        tool_calls: toolCalls
+      });
+      for (const toolCall of toolCalls) {
+        throwIfAborted(input);
+        const toolName = toolCall.function.name;
+        let toolResult;
+        const startedAt = Date.now();
+        emitLoopEvent(input, { kind: "tool-start", name: toolName, atMs: Date.now() });
+        emitToolEvent(input, {
+          type: "tool-call",
+          round,
+          toolCallId: toolCall.id,
+          toolName,
+          argumentsPreview: summarizeToolArguments(toolName, toolCall.function.arguments)
+        });
+        try {
+          const executePromise = input.adapter.executeTool({
+            id: toolCall.id,
+            name: toolName,
+            arguments: toolCall.function.arguments,
+            ...userInputText ? { userInput: userInputText } : {},
+            ...input.runtimeContext ? { runtimeContext: input.runtimeContext } : {},
+            ...input.abortSignal ? { abortSignal: input.abortSignal } : {}
+          }, {
+            ...input.abortSignal ? { abortSignal: input.abortSignal } : {},
+            ...input.runtimeContext ? { runtimeContext: input.runtimeContext } : {}
+          });
+          toolResult = await raceWithAbort(input, executePromise, toolName);
+          const actionGate = buildActionGate({
+            toolName,
+            toolCallId: toolCall.id,
+            metadata: toolResult.metadata
+          });
+          if (actionGate && input.onActionGate) {
+            const replacement = await input.onActionGate(actionGate);
+            if (replacement) {
+              toolResult = replacement;
+            }
+          }
+          emitLoopEvent(input, { kind: "tool-end", name: toolName, atMs: Date.now(), ok: true });
+          emitToolEvent(input, {
+            type: "tool-result",
+            round,
+            toolCallId: toolCall.id,
+            toolName,
+            elapsedMs: Math.max(0, Date.now() - startedAt),
+            summary: summarizeToolResult(toolResult.content, toolResult.metadata),
+            ...typeof toolResult.content === "string" ? { content: toolResult.content } : {},
+            metadata: toolResult.metadata
+          });
+        } catch (error) {
+          emitLoopEvent(input, { kind: "tool-end", name: toolName, atMs: Date.now(), ok: false });
+          if (error && typeof error === "object" && error.code === LOCAL_TURN_ABORTED_CODE) {
+            throw error;
+          }
+          if (!shouldReturnToolExecutionErrors(input.adapter)) throw error;
+          emitToolEvent(input, {
+            type: "tool-error",
+            round,
+            toolCallId: toolCall.id,
+            toolName,
+            elapsedMs: Math.max(0, Date.now() - startedAt),
+            message: toErrorMessage(error)
+          });
+          toolResult = {
+            content: formatStructuredToolExecutionError({ toolName, error }) ?? formatToolExecutionError({ toolName, error }),
+            metadata: {
+              error: true,
+              toolName,
+              message: toErrorMessage(error),
+              ...error && typeof error === "object" && typeof error.code === "string" ? { code: error.code } : {}
+            }
+          };
+        }
+        messages.push({
+          role: "tool",
+          content: formatToolMessageContent({
+            toolName,
+            content: toolResult.content,
+            metadata: toolResult.metadata
+          }),
+          tool_call_id: toolCall.id,
+          toolName,
+          ...toolResult.metadata ? { tool_result_metadata: toolResult.metadata } : {}
+        });
+      }
+      round += 1;
+    }
+  } catch (error) {
+    loopError = error;
+  }
+  if (loopError) {
+    const turnMessages2 = applyPersistedTurnInput(
+      messages.slice(turnStartIndex),
+      input.persistedInput,
+      input.persistedInputReference
+    );
+    const dialogId = await persistFailedLocalTurn({
+      adapter: input.adapter,
+      agentKey: agentConfig.key,
+      messages: turnMessages2,
+      error: loopError,
+      model: agentConfig.model,
+      toolCallCount,
+      partialContent,
+      usage: contextUsage,
+      accountingUsage: addOutOfBandUsage(turnUsage, compactionUsage),
+      usageRecords: [
+        ...compactionUsage ? [{
+          callId: typeof compactionUsage.provider_call_id === "string" && compactionUsage.provider_call_id.trim() ? compactionUsage.provider_call_id.trim() : crypto.randomUUID(),
+          usage: compactionUsage,
+          model: agentConfig.model || "unknown",
+          ...agentConfig.provider ? { provider: agentConfig.provider } : {}
+        }] : [],
+        ...usageRecords
+      ],
+      billingConfig,
+      input
+    });
+    attachDialogIdToError(loopError, dialogId);
+    throw loopError;
+  }
+  result = result;
+  if (!skipFinalAppend) {
+    messages.push({
+      role: "assistant",
+      content: result.content,
+      // 与中间轮(:561)一致带上 reasoning_content,让 saveTurn 持久化思维链,
+      // 空轮/异常排查时能回看模型实际想了什么。
+      ...result.reasoning_content ? { reasoning_content: result.reasoning_content } : {}
+    });
+  }
+  const turnMessages = applyPersistedTurnInput(
+    messages.slice(turnStartIndex),
+    input.persistedInput,
+    input.persistedInputReference
+  );
+  if (compactionUsage && Object.keys(compactionUsage).length > 0) {
+    usageRecords.unshift({
+      callId: typeof compactionUsage.provider_call_id === "string" && compactionUsage.provider_call_id.trim() ? compactionUsage.provider_call_id.trim() : crypto.randomUUID(),
+      usage: compactionUsage,
+      model: agentConfig.model || result.model || "unknown",
+      ...agentConfig.provider ? { provider: agentConfig.provider } : {}
+    });
+  }
+  const accountingUsage = addOutOfBandUsage(turnUsage, compactionUsage);
+  const saved = await input.adapter.saveTurn({
+    agentKey: agentConfig.key,
+    messages: turnMessages,
+    result: {
+      ...result,
+      ...toolCallCount > 0 ? { toolCallCount } : {},
+      ...agentConfig.toolSurface ? { runtimeToolSurface: agentConfig.toolSurface } : {}
+    },
+    ...usageRecords.length > 0 ? { usageRecords } : {},
+    ...accountingUsage ? { accountingUsage } : {},
+    billingConfig,
+    ...input.runtimeContext ? { runtimeContext: input.runtimeContext } : {},
+    ...input.continueDialogId ? { continueDialogId: input.continueDialogId } : {},
+    ...input.spaceId ? { spaceId: input.spaceId } : {},
+    ...input.category ? { category: input.category } : {},
+    ...input.inheritedFromDialogKey ? { inheritedFromDialogKey: input.inheritedFromDialogKey } : {},
+    ...input.parentDialogId ? { parentDialogId: input.parentDialogId } : {}
+  });
+  return {
+    ...result,
+    ...usageRecords.length > 0 ? { usageRecords } : {},
+    ...accountingUsage ? { accountingUsage } : {},
+    ...toolCallCount > 0 ? { toolCallCount } : {},
+    ...agentConfig.toolSurface ? { runtimeToolSurface: agentConfig.toolSurface } : {},
+    // 透出最后一轮 provider 调用的 finish_reason；多轮工具循环里只有最后一轮收尾状态有意义。
+    ...result.finish_reason ? { finish_reason: result.finish_reason } : {},
+    dialogId: saved.dialogId,
+    title: saved.title,
+    ...saved.titlePatchPromise ? { titlePatchPromise: saved.titlePatchPromise } : {},
+    turnMessages
+  };
+}
+
+export {
+  readCommandActionGatePayload,
+  readActionGate,
+  summarizeToolArguments,
+  tryPreprocessWebImageOrReject,
+  resolveHistoricalToolContentCap,
+  projectToolMessageContent,
+  LOCAL_AGENT_CONFIG_MISSING_CODE,
+  EMPTY_ASSISTANT_REPAIR_PROMPT,
+  LOCAL_TURN_ABORTED_CODE,
+  runLocalAgentTurn
+};