nolo-cli 0.108.0-alpha.2 → 0.108.1

package/{chunk-SYXOBWOC.js → chunk-JGLKZGGZ.js}

@@ -1,124 +1,70 @@
 import {
   buildResponseGuidelines
-} from "./chunk-EOARMOVD.js";
+} from "./chunk-W4S6OTSC.js";
 import {
   getLocalProviderSecret
 } from "./chunk-HS7MLR74.js";
 import {
-  clipMultilineText,
-  fetchAndSerializeTable
-} from "./chunk-LPIYPEME.js";
-import {
-  isGatewayHttpStatus
-} from "./chunk-NF64D32W.js";
-import {
-  createDrainExhaustedResponse,
-  isCoreDrainingBody,
-  normalizeNonNegativeMs,
-  parseRetryAfterHeaderMs
-} from "./chunk-3L2WKC3W.js";
-import {
-  slateToSimplifiedMarkdown
-} from "./chunk-J4MOO56S.js";
-import {
-  waitForAbortableDelay
-} from "./chunk-N4G4PKQ6.js";
-import {
-  extractCategorizedMentions
-} from "./chunk-MEYIRKDN.js";
-import {
-  fetchAndCacheMessages
-} from "./chunk-YWIEQS6H.js";
+  performServerProxyFetchWithRetry
+} from "./chunk-IN5UVHHP.js";
 import {
   shouldUseServerProxy
-} from "./chunk-YYLHWIW6.js";
+} from "./chunk-UKZX3NHN.js";
 import {
   fetchServerSyncedCredential
-} from "./chunk-YTLRHRH3.js";
+} from "./chunk-MDOZSLDE.js";
 import {
-  buildSkillGuidancePromptBlock,
-  extractRuntimePageCapabilities,
-  resolveBuiltinSkillPage,
-  resolveSkillGraphFromRoots
-} from "./chunk-JRQFUXY7.js";
+  buildSkillGuidancePromptBlock
+} from "./chunk-RRQQAG7W.js";
 import {
+  DELETE_SAFETY_RED_LINE,
   buildIdentityBlock,
   buildRuntimeGuidanceBlocks,
   compileContextLayers,
   detectDispatchIntentFromMessages,
-  normalizeChatCompletionsBodyForProvider,
   resolveToolGuidedSections
-} from "./chunk-MRIHM22T.js";
+} from "./chunk-LAVSW2C2.js";
 import {
   convertMessagesToResponsesInput,
   getUsageRequestOptions,
+  normalizeChatCompletionsBodyForProvider,
   preserveAgentStateFields,
+  resolveReasoningReplayOptions,
+  shouldStripReasoningContentForOutbound,
   stablePromptCacheKey
-} from "./chunk-PUOC4YRO.js";
+} from "./chunk-SJ3QFSQS.js";
+import {
+  createFileCredentialBroker
+} from "./chunk-PWRS2SU2.js";
+import {
+  canonicalizeToolNames
+} from "./chunk-IHPDK6UD.js";
 import {
   ANTIGRAVITY_CLOUD_CODE_BASE_URL,
   isAntigravityOAuthAgent
-} from "./chunk-GNCCNNZD.js";
+} from "./chunk-TSBCYK5F.js";
 import {
   buildProviderAuthHeaders
-} from "./chunk-6OZ36FXI.js";
-import {
-  estimateTokenCount
-} from "./chunk-PSCNXBYA.js";
+} from "./chunk-KY6GPQ7O.js";
 import {
   isOpenAiResponsesModel,
   resolvePlatformChatCompletionsEndpoint,
   resolvePlatformResponsesEndpoint
-} from "./chunk-GQBOR3G6.js";
+} from "./chunk-NN4UUYGB.js";
 import {
   clampReasoningEffort,
   getModelConfig,
   isModelSupportReasoningEffort
-} from "./chunk-OIVSQH2O.js";
-import {
-  createFileCredentialBroker
-} from "./chunk-HVURBGF3.js";
-import {
-  toErrorMessage
-} from "./chunk-HNMXYYJR.js";
-import {
-  MEMORY_USE_GUIDANCE,
-  buildUserResponseLanguageContext,
-  wrapHistoricalSummaryWithReplayGuard
-} from "./chunk-2GRGFCF6.js";
-import {
-  canonicalizeToolNames
-} from "./chunk-O6OSWFZQ.js";
-import {
-  isDeepInfraKimiModel,
-  isFireworksKimiModel,
-  isPlatformMimoProviderModel,
-  resolveFireworksKimiModel
-} from "./chunk-Q67DOFOO.js";
-import {
-  createSpaceKey
-} from "./chunk-UAD2WT54.js";
-import {
-  read
-} from "./chunk-VRTTFDBM.js";
-import {
-  asTrimmedLowercaseString
-} from "./chunk-QSJ3HFEF.js";
-import {
-  extractCustomId
-} from "./chunk-M2EJHDJP.js";
-import {
-  getRuntimeServerContext
-} from "./chunk-UKWGR5SS.js";
-import {
-  isAbortError
-} from "./chunk-QOKAKDPE.js";
+} from "./chunk-CGEK73JN.js";
 import {
   isRecord
 } from "./chunk-KUG52IAP.js";
 import {
   asTrimmedString
 } from "./chunk-3EUW3WEO.js";
+import {
+  toErrorMessage
+} from "./chunk-HNMXYYJR.js";
 import {
   API_ENDPOINTS
 } from "./chunk-LCBAMY2M.js";
