@cognipeer/agent-sdk 0.8.1 → 0.8.2

package/dist/index.cjs

@@ -52,7 +52,7 @@ function getTokenCounter() {
 function countApproxTokens(text) {
   return activeTokenCounter(text || "");
 }
-function extractMessageText2(m) {
+function extractMessageText(m) {
   if (!m) return "";
   const parts = [];
   parts.push(m.role || "");
@@ -102,7 +102,7 @@ function extractMessageText2(m) {
 }
 function countMessagesTokens(messages) {
   if (!Array.isArray(messages) || messages.length === 0) return 0;
-  const allText = messages.map(extractMessageText2).join("\n");
+  const allText = messages.map(extractMessageText).join("\n");
   return countApproxTokens(allText) + messages.length * 4;
 }
 var activeTokenCounter;
@@ -1088,7 +1088,35 @@ function buildConfigSnapshot(runtime) {
     sink: snapshotSink(runtime)
   };
 }
-async function postTraceSession(url, headers, payload) {
+var TRACE_HTTP_MAX_ATTEMPTS = 4;
+var TRACE_HTTP_ATTEMPT_TIMEOUT_MS = 8e3;
+var TRACE_HTTP_RETRYABLE_STATUS = /* @__PURE__ */ new Set([404, 408, 425, 429, 500, 502, 503, 504]);
+var TRACE_HTTP_RETRY_BASE_MS = 250;
+var TRACE_HTTP_RETRY_MAX_MS = 4e3;
+var RetryableHttpError = class extends Error {
+  constructor(status, message, retryAfterMs) {
+    super(message);
+    this.name = "RetryableHttpError";
+    this.status = status;
+    this.retryAfterMs = retryAfterMs;
+  }
+};
+function traceSleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function traceBackoffDelay(attempt, baseMs, maxMs) {
+  const exp = Math.min(maxMs, baseMs * 2 ** (attempt - 1));
+  return Math.floor(Math.random() * exp);
+}
+function parseRetryAfterMs(headerValue) {
+  if (!headerValue) return void 0;
+  const seconds = Number(headerValue);
+  if (Number.isFinite(seconds)) return Math.max(0, seconds * 1e3);
+  const dateMs = Date.parse(headerValue);
+  if (Number.isFinite(dateMs)) return Math.max(0, dateMs - Date.now());
+  return void 0;
+}
+async function postJsonOnce(url, headers, body) {
   const fetchFn = typeof globalThis.fetch === "function" ? globalThis.fetch.bind(globalThis) : void 0;
   if (!fetchFn) {
     throw new Error("HTTP sink requires fetch to be available in this runtime.");
@@ -1097,135 +1125,71 @@ async function postTraceSession(url, headers, payload) {
   if (!Object.keys(finalHeaders).some((key) => key.toLowerCase() === "content-type")) {
     finalHeaders["content-type"] = "application/json";
   }
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), TRACE_HTTP_ATTEMPT_TIMEOUT_MS);
+  let response;
   try {
-    const response = await fetchFn(url, {
+    response = await fetchFn(url, {
       method: "POST",
       headers: finalHeaders,
-      body: JSON.stringify(payload)
+      body: JSON.stringify(body),
+      signal: controller.signal
     });
-    if (!response.ok) {
-      let responseText = "";
-      try {
-        responseText = await response.text();
-      } catch {
-      }
-      const statusLine = `HTTP ${response.status}${response.statusText ? ` ${response.statusText}` : ""}`;
-      const bodyPreview = responseText ? ` - ${responseText.slice(0, 200)}` : "";
-      const errorMsg = `${statusLine}${bodyPreview}`;
-      if (typeof console !== "undefined" && typeof console.error === "function") {
-        console.error("[Tracing] Error posting to", url, ":", errorMsg);
-      }
-      throw new Error(errorMsg);
-    }
   } catch (err) {
-    const errMsg = err instanceof Error ? err.message : String(err);
-    if (typeof console !== "undefined" && typeof console.error === "function") {
-      console.error("[Tracing] Failed to post:", errMsg);
-    }
-    throw err;
+    const message2 = err instanceof Error ? err.message : String(err);
+    throw new RetryableHttpError(0, `network error - ${message2}`);
+  } finally {
+    clearTimeout(timer);
   }
-}
-async function postStreamingSessionStart(baseUrl, headers, payload) {
-  const fetchFn = typeof globalThis.fetch === "function" ? globalThis.fetch.bind(globalThis) : void 0;
-  if (!fetchFn) {
-    throw new Error("HTTP sink requires fetch to be available in this runtime.");
+  if (response.ok) return;
+  let responseText = "";
+  try {
+    responseText = await response.text();
+  } catch {
   }
-  const url = `${baseUrl.replace(/\/$/, "")}/stream/${payload.sessionId}/start`;
-  const finalHeaders = { ...headers || {} };
-  if (!Object.keys(finalHeaders).some((key) => key.toLowerCase() === "content-type")) {
-    finalHeaders["content-type"] = "application/json";
+  const statusLine = `HTTP ${response.status}${response.statusText ? ` ${response.statusText}` : ""}`;
+  const bodyPreview = responseText ? ` - ${responseText.slice(0, 200)}` : "";
+  const message = `${statusLine}${bodyPreview}`;
+  if (TRACE_HTTP_RETRYABLE_STATUS.has(response.status)) {
+    throw new RetryableHttpError(response.status, message, parseRetryAfterMs(response.headers.get("retry-after")));
   }
-  try {
-    const response = await fetchFn(url, {
-      method: "POST",
-      headers: finalHeaders,
-      body: JSON.stringify(payload)
-    });
-    if (!response.ok) {
-      let responseText = "";
-      try {
-        responseText = await response.text();
-      } catch {
+  throw new Error(message);
+}
+async function postJsonReliable(url, headers, body, opts = {}) {
+  const maxAttempts = opts.retry === false ? 1 : TRACE_HTTP_MAX_ATTEMPTS;
+  let lastError;
+  for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+    try {
+      await postJsonOnce(url, headers, body);
+      return;
+    } catch (err) {
+      lastError = err;
+      if (!(err instanceof RetryableHttpError) || attempt === maxAttempts) {
+        if (typeof console !== "undefined" && typeof console.error === "function") {
+          console.error("[Tracing] Failed to post:", err instanceof Error ? err.message : String(err));
+        }
+        throw err;
       }
-      const statusLine = `HTTP ${response.status}${response.statusText ? ` ${response.statusText}` : ""}`;
-      const bodyPreview = responseText ? ` - ${responseText.slice(0, 200)}` : "";
-      throw new Error(`${statusLine}${bodyPreview}`);
-    }
-  } catch (err) {
-    const errMsg = err instanceof Error ? err.message : String(err);
-    if (typeof console !== "undefined" && typeof console.error === "function") {
-      console.error("[Tracing] Failed to post session start:", errMsg);
+      const wait = err.retryAfterMs ?? traceBackoffDelay(attempt, TRACE_HTTP_RETRY_BASE_MS, TRACE_HTTP_RETRY_MAX_MS);
+      await traceSleep(Math.min(wait, TRACE_HTTP_RETRY_MAX_MS));
     }
-    throw err;
   }
+  throw lastError instanceof Error ? lastError : new Error(String(lastError));
+}
+async function postTraceSession(url, headers, payload) {
+  await postJsonReliable(url, headers, payload, { retry: true });
+}
+async function postStreamingSessionStart(baseUrl, headers, payload) {
+  const url = `${baseUrl.replace(/\/$/, "")}/stream/${payload.sessionId}/start`;
+  await postJsonReliable(url, headers, payload, { retry: true });
 }
 async function postStreamingEvent(baseUrl, headers, sessionId, event) {
-  const fetchFn = typeof globalThis.fetch === "function" ? globalThis.fetch.bind(globalThis) : void 0;
-  if (!fetchFn) {
-    throw new Error("HTTP sink requires fetch to be available in this runtime.");
-  }
   const url = `${baseUrl.replace(/\/$/, "")}/stream/${sessionId}/events`;
-  const finalHeaders = { ...headers || {} };
-  if (!Object.keys(finalHeaders).some((key) => key.toLowerCase() === "content-type")) {
-    finalHeaders["content-type"] = "application/json";
-  }
-  try {
-    const response = await fetchFn(url, {
-      method: "POST",
-      headers: finalHeaders,
-      body: JSON.stringify({ event })
-    });
-    if (!response.ok) {
-      let responseText = "";
-      try {
-        responseText = await response.text();
-      } catch {
-      }
-      const statusLine = `HTTP ${response.status}${response.statusText ? ` ${response.statusText}` : ""}`;
-      const bodyPreview = responseText ? ` - ${responseText.slice(0, 200)}` : "";
-      throw new Error(`${statusLine}${bodyPreview}`);
-    }
-  } catch (err) {
-    const errMsg = err instanceof Error ? err.message : String(err);
-    if (typeof console !== "undefined" && typeof console.error === "function") {
-      console.error("[Tracing] Failed to post streaming event:", errMsg);
-    }
-    throw err;
-  }
+  await postJsonReliable(url, headers, { event }, { retry: false });
 }
 async function postStreamingSessionEnd(baseUrl, headers, payload) {
-  const fetchFn = typeof globalThis.fetch === "function" ? globalThis.fetch.bind(globalThis) : void 0;
-  if (!fetchFn) {
-    throw new Error("HTTP sink requires fetch to be available in this runtime.");
-  }
   const url = `${baseUrl.replace(/\/$/, "")}/stream/${payload.sessionId}/end`;
-  const finalHeaders = { ...headers || {} };
-  if (!Object.keys(finalHeaders).some((key) => key.toLowerCase() === "content-type")) {
-    finalHeaders["content-type"] = "application/json";
-  }
-  try {
-    const response = await fetchFn(url, {
-      method: "POST",
-      headers: finalHeaders,
-      body: JSON.stringify(payload)
-    });
-    if (!response.ok) {
-      let responseText = "";
-      try {
-        responseText = await response.text();
-      } catch {
-      }
-      const statusLine = `HTTP ${response.status}${response.statusText ? ` ${response.statusText}` : ""}`;
-      const bodyPreview = responseText ? ` - ${responseText.slice(0, 200)}` : "";
-      throw new Error(`${statusLine}${bodyPreview}`);
-    }
-  } catch (err) {
-    const errMsg = err instanceof Error ? err.message : String(err);
-    if (typeof console !== "undefined" && typeof console.error === "function") {
-      console.error("[Tracing] Failed to post session end:", errMsg);
-    }
-    throw err;
-  }
+  await postJsonReliable(url, headers, payload, { retry: true });
 }
 function isoToUnixNano(iso) {
   const ms = new Date(iso).getTime();
@@ -1598,7 +1562,8 @@ function convertMessageListToSections(messageList) {
 function createTraceSession(opts) {
   const cfg = withDefaults(opts.tracing);
   if (!cfg.enabled) return void 0;
-  const sessionId = generateSessionId();
+  const providedSessionId = opts.tracing?.sessionId?.trim();
+  const sessionId = providedSessionId || generateSessionId();
   const traceId = generateTraceId();
   const rootSpanId = generateSpanId();
   const runtime = {
@@ -1606,6 +1571,7 @@ function createTraceSession(opts) {
     traceId,
     rootSpanId,
     threadId: opts.tracing?.threadId,
+    configAgentName: opts.tracing?.agentName?.trim() || void 0,
     startedAt: Date.now(),
     resolvedConfig: cfg,
     events: [],
@@ -1629,11 +1595,12 @@ async function startStreamingSession(session, agentRuntime) {
   if (session.resolvedConfig.mode !== "streaming") return;
   if (session.sessionStarted) return;
   const sink = session.resolvedConfig.sink;
-  const agentInfo = agentRuntime ? {
-    name: agentRuntime.name || "unknown-agent",
-    version: agentRuntime.version,
-    model: getModelName(agentRuntime.model) || "unknown-model",
-    provider: getProviderName(agentRuntime.model)
+  const resolvedAgentName = session.configAgentName || agentRuntime?.name || "unknown-agent";
+  const agentInfo = agentRuntime || session.configAgentName ? {
+    name: resolvedAgentName,
+    version: agentRuntime?.version,
+    model: getModelName(agentRuntime?.model) || "unknown-model",
+    provider: getProviderName(agentRuntime?.model)
   } : void 0;
   session.agentInfo = agentInfo;
   const configSnapshot = buildConfigSnapshot(session);
@@ -1983,6 +1950,777 @@ function estimatePayloadBytes(value) {
   }
 }
 
+// src/smart/runtimeConfig.ts
+var DEFAULT_CRITICAL_TOOLS = ["response", "manage_todo_list", "get_tool_response"];
+var BASE_DEFAULTS = {
+  limits: { maxToolCalls: 20, maxParallelTools: 5, maxContextTokens: 96e3, maxTotalOutputTokens: 0, maxCostUsd: 0, maxWallClockMs: 0 },
+  summarization: {
+    enable: true,
+    maxTokens: 96e3,
+    summaryTriggerTokens: 72e3,
+    summaryPromptMaxTokens: 12e3,
+    summaryCompressionRatioTarget: 0.45,
+    summaryMode: "incremental",
+    promptTemplate: "",
+    toolFreeCall: true,
+    integrityCheck: true
+  },
+  context: {
+    policy: "hybrid",
+    lastTurnsToKeep: 16,
+    toolResponsePolicy: "summarize_archive",
+    budget: {
+      systemReserveTokens: 2e3,
+      goalsReserveTokens: 2e3,
+      recentTurnsReserveTokens: 18e3,
+      toolResponseReserveTokens: 9e3
+    }
+  },
+  planning: {
+    mode: "off",
+    replanPolicy: "on_failure",
+    everyNSteps: 0
+  },
+  memory: {
+    provider: "inMemory",
+    scope: "session",
+    writePolicy: "auto_important",
+    readPolicy: "hybrid"
+  },
+  delegation: {
+    mode: "role_based",
+    maxDelegationDepth: 2,
+    maxChildCalls: 6,
+    maxParallelChild: 3,
+    childContextPolicy: "scoped",
+    requireJsonOutputContract: true
+  },
+  toolResponses: {
+    maxToolResponseChars: 32e3,
+    maxToolResponseTokens: 8e3,
+    defaultPolicy: "summarize_archive",
+    toolResponseRetentionByTool: {},
+    criticalTools: [...DEFAULT_CRITICAL_TOOLS],
+    schemaValidation: "strict"
+  },
+  contextPilot: {
+    // Opt-in: ContextPilot never alters tool output unless the caller
+    // explicitly passes `contextPilot: { enabled: true }` (or sets `enabled`
+    // via `customProfile`/profile overrides). This preserves backward
+    // compatibility for every existing `createSmartAgent(...)` call site.
+    enabled: false,
+    compression: {
+      json: { enabled: true, targetRatio: 0.35, minItems: 20 },
+      text: { enabled: true, targetRatio: 0.5, minChars: 1200 },
+      diff: { enabled: true, contextLines: 3 },
+      log: { enabled: true, maxLines: 60 },
+      search: { enabled: true, maxMatches: 30 }
+    },
+    ccr: { enabled: true, ttlMs: 30 * 60 * 1e3, maxEntries: 500 },
+    cacheAlignment: { enabled: true, warnOnVolatilePrompt: true },
+    dedup: { enabled: true, minChars: 500 },
+    excludeTools: []
+  }
+};
+function mergeContextPilot(base, override) {
+  return {
+    enabled: override?.enabled ?? base.enabled,
+    compression: {
+      json: { ...base.compression.json, ...override?.compression?.json },
+      text: { ...base.compression.text, ...override?.compression?.text },
+      diff: { ...base.compression.diff, ...override?.compression?.diff },
+      log: { ...base.compression.log, ...override?.compression?.log },
+      search: { ...base.compression.search, ...override?.compression?.search }
+    },
+    ccr: { ...base.ccr, ...override?.ccr },
+    cacheAlignment: { ...base.cacheAlignment, ...override?.cacheAlignment },
+    dedup: { ...base.dedup, ...override?.dedup },
+    excludeTools: override?.excludeTools ?? base.excludeTools
+  };
+}
+function buildProfile(overrides) {
+  return {
+    limits: { ...BASE_DEFAULTS.limits, ...overrides.limits },
+    summarization: { ...BASE_DEFAULTS.summarization, ...overrides.summarization },
+    context: {
+      ...BASE_DEFAULTS.context,
+      ...overrides.context,
+      budget: { ...BASE_DEFAULTS.context.budget, ...overrides.context?.budget }
+    },
+    planning: { ...BASE_DEFAULTS.planning, ...overrides.planning },
+    memory: { ...BASE_DEFAULTS.memory, ...overrides.memory },
+    delegation: { ...BASE_DEFAULTS.delegation, ...overrides.delegation },
+    toolResponses: {
+      ...BASE_DEFAULTS.toolResponses,
+      ...overrides.toolResponses,
+      criticalTools: overrides.toolResponses?.criticalTools ?? [...DEFAULT_CRITICAL_TOOLS],
+      toolResponseRetentionByTool: overrides.toolResponses?.toolResponseRetentionByTool ?? {}
+    },
+    contextPilot: mergeContextPilot(BASE_DEFAULTS.contextPilot, overrides.contextPilot)
+  };
+}
+var DEFAULT_PROFILE_CONFIGS = {
+  fast: buildProfile({
+    limits: { maxToolCalls: 8, maxParallelTools: 3, maxContextTokens: 32e3 },
+    summarization: {
+      maxTokens: 32e3,
+      summaryTriggerTokens: 24e3,
+      summaryPromptMaxTokens: 6e3,
+      summaryCompressionRatioTarget: 0.5
+    },
+    context: {
+      lastTurnsToKeep: 8,
+      toolResponsePolicy: "keep_structured",
+      budget: { systemReserveTokens: 1500, goalsReserveTokens: 1200, recentTurnsReserveTokens: 6e3, toolResponseReserveTokens: 3500 }
+    },
+    memory: { readPolicy: "recent_only" },
+    delegation: { mode: "off", maxDelegationDepth: 1, maxChildCalls: 2, maxParallelChild: 1, childContextPolicy: "minimal" },
+    toolResponses: { maxToolResponseChars: 16e3, maxToolResponseTokens: 4e3 },
+    contextPilot: {
+      compression: {
+        json: { targetRatio: 0.25, minItems: 12 },
+        text: { targetRatio: 0.35, minChars: 800 }
+      }
+    }
+  }),
+  balanced: buildProfile({}),
+  deep: buildProfile({
+    limits: { maxToolCalls: 40, maxParallelTools: 8, maxContextTokens: 2e5 },
+    summarization: {
+      maxTokens: 2e5,
+      summaryTriggerTokens: 15e4,
+      summaryPromptMaxTokens: 16e3,
+      summaryCompressionRatioTarget: 0.4
+    },
+    context: {
+      lastTurnsToKeep: 30,
+      budget: { systemReserveTokens: 2500, goalsReserveTokens: 2500, recentTurnsReserveTokens: 36e3, toolResponseReserveTokens: 18e3 }
+    },
+    memory: { scope: "workspace" },
+    delegation: { maxDelegationDepth: 3, maxChildCalls: 10, maxParallelChild: 4 },
+    toolResponses: { maxToolResponseChars: 64e3, maxToolResponseTokens: 16e3 },
+    contextPilot: {
+      compression: {
+        json: { targetRatio: 0.5, minItems: 30 },
+        text: { targetRatio: 0.6, minChars: 1600 }
+      },
+      ccr: { ttlMs: 60 * 60 * 1e3 }
+    }
+  }),
+  research: buildProfile({
+    limits: { maxToolCalls: 80, maxParallelTools: 10, maxContextTokens: 4e5 },
+    summarization: {
+      maxTokens: 4e5,
+      summaryTriggerTokens: 3e5,
+      summaryPromptMaxTokens: 24e3,
+      summaryCompressionRatioTarget: 0.35
+    },
+    context: {
+      lastTurnsToKeep: 60,
+      budget: { systemReserveTokens: 3e3, goalsReserveTokens: 3e3, recentTurnsReserveTokens: 72e3, toolResponseReserveTokens: 32e3 }
+    },
+    memory: { scope: "workspace" },
+    delegation: { mode: "automatic", maxDelegationDepth: 4, maxChildCalls: 16, maxParallelChild: 6, childContextPolicy: "full" },
+    toolResponses: { maxToolResponseChars: 96e3, maxToolResponseTokens: 24e3 },
+    contextPilot: {
+      compression: {
+        json: { targetRatio: 0.6, minItems: 40 },
+        text: { targetRatio: 0.65, minChars: 2e3 }
+      },
+      ccr: { ttlMs: 2 * 60 * 60 * 1e3, maxEntries: 1e3 }
+    }
+  })
+};
+function mergeLimits(base, override) {
+  return {
+    maxToolCalls: override?.maxToolCalls ?? base.maxToolCalls,
+    maxParallelTools: override?.maxParallelTools ?? base.maxParallelTools,
+    maxContextTokens: override?.maxContextTokens ?? base.maxContextTokens,
+    maxTotalOutputTokens: override?.maxTotalOutputTokens ?? base.maxTotalOutputTokens ?? 0,
+    maxCostUsd: override?.maxCostUsd ?? base.maxCostUsd ?? 0,
+    maxWallClockMs: override?.maxWallClockMs ?? base.maxWallClockMs ?? 0
+  };
+}
+function resolveBaseProfile(opts, runtimeProfile) {
+  if (opts.customProfile?.extends) return opts.customProfile.extends;
+  if (runtimeProfile !== "custom") return runtimeProfile;
+  return "balanced";
+}
+function normalizeSmartAgentOptions(opts) {
+  const runtimeProfile = opts.runtimeProfile ?? (opts.customProfile ? "custom" : "balanced");
+  const baseProfile = resolveBaseProfile(opts, runtimeProfile);
+  const preset = DEFAULT_PROFILE_CONFIGS[baseProfile];
+  const customProfile = opts.customProfile || {};
+  const useTodoList = opts.useTodoList === true;
+  const summarizationDisabled = opts.summarization === false;
+  const summarizationOverride = typeof opts.summarization === "object" ? opts.summarization : {};
+  const planningMode = opts.planning?.mode ?? customProfile.planning?.mode ?? (useTodoList ? "todo" : preset.planning.mode);
+  const memoryStore = opts.memory?.store ?? customProfile.memory?.store;
+  const contextToolResponsePolicy = opts.context?.toolResponsePolicy ?? customProfile.context?.toolResponsePolicy ?? preset.context.toolResponsePolicy;
+  return {
+    runtimeProfile,
+    baseProfile,
+    limits: mergeLimits(mergeLimits(preset.limits, customProfile.limits), opts.limits),
+    summarization: {
+      ...preset.summarization,
+      ...customProfile.summarization || {},
+      ...summarizationOverride,
+      enable: summarizationDisabled ? false : summarizationOverride.enable ?? customProfile.summarization?.enable ?? preset.summarization.enable,
+      maxTokens: summarizationOverride.maxTokens ?? opts.limits?.maxContextTokens ?? customProfile.summarization?.maxTokens ?? preset.summarization.maxTokens,
+      summaryTriggerTokens: summarizationOverride.summaryTriggerTokens ?? summarizationOverride.maxTokens ?? opts.limits?.maxContextTokens ?? customProfile.summarization?.summaryTriggerTokens ?? customProfile.summarization?.maxTokens ?? preset.summarization.summaryTriggerTokens,
+      promptTemplate: summarizationOverride.promptTemplate ?? customProfile.summarization?.promptTemplate ?? preset.summarization.promptTemplate
+    },
+    context: {
+      ...preset.context,
+      ...customProfile.context || {},
+      ...opts.context || {},
+      budget: {
+        ...preset.context.budget,
+        ...customProfile.context?.budget || {},
+        ...opts.context?.budget || {}
+      },
+      toolResponsePolicy: contextToolResponsePolicy
+    },
+    planning: {
+      ...preset.planning,
+      ...customProfile.planning || {},
+      ...opts.planning || {},
+      mode: planningMode
+    },
+    memory: {
+      ...preset.memory,
+      ...customProfile.memory || {},
+      ...opts.memory || {},
+      store: memoryStore
+    },
+    delegation: {
+      ...preset.delegation,
+      ...customProfile.delegation || {},
+      ...opts.delegation || {}
+    },
+    toolResponses: {
+      ...preset.toolResponses,
+      ...customProfile.toolResponses || {},
+      ...opts.toolResponses || {},
+      defaultPolicy: opts.toolResponses?.defaultPolicy ?? customProfile.toolResponses?.defaultPolicy ?? contextToolResponsePolicy,
+      toolResponseRetentionByTool: {
+        ...preset.toolResponses.toolResponseRetentionByTool,
+        ...customProfile.toolResponses?.toolResponseRetentionByTool || {},
+        ...opts.toolResponses?.toolResponseRetentionByTool || {}
+      },
+      criticalTools: opts.toolResponses?.criticalTools ?? customProfile.toolResponses?.criticalTools ?? preset.toolResponses.criticalTools
+    },
+    contextPilot: mergeContextPilot(mergeContextPilot(preset.contextPilot, customProfile.contextPilot), opts.contextPilot)
+  };
+}
+function getResolvedSmartConfig(opts, runtime) {
+  return runtime?.smart || normalizeSmartAgentOptions(opts);
+}
+
+// src/smart/contextPilot/relevance.ts
+var STOPWORDS = /* @__PURE__ */ new Set([
+  "the",
+  "a",
+  "an",
+  "and",
+  "or",
+  "but",
+  "if",
+  "then",
+  "else",
+  "for",
+  "of",
+  "in",
+  "on",
+  "at",
+  "to",
+  "by",
+  "with",
+  "is",
+  "are",
+  "was",
+  "were",
+  "be",
+  "been",
+  "being",
+  "this",
+  "that",
+  "these",
+  "those",
+  "it",
+  "its",
+  "as",
+  "from"
+]);
+function tokenize(text) {
+  if (!text) return [];
+  const matches = text.toLowerCase().match(/[\p{L}\p{N}_]+/gu);
+  if (!matches) return [];
+  return matches.filter((token) => token.length > 1 && !STOPWORDS.has(token));
+}
+function scoreItemsByRelevance(docs, query, params = {}) {
+  const k1 = params.k1 ?? 1.5;
+  const b = params.b ?? 0.75;
+  const queryTokens = tokenize(query);
+  const docTokens = docs.map((doc) => tokenize(doc));
+  if (queryTokens.length === 0) {
+    return docs.map(() => 1);
+  }
+  const docLengths = docTokens.map((tokens) => tokens.length);
+  const avgDocLen = docLengths.reduce((sum2, len) => sum2 + len, 0) / Math.max(1, docLengths.length);
+  const uniqueQueryTerms = [...new Set(queryTokens)];
+  const df = /* @__PURE__ */ new Map();
+  for (const term of uniqueQueryTerms) {
+    let count = 0;
+    for (const tokens of docTokens) {
+      if (tokens.includes(term)) count += 1;
+    }
+    df.set(term, count);
+  }
+  const n = docs.length;
+  const idf = /* @__PURE__ */ new Map();
+  for (const term of uniqueQueryTerms) {
+    const freq = df.get(term) || 0;
+    idf.set(term, Math.log(1 + (n - freq + 0.5) / (freq + 0.5)));
+  }
+  return docTokens.map((tokens, docIndex) => {
+    if (tokens.length === 0) return 0;
+    const termFreq = /* @__PURE__ */ new Map();
+    for (const token of tokens) {
+      termFreq.set(token, (termFreq.get(token) || 0) + 1);
+    }
+    const docLen = docLengths[docIndex];
+    let score = 0;
+    for (const term of uniqueQueryTerms) {
+      const freq = termFreq.get(term) || 0;
+      if (freq === 0) continue;
+      const termIdf = idf.get(term) || 0;
+      const numerator = freq * (k1 + 1);
+      const denominator = freq + k1 * (1 - b + b * docLen / avgDocLen);
+      score += termIdf * (numerator / denominator);
+    }
+    return score;
+  });
+}
+function selectTopIndicesInOrder(scores, count) {
+  const ranked = scores.map((score, index) => ({ score, index })).sort((a, b) => b.score - a.score).slice(0, Math.max(0, count)).map((entry) => entry.index);
+  return ranked.sort((a, b) => a - b);
+}
+var CCRStore = class _CCRStore {
+  constructor(options = {}) {
+    this.entries = /* @__PURE__ */ new Map();
+    this.defaultTtlMs = options.ttlMs ?? 30 * 60 * 1e3;
+    this.maxEntries = options.maxEntries ?? 500;
+  }
+  /** Stores `value` and returns a short content hash that can be used to retrieve it later. */
+  store(value, ttlMs) {
+    const hash = _CCRStore.hashOf(value);
+    this.entries.delete(hash);
+    this.entries.set(hash, { value, storedAt: Date.now(), ttlMs: ttlMs ?? this.defaultTtlMs });
+    this.evictIfNeeded();
+    return hash;
+  }
+  /** Returns the original value for `hash`, or `undefined` if missing/expired. */
+  retrieve(hash) {
+    const entry = this.entries.get(hash);
+    if (!entry) return void 0;
+    if (Date.now() - entry.storedAt > entry.ttlMs) {
+      this.entries.delete(hash);
+      return void 0;
+    }
+    return entry.value;
+  }
+  has(hash) {
+    return this.retrieve(hash) !== void 0;
+  }
+  get size() {
+    return this.entries.size;
+  }
+  evictIfNeeded() {
+    while (this.entries.size > this.maxEntries) {
+      const oldestKey = this.entries.keys().next().value;
+      if (oldestKey === void 0) break;
+      this.entries.delete(oldestKey);
+    }
+  }
+  static hashOf(value) {
+    const serialized = typeof value === "string" ? value : JSON.stringify(value);
+    return crypto.createHash("sha1").update(serialized).digest("hex").slice(0, 16);
+  }
+};
+var DedupTracker = class {
+  constructor() {
+    this.seen = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Registers `content` under `executionId`/`toolName`. Returns the entry
+   * that first produced this exact content, or `undefined` if this is the
+   * first time it has been seen.
+   */
+  checkAndRegister(content, executionId, toolName) {
+    const hash = crypto.createHash("sha1").update(content).digest("hex");
+    const existing = this.seen.get(hash);
+    if (!existing) {
+      this.seen.set(hash, { executionId, toolName });
+    }
+    return existing;
+  }
+};
+
+// src/smart/contextPilot/cacheAligner.ts
+var PATTERNS = [
+  { kind: "uuid", regex: /\b[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}\b/g },
+  { kind: "iso8601", regex: /\b\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:?\d{2})?\b/g },
+  { kind: "jwt", regex: /\beyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\b/g },
+  { kind: "hex_hash", regex: /\b[0-9a-fA-F]{64}\b|\b[0-9a-fA-F]{40}\b|\b[0-9a-fA-F]{32}\b/g },
+  { kind: "api_key", regex: /\b(?:sk|pk|ghp|gho|ghu|ghs)-[A-Za-z0-9]{10,}\b/g },
+  { kind: "unix_timestamp", regex: /\b1\d{12}\b(?!\d)|\b1\d{9}\b(?!\d)/g }
+];
+function detectVolatileContent(text, limit = 20) {
+  if (!text) return [];
+  const findings = [];
+  for (const { kind, regex } of PATTERNS) {
+    regex.lastIndex = 0;
+    let match;
+    while (findings.length < limit && (match = regex.exec(text)) !== null) {
+      findings.push({ pattern: kind, match: match[0], index: match.index });
+      if (regex.lastIndex === match.index) regex.lastIndex += 1;
+    }
+  }
+  return findings;
+}
+
+// src/smart/contextPilot/jsonCrusher.ts
+init_utilTokens();
+
+// src/utils/content.ts
+function contentToString(content) {
+  try {
+    if (content == null) return "";
+    if (typeof content === "string") return content;
+    if (Array.isArray(content)) {
+      return content.map((p) => {
+        if (!p || typeof p !== "object") return String(p);
+        if (p.type === "text") return String(p.text ?? "");
+        if (p.type === "image_url") {
+          const img = p.image_url;
+          const url = typeof img === "string" ? img : img?.url;
+          const detail = typeof img === "string" ? void 0 : img?.detail;
+          return `[image:${url || "unknown"}${detail ? ` detail=${detail}` : ""}]`;
+        }
+        return JSON.stringify(p);
+      }).join("\n");
+    }
+    return JSON.stringify(content);
+  } catch {
+    return String(content);
+  }
+}
+function mergeContentsToString(contents) {
+  return contents.map((c) => contentToString(c)).join("\n");
+}
+function safeStringify(value, pretty = false) {
+  if (value == null) return "";
+  if (typeof value === "string") return value;
+  try {
+    return JSON.stringify(value, null, pretty ? 2 : void 0) ?? String(value);
+  } catch {
+    return String(value);
+  }
+}
+function extractMessageText2(message) {
+  if (!message) return "";
+  const content = message.content;
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) {
+    return content.map((part) => typeof part === "string" ? part : part?.text ?? part?.content ?? "").join("");
+  }
+  return "";
+}
+
+// src/smart/contextPilot/jsonCrusher.ts
+var CONTEXT_PILOT_JSON_MARKER_KEY = "__contextPilotDropped";
+function findCompressibleArray(output, minItems) {
+  if (Array.isArray(output)) {
+    return { array: output, wrap: (arr) => arr };
+  }
+  if (output && typeof output === "object") {
+    let bestKey;
+    let bestArray;
+    for (const [key, value] of Object.entries(output)) {
+      if (Array.isArray(value) && (!bestArray || value.length > bestArray.length)) {
+        bestKey = key;
+        bestArray = value;
+      }
+    }
+    if (bestKey && bestArray && bestArray.length >= minItems) {
+      const key = bestKey;
+      return {
+        array: bestArray,
+        wrap: (arr) => ({ ...output, [key]: arr })
+      };
+    }
+  }
+  return null;
+}
+function notApplied(output) {
+  const tokens = countApproxTokens(safeStringify(output));
+  return { applied: false, compressorUsed: "none", output, originalTokens: tokens, compressedTokens: tokens };
+}
+function compressJsonOutput(output, query, config, ccrStore) {
+  if (!config.enabled) return notApplied(output);
+  const target = findCompressibleArray(output, config.minItems);
+  if (!target || target.array.length < config.minItems) return notApplied(output);
+  const { array, wrap } = target;
+  const itemTexts = array.map((item) => safeStringify(item));
+  const scores = scoreItemsByRelevance(itemTexts, query);
+  const keepCount = Math.max(1, Math.min(array.length, Math.ceil(array.length * config.targetRatio)));
+  const keepIndices = new Set(selectTopIndicesInOrder(scores, keepCount));
+  const droppedCount = array.length - keepIndices.size;
+  if (droppedCount <= 0) return notApplied(output);
+  const originalTokens = countApproxTokens(safeStringify(output));
+  const ccrHash = ccrStore.store(output);
+  const keptItems = array.filter((_item, index) => keepIndices.has(index));
+  const marker = {
+    [CONTEXT_PILOT_JSON_MARKER_KEY]: droppedCount,
+    note: `${droppedCount} lower-relevance item(s) omitted by ContextPilot. Use get_tool_response with executionId="${ccrHash}" to retrieve the full original array if a dropped item is actually needed.`
+  };
+  const compressedOutput = wrap([...keptItems, marker]);
+  const compressedTokens = countApproxTokens(safeStringify(compressedOutput));
+  if (compressedTokens >= originalTokens * 0.9) return notApplied(output);
+  return {
+    applied: true,
+    compressorUsed: "jsonCrusher",
+    output: compressedOutput,
+    originalTokens,
+    compressedTokens,
+    droppedItems: droppedCount,
+    ccrHash
+  };
+}
+
+// src/smart/contextPilot/textCrusher.ts
+init_utilTokens();
+function splitIntoSentences(text) {
+  return text.split(/(?<=[.!?。！？\n])\s*/u).map((sentence) => sentence.trim()).filter(Boolean);
+}
+function normalizeForDedup(sentence) {
+  return sentence.toLowerCase().replace(/\s+/g, " ").trim();
+}
+function notApplied2(text) {
+  const tokens = countApproxTokens(text);
+  return { applied: false, compressorUsed: "none", output: text, originalTokens: tokens, compressedTokens: tokens };
+}
+function compressTextOutput(text, query, config, ccrStore) {
+  if (!config.enabled || text.length < config.minChars) return notApplied2(text);
+  const rawSentences = splitIntoSentences(text);
+  if (rawSentences.length < 6) return notApplied2(text);
+  const seenNormalized = /* @__PURE__ */ new Set();
+  const dedupedIndices = [];
+  rawSentences.forEach((sentence, index) => {
+    const key = normalizeForDedup(sentence);
+    if (seenNormalized.has(key)) return;
+    seenNormalized.add(key);
+    dedupedIndices.push(index);
+  });
+  const relevanceScores = scoreItemsByRelevance(dedupedIndices.map((i) => rawSentences[i]), query);
+  const recencyBoost = dedupedIndices.map((_value, position) => position / Math.max(1, dedupedIndices.length - 1));
+  const combinedScores = relevanceScores.map((score, i) => score + recencyBoost[i] * 0.25);
+  const keepCount = Math.max(3, Math.ceil(dedupedIndices.length * config.targetRatio));
+  const keepPositions = new Set(selectTopIndicesInOrder(combinedScores, keepCount));
+  const keptSentences = dedupedIndices.filter((_index, position) => keepPositions.has(position)).map((i) => rawSentences[i]);
+  const droppedCount = rawSentences.length - keptSentences.length;
+  if (droppedCount <= 0) return notApplied2(text);
+  const originalTokens = countApproxTokens(text);
+  const ccrHash = ccrStore.store(text);
+  const compressedText = `${keptSentences.join(" ")}
+[ContextPilot: ${droppedCount} lower-relevance sentence(s) omitted. Use get_tool_response with executionId="${ccrHash}" to retrieve the full original text.]`;
+  const compressedTokens = countApproxTokens(compressedText);
+  if (compressedTokens >= originalTokens * 0.9) return notApplied2(text);
+  return {
+    applied: true,
+    compressorUsed: "textCrusher",
+    output: compressedText,
+    originalTokens,
+    compressedTokens,
+    droppedItems: droppedCount,
+    ccrHash
+  };
+}
+
+// src/smart/contextPilot/formatCompressors.ts
+init_utilTokens();
+function notApplied3(text) {
+  const tokens = countApproxTokens(text);
+  return { applied: false, compressorUsed: "none", output: text, originalTokens: tokens, compressedTokens: tokens };
+}
+function detectTextFormat(text) {
+  const sample = text.slice(0, 2e3);
+  if (/^diff --git |^---\s|^\+\+\+\s|^@@ -\d+/m.test(sample)) return "diff";
+  if (/^[\w./-]+:\d+:/m.test(sample) || /^[\w./-]+-\d+-/m.test(sample)) return "search";
+  if (/\b(ERROR|FAIL|FAILED|WARN|PASS|PASSED)\b/.test(sample) && text.split("\n").length > 15) return "log";
+  return "text";
+}
+function compressDiffOutput(text, config, ccrStore) {
+  if (!config.enabled) return notApplied3(text);
+  const lines = text.split("\n");
+  const kept = [];
+  let contextRun = 0;
+  let trimmedAny = false;
+  for (const line of lines) {
+    const isHeader = line.startsWith("diff --git") || line.startsWith("---") || line.startsWith("+++") || line.startsWith("@@");
+    const isChange = line.startsWith("+") || line.startsWith("-");
+    if (isHeader || isChange) {
+      kept.push(line);
+      contextRun = 0;
+      continue;
+    }
+    if (contextRun < config.contextLines) {
+      kept.push(line);
+      contextRun += 1;
+    } else {
+      trimmedAny = true;
+    }
+  }
+  if (!trimmedAny) return notApplied3(text);
+  const originalTokens = countApproxTokens(text);
+  const ccrHash = ccrStore.store(text);
+  const compressedText = `${kept.join("\n")}
+[ContextPilot: unchanged context lines beyond ${config.contextLines} trimmed. Use get_tool_response with executionId="${ccrHash}" to retrieve the full diff.]`;
+  const compressedTokens = countApproxTokens(compressedText);
+  if (compressedTokens >= originalTokens * 0.9) return notApplied3(text);
+  return { applied: true, compressorUsed: "diffCompressor", output: compressedText, originalTokens, compressedTokens, ccrHash };
+}
+var LOG_LEVEL_SCORE = [
+  { regex: /\b(FAIL|FAILED|ERROR|FATAL|EXCEPTION|TRACEBACK)\b/i, score: 1 },
+  { regex: /\b(WARN|WARNING)\b/i, score: 0.7 },
+  { regex: /\b(PASS|PASSED|OK|SUCCESS)\b/i, score: 0.4 },
+  { regex: /\bINFO\b/i, score: 0.3 },
+  { regex: /\b(DEBUG|TRACE)\b/i, score: 0.1 }
+];
+function scoreLogLine(line) {
+  for (const { regex, score } of LOG_LEVEL_SCORE) {
+    if (regex.test(line)) return score;
+  }
+  return 0.2;
+}
+function compressLogOutput(text, config, ccrStore) {
+  if (!config.enabled) return notApplied3(text);
+  const lines = text.split("\n").filter((line) => line.length > 0);
+  if (lines.length <= config.maxLines) return notApplied3(text);
+  const scored = lines.map((line, index) => ({ line, index, score: scoreLogLine(line) }));
+  const mustKeep = /* @__PURE__ */ new Set([0, lines.length - 1]);
+  const ranked = scored.filter((entry) => !mustKeep.has(entry.index)).sort((a, b) => b.score - a.score).slice(0, Math.max(0, config.maxLines - mustKeep.size)).map((entry) => entry.index);
+  const keepIndices = /* @__PURE__ */ new Set([...mustKeep, ...ranked]);
+  const droppedCount = lines.length - keepIndices.size;
+  if (droppedCount <= 0) return notApplied3(text);
+  const originalTokens = countApproxTokens(text);
+  const ccrHash = ccrStore.store(text);
+  const keptLines = lines.filter((_line, index) => keepIndices.has(index));
+  const compressedText = `${keptLines.join("\n")}
+[ContextPilot: ${droppedCount} lower-priority log line(s) omitted (errors/warnings preserved). Use get_tool_response with executionId="${ccrHash}" to retrieve the full log.]`;
+  const compressedTokens = countApproxTokens(compressedText);
+  if (compressedTokens >= originalTokens * 0.9) return notApplied3(text);
+  return { applied: true, compressorUsed: "logCompressor", output: compressedText, originalTokens, compressedTokens, droppedItems: droppedCount, ccrHash };
+}
+function compressSearchOutput(text, config, ccrStore) {
+  if (!config.enabled) return notApplied3(text);
+  const lines = text.split("\n").filter((line) => line.length > 0);
+  if (lines.length <= config.maxMatches) return notApplied3(text);
+  const perFileCount = /* @__PURE__ */ new Map();
+  const perFileCap = Math.max(3, Math.ceil(config.maxMatches / 4));
+  const kept = [];
+  for (const line of lines) {
+    if (kept.length >= config.maxMatches) break;
+    const fileKey = line.split(/[:-]/)[0] || "unknown";
+    const count = perFileCount.get(fileKey) || 0;
+    if (count >= perFileCap) continue;
+    perFileCount.set(fileKey, count + 1);
+    kept.push(line);
+  }
+  const droppedCount = lines.length - kept.length;
+  if (droppedCount <= 0) return notApplied3(text);
+  const originalTokens = countApproxTokens(text);
+  const ccrHash = ccrStore.store(text);
+  const compressedText = `${kept.join("\n")}
+[ContextPilot: ${droppedCount} additional match(es) omitted. Use get_tool_response with executionId="${ccrHash}" to retrieve all matches.]`;
+  const compressedTokens = countApproxTokens(compressedText);
+  if (compressedTokens >= originalTokens * 0.9) return notApplied3(text);
+  return { applied: true, compressorUsed: "searchCompressor", output: compressedText, originalTokens, compressedTokens, droppedItems: droppedCount, ccrHash };
+}
+
+// src/smart/contextPilot/pipeline.ts
+init_utilTokens();
+function createContextPilotRuntime(config) {
+  return {
+    ccrStore: new CCRStore({ ttlMs: config.ccr.ttlMs, maxEntries: config.ccr.maxEntries }),
+    dedupTracker: new DedupTracker()
+  };
+}
+function extractLatestUserQuery(messages) {
+  if (!Array.isArray(messages)) return "";
+  for (let i = messages.length - 1; i >= 0; i -= 1) {
+    const message = messages[i];
+    if (message?.role !== "user") continue;
+    if (typeof message.content === "string") return message.content;
+    if (Array.isArray(message.content)) {
+      return message.content.map((part) => typeof part?.text === "string" ? part.text : "").filter(Boolean).join(" ");
+    }
+  }
+  return "";
+}
+function notApplied4(output) {
+  const tokens = countApproxTokens(safeStringify(output));
+  return { applied: false, compressorUsed: "none", output, originalTokens: tokens, compressedTokens: tokens };
+}
+function compressToolOutput(params) {
+  const { toolName, output, query, executionId, config, runtime } = params;
+  if (!config.enabled || config.excludeTools.includes(toolName)) return notApplied4(output);
+  const ccrAvailable = config.ccr.enabled && config.ccr.maxEntries > 0;
+  if (config.dedup.enabled) {
+    const serialized = typeof output === "string" ? output : safeStringify(output);
+    if (serialized.length >= config.dedup.minChars) {
+      const duplicate = runtime.dedupTracker.checkAndRegister(serialized, executionId, toolName);
+      if (duplicate) {
+        const originalTokens = countApproxTokens(serialized);
+        const pointer = `DUPLICATE_TOOL_RESPONSE [toolName=${toolName}]
+Identical to an earlier ${duplicate.toolName} result. Use get_tool_response with executionId="${duplicate.executionId}" to view it.`;
+        return {
+          applied: true,
+          compressorUsed: "none",
+          output: pointer,
+          originalTokens,
+          compressedTokens: countApproxTokens(pointer),
+          duplicateOf: duplicate.executionId
+        };
+      }
+    }
+  }
+  if (typeof output !== "string") {
+    if (ccrAvailable && config.compression.json.enabled) {
+      const result = compressJsonOutput(output, query, config.compression.json, runtime.ccrStore);
+      if (result.applied) return result;
+    }
+    return notApplied4(output);
+  }
+  const format = detectTextFormat(output);
+  if (ccrAvailable && format === "diff" && config.compression.diff.enabled) {
+    const result = compressDiffOutput(output, config.compression.diff, runtime.ccrStore);
+    if (result.applied) return result;
+  } else if (ccrAvailable && format === "log" && config.compression.log.enabled) {
+    const result = compressLogOutput(output, config.compression.log, runtime.ccrStore);
+    if (result.applied) return result;
+  } else if (ccrAvailable && format === "search" && config.compression.search.enabled) {
+    const result = compressSearchOutput(output, config.compression.search, runtime.ccrStore);
+    if (result.applied) return result;
+  }
+  if (ccrAvailable && config.compression.text.enabled) {
+    const result = compressTextOutput(output, query, config.compression.text, runtime.ccrStore);
+    if (result.applied) return result;
+  }
+  return notApplied4(output);
+}
+
 // src/nodes/agentCore.ts
 function createAgentCoreNode(opts) {
   return async (state) => {
@@ -2082,6 +2820,42 @@ function createAgentCoreNode(opts) {
     const streamingEnabled = Boolean(state.ctx?.__streaming);
     const cancellationToken = state.ctx?.__cancellationToken;
     const abortSignal = state.ctx?.__abortSignal;
+    const resolvedForCachePilot = getResolvedSmartConfig(opts, runtime);
+    if (resolvedForCachePilot.contextPilot.enabled && resolvedForCachePilot.contextPilot.cacheAlignment.enabled) {
+      const ctxForCacheWarning = state.ctx = state.ctx || {};
+      if (!ctxForCacheWarning.__contextPilotCacheWarned) {
+        const systemMessages = (state.messages || []).filter((m) => m?.role === "system");
+        const systemText = systemMessages.map((m) => typeof m.content === "string" ? m.content : "").join("\n");
+        const findings = detectVolatileContent(systemText);
+        if (findings.length > 0) {
+          ctxForCacheWarning.__contextPilotCacheWarned = true;
+          if (resolvedForCachePilot.contextPilot.cacheAlignment.warnOnVolatilePrompt) {
+            const patternCounts = findings.reduce((acc, finding) => {
+              acc[finding.pattern] = (acc[finding.pattern] || 0) + 1;
+              return acc;
+            }, {});
+            onEvent?.({
+              type: "metadata",
+              reason: "context_pilot_cache_alignment",
+              message: "Volatile content detected in system prompt; this may defeat provider-side prompt caching.",
+              patternCounts
+            });
+            recordTraceEvent(traceSession, {
+              type: "metadata",
+              label: "ContextPilot: volatile system prompt content",
+              actor: { scope: "agent", name: actorName, role: "agent" },
+              sections: [
+                {
+                  kind: "metadata",
+                  label: "Volatile content findings",
+                  data: { patternCounts, totalFindings: findings.length }
+                }
+              ]
+            });
+          }
+        }
+      }
+    }
     const responseFormat = runtime.responseFormat;
     const reasoningForCall = state.ctx?.__reasoning;
     const reasoningInvokeOpts = reasoningForCall ? { reasoning: reasoningForCall } : void 0;
@@ -2176,68 +2950,23 @@ function createAgentCoreNode(opts) {
       const id = `${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
       const turn = usageState.perRequest.length + 1;
       const timestamp = (/* @__PURE__ */ new Date()).toISOString();
-      const cachedInputTok = normalized.prompt_tokens_details?.cached_tokens;
-      usageState.perRequest.push({ id, modelName, usage: normalized, timestamp, turn, cachedInput: cachedInputTok });
-      const inputTok = normalized.prompt_tokens;
-      const outputTok = normalized.completion_tokens;
-      const totalTok = normalized.total_tokens;
-      const key = modelName;
-      const agg = usageState.totals[key] || { input: 0, output: 0, total: 0, cachedInput: 0 };
-      usageState.totals[key] = {
-        input: agg.input + (Number(inputTok) || 0),
-        output: agg.output + (Number(outputTok) || 0),
-        total: agg.total + (Number(totalTok) || 0),
-        cachedInput: agg.cachedInput + (Number(cachedInputTok) || 0)
-      };
-      state.usage = usageState;
-    }
-    return { messages: messagesWithResponse, usage: state.usage };
-  };
-}
-
-// src/utils/content.ts
-function contentToString(content) {
-  try {
-    if (content == null) return "";
-    if (typeof content === "string") return content;
-    if (Array.isArray(content)) {
-      return content.map((p) => {
-        if (!p || typeof p !== "object") return String(p);
-        if (p.type === "text") return String(p.text ?? "");
-        if (p.type === "image_url") {
-          const img = p.image_url;
-          const url = typeof img === "string" ? img : img?.url;
-          const detail = typeof img === "string" ? void 0 : img?.detail;
-          return `[image:${url || "unknown"}${detail ? ` detail=${detail}` : ""}]`;
-        }
-        return JSON.stringify(p);
-      }).join("\n");
+      const cachedInputTok = normalized.prompt_tokens_details?.cached_tokens;
+      usageState.perRequest.push({ id, modelName, usage: normalized, timestamp, turn, cachedInput: cachedInputTok });
+      const inputTok = normalized.prompt_tokens;
+      const outputTok = normalized.completion_tokens;
+      const totalTok = normalized.total_tokens;
+      const key = modelName;
+      const agg = usageState.totals[key] || { input: 0, output: 0, total: 0, cachedInput: 0 };
+      usageState.totals[key] = {
+        input: agg.input + (Number(inputTok) || 0),
+        output: agg.output + (Number(outputTok) || 0),
+        total: agg.total + (Number(totalTok) || 0),
+        cachedInput: agg.cachedInput + (Number(cachedInputTok) || 0)
+      };
+      state.usage = usageState;
     }
-    return JSON.stringify(content);
-  } catch {
-    return String(content);
-  }
-}
-function mergeContentsToString(contents) {
-  return contents.map((c) => contentToString(c)).join("\n");
-}
-function safeStringify(value, pretty = false) {
-  if (value == null) return "";
-  if (typeof value === "string") return value;
-  try {
-    return JSON.stringify(value, null, pretty ? 2 : void 0) ?? String(value);
-  } catch {
-    return String(value);
-  }
-}
-function extractMessageText(message) {
-  if (!message) return "";
-  const content = message.content;
-  if (typeof content === "string") return content;
-  if (Array.isArray(content)) {
-    return content.map((part) => typeof part === "string" ? part : part?.text ?? part?.content ?? "").join("");
-  }
-  return "";
+    return { messages: messagesWithResponse, usage: state.usage };
+  };
 }
 
 // src/utils/traceSections.ts
@@ -2278,217 +3007,6 @@ function extractToolItems(output) {
   });
 }
 
-// src/smart/runtimeConfig.ts
-var DEFAULT_CRITICAL_TOOLS = ["response", "manage_todo_list", "get_tool_response"];
-var BASE_DEFAULTS = {
-  limits: { maxToolCalls: 20, maxParallelTools: 5, maxContextTokens: 96e3, maxTotalOutputTokens: 0, maxCostUsd: 0, maxWallClockMs: 0 },
-  summarization: {
-    enable: true,
-    maxTokens: 96e3,
-    summaryTriggerTokens: 72e3,
-    summaryPromptMaxTokens: 12e3,
-    summaryCompressionRatioTarget: 0.45,
-    summaryMode: "incremental",
-    promptTemplate: "",
-    toolFreeCall: true,
-    integrityCheck: true
-  },
-  context: {
-    policy: "hybrid",
-    lastTurnsToKeep: 16,
-    toolResponsePolicy: "summarize_archive",
-    budget: {
-      systemReserveTokens: 2e3,
-      goalsReserveTokens: 2e3,
-      recentTurnsReserveTokens: 18e3,
-      toolResponseReserveTokens: 9e3
-    }
-  },
-  planning: {
-    mode: "off",
-    replanPolicy: "on_failure",
-    everyNSteps: 0
-  },
-  memory: {
-    provider: "inMemory",
-    scope: "session",
-    writePolicy: "auto_important",
-    readPolicy: "hybrid"
-  },
-  delegation: {
-    mode: "role_based",
-    maxDelegationDepth: 2,
-    maxChildCalls: 6,
-    maxParallelChild: 3,
-    childContextPolicy: "scoped",
-    requireJsonOutputContract: true
-  },
-  toolResponses: {
-    maxToolResponseChars: 32e3,
-    maxToolResponseTokens: 8e3,
-    defaultPolicy: "summarize_archive",
-    toolResponseRetentionByTool: {},
-    criticalTools: [...DEFAULT_CRITICAL_TOOLS],
-    schemaValidation: "strict"
-  }
-};
-function buildProfile(overrides) {
-  return {
-    limits: { ...BASE_DEFAULTS.limits, ...overrides.limits },
-    summarization: { ...BASE_DEFAULTS.summarization, ...overrides.summarization },
-    context: {
-      ...BASE_DEFAULTS.context,
-      ...overrides.context,
-      budget: { ...BASE_DEFAULTS.context.budget, ...overrides.context?.budget }
-    },
-    planning: { ...BASE_DEFAULTS.planning, ...overrides.planning },
-    memory: { ...BASE_DEFAULTS.memory, ...overrides.memory },
-    delegation: { ...BASE_DEFAULTS.delegation, ...overrides.delegation },
-    toolResponses: {
-      ...BASE_DEFAULTS.toolResponses,
-      ...overrides.toolResponses,
-      criticalTools: overrides.toolResponses?.criticalTools ?? [...DEFAULT_CRITICAL_TOOLS],
-      toolResponseRetentionByTool: overrides.toolResponses?.toolResponseRetentionByTool ?? {}
-    }
-  };
-}
-var DEFAULT_PROFILE_CONFIGS = {
-  fast: buildProfile({
-    limits: { maxToolCalls: 8, maxParallelTools: 3, maxContextTokens: 32e3 },
-    summarization: {
-      maxTokens: 32e3,
-      summaryTriggerTokens: 24e3,
-      summaryPromptMaxTokens: 6e3,
-      summaryCompressionRatioTarget: 0.5
-    },
-    context: {
-      lastTurnsToKeep: 8,
-      toolResponsePolicy: "keep_structured",
-      budget: { systemReserveTokens: 1500, goalsReserveTokens: 1200, recentTurnsReserveTokens: 6e3, toolResponseReserveTokens: 3500 }
-    },
-    memory: { readPolicy: "recent_only" },
-    delegation: { mode: "off", maxDelegationDepth: 1, maxChildCalls: 2, maxParallelChild: 1, childContextPolicy: "minimal" },
-    toolResponses: { maxToolResponseChars: 16e3, maxToolResponseTokens: 4e3 }
-  }),
-  balanced: buildProfile({}),
-  deep: buildProfile({
-    limits: { maxToolCalls: 40, maxParallelTools: 8, maxContextTokens: 2e5 },
-    summarization: {
-      maxTokens: 2e5,
-      summaryTriggerTokens: 15e4,
-      summaryPromptMaxTokens: 16e3,
-      summaryCompressionRatioTarget: 0.4
-    },
-    context: {
-      lastTurnsToKeep: 30,
-      budget: { systemReserveTokens: 2500, goalsReserveTokens: 2500, recentTurnsReserveTokens: 36e3, toolResponseReserveTokens: 18e3 }
-    },
-    memory: { scope: "workspace" },
-    delegation: { maxDelegationDepth: 3, maxChildCalls: 10, maxParallelChild: 4 },
-    toolResponses: { maxToolResponseChars: 64e3, maxToolResponseTokens: 16e3 }
-  }),
-  research: buildProfile({
-    limits: { maxToolCalls: 80, maxParallelTools: 10, maxContextTokens: 4e5 },
-    summarization: {
-      maxTokens: 4e5,
-      summaryTriggerTokens: 3e5,
-      summaryPromptMaxTokens: 24e3,
-      summaryCompressionRatioTarget: 0.35
-    },
-    context: {
-      lastTurnsToKeep: 60,
-      budget: { systemReserveTokens: 3e3, goalsReserveTokens: 3e3, recentTurnsReserveTokens: 72e3, toolResponseReserveTokens: 32e3 }
-    },
-    memory: { scope: "workspace" },
-    delegation: { mode: "automatic", maxDelegationDepth: 4, maxChildCalls: 16, maxParallelChild: 6, childContextPolicy: "full" },
-    toolResponses: { maxToolResponseChars: 96e3, maxToolResponseTokens: 24e3 }
-  })
-};
-function mergeLimits(base, override) {
-  return {
-    maxToolCalls: override?.maxToolCalls ?? base.maxToolCalls,
-    maxParallelTools: override?.maxParallelTools ?? base.maxParallelTools,
-    maxContextTokens: override?.maxContextTokens ?? base.maxContextTokens,
-    maxTotalOutputTokens: override?.maxTotalOutputTokens ?? base.maxTotalOutputTokens ?? 0,
-    maxCostUsd: override?.maxCostUsd ?? base.maxCostUsd ?? 0,
-    maxWallClockMs: override?.maxWallClockMs ?? base.maxWallClockMs ?? 0
-  };
-}
-function resolveBaseProfile(opts, runtimeProfile) {
-  if (opts.customProfile?.extends) return opts.customProfile.extends;
-  if (runtimeProfile !== "custom") return runtimeProfile;
-  return "balanced";
-}
-function normalizeSmartAgentOptions(opts) {
-  const runtimeProfile = opts.runtimeProfile ?? (opts.customProfile ? "custom" : "balanced");
-  const baseProfile = resolveBaseProfile(opts, runtimeProfile);
-  const preset = DEFAULT_PROFILE_CONFIGS[baseProfile];
-  const customProfile = opts.customProfile || {};
-  const useTodoList = opts.useTodoList === true;
-  const summarizationDisabled = opts.summarization === false;
-  const summarizationOverride = typeof opts.summarization === "object" ? opts.summarization : {};
-  const planningMode = opts.planning?.mode ?? customProfile.planning?.mode ?? (useTodoList ? "todo" : preset.planning.mode);
-  const memoryStore = opts.memory?.store ?? customProfile.memory?.store;
-  const contextToolResponsePolicy = opts.context?.toolResponsePolicy ?? customProfile.context?.toolResponsePolicy ?? preset.context.toolResponsePolicy;
-  return {
-    runtimeProfile,
-    baseProfile,
-    limits: mergeLimits(mergeLimits(preset.limits, customProfile.limits), opts.limits),
-    summarization: {
-      ...preset.summarization,
-      ...customProfile.summarization || {},
-      ...summarizationOverride,
-      enable: summarizationDisabled ? false : summarizationOverride.enable ?? customProfile.summarization?.enable ?? preset.summarization.enable,
-      maxTokens: summarizationOverride.maxTokens ?? opts.limits?.maxContextTokens ?? customProfile.summarization?.maxTokens ?? preset.summarization.maxTokens,
-      summaryTriggerTokens: summarizationOverride.summaryTriggerTokens ?? summarizationOverride.maxTokens ?? opts.limits?.maxContextTokens ?? customProfile.summarization?.summaryTriggerTokens ?? customProfile.summarization?.maxTokens ?? preset.summarization.summaryTriggerTokens,
-      promptTemplate: summarizationOverride.promptTemplate ?? customProfile.summarization?.promptTemplate ?? preset.summarization.promptTemplate
-    },
-    context: {
-      ...preset.context,
-      ...customProfile.context || {},
-      ...opts.context || {},
-      budget: {
-        ...preset.context.budget,
-        ...customProfile.context?.budget || {},
-        ...opts.context?.budget || {}
-      },
-      toolResponsePolicy: contextToolResponsePolicy
-    },
-    planning: {
-      ...preset.planning,
-      ...customProfile.planning || {},
-      ...opts.planning || {},
-      mode: planningMode
-    },
-    memory: {
-      ...preset.memory,
-      ...customProfile.memory || {},
-      ...opts.memory || {},
-      store: memoryStore
-    },
-    delegation: {
-      ...preset.delegation,
-      ...customProfile.delegation || {},
-      ...opts.delegation || {}
-    },
-    toolResponses: {
-      ...preset.toolResponses,
-      ...customProfile.toolResponses || {},
-      ...opts.toolResponses || {},
-      defaultPolicy: opts.toolResponses?.defaultPolicy ?? customProfile.toolResponses?.defaultPolicy ?? contextToolResponsePolicy,
-      toolResponseRetentionByTool: {
-        ...preset.toolResponses.toolResponseRetentionByTool,
-        ...customProfile.toolResponses?.toolResponseRetentionByTool || {},
-        ...opts.toolResponses?.toolResponseRetentionByTool || {}
-      },
-      criticalTools: opts.toolResponses?.criticalTools ?? customProfile.toolResponses?.criticalTools ?? preset.toolResponses.criticalTools
-    }
-  };
-}
-function getResolvedSmartConfig(opts, runtime) {
-  return runtime?.smart || normalizeSmartAgentOptions(opts);
-}
-
 // src/smart/toolResponses.ts
 init_utilTokens();
 function summarizeObject(value) {
@@ -2730,6 +3248,23 @@ function createToolsNode(initialTools, opts) {
       outputSchema: opts?.outputSchema
     };
     const resolved = getResolvedSmartConfig(opts || {}, runtime);
+    const contextPilotRuntime = state.ctx?.__contextPilot;
+    const contextPilotQuery = contextPilotRuntime ? extractLatestUserQuery(state.messages) : "";
+    const maybeCompressToolOutput = (toolNameForCompression, rawValue, executionIdForCompression) => {
+      if (!contextPilotRuntime || !resolved.contextPilot.enabled) return { output: rawValue };
+      if (resolved.toolResponses.criticalTools.includes(toolNameForCompression)) return { output: rawValue };
+      const result = compressToolOutput({
+        toolName: toolNameForCompression,
+        output: rawValue,
+        query: contextPilotQuery,
+        executionId: executionIdForCompression,
+        config: resolved.contextPilot,
+        runtime: contextPilotRuntime
+      });
+      if (!result.applied) return { output: rawValue };
+      const { output: compressedValue, ...stats } = result;
+      return { output: compressedValue, stats };
+    };
     const activeTools = runtime.tools;
     const toolByName = /* @__PURE__ */ new Map();
     for (const tool of activeTools) toolByName.set(tool.name, tool);
@@ -2967,12 +3502,13 @@ function createToolsNode(initialTools, opts) {
       try {
         if (cachedHit !== void 0) {
           const executionId2 = nanoid.nanoid();
-          const responsePolicy2 = applyToolResponseHardCap(toolName, cachedHit, executionId2, resolved);
+          const { output: compressedCachedHit, stats: cachedContextPilotStats } = maybeCompressToolOutput(toolName, cachedHit, executionId2);
+          const responsePolicy2 = applyToolResponseHardCap(toolName, compressedCachedHit, executionId2, resolved);
           toolHistory.push({
             executionId: executionId2,
             toolName,
             args,
-            output: cachedHit,
+            output: compressedCachedHit,
             rawOutput: cachedHit,
             timestamp: (/* @__PURE__ */ new Date()).toISOString(),
             tool_call_id: tc.id,
@@ -2981,7 +3517,8 @@ function createToolsNode(initialTools, opts) {
             classification: responsePolicy2.classification,
             retentionPolicy: "keep_full",
             fromCache: true,
-            status: "success"
+            status: "success",
+            contextPilot: cachedContextPilotStats
           });
           push({ role: "tool", content: responsePolicy2.content, tool_call_id: tc.id || `${tc.name}_${toolCount}`, name: tc.name });
           onEvent?.({ type: "tool_call", phase: "success", name: toolName, id: tc.id, args, result: cachedHit, durationMs: 0 });
@@ -3014,7 +3551,8 @@ function createToolsNode(initialTools, opts) {
               retentionPolicy: "keep_full",
               originalTokenCount: responsePolicy2.tokenCount,
               truncated: responsePolicy2.truncated,
-              fromCache: true
+              fromCache: true,
+              contextPilot: cachedContextPilotStats
             }
           });
           toolCount += 1;
@@ -3119,13 +3657,14 @@ function createToolsNode(initialTools, opts) {
           state.ctx.__structuredOutputParsed = output.data;
           state.ctx.__finalizedDueToStructuredOutput = true;
         }
-        const responsePolicy = applyToolResponseHardCap(toolName, output, executionId, resolved);
+        const { output: compressedOutput, stats: contextPilotStats } = maybeCompressToolOutput(toolName, output, executionId);
+        const responsePolicy = applyToolResponseHardCap(toolName, compressedOutput, executionId, resolved);
         const timestamp = (/* @__PURE__ */ new Date()).toISOString();
         toolHistory.push({
           executionId,
           toolName,
           args,
-          output,
+          output: compressedOutput,
           rawOutput: output,
           timestamp,
           tool_call_id: tc.id,
@@ -3135,7 +3674,8 @@ function createToolsNode(initialTools, opts) {
           retentionPolicy: "keep_full",
           summary: void 0,
           archiveId: void 0,
-          status: "success"
+          status: "success",
+          contextPilot: contextPilotStats
         });
         push({ role: "tool", content: responsePolicy.content, tool_call_id: tc.id || `${tc.name}_${toolCount}`, name: tc.name });
         onEvent?.({ type: "tool_call", phase: "success", name: toolName, id: tc.id, args, result: output, durationMs });
@@ -3173,7 +3713,8 @@ function createToolsNode(initialTools, opts) {
             classification: responsePolicy.classification,
             retentionPolicy: "keep_full",
             originalTokenCount: responsePolicy.tokenCount,
-            truncated: responsePolicy.truncated
+            truncated: responsePolicy.truncated,
+            contextPilot: contextPilotStats
           }
         });
         toolCount += 1;
@@ -3812,7 +4353,8 @@ var DISALLOWED_CTX_KEYS = /* @__PURE__ */ new Set([
   "__traceSession",
   "__paused",
   "__cancellationToken",
-  "__abortSignal"
+  "__abortSignal",
+  "__contextPilot"
 ]);
 var clone = (value) => {
   if (typeof globalThis.structuredClone === "function") {
@@ -4763,7 +5305,7 @@ function createAgent(opts) {
       if (toolCalls.length === 0) {
         if (soManager && !state.ctx?.__finalizedDueToStructuredOutput && !state.ctx?.__structuredOutputForceFinalize) {
           if (soManager.strategy.kind === "native") {
-            const assistantText = extractMessageText(lastMsg);
+            const assistantText = extractMessageText2(lastMsg);
             if (assistantText) {
               const parsed = soManager.parseFromContent(assistantText);
               if (parsed.success) {
@@ -4816,7 +5358,7 @@ function createAgent(opts) {
     if (soManager && !state.ctx?.__finalizedDueToStructuredOutput) {
       const lastForParse = state.messages[state.messages.length - 1];
       if (lastForParse?.role === "assistant") {
-        const assistantText = extractMessageText(lastForParse);
+        const assistantText = extractMessageText2(lastForParse);
         if (assistantText) {
           const parsed = soManager.parseFromContent(assistantText);
           if (parsed.success) {
@@ -4925,6 +5467,10 @@ function createAgent(opts) {
     if (config?.timeoutMs && config.timeoutMs > 0) {
       ctx.__deadline = Date.now() + config.timeoutMs;
     }
+    if (!ctx.__contextPilot) {
+      const resolvedForContextPilot = getResolvedSmartConfig(opts, runtime);
+      ctx.__contextPilot = createContextPilotRuntime(resolvedForContextPilot.contextPilot);
+    }
     const runtimeWithInvokeLimits = config?.limits ? { ...runtime, limits: { ...runtime.limits || {}, ...config.limits } } : runtime;
     const initial = {
       messages: input.messages || [],
@@ -4969,7 +5515,7 @@ function createAgent(opts) {
     const isTransientSummarizationExit = !!res.ctx?.__needsSummarization;
     const finalAssistantMsg = isTransientSummarizationExit ? void 0 : getLastAssistantMessage(res.messages);
     const finalIsSyntheticSummary = !isTransientSummarizationExit && finalAssistantMsg && isSyntheticSummaryMessage(finalAssistantMsg);
-    const content = isTransientSummarizationExit || finalIsSyntheticSummary ? "" : extractMessageText(finalAssistantMsg);
+    const content = isTransientSummarizationExit || finalIsSyntheticSummary ? "" : extractMessageText2(finalAssistantMsg);
     let parsed = void 0;
     let outputError = void 0;
     if (soManager) {
@@ -5278,7 +5824,7 @@ function renderMemoryBlock(facts) {
 function clampToBudget(messages, maxContextTokens) {
   let working = [...messages];
   while (working.length > 2) {
-    const tokenCount = countApproxTokens(working.map(extractMessageText).join("\n"));
+    const tokenCount = countApproxTokens(working.map(extractMessageText2).join("\n"));
     if (tokenCount <= maxContextTokens) return working;
     const firstNonSystem = working.findIndex((message, index) => !(index === 0 && message.role === "system"));
     if (firstNonSystem < 0) break;
@@ -6151,6 +6697,13 @@ function createGetToolResponseTool(stateRef) {
       if (execution) {
         return execution.rawOutput || execution.output;
       }
+      const ccrStore = stateRef.ctx?.__contextPilot?.ccrStore;
+      if (ccrStore && typeof ccrStore.retrieve === "function") {
+        const recovered = ccrStore.retrieve(executionId);
+        if (recovered !== void 0) {
+          return recovered;
+        }
+      }
       return "Execution not found. Please check the executionId.";
     }
   });
@@ -7082,7 +7635,7 @@ function createSmartAgent(opts) {
   ].join("\n");
   function latestUserPrompt(messages) {
     const latest = [...messages].reverse().find((message) => message.role === "user");
-    return latest ? extractMessageText(latest) : "";
+    return latest ? extractMessageText2(latest) : "";
   }
   async function syncMemory(state) {
     const query = latestUserPrompt(state.messages || []);
@@ -10189,10 +10742,13 @@ exports.AnthropicProvider = AnthropicProvider;
 exports.AzureProvider = AzureProvider;
 exports.BaseProvider = BaseProvider;
 exports.BedrockProvider = BedrockProvider;
+exports.CCRStore = CCRStore;
+exports.CONTEXT_PILOT_JSON_MARKER_KEY = CONTEXT_PILOT_JSON_MARKER_KEY;
 exports.DEFAULT_PROFILE_CONFIGS = DEFAULT_PROFILE_CONFIGS;
 exports.DEFAULT_SKILL_POLICY = DEFAULT_SKILL_POLICY;
 exports.DEFAULT_SUBAGENT_POLICY = DEFAULT_SUBAGENT_POLICY;
 exports.DEFAULT_SUBAGENT_TOOL_NAMES = DEFAULT_SUBAGENT_TOOL_NAMES;
+exports.DedupTracker = DedupTracker;
 exports.GuardrailPhase = GuardrailPhase;
 exports.InMemoryMemoryStore = InMemoryMemoryStore;
 exports.NativeJsonSchemaStrategy = NativeJsonSchemaStrategy;
@@ -10214,6 +10770,12 @@ exports.captureSnapshot = captureSnapshot;
 exports.codePresenceRule = codePresenceRule;
 exports.cognipeerSink = cognipeerSink;
 exports.composeToolSets = composeToolSets;
+exports.compressDiffOutput = compressDiffOutput;
+exports.compressJsonOutput = compressJsonOutput;
+exports.compressLogOutput = compressLogOutput;
+exports.compressSearchOutput = compressSearchOutput;
+exports.compressTextOutput = compressTextOutput;
+exports.compressToolOutput = compressToolOutput;
 exports.countApproxTokens = countApproxTokens;
 exports.countMessagesTokens = countMessagesTokens;
 exports.createAgent = createAgent;
@@ -10221,6 +10783,7 @@ exports.createAgentNode = createAgentNode;
 exports.createAskUserQuestionTool = createAskUserQuestionTool;
 exports.createBindSkillToolsTool = createBindSkillToolsTool;
 exports.createCodeGuardrail = createCodeGuardrail;
+exports.createContextPilotRuntime = createContextPilotRuntime;
 exports.createContextSummarizeNode = createContextSummarizeNode;
 exports.createContextTools = createContextTools;
 exports.createDelegateTool = createDelegateTool;
@@ -10246,8 +10809,11 @@ exports.customCallbackRule = customCallbackRule;
 exports.customSink = customSink;
 exports.dedupeToolsByName = dedupeToolsByName;
 exports.defaultTokenCounter = defaultTokenCounter;
+exports.detectTextFormat = detectTextFormat;
+exports.detectVolatileContent = detectVolatileContent;
 exports.emptyUsage = emptyUsage;
 exports.evaluateGuardrails = evaluateGuardrails;
+exports.extractLatestUserQuery = extractLatestUserQuery;
 exports.fileSink = fileSink;
 exports.findSubagent = findSubagent;
 exports.formatZodError = formatZodError;
@@ -10280,9 +10846,12 @@ exports.resolveToolApprovalState = resolveToolApprovalState;
 exports.resolveUserQuestionState = resolveUserQuestionState;
 exports.restoreSnapshot = restoreSnapshot;
 exports.runSmartAgentEvalHarness = runSmartAgentEvalHarness;
+exports.scoreItemsByRelevance = scoreItemsByRelevance;
 exports.seedChildMessages = seedChildMessages;
+exports.selectTopIndicesInOrder = selectTopIndicesInOrder;
 exports.setTokenCounter = setTokenCounter;
 exports.startStreamingSession = startStreamingSession;
+exports.tokenize = tokenize;
 exports.traceSessionToOtlp = traceSessionToOtlp;
 exports.validateReasoningConfig = validateReasoningConfig;
 exports.withTools = withTools;