nolo-cli 0.107.0-alpha.4 → 0.107.1

package/chunk-UM7TA3K4.js

@@ -0,0 +1,1008 @@
+import {
+  asTrimmedLowercaseString
+} from "./chunk-QSJ3HFEF.js";
+import {
+  isRecord
+} from "./chunk-KUG52IAP.js";
+import {
+  asOptionalTrimmedString
+} from "./chunk-G3SUCT4W.js";
+
+// packages/agent-runtime/declaredToolNames.ts
+function extractDeclaredToolNames(tools) {
+  if (!Array.isArray(tools)) return void 0;
+  const names = /* @__PURE__ */ new Set();
+  for (const t of tools) {
+    const fn = t?.function;
+    if (fn && typeof fn.name === "string" && fn.name) names.add(fn.name);
+  }
+  return names;
+}
+
+// packages/agent-runtime/toolArgsShape.ts
+function scanRawToolArgs(input) {
+  const stack = [];
+  const commaAtDepth = [];
+  let inString = false;
+  let escaped = false;
+  const closersOf2 = () => stack.slice().reverse().map((ch) => ch === "{" ? "}" : "]").join("");
+  for (let i = 0; i < input.length; i += 1) {
+    const ch = input[i];
+    if (inString) {
+      if (escaped) escaped = false;
+      else if (ch === "\\") escaped = true;
+      else if (ch === '"') inString = false;
+      continue;
+    }
+    if (ch === '"') {
+      inString = true;
+    } else if (ch === "{" || ch === "[") {
+      stack.push(ch);
+      commaAtDepth[stack.length] = void 0;
+    } else if (ch === "}" || ch === "]") {
+      const open = stack.pop();
+      if (open !== (ch === "}" ? "{" : "[")) {
+        return {
+          inString,
+          mismatched: true,
+          unclosed: false,
+          // 结构已坏：与迁移前一致，不再给出尾部数组逗号坐标。
+          tailArrayComma: null
+        };
+      }
+      commaAtDepth[stack.length + 1] = void 0;
+    } else if (ch === "," && stack[stack.length - 1] === "[") {
+      commaAtDepth[stack.length] = { index: i, closers: closersOf2() };
+    }
+  }
+  let tailArrayComma = null;
+  for (let d = stack.length; d >= 1; d -= 1) {
+    const c = commaAtDepth[d];
+    if (c && stack[d - 1] === "[") {
+      tailArrayComma = c;
+      break;
+    }
+  }
+  return {
+    inString,
+    mismatched: false,
+    unclosed: stack.length > 0,
+    tailArrayComma
+  };
+}
+function classifyUnparsableToolArgs(raw) {
+  if (typeof raw !== "string") return "malformed";
+  const scan = scanRawToolArgs(raw);
+  if (scan.inString) return "truncated";
+  return scan.mismatched || scan.unclosed ? "truncated" : "malformed";
+}
+
+// packages/agent-runtime/outboundHistorySanitize.ts
+var DOWNGRADED_TOOL_TURN_ORIGIN = Symbol(
+  "nolo.downgradedToolTurnOrigin"
+);
+function markDowngradedToolTurnOrigin(message) {
+  Object.defineProperty(message, DOWNGRADED_TOOL_TURN_ORIGIN, {
+    value: true,
+    enumerable: false,
+    writable: false,
+    configurable: true
+  });
+  return message;
+}
+function transferDowngradedToolTurnOrigin(source, rebuilt) {
+  if (hasDowngradedToolTurnOrigin(source)) markDowngradedToolTurnOrigin(rebuilt);
+  return rebuilt;
+}
+function hasDowngradedToolTurnOrigin(message) {
+  return typeof message === "object" && message !== null && message[DOWNGRADED_TOOL_TURN_ORIGIN] === true;
+}
+function emptyToolArgsProjectionStats() {
+  return {
+    badArguments: { truncated: 0, malformed: 0 },
+    rewrittenToolCalls: 0,
+    rewrittenAssistantMessages: 0,
+    rewrittenToolMessages: 0
+  };
+}
+function sanitizeForOutbound(messages, tools) {
+  return sanitizeOutboundHistory(messages, {
+    declaredToolNames: extractDeclaredToolNames(tools)
+  });
+}
+function stableToolCallId(assistantIndex, callIndex) {
+  return `call_sanitize_${assistantIndex}_${callIndex}`;
+}
+function isString(v) {
+  return typeof v === "string";
+}
+function isNonEmptyString(v) {
+  return typeof v === "string" && v.length > 0;
+}
+function joinLines(...parts) {
+  return parts.filter(isNonEmptyString).join("\n");
+}
+function jsonStringifyArguments(args) {
+  if (typeof args === "string") return args;
+  try {
+    return JSON.stringify(args ?? "");
+  } catch {
+    return "";
+  }
+}
+function renderToolCallAsText(call) {
+  const c = call && typeof call === "object" ? call : {};
+  const name = isString(c.function?.name) && c.function.name.length > 0 ? c.function.name : "unknown";
+  const rawArgs = c.function?.arguments;
+  const args = jsonStringifyArguments(rawArgs);
+  return `[tool_call: ${name}(${args})]`;
+}
+function renderToolResultAsText(message) {
+  const name = isNonEmptyString(message.toolName) ? message.toolName : "tool";
+  const body = typeof message.content === "string" ? message.content : "";
+  return `[tool_result: ${name}: ${body}]`;
+}
+function normalizeToolCall(call, assistantIndex, callIndex) {
+  if (!call || typeof call !== "object") return null;
+  const c = call;
+  const fn = c.function;
+  if (!fn || typeof fn !== "object" || !isString(fn.name) || fn.name.length === 0) return null;
+  const id = isNonEmptyString(c.id) ? c.id : stableToolCallId(assistantIndex, callIndex);
+  return {
+    id,
+    type: isString(c.type) && c.type ? c.type : "function",
+    function: { name: fn.name, arguments: jsonStringifyArguments(fn.arguments) },
+    ...typeof c.extra_content?.google?.thought_signature === "string" ? { extra_content: { google: { thought_signature: c.extra_content.google.thought_signature } } } : {},
+    ...typeof c.thought_signature === "string" ? { thought_signature: c.thought_signature } : {}
+  };
+}
+function classifyAssistantCalls(toolCalls, assistantIndex) {
+  const callIds = [];
+  const idCounts = /* @__PURE__ */ new Map();
+  const unparsableIndices = /* @__PURE__ */ new Set();
+  const unparsableIds = /* @__PURE__ */ new Set();
+  toolCalls.forEach((rawCall, callIndex) => {
+    const c = rawCall && typeof rawCall === "object" ? rawCall : {};
+    const id = isNonEmptyString(c.id) ? c.id : stableToolCallId(assistantIndex, callIndex);
+    callIds.push(id);
+    idCounts.set(id, (idCounts.get(id) ?? 0) + 1);
+    if (!hasParsableObjectArguments(c.function?.arguments)) {
+      unparsableIndices.add(callIndex);
+      unparsableIds.add(id);
+    }
+  });
+  const duplicateIds = /* @__PURE__ */ new Set();
+  for (const [id, count] of idCounts) {
+    if (count > 1) duplicateIds.add(id);
+  }
+  return { callIds, duplicateIds, unparsableIndices, unparsableIds };
+}
+function sanitizeOutboundHistory(messages, options) {
+  if (!Array.isArray(messages) || messages.length === 0) return messages;
+  const declared = options?.declaredToolNames;
+  const keptCallIndicesPerAssistant = /* @__PURE__ */ new Map();
+  const keptToolIndices = /* @__PURE__ */ new Set();
+  let i = 0;
+  while (i < messages.length) {
+    const m = messages[i];
+    if (m.role === "assistant" && Array.isArray(m.tool_calls) && m.tool_calls.length > 0) {
+      const asstIdx = i;
+      const { callIds, duplicateIds, unparsableIndices } = classifyAssistantCalls(m.tool_calls, asstIdx);
+      const candidateCallMap = /* @__PURE__ */ new Map();
+      m.tool_calls.forEach((call, callIndex) => {
+        const id = callIds[callIndex];
+        if (duplicateIds.has(id)) return;
+        if (unparsableIndices.has(callIndex)) return;
+        const name = call?.function?.name;
+        if (!isString(name) || name.length === 0) return;
+        const declaredAllows = !declared || declared.has(name);
+        if (!declaredAllows) return;
+        candidateCallMap.set(id, callIndex);
+      });
+      let j = i + 1;
+      const matchedCallIndices = /* @__PURE__ */ new Set();
+      const matchedToolIds = /* @__PURE__ */ new Set();
+      while (j < messages.length && messages[j].role === "tool") {
+        const toolMsg = messages[j];
+        const toolCallId = isNonEmptyString(toolMsg.tool_call_id) ? toolMsg.tool_call_id : "";
+        if (toolCallId && candidateCallMap.has(toolCallId) && !matchedToolIds.has(toolCallId)) {
+          matchedToolIds.add(toolCallId);
+          matchedCallIndices.add(candidateCallMap.get(toolCallId));
+          keptToolIndices.add(j);
+        }
+        j++;
+      }
+      keptCallIndicesPerAssistant.set(asstIdx, matchedCallIndices);
+      i = j;
+    } else {
+      i++;
+    }
+  }
+  const out = [];
+  let k = 0;
+  while (k < messages.length) {
+    const m = messages[k];
+    if (m.role === "assistant" && Array.isArray(m.tool_calls) && m.tool_calls.length > 0) {
+      const asstIdx = k;
+      const keptIndices = keptCallIndicesPerAssistant.get(asstIdx) ?? /* @__PURE__ */ new Set();
+      const keptToolCalls = [];
+      const downgradedCallLines = [];
+      m.tool_calls.forEach((call, callIndex) => {
+        const name = call?.function?.name;
+        const declaredAllows = !declared || isString(name) && declared.has(name);
+        const keep = keptIndices.has(callIndex) && declaredAllows && hasParsableObjectArguments(call?.function?.arguments);
+        if (keep) {
+          const normalized = normalizeToolCall(call, asstIdx, callIndex);
+          if (normalized) {
+            keptToolCalls.push(normalized);
+          } else {
+            downgradedCallLines.push(renderToolCallAsText(call));
+          }
+        } else {
+          downgradedCallLines.push(renderToolCallAsText(call));
+        }
+      });
+      if (keptToolCalls.length === 0) {
+        const downgradedText = joinLines(...downgradedCallLines);
+        const contentWithDowngrade = downgradedText.length > 0 ? combineContentWithText(m.content, downgradedText) : m.content;
+        const sanitizedAssistant2 = transferDowngradedToolTurnOrigin(m, {
+          ...m,
+          content: contentWithDowngrade
+        });
+        delete sanitizedAssistant2.tool_calls;
+        markDowngradedToolTurnOrigin(sanitizedAssistant2);
+        out.push(sanitizedAssistant2);
+        let nextIdx2 = k + 1;
+        while (nextIdx2 < messages.length && messages[nextIdx2].role === "tool") {
+          const downgradedToolMsg = messages[nextIdx2];
+          out.push(
+            transferDowngradedToolTurnOrigin(downgradedToolMsg, {
+              role: "assistant",
+              content: renderToolResultAsText(downgradedToolMsg)
+            })
+          );
+          nextIdx2++;
+        }
+        k = nextIdx2;
+        continue;
+      }
+      const sanitizedAssistant = transferDowngradedToolTurnOrigin(m, {
+        ...m,
+        tool_calls: keptToolCalls
+      });
+      out.push(sanitizedAssistant);
+      let nextIdx = k + 1;
+      const deferredResultLines = [];
+      while (nextIdx < messages.length && messages[nextIdx].role === "tool") {
+        if (keptToolIndices.has(nextIdx)) {
+          const toolMsg = messages[nextIdx];
+          out.push({
+            ...toolMsg,
+            content: toolMsg.content ?? "",
+            tool_call_id: toolMsg.tool_call_id
+          });
+        } else {
+          deferredResultLines.push(renderToolResultAsText(messages[nextIdx]));
+        }
+        nextIdx++;
+      }
+      const deferredLines = [...downgradedCallLines, ...deferredResultLines];
+      if (deferredLines.length > 0) {
+        out.push({
+          role: "assistant",
+          content: joinLines(...deferredLines)
+        });
+      }
+      k = nextIdx;
+      continue;
+    }
+    if (m.role === "tool") {
+      out.push(
+        transferDowngradedToolTurnOrigin(m, {
+          role: "assistant",
+          content: renderToolResultAsText(m)
+        })
+      );
+      k++;
+      continue;
+    }
+    out.push(transferDowngradedToolTurnOrigin(m, { ...m }));
+    k++;
+  }
+  return out;
+}
+function combineContentWithText(base, extra) {
+  if (typeof base === "string") {
+    return base ? `${base}
+${extra}` : extra;
+  }
+  if (Array.isArray(base)) {
+    return [...base, { type: "text", text: extra }];
+  }
+  return extra;
+}
+function hasParsableObjectArguments(raw) {
+  if (raw === void 0) return true;
+  if (raw === null || typeof raw === "number" || typeof raw === "boolean") {
+    return false;
+  }
+  if (typeof raw !== "string") return true;
+  if (raw.trim() === "") return true;
+  try {
+    const parsed = JSON.parse(raw);
+    return parsed !== null && typeof parsed === "object";
+  } catch {
+    return false;
+  }
+}
+var STRICT_JSON_STRING_TOKEN = /^"(?:[^"\\\u0000-\u001F]|\\["\\/bfnrt]|\\u[0-9A-Fa-f]{4})*"$/;
+function isStrictJsonStringToken(value) {
+  if (!STRICT_JSON_STRING_TOKEN.test(value)) return false;
+  try {
+    return typeof JSON.parse(value) === "string";
+  } catch {
+    return false;
+  }
+}
+function closersOf(openStack) {
+  return openStack.slice().reverse().map((ch) => ch === "{" ? "}" : "]").join("");
+}
+function scanJsonForTailRepair(input) {
+  const stack = [];
+  let inString = false;
+  let escaped = false;
+  let lastCommaOutsideString = null;
+  for (let i = 0; i < input.length; i += 1) {
+    const ch = input[i];
+    if (inString) {
+      if (escaped) escaped = false;
+      else if (ch === "\\") escaped = true;
+      else if (ch === '"') inString = false;
+      continue;
+    }
+    if (ch === '"') {
+      inString = true;
+      continue;
+    }
+    if (ch === "{" || ch === "[") {
+      stack.push(ch);
+      continue;
+    }
+    if (ch === "}" || ch === "]") {
+      const open = stack.pop();
+      if (open !== (ch === "}" ? "{" : "[")) return null;
+      continue;
+    }
+    if (ch === ",") {
+      lastCommaOutsideString = { index: i, closers: closersOf(stack) };
+      continue;
+    }
+  }
+  return { inString, closers: closersOf(stack), lastCommaOutsideString };
+}
+function repairTruncatedToolArguments(raw) {
+  if (typeof raw !== "string") return null;
+  const withoutTrailingSpace = raw.replace(/\s+$/, "");
+  const endsWithComma = withoutTrailingSpace.endsWith(",");
+  const trimmed = endsWithComma ? withoutTrailingSpace.slice(0, -1).replace(/\s+$/, "") : withoutTrailingSpace;
+  if (trimmed === "" || trimmed.endsWith(",")) return null;
+  const scan = scanJsonForTailRepair(trimmed);
+  if (!scan || scan.inString) return null;
+  const lastChar = trimmed[trimmed.length - 1];
+  const tailIsCompleteToken = endsWithComma || lastChar === '"' || lastChar === "}" || lastChar === "]";
+  if (!tailIsCompleteToken) return null;
+  const candidates = [trimmed + scan.closers];
+  const lastComma = scan.lastCommaOutsideString;
+  if (lastComma && lastComma.index > 0) {
+    const tailAfterComma = trimmed.slice(lastComma.index + 1).trim();
+    if (isStrictJsonStringToken(tailAfterComma)) {
+      const head = trimmed.slice(0, lastComma.index);
+      candidates.push(head + lastComma.closers);
+    }
+  }
+  for (const candidate of candidates) {
+    try {
+      const parsed = JSON.parse(candidate);
+      if (parsed !== null && typeof parsed === "object" && !Array.isArray(parsed) && Object.keys(parsed).length > 0) {
+        return candidate;
+      }
+    } catch {
+    }
+  }
+  return null;
+}
+function downgradeUnparsableToolCalls(messages) {
+  if (!Array.isArray(messages) || messages.length === 0) {
+    return { messages, downgraded: 0, stats: emptyToolArgsProjectionStats() };
+  }
+  let hasAnyPoison = false;
+  for (const m of messages) {
+    if (m.role === "assistant" && Array.isArray(m.tool_calls)) {
+      for (const call of m.tool_calls) {
+        if (!hasParsableObjectArguments(call?.function?.arguments)) {
+          hasAnyPoison = true;
+          break;
+        }
+      }
+    }
+    if (hasAnyPoison) break;
+  }
+  if (!hasAnyPoison) return { messages, downgraded: 0, stats: emptyToolArgsProjectionStats() };
+  const poisonedCallsPerAssistant = /* @__PURE__ */ new Map();
+  const poisonedToolIndices = /* @__PURE__ */ new Set();
+  const badArguments = {
+    truncated: 0,
+    malformed: 0
+  };
+  let i = 0;
+  while (i < messages.length) {
+    const m = messages[i];
+    if (m.role === "assistant" && Array.isArray(m.tool_calls) && m.tool_calls.length > 0) {
+      const asstIdx = i;
+      const { unparsableIds, unparsableIndices } = classifyAssistantCalls(m.tool_calls, asstIdx);
+      for (const badIndex of unparsableIndices) {
+        const badCall = m.tool_calls[badIndex];
+        badArguments[classifyUnparsableToolArgs(badCall?.function?.arguments)] += 1;
+      }
+      let j = i + 1;
+      while (j < messages.length && messages[j].role === "tool") {
+        const toolMsg = messages[j];
+        const toolCallId = isNonEmptyString(toolMsg.tool_call_id) ? toolMsg.tool_call_id : "";
+        if (toolCallId && unparsableIds.has(toolCallId)) {
+          poisonedToolIndices.add(j);
+        }
+        j++;
+      }
+      if (unparsableIds.size > 0) {
+        poisonedCallsPerAssistant.set(asstIdx, unparsableIds);
+      }
+      i = j;
+    } else {
+      i++;
+    }
+  }
+  let downgraded = 0;
+  let rewrittenAssistantMessages = 0;
+  let rewrittenToolMessages = 0;
+  const out = [];
+  let k = 0;
+  while (k < messages.length) {
+    const m = messages[k];
+    if (m.role === "assistant" && Array.isArray(m.tool_calls) && m.tool_calls.length > 0) {
+      const badIds = poisonedCallsPerAssistant.get(k);
+      if (!badIds || badIds.size === 0) {
+        out.push(m);
+        k++;
+        continue;
+      }
+      const kept = [];
+      const lines = [];
+      const { callIds } = classifyAssistantCalls(m.tool_calls, k);
+      rewrittenAssistantMessages += 1;
+      m.tool_calls.forEach((call, callIndex) => {
+        const id = callIds[callIndex];
+        if (badIds.has(id)) {
+          lines.push(renderToolCallAsText(call));
+          downgraded++;
+        } else {
+          kept.push(call);
+        }
+      });
+      if (kept.length === 0) {
+        const sanitized2 = transferDowngradedToolTurnOrigin(m, {
+          ...m,
+          content: combineContentWithText(m.content, joinLines(...lines))
+        });
+        delete sanitized2.tool_calls;
+        markDowngradedToolTurnOrigin(sanitized2);
+        out.push(sanitized2);
+        let nextIdx2 = k + 1;
+        while (nextIdx2 < messages.length && messages[nextIdx2].role === "tool") {
+          if (poisonedToolIndices.has(nextIdx2)) {
+            const poisonedToolMsg = messages[nextIdx2];
+            out.push(
+              transferDowngradedToolTurnOrigin(poisonedToolMsg, {
+                role: "assistant",
+                content: renderToolResultAsText(poisonedToolMsg)
+              })
+            );
+            rewrittenToolMessages += 1;
+          } else {
+            out.push(messages[nextIdx2]);
+          }
+          nextIdx2++;
+        }
+        k = nextIdx2;
+        continue;
+      }
+      const sanitized = transferDowngradedToolTurnOrigin(m, {
+        ...m,
+        content: lines.length > 0 ? combineContentWithText(m.content, joinLines(...lines)) : m.content,
+        tool_calls: kept
+      });
+      out.push(sanitized);
+      let nextIdx = k + 1;
+      const deferredResultLines = [];
+      while (nextIdx < messages.length && messages[nextIdx].role === "tool") {
+        if (poisonedToolIndices.has(nextIdx)) {
+          deferredResultLines.push(renderToolResultAsText(messages[nextIdx]));
+          rewrittenToolMessages += 1;
+        } else {
+          out.push(messages[nextIdx]);
+        }
+        nextIdx++;
+      }
+      if (deferredResultLines.length > 0) {
+        out.push({
+          role: "assistant",
+          content: joinLines(...deferredResultLines)
+        });
+      }
+      k = nextIdx;
+      continue;
+    }
+    if (m.role === "tool") {
+      if (poisonedToolIndices.has(k)) {
+        out.push(
+          transferDowngradedToolTurnOrigin(m, {
+            role: "assistant",
+            content: renderToolResultAsText(m)
+          })
+        );
+        rewrittenToolMessages += 1;
+      } else {
+        out.push(m);
+      }
+      k++;
+      continue;
+    }
+    out.push(m);
+    k++;
+  }
+  return {
+    messages: out,
+    downgraded,
+    stats: {
+      badArguments,
+      // 投影改写数与坏参数数是两套口径：rewrittenToolCalls 含同 ID 连带降级的
+      // 调用，二者允许不相等（同 ID 一坏一好 → 坏参数 1、改写调用 2）。
+      rewrittenToolCalls: downgraded,
+      rewrittenAssistantMessages,
+      rewrittenToolMessages
+    }
+  };
+}
+
+// packages/core/ollamaEndpoint.ts
+function isOllamaEndpoint(endpoint) {
+  if (!endpoint || typeof endpoint !== "string") return false;
+  try {
+    const url = new URL(endpoint.includes("://") ? endpoint : `http://${endpoint}`);
+    if (url.port === "11434") return true;
+    const host = url.hostname.toLowerCase();
+    return host === "ollama.com" || host.endsWith(".ollama.com") || host === "ollama.ai" || host.endsWith(".ollama.ai");
+  } catch {
+    return false;
+  }
+}
+
+// packages/ai/llm/usageRequestOptions.ts
+var STREAM_USAGE_PROVIDERS = /* @__PURE__ */ new Set([
+  "google",
+  "openrouter",
+  "xai",
+  "openai",
+  "fireworks",
+  "mistral",
+  "cloudflare",
+  "gmi",
+  // OpenAI-compatible hosted providers expose the terminal usage chunk when
+  // requested, including DeepInfra and Vultr. Keep this capability decision
+  // in the shared seam so proxy and local runtimes cannot drift.
+  "deepinfra",
+  "vultr",
+  // Explicit local-runtime providers with OpenAI-compatible streaming: both
+  // DeepSeek official and Ollama honor stream_options.include_usage on their
+  // chat.completions endpoints. Without them, locally-configured agents lose
+  // token statistics / local billing (the whitelist replaced the previous
+  // always-on include_usage). ollama-cloud is the Ollama Cloud subscription
+  // endpoint (https://ollama.com/v1), an OpenAI-compatible API that likewise
+  // honors stream_options.include_usage.
+  "deepseek",
+  "ollama",
+  "ollama-cloud",
+  // RunInfra hosted fallback channel: OpenAI-compatible chat.completions
+  // endpoint, supports stream_options.include_usage (measured to return
+  // prompt_tokens_details.cached_tokens).
+  "runinfra",
+  "baseten",
+  // Kimi For Coding subscription (api.kimi.com/coding/v1): OpenAI-compatible
+  // chat.completions streaming that only emits the terminal usage frame when
+  // stream_options.include_usage is requested (measured; the official
+  // kimi-code CLI also sends include_usage). Custom agents pointing at the
+  // same endpoint are covered by the endpoint check below, not here.
+  "kimi-code"
+]);
+var KIMI_CODE_ENDPOINT_MARKER = "api.kimi.com";
+var isKimiCodeEndpoint = (endpoint) => typeof endpoint === "string" && endpoint.includes(KIMI_CODE_ENDPOINT_MARKER);
+var EXTRA_USAGE_FIELD_PROVIDERS = /* @__PURE__ */ new Set(["openrouter"]);
+var normalizeProviderName = (providerName) => asTrimmedLowercaseString(providerName);
+var getUsageRequestOptions = (providerName, options) => {
+  const normalizedProvider = normalizeProviderName(providerName);
+  const api = options?.api ?? "chat-completions";
+  const shouldRequestStreamUsage = STREAM_USAGE_PROVIDERS.has(normalizedProvider) || normalizedProvider === "custom" && (isKimiCodeEndpoint(options?.endpoint) || isOllamaEndpoint(options?.endpoint));
+  if (api === "responses") {
+    return EXTRA_USAGE_FIELD_PROVIDERS.has(normalizedProvider) ? {
+      usage: {
+        include: true
+      }
+    } : {};
+  }
+  return {
+    ...shouldRequestStreamUsage ? {
+      stream_options: {
+        include_usage: true
+      }
+    } : {},
+    ...EXTRA_USAGE_FIELD_PROVIDERS.has(normalizedProvider) ? {
+      usage: {
+        include: true
+      }
+    } : {}
+  };
+};
+
+// packages/agent-runtime/openAiCompatibleMessages.ts
+function isGeminiCompatibleTarget(provider, model) {
+  const p = (provider ?? "").trim().toLowerCase();
+  const m = (model ?? "").trim().toLowerCase();
+  return p === "google" || p === "google-antigravity" || p.startsWith("google-") || p.includes("gemini") || m.includes("gemini");
+}
+function preserveAgentStateFields(source, target, options) {
+  const mutableTarget = target;
+  if (source.role === "assistant") {
+    const shapingCounts = options?.shapingCounts;
+    if (!options?.stripReasoningContent && typeof source.reasoning_content === "string") {
+      mutableTarget.reasoning_content = source.reasoning_content;
+    }
+    if (Array.isArray(source.tool_calls)) {
+      if (shapingCounts && source.tool_calls.length > 0) {
+        shapingCounts.assistantToolTurns += 1;
+        const hadUsableReasoning = typeof source.reasoning_content === "string" && source.reasoning_content.length > 0;
+        if (options?.stripReasoningContent) {
+          if (hadUsableReasoning) shapingCounts.reasoningStrippedTurns += 1;
+          else shapingCounts.missingReasoningTurns += 1;
+        } else if (!hadUsableReasoning) {
+          shapingCounts.missingReasoningTurns += 1;
+        }
+      }
+      const isExplicitTarget = Boolean(options?.targetProvider || options?.targetModel);
+      const allowSignature = options?.allowThoughtSignature ?? (isExplicitTarget ? isGeminiCompatibleTarget(options?.targetProvider, options?.targetModel) : true);
+      mutableTarget.tool_calls = source.tool_calls.map((call) => {
+        if (!call || typeof call !== "object") return call;
+        const cleaned = {
+          id: call.id,
+          type: call.type ?? "function",
+          function: call.function
+        };
+        if (allowSignature) {
+          if (call.extra_content !== void 0) cleaned.extra_content = call.extra_content;
+          if (call.thought_signature !== void 0) cleaned.thought_signature = call.thought_signature;
+        }
+        return cleaned;
+      });
+    }
+    const hasReplayableToolCalls = Array.isArray(mutableTarget.tool_calls) && mutableTarget.tool_calls.length > 0;
+    const replayPlaceholder = options?.replayReasoningPlaceholder;
+    if (typeof replayPlaceholder === "string" && replayPlaceholder.length > 0 && // strip 优先：拒 string reasoning_content 的 provider 也会拒这个占位。
+    !options?.stripReasoningContent && (hasReplayableToolCalls || hasDowngradedToolTurnOrigin(source)) && !// 真实 reasoning_content 优先，永不被占位覆盖。
+    (typeof mutableTarget.reasoning_content === "string" && mutableTarget.reasoning_content.length > 0)) {
+      mutableTarget.reasoning_content = replayPlaceholder;
+      if (shapingCounts) shapingCounts.placeholderInjectedTurns += 1;
+    }
+  }
+  if (source.role === "tool") {
+    const toolCallId = typeof source.tool_call_id === "string" ? source.tool_call_id.trim() : typeof source.toolCallId === "string" ? source.toolCallId.trim() : "";
+    if (toolCallId) mutableTarget.tool_call_id = toolCallId;
+  }
+  return target;
+}
+function toOpenAiCompatibleMessages(messages, options) {
+  return messages.map(
+    (message) => preserveAgentStateFields(message, {
+      role: message.role,
+      content: message.content ?? ""
+    }, options)
+  );
+}
+function shouldStripReasoningContentForOutbound(provider, model) {
+  const p = provider?.trim().toLowerCase();
+  const m = model?.trim().toLowerCase();
+  if (!p || !m) return false;
+  if (p === "deepseek" || p === "nolo") {
+    return m === "deepseek-flash" || m === "deepseek-v4-flash" || m === "deepseek-v4-flash-vision-exp" || m === "deepseek-v4-pro";
+  }
+  return false;
+}
+function shouldReplayReasoningContentForOutbound(provider, model) {
+  const p = provider?.trim().toLowerCase();
+  const m = model?.trim().toLowerCase();
+  if (!p || !m) return false;
+  return (p === "opencode-go" || p === "opencode") && m.includes("deepseek");
+}
+
+// packages/integrations/openai/responsesHelpers.ts
+var RESPONSES_TOP_LEVEL_SCHEMA_KEYS = ["anyOf", "oneOf", "allOf", "enum", "not"];
+var sanitizeResponsesParameters = (parameters) => {
+  if (!isRecord(parameters)) {
+    return parameters;
+  }
+  const next = { ...parameters };
+  for (const key of RESPONSES_TOP_LEVEL_SCHEMA_KEYS) {
+    delete next[key];
+  }
+  return next;
+};
+var appendTextPart = (parts, text, role) => {
+  if (!text) return;
+  const last = parts.at(-1);
+  const textType = role === "assistant" ? "output_text" : "input_text";
+  if (last?.type === textType) {
+    last.text += text;
+    return;
+  }
+  parts.push({ type: textType, text });
+};
+var normalizeMessageParts = (content, role) => {
+  if (typeof content === "string") {
+    if (!content) return [];
+    return [
+      {
+        type: role === "assistant" ? "output_text" : "input_text",
+        text: content
+      }
+    ];
+  }
+  const parts = [];
+  for (const part of content ?? []) {
+    const typedPart = part;
+    if (typedPart?.type === "text" && typeof typedPart.text === "string") {
+      appendTextPart(parts, typedPart.text, role);
+      continue;
+    }
+    if (typedPart?.type === "image_url" && typeof typedPart.image_url?.url === "string" && typedPart.image_url.url) {
+      if (role === "assistant") continue;
+      parts.push({
+        type: "input_image",
+        image_url: typedPart.image_url.url,
+        detail: typedPart.image_url.detail
+      });
+    }
+  }
+  return parts;
+};
+var normalizeToolOutput = (content) => {
+  if (typeof content === "string") return content;
+  return JSON.stringify(content ?? "");
+};
+var toResponsesTools = (tools) => {
+  if (!Array.isArray(tools) || tools.length === 0) return void 0;
+  const normalized = tools.map((tool) => {
+    const fn = tool?.function;
+    const name = fn?.name ?? tool?.name;
+    if (!name) return null;
+    const parameters = fn?.parameters ?? tool?.parameters;
+    return {
+      type: "function",
+      name,
+      ...typeof (fn?.description ?? tool?.description) === "string" ? { description: fn?.description ?? tool?.description } : {},
+      parameters: sanitizeResponsesParameters(parameters),
+      ...fn?.strict !== void 0 || tool?.strict !== void 0 ? { strict: fn?.strict ?? tool?.strict } : {}
+    };
+  }).filter(Boolean);
+  return normalized.length > 0 ? normalized : void 0;
+};
+var convertMessagesToResponsesInput = (messages, options) => {
+  const input = [];
+  for (const message of messages) {
+    if (!message?.role) continue;
+    if (message.role === "tool") {
+      if (!message.tool_call_id) continue;
+      input.push({
+        type: "function_call_output",
+        call_id: message.tool_call_id,
+        output: normalizeToolOutput(message.content)
+      });
+      continue;
+    }
+    const role = message.role;
+    if (role === "assistant" && !options?.stripReasoningContent && typeof message.reasoning_content === "string" && message.reasoning_content) {
+      input.push({
+        type: "reasoning",
+        content: [
+          { type: "reasoning_text", text: message.reasoning_content }
+        ]
+      });
+    }
+    const contentParts = normalizeMessageParts(message.content, role);
+    if (contentParts.length > 0) {
+      input.push({
+        type: "message",
+        role,
+        content: contentParts
+      });
+    }
+    if (role === "assistant" && Array.isArray(message.content)) {
+      const replayImages = message.content.map((part) => part).filter(
+        (part) => part?.type === "image_url" && typeof part.image_url?.url === "string" && Boolean(part.image_url.url)
+      ).map((part) => ({
+        type: "input_image",
+        image_url: part.image_url.url,
+        detail: part.image_url.detail
+      }));
+      if (replayImages.length > 0) {
+        input.push({
+          type: "message",
+          role: "user",
+          content: replayImages
+        });
+      }
+    }
+    if (role === "assistant" && Array.isArray(message.tool_calls)) {
+      for (const toolCall of message.tool_calls) {
+        if (!toolCall?.id || !toolCall.function?.name) continue;
+        input.push({
+          type: "function_call",
+          call_id: toolCall.id,
+          name: toolCall.function.name,
+          arguments: typeof toolCall.function.arguments === "string" ? toolCall.function.arguments : JSON.stringify(toolCall.function.arguments ?? {})
+        });
+      }
+    }
+  }
+  return input;
+};
+var extractTextFromResponseOutput = (response) => {
+  const parts = [];
+  for (const item of response?.output ?? []) {
+    if (item?.type !== "message") continue;
+    for (const content of item.content ?? []) {
+      if (content?.type === "output_text" && typeof content.text === "string") {
+        parts.push(content.text);
+      }
+    }
+  }
+  return parts.join("");
+};
+var extractReasoningFromResponseOutput = (response) => {
+  const parts = [];
+  for (const item of response?.output ?? []) {
+    if (item?.type !== "reasoning") continue;
+    if (typeof item.content === "string") {
+      parts.push(item.content);
+      continue;
+    }
+    for (const content of item.content ?? []) {
+      if (typeof content === "string") parts.push(content);
+      else if (typeof content?.text === "string") parts.push(content.text);
+    }
+  }
+  return parts.join("");
+};
+var toDataUrl = (base64Data, mimeType) => {
+  const normalizedMimeType = asOptionalTrimmedString(mimeType) ?? "image/png";
+  return `data:${normalizedMimeType};base64,${base64Data}`;
+};
+var extractImagePartsFromResponseOutput = (response) => {
+  const images = [];
+  for (const item of response?.output ?? []) {
+    if (item?.type === "image_generation_call") {
+      const result = asOptionalTrimmedString(item.result);
+      if (result) {
+        const outputFormat = asOptionalTrimmedString(item.output_format);
+        images.push({
+          type: "image_url",
+          image_url: {
+            url: toDataUrl(
+              result,
+              outputFormat ? `image/${outputFormat}` : void 0
+            )
+          }
+        });
+      }
+      continue;
+    }
+    if (item?.type !== "message") continue;
+    for (const content of item.content ?? []) {
+      const result = asOptionalTrimmedString(content?.result);
+      if (content?.type === "output_image" && result) {
+        images.push({
+          type: "image_url",
+          image_url: {
+            url: toDataUrl(
+              result,
+              content.mime_type ?? content.mimeType ?? null
+            )
+          }
+        });
+      }
+    }
+  }
+  return images;
+};
+var extractToolCallsFromResponseOutput = (response) => {
+  const calls = [];
+  for (const item of response?.output ?? []) {
+    if (item?.type !== "function_call") continue;
+    if (!item.call_id || !item.name) continue;
+    calls.push({
+      id: item.call_id,
+      type: "function",
+      function: {
+        name: item.name,
+        arguments: typeof item.arguments === "string" ? item.arguments : JSON.stringify(item.arguments ?? {})
+      }
+    });
+  }
+  return calls;
+};
+
+// packages/agent-runtime/promptCacheKey.ts
+function collectStablePromptPrefix(messages, fallbackPrompt) {
+  const systemTexts = [];
+  if (fallbackPrompt?.trim()) systemTexts.push(fallbackPrompt.trim());
+  for (const raw of messages) {
+    if (!raw || typeof raw !== "object") continue;
+    const message = raw;
+    const role = String(message.role ?? "");
+    if (role !== "system" && role !== "developer") continue;
+    if (typeof message.content === "string") {
+      const boundary = Number(message.stable_prefix_chars);
+      const text = Number.isFinite(boundary) && boundary > 0 ? message.content.slice(0, boundary) : message.content;
+      if (text.trim()) systemTexts.push(text.trim());
+    }
+  }
+  return systemTexts.join("\n\n");
+}
+function stablePromptCacheKey(parts, namespace) {
+  const value = JSON.stringify(parts);
+  let hash = 2166136261;
+  for (let index = 0; index < value.length; index += 1) {
+    hash ^= value.charCodeAt(index);
+    hash = Math.imul(hash, 16777619) >>> 0;
+  }
+  return `${namespace}-${hash.toString(16).padStart(8, "0")}`;
+}
+
+// packages/core/chat/imageParts.ts
+function isImageUrlPart(part) {
+  return isRecord(part) && part.type === "image_url";
+}
+function hasImageParts(messages) {
+  return messages.some(
+    (message) => Array.isArray(message.content) && message.content.some(isImageUrlPart)
+  );
+}
+
+export {
+  sanitizeForOutbound,
+  hasParsableObjectArguments,
+  repairTruncatedToolArguments,
+  downgradeUnparsableToolCalls,
+  isOllamaEndpoint,
+  getUsageRequestOptions,
+  isImageUrlPart,
+  hasImageParts,
+  preserveAgentStateFields,
+  toOpenAiCompatibleMessages,
+  shouldStripReasoningContentForOutbound,
+  shouldReplayReasoningContentForOutbound,
+  toResponsesTools,
+  convertMessagesToResponsesInput,
+  extractTextFromResponseOutput,
+  extractReasoningFromResponseOutput,
+  extractImagePartsFromResponseOutput,
+  extractToolCallsFromResponseOutput,
+  collectStablePromptPrefix,
+  stablePromptCacheKey
+};