@@ -128,204 +74,20 @@ import {
 import {
   asOptionalTrimmedString
 } from "./chunk-G3SUCT4W.js";
-
-// packages/ai/agent/referenceUtils.ts
-function mergeReferences(base, extra) {
-  const safeBase = Array.isArray(base) ? base : [];
-  const safeExtra = Array.isArray(extra) ? extra : [];
-  const seen = /* @__PURE__ */ new Set();
-  const merged = [];
-  for (const item of [...safeBase, ...safeExtra]) {
-    const key = item.dbKey;
-    if (key && seen.has(key)) continue;
-    if (key) seen.add(key);
-    merged.push(item);
-  }
-  return merged;
-}
-var loadContentsByKeys = async (keys, dispatch, preloaded) => {
-  const contentByKey = /* @__PURE__ */ new Map();
-  const uniqueKeys = Array.from(new Set(keys.filter(Boolean)));
-  await Promise.all(
-    uniqueKeys.map(async (dbKey) => {
-      if (preloaded?.has(dbKey)) {
-        const content = preloaded.get(dbKey);
-        if (content) contentByKey.set(dbKey, content);
-        return;
-      }
-      const builtin = resolveBuiltinSkillPage(dbKey);
-      if (builtin) {
-        contentByKey.set(dbKey, builtin);
-        return;
-      }
-      try {
-        const content = await dispatch(read({ dbKey })).unwrap();
-        if (content) contentByKey.set(dbKey, content);
-      } catch {
-      }
-    })
-  );
-  return contentByKey;
-};
-var resolveReferenceAssets = async (references, dispatch) => {
-  if (!Array.isArray(references) || references.length === 0) {
-    return {
-      references: [],
-      referencedTools: [],
-      recommendedSkillTools: [],
-      recommendedSkillHints: [],
-      skillPromptPatches: [],
-      contentByKey: /* @__PURE__ */ new Map()
-    };
-  }
-  const entries = await Promise.all(
-    references.filter((ref) => ref?.dbKey).map(async (ref) => {
-      const builtin = resolveBuiltinSkillPage(ref.dbKey);
-      if (builtin) return { ref, content: builtin };
-      try {
-        const content = await dispatch(read({ dbKey: ref.dbKey })).unwrap();
-        return { ref, content };
-      } catch {
-        return { ref, content: null };
-      }
-    })
-  );
-  const contentByKey = /* @__PURE__ */ new Map();
-  const toolSet = /* @__PURE__ */ new Set();
-  const recommendedToolSet = /* @__PURE__ */ new Set();
-  const recommendedSkillHints = /* @__PURE__ */ new Set();
-  const skillPromptPatches = /* @__PURE__ */ new Set();
-  const normalizedReferences = [];
-  const hardSkillKeys = /* @__PURE__ */ new Set();
-  const softSkillKeys = /* @__PURE__ */ new Set();
-  for (const { ref, content } of entries) {
-    if (content) {
-      contentByKey.set(ref.dbKey, content);
-    }
-    const capabilities = extractRuntimePageCapabilities(content);
-    for (const tool of capabilities.directTools) {
-      toolSet.add(tool);
-    }
-    for (const tool of capabilities.hardSkillTools) {
-      toolSet.add(tool);
-    }
-    for (const hint of capabilities.softSkillHints) {
-      recommendedSkillHints.add(hint);
-    }
-    for (const patch of capabilities.promptPatches) {
-      skillPromptPatches.add(patch);
-    }
-    for (const skillKey of capabilities.hardSkillKeys) {
-      hardSkillKeys.add(skillKey);
-    }
-    for (const skillKey of capabilities.softSkillKeys) {
-      softSkillKeys.add(skillKey);
-    }
-    normalizedReferences.push({
-      ...ref,
-      type: capabilities.shouldUpgradeReference ? "instruction" : ref.type
-    });
-  }
-  const resolvedSkillLinks = await resolveSkillGraphFromRoots({
-    roots: [
-      ...Array.from(hardSkillKeys).map((identifier) => ({ identifier, mode: "required" })),
-      ...Array.from(softSkillKeys).map((identifier) => ({ identifier, mode: "recommended" }))
-    ],
-    loadPage: async (identifier) => {
-      const loaded = await loadContentsByKeys([identifier], dispatch, contentByKey);
-      return loaded.get(identifier) ?? null;
-    },
-    contentByKey
-  });
-  resolvedSkillLinks.contentByKey.forEach((value, key) => contentByKey.set(key, value));
-  for (const tool of resolvedSkillLinks.requiredTools) {
-    toolSet.add(tool);
-  }
-  for (const tool of resolvedSkillLinks.recommendedTools) {
-    recommendedToolSet.add(tool);
-  }
-  for (const hint of resolvedSkillLinks.recommendedSkillHints) {
-    recommendedSkillHints.add(hint);
-  }
-  for (const patch of resolvedSkillLinks.skillPromptPatches) {
-    skillPromptPatches.add(patch);
-  }
-  return {
-    references: normalizedReferences,
-    referencedTools: Array.from(toolSet),
-    recommendedSkillTools: Array.from(recommendedToolSet),
-    recommendedSkillHints: Array.from(recommendedSkillHints),
-    skillPromptPatches: Array.from(skillPromptPatches),
-    contentByKey
-  };
-};
-var resolveToolsFromKeys = async (keys, dispatch, preloaded) => {
-  if (!Array.isArray(keys) || keys.length === 0) {
-    return {
-      tools: [],
-      recommendedSkillTools: [],
-      recommendedSkillHints: [],
-      skillPromptPatches: [],
-      contentByKey: /* @__PURE__ */ new Map()
-    };
-  }
-  const contentByKey = await loadContentsByKeys(keys, dispatch, preloaded);
-  const toolSet = /* @__PURE__ */ new Set();
-  const recommendedToolSet = /* @__PURE__ */ new Set();
-  const recommendedSkillHints = /* @__PURE__ */ new Set();
-  const skillPromptPatches = /* @__PURE__ */ new Set();
-  const hardSkillKeys = /* @__PURE__ */ new Set();
-  const softSkillKeys = /* @__PURE__ */ new Set();
-  for (const content of contentByKey.values()) {
-    const capabilities = extractRuntimePageCapabilities(content);
-    for (const tool of [...capabilities.directTools, ...capabilities.hardSkillTools]) {
-      toolSet.add(tool);
-    }
-    for (const hint of capabilities.softSkillHints) {
-      recommendedSkillHints.add(hint);
-    }
-    for (const patch of capabilities.promptPatches) {
-      skillPromptPatches.add(patch);
-    }
-    for (const skillKey of capabilities.hardSkillKeys) {
-      hardSkillKeys.add(skillKey);
-    }
-    for (const skillKey of capabilities.softSkillKeys) {
-      softSkillKeys.add(skillKey);
-    }
-  }
-  const resolvedSkillLinks = await resolveSkillGraphFromRoots({
-    roots: [
-      ...Array.from(hardSkillKeys).map((identifier) => ({ identifier, mode: "required" })),
-      ...Array.from(softSkillKeys).map((identifier) => ({ identifier, mode: "recommended" }))
-    ],
-    loadPage: async (identifier) => {
-      const loaded = await loadContentsByKeys([identifier], dispatch, contentByKey);
-      return loaded.get(identifier) ?? null;
-    },
-    contentByKey
-  });
-  resolvedSkillLinks.contentByKey.forEach((value, key) => contentByKey.set(key, value));
-  for (const tool of resolvedSkillLinks.requiredTools) {
-    toolSet.add(tool);
-  }
-  for (const tool of resolvedSkillLinks.recommendedTools) {
-    recommendedToolSet.add(tool);
-  }
-  for (const hint of resolvedSkillLinks.recommendedSkillHints) {
-    recommendedSkillHints.add(hint);
-  }
-  for (const patch of resolvedSkillLinks.skillPromptPatches) {
-    skillPromptPatches.add(patch);
-  }
-  return {
-    tools: Array.from(toolSet),
-    recommendedSkillTools: Array.from(recommendedToolSet),
-    recommendedSkillHints: Array.from(recommendedSkillHints),
-    skillPromptPatches: Array.from(skillPromptPatches),
-    contentByKey
-  };
-};
+import {
+  isDeepInfraKimiModel,
+  isFireworksKimiModel,
+  isPlatformMimoProviderModel,
+  resolveFireworksKimiModel
+} from "./chunk-SZC4REES.js";
+import {
+  asTrimmedLowercaseString
+} from "./chunk-QSJ3HFEF.js";
+import {
+  MEMORY_USE_GUIDANCE,
+  buildUserResponseLanguageContext,
+  wrapHistoricalSummaryWithReplayGuard
+} from "./chunk-4VJAC32I.js";
 
 // packages/agent-runtime/responsesConversationState.ts
 function supportsResponsesConversationState(agent) {
@@ -648,6 +410,14 @@ ${contexts.userGlobalPrompt.trim()} ` : "";
   const dialogSummarySection = contexts.dialogSummary?.trim() ? `--- \u5386\u53F2\u5BF9\u8BDD\u6458\u8981 ---
 ${wrapHistoricalSummaryWithReplayGuard(contexts.dialogSummary)}` : "";
   return compileContextLayers([
+    // 删除安全红线：系统层最高优先级约束，位于所有层之前（含身份信息），
+    // owner 要求常驻「根本提示词」的最顶部（2026-09-26 批量误删事故）。
+    {
+      id: "delete-safety-red-line",
+      owner: "platform",
+      cacheScope: "static",
+      content: DELETE_SAFETY_RED_LINE
+    },
     { id: "identity", owner: "platform", cacheScope: "session", content: identitySection },
     { id: "user-response-language", owner: "platform", cacheScope: "session", content: buildUserResponseLanguageContext({ language: safeLanguage }) },
     { id: "startup-protocol", owner: "platform", cacheScope: "static", content: startupProtocol },
@@ -659,6 +429,7 @@ ${wrapHistoricalSummaryWithReplayGuard(contexts.dialogSummary)}` : "";
     { id: "agent-collaboration", owner: "platform", cacheScope: "session", content: toolSections.agentCollaboration },
     { id: "web-access", owner: "platform", cacheScope: "session", content: toolSections.webAccess },
     { id: "menu-usage", owner: "platform", cacheScope: "session", content: toolSections.menuUsage },
+    { id: "show-interaction", owner: "platform", cacheScope: "session", content: toolSections.showInteraction },
     { id: "clarification-mode", owner: "platform", cacheScope: "session", content: clarifyingSection },
     { id: "knowledge-management", owner: "platform", cacheScope: "session", content: toolSections.knowledgeManagement },
     { id: "memory-capture", owner: "platform", cacheScope: "session", content: toolSections.memoryCapture },
@@ -741,14 +512,28 @@ var normalizeChatCompletionsContent = (content) => {
   if (content == null) return null;
   return JSON.stringify(content);
 };
-var sanitizeChatCompletionsMessage = (message) => {
+var sanitizeChatCompletionsMessage = (message, options) => {
   const sanitized = {
     role: message.role,
     content: normalizeChatCompletionsContent(message.content)
   };
   const name = asOptionalTrimmedString(message.name);
   if (name) sanitized.name = name;
-  return preserveAgentStateFields(message, sanitized);
+  const shouldStripReasoning = shouldStripReasoningContentForOutbound(
+    options?.provider,
+    options?.model
+  );
+  return preserveAgentStateFields(message, sanitized, {
+    targetProvider: options?.provider,
+    targetModel: options?.model,
+    stripReasoningContent: shouldStripReasoning,
+    ...options?.shapingCounts ? { shapingCounts: options.shapingCounts } : {},
+    ...resolveReasoningReplayOptions(
+      options?.provider,
+      options?.model,
+      shouldStripReasoning
+    )
+  });
 };
 var buildRequestBody = (options) => {
   const {
@@ -761,10 +546,15 @@ var buildRequestBody = (options) => {
     frequency_penalty,
     presence_penalty,
     max_tokens,
-    reasoning_effort
+    reasoning_effort,
+    shapingCounts
   } = options;
   const cleanedMessages = messages.map(
-    (message) => sanitizeChatCompletionsMessage(message)
+    (message) => sanitizeChatCompletionsMessage(message, {
+      provider: providerName,
+      model,
+      ...shapingCounts ? { shapingCounts } : {}
+    })
   );
   const bodyData = {
     model,
@@ -776,8 +566,13 @@ var buildRequestBody = (options) => {
     endpoint: customProviderUrl
   });
   Object.assign(bodyData, usageRequestOptions);
-  if (reasoning_effort && isModelSupportReasoningEffort(model)) {
-    const clamped = clampReasoningEffort(reasoning_effort, providerName);
+  const effectiveProviderForReasoning = providerName?.toLowerCase() === "openrouter" || customProviderUrl?.toLowerCase().includes("openrouter.ai") ? "openrouter" : providerName;
+  if (reasoning_effort && isModelSupportReasoningEffort(model, effectiveProviderForReasoning)) {
+    const clamped = clampReasoningEffort(
+      reasoning_effort,
+      effectiveProviderForReasoning,
+      model
+    );
     if (clamped) {
       bodyData.reasoning_effort = clamped;
     }
@@ -791,7 +586,7 @@ var buildRequestBody = (options) => {
   if (typeof max_tokens === "number") bodyData.max_tokens = max_tokens;
   return bodyData;
 };
-var generateOpenAIRequestBody = (agentConfig, providerName, messages, contexts, stableMessages = [], prependSystemPrompt = true) => {
+var generateOpenAIRequestBody = (agentConfig, providerName, messages, contexts, stableMessages = [], prependSystemPrompt = true, shapingCounts) => {
   const resolvedModel = providerName === "fireworks" ? resolveFireworksKimiModel(agentConfig.model) : agentConfig.model ?? "";
   let processedStable = [...stableMessages];
   if (isClaudeModel(resolvedModel) && processedStable.length > 0) {
@@ -835,7 +630,8 @@ var generateOpenAIRequestBody = (agentConfig, providerName, messages, contexts,
     frequency_penalty: agentConfig.frequency_penalty,
     presence_penalty: agentConfig.presence_penalty,
     max_tokens: agentConfig.max_tokens,
-    reasoning_effort: agentConfig.reasoning_effort
+    reasoning_effort: agentConfig.reasoning_effort,
+    ...shapingCounts ? { shapingCounts } : {}
   });
   if (shouldInjectLlamaCppThinkingToggle(agentConfig)) {
     requestBody.chat_template_kwargs = {
@@ -1057,94 +853,6 @@ var generateRequestBody = ({
   return applyImageConfigIfNeeded(baseBody, agentConfigForRequest, provider);
 };
 
-// packages/ai/chat/serverProxyRetry.ts
-var DEFAULT_SERVER_PROXY_RETRY_AFTER_MS = 1500;
-var MAX_SERVER_PROXY_RETRIES = 2;
-var MAX_STATUS_RETRIES = 3;
-var MAX_SERVER_DRAIN_STATUS_RETRIES = 30;
-var readRetryableResponseBody = async (response) => {
-  try {
-    return await response.clone().json();
-  } catch {
-    return null;
-  }
-};
-var resolveServerProxyRetryAfterMs = (response, body) => parseRetryAfterHeaderMs(response.headers.get("Retry-After")) ?? normalizeNonNegativeMs(
-  body?.retryAfterMs,
-  DEFAULT_SERVER_PROXY_RETRY_AFTER_MS
-);
-var isRetryableServerProxyFetchError = (error) => {
-  if (!error || isAbortError(error)) return false;
-  const message = typeof error?.message === "string" ? error.message : String(error);
-  return /ECONNREFUSED|ECONNRESET|EPIPE|socket hang up|network error|failed to fetch|fetch failed|connection closed|load failed|502|503|504/i.test(
-    message
-  );
-};
-var waitForServerProxyRetry = async (retryAfterMs, signal) => {
-  const delayMs = normalizeNonNegativeMs(
-    retryAfterMs,
-    DEFAULT_SERVER_PROXY_RETRY_AFTER_MS
-  );
-  if (delayMs <= 0) return;
-  await waitForAbortableDelay(delayMs, signal);
-};
-var performServerProxyFetchWithRetry = async ({
-  execute,
-  signal,
-  logPrefix = "[fetchWithServerProxy]",
-  onRetry
-}) => {
-  let networkRetries = 0;
-  let statusRetries = 0;
-  while (true) {
-    try {
-      const response = await execute();
-      const responseBody = response.status === 503 ? await readRetryableResponseBody(response) : null;
-      const isCoreDraining = response.status === 503 && isCoreDrainingBody(responseBody);
-      const maxStatusRetries = isCoreDraining ? MAX_SERVER_DRAIN_STATUS_RETRIES : MAX_STATUS_RETRIES;
-      if (statusRetries < maxStatusRetries && isGatewayHttpStatus(response.status)) {
-        statusRetries += 1;
-        const retryAfterMs = resolveServerProxyRetryAfterMs(
-          response,
-          responseBody
-        );
-        console.warn(
-          `${logPrefix} \u68C0\u6D4B\u5230${response.status}\u72B6\u6001\uFF0C${retryAfterMs}ms\u540E\u91CD\u8BD5...`
-        );
-        onRetry?.({
-          attempt: statusRetries,
-          maxAttempts: maxStatusRetries,
-          delayMs: retryAfterMs
-        });
-        await waitForServerProxyRetry(retryAfterMs, signal);
-        continue;
-      }
-      if (isCoreDraining) {
-        console.warn(`${logPrefix} core_draining \u91CD\u8BD5\u8017\u5C3D\uFF0C\u8FD4\u56DE\u53CB\u597D\u63D0\u793A`);
-        return createDrainExhaustedResponse(response);
-      }
-      return response;
-    } catch (error) {
-      if (networkRetries < MAX_SERVER_PROXY_RETRIES && isRetryableServerProxyFetchError(error)) {
-        networkRetries += 1;
-        const retryDelay = networkRetries * 1e3;
-        console.warn(
-          `${logPrefix} \u68C0\u6D4B\u5230\u7F51\u7EDC\u77AC\u65AD\uFF0C${retryDelay}ms\u540E\u91CD\u8BD5(\u7B2C${networkRetries}\u6B21)...`,
-          error
-        );
-        onRetry?.({
-          attempt: networkRetries,
-          maxAttempts: MAX_SERVER_PROXY_RETRIES,
-          delayMs: retryDelay
-        });
-        await waitForServerProxyRetry(retryDelay, signal);
-        continue;
-      }
-      throw error;
-    }
-  }
-};
-
 // packages/ai/chat/resolveDirectRequestApiKey.ts
 var DIRECT_API_KEY_UNAVAILABLE_MESSAGE = "\u65E0\u6CD5\u52A0\u8F7D\u672C\u5730 API \u5BC6\u94A5\u3002\u8BF7\u5728 Agent \u8BBE\u7F6E\u4E2D\u91CD\u65B0\u586B\u5199\u5BC6\u94A5\uFF0C\u6216\u786E\u8BA4\u672C\u673A\u51ED\u636E\u53EF\u7528\u3002";
 var DirectApiKeyResolutionError = class extends Error {
@@ -1208,7 +916,7 @@ var buildProxyPayload = (bodyData, api, agentConfig, dialogId) => {
   };
 };
 var fetchDirectly = async (params) => {
-  const { api, agentConfig, bodyData, signal, currentServer, token } = params;
+  const { api, agentConfig, bodyData, signal, currentServer, token, dialogId } = params;
   try {
     const apiKey = await resolveDirectRequestApiKey(agentConfig, {
       syncFetcher: currentServer && token ? (ref) => fetchServerSyncedCredential({ currentServer, authToken: token }, ref) : void 0,
@@ -1228,7 +936,8 @@ var fetchDirectly = async (params) => {
     const authHeaders = buildProviderAuthHeaders({
       endpoint: api,
       apiKey: apiKey ?? "",
-      apiKeyHeader: agentConfig.apiKeyHeader
+      apiKeyHeader: agentConfig.apiKeyHeader,
+      sessionId: dialogId || agentConfig.dbKey || agentConfig.key
     });
     return await fetch(api, {
       method: "POST",
@@ -1543,346 +1252,58 @@ function sanitizeOutboundBody(body) {
   return next;
 }
 
-// packages/create/editor/transforms/slateToText.ts
-function getNodeText(node) {
-  if (node.text) {
-    return node.text;
-  }
-  if (node.children && Array.isArray(node.children)) {
-    return node.children.map(getNodeText).join("\n");
-  }
-  return "";
-}
-function slateToText(nodes) {
-  if (!nodes || nodes.length === 0) {
-    return "";
-  }
-  return nodes.map(getNodeText).join("\n\n");
-}
-
-// packages/ai/context/buildReferenceContext.ts
-var MAX_META_TEXT_LENGTH = 80;
-var DIALOG_REFERENCE_MESSAGE_LIMIT = 20;
-var DIALOG_REFERENCE_SNIPPET_CHARS = 1200;
-var DIALOG_HANDOFF_SNIPPET_CHARS = 360;
-var truncateMetaText = (value, max = MAX_META_TEXT_LENGTH) => {
-  if (!value) return "";
-  if (value.length <= max) return value;
-  return `${value.slice(0, max - 3)}...`;
+// packages/ai/tools/stripModelConfirmationFlags.ts
+var CONFIRMATION_INPUT_KEYS = {
+  self_evolution_requires_confirmation: "__confirmedSelfEvolution",
+  agent_update_requires_confirmation: "__confirmedSelfEvolution",
+  media_job_start_requires_confirmation: "__confirmedMediaJobStart"
 };
-var readSafe = async (dispatch, dbKey) => {
-  try {
-    return await dispatch(read({
-      dbKey
-    })).unwrap();
-  } catch {
-    return null;
-  }
-};
-var buildMentionMetaMap = async (slateData, dispatch) => {
-  const metaMap = /* @__PURE__ */ new Map();
-  const mentions = extractCategorizedMentions(slateData);
-  if (!mentions) return metaMap;
-  const pageEntries = await Promise.all(
-    (mentions.pages || []).map(async (pageId) => {
-      const pageData = await readSafe(dispatch, pageId);
-      if (!pageData) {
-        return [`page:${pageId}`, { displayType: "page", metaParts: [] }];
-      }
-      if (pageData.type === "dialog" /* DIALOG */) {
-        const agentCount = Array.isArray(pageData.cybots) ? pageData.cybots.length : 0;
-        return [
-          `page:${pageId}`,
-          {
-            displayType: "dialog",
-            title: pageData.title,
-            metaParts: [
-              `agents=${agentCount}`,
-              `updated=${pageData.updatedAt || pageData.updated_at || pageData.updated || "Unknown"}`
-            ]
-          }
-        ];
-      }
-      const tags = pageData.tags && pageData.tags.length > 0 ? pageData.tags.slice(0, 5).join(", ") : "";
-      return [
-        `page:${pageId}`,
-        {
-          displayType: "page",
-          title: pageData.title,
-          metaParts: [
-            pageData.spaceId ? `space=${pageData.spaceId}` : "",
-            tags ? `tags=${tags}` : "",
-            `updated=${pageData.updatedAt || pageData.updated_at || pageData.updated || "Unknown"}`
-          ].filter(Boolean)
-        }
-      ];
-    })
-  );
-  pageEntries.forEach((entry) => metaMap.set(entry[0], entry[1]));
-  const agentEntries = await Promise.all(
-    (mentions.agents || []).map(async (agentId) => {
-      const agentData = await readSafe(dispatch, agentId);
-      if (!agentData) {
-        return [`agent:${agentId}`, { displayType: "agent", metaParts: [] }];
-      }
-      const desc = truncateMetaText(
-        agentData.description || agentData.introduction || ""
-      );
-      return [
-        `agent:${agentId}`,
-        {
-          displayType: "agent",
-          title: agentData.name,
-          metaParts: [
-            `public=${agentData.isPublic ? "yes" : "no"}`,
-            desc ? `desc=${desc}` : ""
-          ].filter(Boolean)
-        }
-      ];
-    })
-  );
-  agentEntries.forEach((entry) => metaMap.set(entry[0], entry[1]));
-  const spaceEntries = await Promise.all(
-    (mentions.spaces || []).map(async (spaceId) => {
-      const spaceKey = createSpaceKey.space(spaceId);
-      const spaceData = await readSafe(dispatch, spaceKey);
-      if (!spaceData) {
-        return [`space:${spaceId}`, { displayType: "space", metaParts: [] }];
-      }
-      const desc = truncateMetaText(spaceData.description || "");
-      const categoriesCount = Object.keys(spaceData.categories || {}).length;
-      const contentsCount = Object.keys(spaceData.contents || {}).length;
-      return [
-        `space:${spaceId}`,
-        {
-          displayType: "space",
-          title: spaceData.name,
-          metaParts: [
-            desc ? `desc=${desc}` : "",
-            `categories=${categoriesCount}`,
-            `contents=${contentsCount}`
-          ].filter(Boolean)
-        }
-      ];
-    })
-  );
-  spaceEntries.forEach((entry) => metaMap.set(entry[0], entry[1]));
-  return metaMap;
-};
-var buildInlineMention = (node, metaMap) => {
-  const resourceType = node.resourceType || "unknown";
-  const resourceId = node.resourceId || "unknown";
-  const key = `${resourceType}:${resourceId}`;
-  const meta = metaMap.get(key);
-  const label = meta?.title || node.label || resourceId || "mention";
-  const displayType = meta?.displayType || resourceType;
-  const metaParts = meta?.metaParts ?? [];
-  const idPart = resourceType === "tool" ? `tool=${resourceId}` : `dbkey=${resourceId}`;
-  const metaSuffix = metaParts.length ? ` | ${metaParts.join(" | ")}` : "";
-  return `@${label}(${displayType} | ${idPart}${metaSuffix})`;
-};
-var clipReferenceText = (value, max) => {
-  const raw = typeof value === "string" ? value : value == null ? "" : JSON.stringify(value);
-  return clipMultilineText(raw, max);
-};
-var fetchDialogReference = async (dbKey, refContent, dispatch) => {
-  const dialogConfig = refContent;
-  const dialogTitle = dialogConfig.title || `Untitled Dialog (${dbKey})`;
-  const dialogId = extractCustomId(dbKey) || dbKey.replace(/^dialog-/, "");
-  const checkpoint = dialogConfig.runtimeCheckpoint || null;
-  const summary = asTrimmedString(dialogConfig.summary);
-  const messages = await dispatch(
-    async (_dispatch, getState, { db }) => {
-      const state = getState();
-      const { currentToken: token, remoteServers } = getRuntimeServerContext(state);
-      return await fetchAndCacheMessages({
-        db,
-        dialogId,
-        limit: DIALOG_REFERENCE_MESSAGE_LIMIT,
-        token,
-        remoteServers: remoteServers.length > 0 ? remoteServers : void 0
-      });
-    }
+function stripModelConfirmationFlags(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return value;
+  return Object.fromEntries(
+    Object.entries(value).filter(
+      ([key]) => !key.startsWith("__confirmed")
+    )
   );
-  const sortedMessages = [...messages].reverse();
-  const formatContent = (content) => clipReferenceText(content, DIALOG_REFERENCE_SNIPPET_CHARS);
-  const transcript = sortedMessages.map((msg, index) => {
-    const toolLine = msg.toolName ? ` tool=${msg.toolName}` : "";
-    const agentLine = msg.cybotKey ? ` agent=${msg.cybotKey}` : "";
-    const createdLine = msg.createdAt ? ` at=${msg.createdAt}` : "";
-    return [
-      `### Message ${index + 1}: ${msg.role || "unknown"} id=${msg.id || "unknown"}${toolLine}${agentLine}${createdLine}`,
-      formatContent(msg.content) || "[empty]"
-    ].join("\n");
-  }).join("\n\n");
-  const checkpointLines = [];
-  if (checkpoint && typeof checkpoint === "object") {
-    if (checkpoint.status) checkpointLines.push(`- status: ${checkpoint.status}`);
-    if (checkpoint.lastUserInput) checkpointLines.push(`- lastUserInput: ${formatContent(checkpoint.lastUserInput)}`);
-    if (checkpoint.lastAssistantText) checkpointLines.push(`- lastAssistantText: ${formatContent(checkpoint.lastAssistantText)}`);
-    if (Array.isArray(checkpoint.lastToolNames) && checkpoint.lastToolNames.length) {
-      checkpointLines.push(`- lastToolNames: ${checkpoint.lastToolNames.join(", ")}`);
-    }
-    if (Array.isArray(checkpoint.toolSurface?.finalToolNames) && checkpoint.toolSurface.finalToolNames.length) {
-      checkpointLines.push(`- availableToolNames: ${checkpoint.toolSurface.finalToolNames.join(", ")}`);
-    }
-  }
-  const recentToolEvidence = sortedMessages.filter((msg) => msg.role === "tool" || msg.toolName).slice(-3).map((msg) => {
-    const label = msg.toolName ? `${msg.toolName}` : "tool";
-    return `- ${label} id=${msg.id || "unknown"}: ${clipReferenceText(msg.content, DIALOG_HANDOFF_SNIPPET_CHARS) || "[empty]"}`;
-  });
-  const handoffLines = [
-    `- Use this when continuing work, transferring to another Agent, comparing with the current task, or preparing a document/plan from the prior discussion.`,
-    `- Current state source: ${checkpointLines.length ? "Runtime Checkpoint" : "summaries and recent transcript"}.`,
-    summary ? `- Compressed background: passive summary is available below; treat it as lossy, not original wording.` : "",
-    recentToolEvidence.length ? `- Recent tool evidence:
-${recentToolEvidence.join("\n")}` : `- Recent tool evidence: none loaded in the latest ${DIALOG_REFERENCE_MESSAGE_LIMIT} messages.`,
-    `- For exact claims, old decisions, original wording, files/tools mentioned earlier, or anything not visible in the recent transcript, call searchDialogMessages with DB Key ${dbKey}.`
-  ].filter(Boolean);
-  const referenceBody = [
-    `Conversation Reference:`,
-    `DB Key: ${dbKey}`,
-    `Title: ${dialogTitle}`,
-    `Status: ${dialogConfig.status || "unknown"}`,
-    `Loaded Recent Messages: ${sortedMessages.length}`,
-    `Conversation Handoff:
-${handoffLines.join("\n")}`,
-    checkpointLines.length ? `Runtime Checkpoint:
-${checkpointLines.join("\n")}` : "",
-    summary ? `Passive Summary (compressed history, not original wording):
-${wrapHistoricalSummaryWithReplayGuard(summary)}` : "",
-    `Recent Transcript (original message excerpts, oldest to newest):
-${transcript || "[no recent messages loaded]"}`,
-    [
-      `Coverage Note: This reference intentionally loads only the latest ${DIALOG_REFERENCE_MESSAGE_LIMIT} messages plus summaries/checkpoint to control token load.`,
-      `Original Message Lookup Policy: If the user asks for an exact old message, original wording, who said what, why a decision was made, early-history detail, file/tool evidence, failed attempts, or a comparison with prior work, use searchDialogMessages({ dialogKey: "${dbKey}", query: "..." }) before making a factual claim from this referenced conversation.`
-    ].join("\n")
-  ].filter(Boolean).join("\n\n");
-  const tokenEstimate = estimateTokenCount(referenceBody);
-  return `${referenceBody}
-
-Token Load Estimate: ${tokenEstimate} tokens for this conversation reference.
----
-
-`;
-};
-var fetchTableReference = async (dbKey, refContent, dispatch) => {
-  const tableMeta = refContent;
-  const title = tableMeta.displayName || tableMeta.description || `Untitled Table (${dbKey})`;
-  const { markdown: tableMd } = await dispatch(
-    async (_dispatch, getState, { db }) => {
-      const state = getState();
-      const { currentToken: token, remoteServers } = getRuntimeServerContext(state);
-      return await fetchAndSerializeTable(tableMeta, db, {
-        token,
-        remoteServers
-      });
-    }
+}
+var MODEL_DIALOG_BINDING_STRIPPED_TOOLS = /* @__PURE__ */ new Set([
+  "mediaJobTool",
+  "transcribe",
+  "translate",
+  "exportDocument",
+  "readArtifact"
+]);
+var TRUSTED_ONLY_MODEL_INPUT_KEYS = /* @__PURE__ */ new Set(["confirmationToken", "expectedExecutionRevision"]);
+function stripModelToolArgs(canonicalToolName, value) {
+  const base = stripModelConfirmationFlags(value);
+  if (!base || typeof base !== "object" || Array.isArray(base)) return base;
+  const withoutTrustedOnlyKeys = Object.fromEntries(
+    Object.entries(base).filter(
+      ([key]) => !TRUSTED_ONLY_MODEL_INPUT_KEYS.has(key)
+    )
   );
-  const tags = tableMeta.tags?.length ? tableMeta.tags.join(", ") : "None";
-  const description = tableMeta.description || "No description provided.";
-  return `Reference Item (Table):
-DB Key: ${dbKey}
-Title: ${title}
-Description: ${description}
-Tags: ${tags}
-Content (Markdown Table):
-
-${tableMd}
----
-
-`;
-};
-var fetchSlateReference = async (dbKey, refContent, dispatch, options) => {
-  if (!refContent?.slateData) return null;
-  const title = refContent.title || `Untitled (${dbKey})`;
-  let contentString;
-  let contentType;
-  const inlineMentionMeta = options.inlineMentionMeta ?? options.format === "simplified_markdown";
-  switch (options.format) {
-    case "text":
-      contentType = "Plain Text";
-      contentString = slateToText(refContent.slateData);
-      break;
-    case "simplified_markdown":
-      contentType = "Simplified Markdown";
-      if (inlineMentionMeta) {
-        const metaMap = await buildMentionMetaMap(refContent.slateData, dispatch);
-        contentString = slateToSimplifiedMarkdown(refContent.slateData, {
-          mentionResolver: (node) => buildInlineMention(node, metaMap)
-        });
-      } else {
-        contentString = slateToSimplifiedMarkdown(refContent.slateData);
-      }
-      break;
-    case "json":
-    default:
-      contentType = "Slate JSON";
-      contentString = JSON.stringify(refContent.slateData, null, 2);
-      break;
+  if (!MODEL_DIALOG_BINDING_STRIPPED_TOOLS.has(canonicalToolName)) {
+    return withoutTrustedOnlyKeys;
   }
-  if (!contentString || typeof contentString === "string" && !contentString.trim() || contentString === "[]") {
-    return null;
+  if (!withoutTrustedOnlyKeys || typeof withoutTrustedOnlyKeys !== "object" || Array.isArray(withoutTrustedOnlyKeys)) {
+    return withoutTrustedOnlyKeys;
   }
-  const tags = (refContent.tags || []).length > 0 ? refContent.tags.join(", ") : "None";
-  const createdAt = refContent.created || "Unknown Creation Date";
-  const updatedAt = refContent.updated || "Unknown Update Date";
-  return `Reference Item:
-DB Key: ${dbKey}
-Title: ${title}
-Content (${contentType}):
-${contentString}
-Tags: ${tags}
-Created At: ${createdAt}
-Updated At: ${updatedAt}
----
-
-`;
-};
-var fetchReferenceContents = async (references, dispatch, options = { format: "simplified_markdown" }) => {
-  const result = /* @__PURE__ */ new Map();
-  if (!references || references.length === 0) return result;
-  const referencePromises = references.map(async (dbKey) => {
-    try {
-      const hasPreloaded = options.preloaded?.has(dbKey);
-      const refContent = hasPreloaded ? options.preloaded?.get(dbKey) : await dispatch(read({
-        dbKey
-      })).unwrap();
-      if (!refContent) return null;
-      let formatted = null;
-      if (refContent.type === "dialog" /* DIALOG */) {
-        formatted = await fetchDialogReference(dbKey, refContent, dispatch);
-      } else if (refContent.type === "table" /* TABLE */) {
-        formatted = await fetchTableReference(dbKey, refContent, dispatch);
-      } else {
-        formatted = await fetchSlateReference(dbKey, refContent, dispatch, options);
-      }
-      if (formatted) return [dbKey, formatted];
-      return null;
-    } catch (error) {
-      console.error(`Error fetching reference ${dbKey}:`, error);
-      return null;
-    }
-  });
-  const resolved = await Promise.all(referencePromises);
-  resolved.forEach((item) => {
-    if (item) result.set(item[0], item[1]);
-  });
-  return result;
-};
+  return Object.fromEntries(
+    Object.entries(withoutTrustedOnlyKeys).filter(
+      ([key]) => key !== "dialogId" && key !== "autoApproveCredits"
+    )
+  );
+}
 
 export {
-  fetchReferenceContents,
-  mergeReferences,
-  resolveReferenceAssets,
-  resolveToolsFromKeys,
   selectResponsesConversationState,
   updateResponsesConversationState,
   isResponsesConversationStateRejection,
   resolveClientWire,
   resolveAgentCallPlan,
   generateRequestBody,
-  performServerProxyFetchWithRetry,
+  CONFIRMATION_INPUT_KEYS,
+  stripModelToolArgs,
   performFetchRequest,
   INVALID_TOOL_ARGS_REPLACEMENT,
   parseToolCallArguments,