nolo-cli 0.8.0 → 0.9.0

package/chunk-XS466O7S.js

@@ -0,0 +1,933 @@
+import {
+  buildCurrentTimeBlock,
+  buildIdentityBlock,
+  buildRuntimeGuidanceBlocks
+} from "./chunk-PAKN26FP.js";
+import {
+  canonicalizeToolNames
+} from "./chunk-AUQ747NZ.js";
+import {
+  clipCompactText
+} from "./chunk-5MMAK75Q.js";
+import {
+  findModelConfig,
+  getProviderByModelName
+} from "./chunk-BBYVOSU2.js";
+import {
+  compactWhitespace
+} from "./chunk-DWLEOOGR.js";
+import {
+  toErrorMessage
+} from "./chunk-HNMXYYJR.js";
+import {
+  asRecordOrEmpty
+} from "./chunk-KX6YBIHG.js";
+import {
+  asTrimmedLowercaseString
+} from "./chunk-QSJ3HFEF.js";
+import {
+  asOptionalTrimmedString
+} from "./chunk-G3SUCT4W.js";
+import {
+  isRecord
+} from "./chunk-KUG52IAP.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;
+  return {
+    id: value.id.trim(),
+    kind: value.kind,
+    title: value.title.trim(),
+    ...asOptionalTrimmedString(value.body) ? { body: asOptionalTrimmedString(value.body) } : {},
+    ...Object.prototype.hasOwnProperty.call(value, "payload") ? { payload: value.payload } : {}
+  };
+}
+
+// packages/ai/llm/agentCapabilities.ts
+var isCustomAgent = (agent) => {
+  const apiSource = agent.apiSource?.toLowerCase();
+  const provider = agent.provider?.toLowerCase();
+  return apiSource === "custom" || provider === "custom";
+};
+var ANTIGRAVITY_EFFORT_SUFFIXES = [
+  "-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;
+}
+var lookupKnownModelVision = (provider, model) => {
+  if (!model) return void 0;
+  const candidates = [model];
+  const stripped = stripEffortSuffix(model);
+  if (stripped !== model) candidates.push(stripped);
+  for (const candidate of candidates) {
+    if (provider) {
+      const direct = findModelConfig(provider, candidate);
+      if (direct) return direct.hasVision;
+    }
+    const detected = getProviderByModelName(candidate);
+    if (detected) {
+      const found = findModelConfig(detected, candidate)?.hasVision;
+      if (found !== void 0) return found;
+    }
+    if (!provider && 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) 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 custom = isCustomAgent(agent);
+  const catalogHasVision = lookupKnownModelVision(
+    custom ? null : provider,
+    model
+  );
+  if (!custom && catalogHasVision !== void 0) {
+    return catalogHasVision;
+  }
+  if (custom) {
+    if (catalogHasVision === true) return true;
+    return true;
+  }
+  if (typeof agent.hasVision === "boolean") {
+    return agent.hasVision;
+  }
+  return true;
+};
+
+// 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/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) 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();
+}
+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 } = args;
+  emitLoopEvent(input, { kind: "llm-start", round, atMs: Date.now() });
+  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 MAX_HISTORICAL_TOOL_CONTENT_CHARS = 1600;
+var MAX_IN_TURN_TOOL_CONTENT_CHARS = 4e3;
+function summarizeToolContentForProvider(content, maxChars, label) {
+  if (typeof content !== "string") return content;
+  if (content.length <= maxChars) return content;
+  const compact = compactWhitespace(content);
+  const clipped = compact.length > maxChars ? compact.slice(0, maxChars - 160) : compact;
+  return [
+    `[${label}]`,
+    `originalChars=${content.length}`,
+    clipped
+  ].join("\n");
+}
+function summarizeHistoricalToolContent(content) {
+  return summarizeToolContentForProvider(
+    content,
+    MAX_HISTORICAL_TOOL_CONTENT_CHARS,
+    "historical tool result truncated for the next turn"
+  );
+}
+function prepareMessagesForProviderCall(messages) {
+  const paired = sanitizeToolCallPairing(messages);
+  return paired.map((message) => {
+    const sanitizedContent = message.content == null ? "" : typeof message.content === "string" ? message.content : message.content;
+    if (message.role !== "tool") {
+      return {
+        ...message,
+        content: sanitizedContent
+      };
+    }
+    return {
+      ...message,
+      content: summarizeToolContentForProvider(
+        sanitizedContent,
+        MAX_IN_TURN_TOOL_CONTENT_CHARS,
+        "in-turn tool result truncated before next provider call"
+      )
+    };
+  });
+}
+function prepareHistoryForNextTurn(history) {
+  return history.map((message) => {
+    if (message.role !== "tool") return message;
+    return {
+      ...message,
+      content: summarizeHistoricalToolContent(message.content)
+    };
+  });
+}
+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 filterImagePartsFromMessages(messages, supportsImages) {
+  if (supportsImages) return messages;
+  return messages.map((msg) => ({
+    ...msg,
+    content: stripImagePartsFromContent(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).filter(Boolean);
+    const stableContent = stableParts.join("\n\n");
+    const dynamicContent = dynamicParts.join("\n\n");
+    const systemContent2 = dynamicContent ? `${stableContent}
+
+${dynamicContent}` : stableContent;
+    return [
+      ...systemContent2 ? [{ role: "system", content: systemContent2 }] : [],
+      ...prepareHistoryForNextTurn(args.history),
+      { role: "user", content: args.input }
+    ];
+  }
+  const blocks = (args.contextBlocks ?? []).map((block) => block.trim()).filter(Boolean);
+  const systemContent = [args.prompt?.trim(), ...blocks].filter(Boolean).join("\n\n");
+  return [
+    ...systemContent ? [{ role: "system", content: systemContent }] : [],
+    ...prepareHistoryForNextTurn(args.history),
+    { role: "user", content: args.input }
+  ];
+}
+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: right.input || left.input,
+    output_tokens: left.output + right.output,
+    cache_read_input_tokens: left.cacheHit + right.cacheHit,
+    cache_creation_input_tokens: left.cacheMiss + right.cacheMiss
+  };
+}
+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();
+}
+async function runLocalAgentTurn(input) {
+  const agentConfig = await input.adapter.loadAgentConfig(input.agentRef);
+  if (!agentConfig) {
+    const error = new Error(`Local agent config not found: ${input.agentRef}`);
+    error.code = LOCAL_AGENT_CONFIG_MISSING_CODE;
+    error.agentRef = input.agentRef;
+    throw error;
+  }
+  const history = input.continueDialogId ? await input.adapter.loadDialogHistory(input.continueDialogId) : [];
+  const identityBlock = buildIdentityBlock({
+    agentName: agentConfig.name,
+    agentId: agentConfig.key,
+    model: agentConfig.model
+  });
+  const agentTools = canonicalizeToolNames(agentConfig.toolNames ?? []);
+  const guidanceBlocks = buildRuntimeGuidanceBlocks(agentTools);
+  const guidanceScopes = [
+    guidanceBlocks.startupProtocol,
+    guidanceBlocks.contextLayerContract,
+    guidanceBlocks.emailRegistrationWorkflow,
+    guidanceBlocks.webResearchToolPolicy
+  ].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 mergedContextBlockScopes = [
+    { content: identityBlock, cacheScope: "session" },
+    ...guidanceScopes,
+    ...currentTimeScope,
+    ...input.contextBlockScopes ?? []
+  ];
+  const hasContextBlocks = (input.contextBlocks ?? []).some(
+    (block) => block.trim()
+  ) || mergedContextBlockScopes.some(
+    (block) => block.content.trim()
+  );
+  const promptMessageCount = agentConfig.prompt?.trim() || hasContextBlocks ? 1 : 0;
+  const turnStartIndex = promptMessageCount + history.length;
+  const messages = buildMessages({
+    prompt: agentConfig.prompt,
+    contextBlocks: input.contextBlocks,
+    contextBlockScopes: mergedContextBlockScopes,
+    history,
+    input: input.input
+  });
+  const provider = await input.adapter.resolveProvider(agentConfig);
+  const supportsImages = resolveAgentImageInputSupport({
+    apiSource: agentConfig.apiSource,
+    provider: agentConfig.provider,
+    model: agentConfig.model,
+    hasVision: agentConfig.hasVision
+  });
+  const userInputText = extractUserInputText(input.input);
+  let toolCallCount = 0;
+  let result;
+  let turnUsage;
+  let loopError;
+  let round = 0;
+  let emptyAssistantRepairPending = false;
+  let emptyAssistantRepairUsed = false;
+  let imageDowngradeNotified = false;
+  let skipFinalAppend = false;
+  let partialContent = "";
+  try {
+    while (true) {
+      partialContent = "";
+      throwIfAborted(input);
+      const baseRequestMessages = filterImagePartsFromMessages(
+        prepareMessagesForProviderCall(messages),
+        supportsImages
+      );
+      if (!supportsImages && !imageDowngradeNotified && messages.some((m) => Array.isArray(m.content) && m.content.some((p) => p?.type === "image_url"))) {
+        imageDowngradeNotified = true;
+        emitLoopEvent(input, {
+          kind: "image-downgraded",
+          reason: "no-vision",
+          atMs: Date.now()
+        });
+      }
+      const requestMessages = emptyAssistantRepairPending ? [...baseRequestMessages, { role: "user", content: EMPTY_ASSISTANT_REPAIR_PROMPT }] : baseRequestMessages;
+      emptyAssistantRepairPending = false;
+      result = await runCompleteWithTimeout({
+        provider,
+        messages: requestMessages,
+        options: {
+          ...typeof input.timeoutMs === "number" ? { timeoutMs: input.timeoutMs } : {},
+          ...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
+      });
+      turnUsage = mergeTurnUsage(turnUsage, result.usage);
+      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
+        });
+        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 {
+          toolResult = await input.adapter.executeTool({
+            id: toolCall.id,
+            name: toolName,
+            arguments: toolCall.function.arguments,
+            ...userInputText ? { userInput: userInputText } : {},
+            ...input.abortSignal ? { abortSignal: input.abortSignal } : {}
+          });
+          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 (!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 errorMessage = toErrorMessage(loopError);
+    const turnMessages2 = messages.slice(turnStartIndex);
+    const saved2 = await input.adapter.saveTurn({
+      agentKey: agentConfig.key,
+      messages: turnMessages2,
+      result: {
+        content: partialContent || `[nolo] Agent run failed: ${errorMessage}`,
+        model: agentConfig.model ?? "unknown",
+        toolCallCount,
+        error: true,
+        errorMessage
+      },
+      ...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 } : {}
+    });
+    if (saved2?.dialogId && typeof loopError === "object" && loopError !== null) {
+      loopError.dialogId = saved2.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 = messages.slice(turnStartIndex);
+  const saved = await input.adapter.saveTurn({
+    agentKey: agentConfig.key,
+    messages: turnMessages,
+    result: {
+      ...result,
+      ...toolCallCount > 0 ? { toolCallCount } : {},
+      ...agentConfig.toolSurface ? { runtimeToolSurface: agentConfig.toolSurface } : {}
+    },
+    ...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,
+    ...turnUsage ? { usage: turnUsage } : {},
+    ...toolCallCount > 0 ? { toolCallCount } : {},
+    ...agentConfig.toolSurface ? { runtimeToolSurface: agentConfig.toolSurface } : {},
+    // 透出最后一轮 provider 调用的 finish_reason；多轮工具循环里只有最后一轮收尾状态有意义。
+    ...result.finish_reason ? { finish_reason: result.finish_reason } : {},
+    dialogId: saved.dialogId,
+    turnMessages
+  };
+}
+
+export {
+  readCommandActionGatePayload,
+  readActionGate,
+  parseToolArgumentsJson,
+  summarizeToolArguments,
+  resolveAgentImageInputSupport,
+  LOCAL_AGENT_CONFIG_MISSING_CODE,
+  EMPTY_ASSISTANT_REPAIR_PROMPT,
+  LOCAL_TURN_ABORTED_CODE,
+  runLocalAgentTurn
+};