@cognipeer/agent-sdk 0.8.0 → 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,301 +1950,6 @@ function estimatePayloadBytes(value) {
   }
 }
 
-// src/nodes/agentCore.ts
-function createAgentCoreNode(opts) {
-  return async (state) => {
-    const runtime = state.agent || {
-      name: opts.name,
-      version: opts.version,
-      model: opts.model,
-      tools: opts.tools || [],
-      guardrails: opts.guardrails,
-      todoListPrompt: opts.todoListPrompt,
-      limits: opts.limits,
-      outputSchema: opts.outputSchema,
-      tracing: opts.tracing,
-      responseFormat: void 0
-    };
-    const tools = runtime.tools ?? [];
-    const shouldUseStrictToolCalling = Boolean(
-      runtime.responseFormat && runtime.model?.capabilities?.strictToolCalling
-    );
-    const modelWithTools = runtime.model?.bindTools ? runtime.model.bindTools(
-      tools,
-      shouldUseStrictToolCalling ? { strict: true } : void 0
-    ) : runtime.model;
-    const traceSession = state.ctx?.__traceSession;
-    const actorName = runtime.name ?? opts.name ?? "agent";
-    const actorVersion = runtime.version ?? opts.version;
-    const start = Date.now();
-    const shouldLogPrompt = !!traceSession && traceSession.resolvedConfig.logData;
-    const promptPayload = shouldLogPrompt ? sanitizeTracePayload(state.messages) : void 0;
-    const promptBytes = promptPayload !== void 0 ? estimatePayloadBytes(promptPayload) : void 0;
-    const extractToolUses = (m) => {
-      const tcs = m?.tool_calls || m?.additional_kwargs?.tool_calls;
-      if (!Array.isArray(tcs)) return [];
-      return tcs.map((tc) => ({ id: tc?.id, name: tc?.function?.name || tc?.name })).filter((x) => typeof x.id === "string" && x.id.length > 0);
-    };
-    const normalizeBedrockToolPairing = (input) => {
-      const msgs = Array.isArray(input) ? [...input] : [];
-      const validToolCallIds = /* @__PURE__ */ new Set();
-      for (const m of msgs) {
-        if (m?.role === "assistant") {
-          for (const tu of extractToolUses(m)) {
-            if (tu.id) validToolCallIds.add(tu.id);
-          }
-        }
-      }
-      const filteredMsgs = msgs.filter((m) => {
-        if (m?.role === "tool") {
-          const toolCallId = m.tool_call_id;
-          if (!toolCallId || !validToolCallIds.has(toolCallId)) {
-            return false;
-          }
-        }
-        return true;
-      });
-      for (let i = 0; i < filteredMsgs.length; i++) {
-        const m = filteredMsgs[i];
-        if (m?.role !== "assistant") continue;
-        const toolUses = extractToolUses(m);
-        if (toolUses.length === 0) continue;
-        const next = filteredMsgs[i + 1];
-        const firstId = toolUses[0]?.id;
-        const nextIsToolForFirst = !!(next && next.role === "tool" && next.tool_call_id === firstId);
-        if (nextIsToolForFirst) continue;
-        const placeholders = toolUses.map((tu) => ({
-          role: "tool",
-          name: tu.name || "unknown_tool",
-          tool_call_id: tu.id,
-          content: "SUMMARIZED/DEFERRED: tool result missing in transcript; inserted placeholder for tool_result adjacency."
-        }));
-        filteredMsgs.splice(i + 1, 0, ...placeholders);
-        i += placeholders.length;
-      }
-      return filteredMsgs;
-    };
-    const debugToolPairing = (messagesToSend) => {
-      try {
-        const msgs = Array.isArray(messagesToSend) ? messagesToSend : [];
-        const toolUseIds = [];
-        const missingResults = [];
-        for (let i = 0; i < msgs.length; i++) {
-          const m = msgs[i];
-          if (m?.role === "assistant") {
-            for (const tu of extractToolUses(m)) {
-              toolUseIds.push(tu.id);
-              const next = msgs[i + 1];
-              if (!(next && next.role === "tool" && (next.tool_call_id === tu.id || next.tool_call_id === m?.tool_call_id))) {
-                missingResults.push({ id: tu.id, atIndex: i, tool: tu.name });
-              }
-            }
-          }
-        }
-      } catch {
-      }
-    };
-    const onEvent = state.ctx?.__onEvent;
-    const onStream = state.ctx?.__onStream;
-    const streamingEnabled = Boolean(state.ctx?.__streaming);
-    const cancellationToken = state.ctx?.__cancellationToken;
-    const abortSignal = state.ctx?.__abortSignal;
-    const responseFormat = runtime.responseFormat;
-    const reasoningForCall = state.ctx?.__reasoning;
-    const reasoningInvokeOpts = reasoningForCall ? { reasoning: reasoningForCall } : void 0;
-    const extractText2 = (chunk) => {
-      if (chunk == null) return "";
-      if (typeof chunk === "string") return chunk;
-      if (typeof chunk?.content === "string") return chunk.content;
-      if (Array.isArray(chunk?.content)) {
-        return chunk.content.map((c) => typeof c === "string" ? c : c?.text ?? c?.content ?? "").join("");
-      }
-      if (typeof chunk?.text === "string") return chunk.text;
-      if (typeof chunk?.delta?.content === "string") return chunk.delta.content;
-      return "";
-    };
-    let response;
-    try {
-      const normalizedMessages = normalizeBedrockToolPairing([...state.messages]);
-      debugToolPairing(normalizedMessages);
-      if (streamingEnabled && typeof modelWithTools.stream === "function") {
-        let streamedText = "";
-        let streamedMessage;
-        const streamOptions = { signal: abortSignal, cancellationToken, ...responseFormat, ...reasoningInvokeOpts };
-        for await (const chunk of modelWithTools.stream(normalizedMessages, streamOptions)) {
-          if (cancellationToken && cancellationToken.isCancellationRequested || abortSignal?.aborted) {
-            break;
-          }
-          if (chunk && typeof chunk === "object" && chunk.role) {
-            streamedMessage = chunk;
-          }
-          const text = extractText2(chunk);
-          if (text) {
-            streamedText += text;
-            onStream?.({ text });
-            onEvent?.({ type: "stream", text });
-          }
-        }
-        if (streamedMessage) {
-          response = { ...streamedMessage };
-          if (response.content == null || response.content === "") {
-            response.content = streamedText;
-          }
-        } else {
-          response = { role: "assistant", content: streamedText };
-        }
-      } else {
-        response = await modelWithTools.invoke(normalizedMessages, { signal: abortSignal, cancellationToken, ...responseFormat, ...reasoningInvokeOpts });
-      }
-    } catch (err) {
-      const durationMs2 = Date.now() - start;
-      recordTraceEvent(traceSession, {
-        type: "ai_call",
-        label: "Assistant Error",
-        actor: { scope: "agent", name: actorName, role: "assistant", version: actorVersion },
-        status: "error",
-        durationMs: durationMs2,
-        requestBytes: promptBytes,
-        model: getModelName(runtime.model || opts.model),
-        provider: getProviderName(runtime.model || opts.model),
-        error: { message: err?.message || String(err), stack: err?.stack },
-        messageList: state.messages
-      });
-      throw err;
-    }
-    const messagesWithResponse = [
-      ...state.messages,
-      response
-    ];
-    const rawUsage = response?.usage || response?.usage_metadata || response?.response_metadata?.token_usage || response?.response_metadata?.tokenUsage || response?.response_metadata?.usage || response?.response_metadata?.usage_metadata || response?.response_metadata?.usageMetadata;
-    const normalized = normalizeUsage(rawUsage);
-    const modelName = getModelName(runtime.model || opts.model) || "unknown_model";
-    const durationMs = Date.now() - start;
-    const shouldLogResponse = !!traceSession && traceSession.resolvedConfig.logData;
-    const responsePayload = shouldLogResponse ? sanitizeTracePayload(response) : void 0;
-    const responseBytes = responsePayload !== void 0 ? estimatePayloadBytes(responsePayload) : void 0;
-    recordTraceEvent(traceSession, {
-      type: "ai_call",
-      label: "Assistant Response",
-      actor: { scope: "agent", name: actorName, role: "assistant", version: actorVersion },
-      durationMs,
-      inputTokens: normalized?.prompt_tokens,
-      outputTokens: normalized?.completion_tokens,
-      totalTokens: normalized?.total_tokens,
-      cachedInputTokens: normalized?.prompt_tokens_details?.cached_tokens,
-      requestBytes: promptBytes,
-      responseBytes,
-      model: modelName,
-      provider: getProviderName(runtime.model || opts.model),
-      messageList: messagesWithResponse
-    });
-    if (normalized) {
-      const usageState = state.usage || { perRequest: [], totals: {} };
-      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");
-    }
-    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 "";
-}
-
-// src/utils/traceSections.ts
-function truncate(text, max = 500) {
-  if (!text) return "";
-  return text.length > max ? `${text.slice(0, max)}\u2026` : text;
-}
-function summarizeToolOutput(output) {
-  if (output == null) return "";
-  if (typeof output === "string") return truncate(output.trim());
-  if (Array.isArray(output)) {
-    const preview = output.slice(0, 3).map((item, index) => `${index + 1}. ${truncate(safeStringify(item))}`).join("\n");
-    const suffix = output.length > 3 ? `
-\u2026 (+${output.length - 3} more)` : "";
-    return `${preview}${suffix}`.trim();
-  }
-  if (typeof output === "object") {
-    if (Array.isArray(output.items)) {
-      return summarizeToolOutput(output.items);
-    }
-    return truncate(safeStringify(output));
-  }
-  return truncate(String(output));
-}
-function extractToolItems(output) {
-  const source = Array.isArray(output) ? output : Array.isArray(output?.items) ? output.items : void 0;
-  if (!Array.isArray(source) || source.length === 0) return void 0;
-  return source.slice(0, 5).map((item) => {
-    if (item && typeof item === "object") {
-      const snippetSource = item.content ?? item.snippet ?? item.description ?? item.text ?? item.summary ?? item;
-      return {
-        title: typeof item.title === "string" ? item.title : void 0,
-        url: typeof item.url === "string" ? item.url : void 0,
-        snippet: truncate(safeStringify(snippetSource))
-      };
-    }
-    return { snippet: truncate(safeStringify(item)) };
-  });
-}
-
 // src/smart/runtimeConfig.ts
 var DEFAULT_CRITICAL_TOOLS = ["response", "manage_todo_list", "get_tool_response"];
 var BASE_DEFAULTS = {
@@ -2330,8 +2002,42 @@ var BASE_DEFAULTS = {
     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 },
@@ -2349,144 +2055,956 @@ function buildProfile(overrides) {
       ...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) => {
+    const runtime = state.agent || {
+      name: opts.name,
+      version: opts.version,
+      model: opts.model,
+      tools: opts.tools || [],
+      guardrails: opts.guardrails,
+      todoListPrompt: opts.todoListPrompt,
+      limits: opts.limits,
+      outputSchema: opts.outputSchema,
+      tracing: opts.tracing,
+      responseFormat: void 0
+    };
+    const tools = runtime.tools ?? [];
+    const shouldUseStrictToolCalling = Boolean(
+      runtime.responseFormat && runtime.model?.capabilities?.strictToolCalling
+    );
+    const modelWithTools = runtime.model?.bindTools ? runtime.model.bindTools(
+      tools,
+      shouldUseStrictToolCalling ? { strict: true } : void 0
+    ) : runtime.model;
+    const traceSession = state.ctx?.__traceSession;
+    const actorName = runtime.name ?? opts.name ?? "agent";
+    const actorVersion = runtime.version ?? opts.version;
+    const start = Date.now();
+    const shouldLogPrompt = !!traceSession && traceSession.resolvedConfig.logData;
+    const promptPayload = shouldLogPrompt ? sanitizeTracePayload(state.messages) : void 0;
+    const promptBytes = promptPayload !== void 0 ? estimatePayloadBytes(promptPayload) : void 0;
+    const extractToolUses = (m) => {
+      const tcs = m?.tool_calls || m?.additional_kwargs?.tool_calls;
+      if (!Array.isArray(tcs)) return [];
+      return tcs.map((tc) => ({ id: tc?.id, name: tc?.function?.name || tc?.name })).filter((x) => typeof x.id === "string" && x.id.length > 0);
+    };
+    const normalizeBedrockToolPairing = (input) => {
+      const msgs = Array.isArray(input) ? [...input] : [];
+      const validToolCallIds = /* @__PURE__ */ new Set();
+      for (const m of msgs) {
+        if (m?.role === "assistant") {
+          for (const tu of extractToolUses(m)) {
+            if (tu.id) validToolCallIds.add(tu.id);
+          }
+        }
+      }
+      const filteredMsgs = msgs.filter((m) => {
+        if (m?.role === "tool") {
+          const toolCallId = m.tool_call_id;
+          if (!toolCallId || !validToolCallIds.has(toolCallId)) {
+            return false;
+          }
+        }
+        return true;
+      });
+      for (let i = 0; i < filteredMsgs.length; i++) {
+        const m = filteredMsgs[i];
+        if (m?.role !== "assistant") continue;
+        const toolUses = extractToolUses(m);
+        if (toolUses.length === 0) continue;
+        const next = filteredMsgs[i + 1];
+        const firstId = toolUses[0]?.id;
+        const nextIsToolForFirst = !!(next && next.role === "tool" && next.tool_call_id === firstId);
+        if (nextIsToolForFirst) continue;
+        const placeholders = toolUses.map((tu) => ({
+          role: "tool",
+          name: tu.name || "unknown_tool",
+          tool_call_id: tu.id,
+          content: "SUMMARIZED/DEFERRED: tool result missing in transcript; inserted placeholder for tool_result adjacency."
+        }));
+        filteredMsgs.splice(i + 1, 0, ...placeholders);
+        i += placeholders.length;
+      }
+      return filteredMsgs;
+    };
+    const debugToolPairing = (messagesToSend) => {
+      try {
+        const msgs = Array.isArray(messagesToSend) ? messagesToSend : [];
+        const toolUseIds = [];
+        const missingResults = [];
+        for (let i = 0; i < msgs.length; i++) {
+          const m = msgs[i];
+          if (m?.role === "assistant") {
+            for (const tu of extractToolUses(m)) {
+              toolUseIds.push(tu.id);
+              const next = msgs[i + 1];
+              if (!(next && next.role === "tool" && (next.tool_call_id === tu.id || next.tool_call_id === m?.tool_call_id))) {
+                missingResults.push({ id: tu.id, atIndex: i, tool: tu.name });
+              }
+            }
+          }
+        }
+      } catch {
+      }
+    };
+    const onEvent = state.ctx?.__onEvent;
+    const onStream = state.ctx?.__onStream;
+    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;
+    const extractText2 = (chunk) => {
+      if (chunk == null) return "";
+      if (typeof chunk === "string") return chunk;
+      if (typeof chunk?.content === "string") return chunk.content;
+      if (Array.isArray(chunk?.content)) {
+        return chunk.content.map((c) => typeof c === "string" ? c : c?.text ?? c?.content ?? "").join("");
+      }
+      if (typeof chunk?.text === "string") return chunk.text;
+      if (typeof chunk?.delta?.content === "string") return chunk.delta.content;
+      return "";
+    };
+    let response;
+    try {
+      const normalizedMessages = normalizeBedrockToolPairing([...state.messages]);
+      debugToolPairing(normalizedMessages);
+      if (streamingEnabled && typeof modelWithTools.stream === "function") {
+        let streamedText = "";
+        let streamedMessage;
+        const streamOptions = { signal: abortSignal, cancellationToken, ...responseFormat, ...reasoningInvokeOpts };
+        for await (const chunk of modelWithTools.stream(normalizedMessages, streamOptions)) {
+          if (cancellationToken && cancellationToken.isCancellationRequested || abortSignal?.aborted) {
+            break;
+          }
+          if (chunk && typeof chunk === "object" && chunk.role) {
+            streamedMessage = chunk;
+          }
+          const text = extractText2(chunk);
+          if (text) {
+            streamedText += text;
+            onStream?.({ text });
+            onEvent?.({ type: "stream", text });
+          }
+        }
+        if (streamedMessage) {
+          response = { ...streamedMessage };
+          if (response.content == null || response.content === "") {
+            response.content = streamedText;
+          }
+        } else {
+          response = { role: "assistant", content: streamedText };
+        }
+      } else {
+        response = await modelWithTools.invoke(normalizedMessages, { signal: abortSignal, cancellationToken, ...responseFormat, ...reasoningInvokeOpts });
+      }
+    } catch (err) {
+      const durationMs2 = Date.now() - start;
+      recordTraceEvent(traceSession, {
+        type: "ai_call",
+        label: "Assistant Error",
+        actor: { scope: "agent", name: actorName, role: "assistant", version: actorVersion },
+        status: "error",
+        durationMs: durationMs2,
+        requestBytes: promptBytes,
+        model: getModelName(runtime.model || opts.model),
+        provider: getProviderName(runtime.model || opts.model),
+        error: { message: err?.message || String(err), stack: err?.stack },
+        messageList: state.messages
+      });
+      throw err;
+    }
+    const messagesWithResponse = [
+      ...state.messages,
+      response
+    ];
+    const rawUsage = response?.usage || response?.usage_metadata || response?.response_metadata?.token_usage || response?.response_metadata?.tokenUsage || response?.response_metadata?.usage || response?.response_metadata?.usage_metadata || response?.response_metadata?.usageMetadata;
+    const normalized = normalizeUsage(rawUsage);
+    const modelName = getModelName(runtime.model || opts.model) || "unknown_model";
+    const durationMs = Date.now() - start;
+    const shouldLogResponse = !!traceSession && traceSession.resolvedConfig.logData;
+    const responsePayload = shouldLogResponse ? sanitizeTracePayload(response) : void 0;
+    const responseBytes = responsePayload !== void 0 ? estimatePayloadBytes(responsePayload) : void 0;
+    recordTraceEvent(traceSession, {
+      type: "ai_call",
+      label: "Assistant Response",
+      actor: { scope: "agent", name: actorName, role: "assistant", version: actorVersion },
+      durationMs,
+      inputTokens: normalized?.prompt_tokens,
+      outputTokens: normalized?.completion_tokens,
+      totalTokens: normalized?.total_tokens,
+      cachedInputTokens: normalized?.prompt_tokens_details?.cached_tokens,
+      requestBytes: promptBytes,
+      responseBytes,
+      model: modelName,
+      provider: getProviderName(runtime.model || opts.model),
+      messageList: messagesWithResponse
+    });
+    if (normalized) {
+      const usageState = state.usage || { perRequest: [], totals: {} };
+      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 };
   };
 }
-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";
+
+// src/utils/traceSections.ts
+function truncate(text, max = 500) {
+  if (!text) return "";
+  return text.length > max ? `${text.slice(0, max)}\u2026` : text;
 }
-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 summarizeToolOutput(output) {
+  if (output == null) return "";
+  if (typeof output === "string") return truncate(output.trim());
+  if (Array.isArray(output)) {
+    const preview = output.slice(0, 3).map((item, index) => `${index + 1}. ${truncate(safeStringify(item))}`).join("\n");
+    const suffix = output.length > 3 ? `
+\u2026 (+${output.length - 3} more)` : "";
+    return `${preview}${suffix}`.trim();
+  }
+  if (typeof output === "object") {
+    if (Array.isArray(output.items)) {
+      return summarizeToolOutput(output.items);
     }
-  };
+    return truncate(safeStringify(output));
+  }
+  return truncate(String(output));
 }
-function getResolvedSmartConfig(opts, runtime) {
-  return runtime?.smart || normalizeSmartAgentOptions(opts);
+function extractToolItems(output) {
+  const source = Array.isArray(output) ? output : Array.isArray(output?.items) ? output.items : void 0;
+  if (!Array.isArray(source) || source.length === 0) return void 0;
+  return source.slice(0, 5).map((item) => {
+    if (item && typeof item === "object") {
+      const snippetSource = item.content ?? item.snippet ?? item.description ?? item.text ?? item.summary ?? item;
+      return {
+        title: typeof item.title === "string" ? item.title : void 0,
+        url: typeof item.url === "string" ? item.url : void 0,
+        snippet: truncate(safeStringify(snippetSource))
+      };
+    }
+    return { snippet: truncate(safeStringify(item)) };
+  });
 }
 
 // src/smart/toolResponses.ts
@@ -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 || []);
@@ -8614,7 +9167,7 @@ var AnthropicProvider = class extends BaseProvider {
     const { system, messages } = this.splitSystemMessages(request.messages);
     const body = {
       model: request.model || this.defaultModel,
-      messages: messages.map((m) => this.toAnthropicMessage(m)),
+      messages: this.toAnthropicMessages(messages),
       max_tokens: request.maxTokens ?? 4096,
       stream
     };
@@ -8670,20 +9223,44 @@ var AnthropicProvider = class extends BaseProvider {
       messages: rest
     };
   }
-  toAnthropicMessage(m) {
-    if (m.role === "tool" && m.toolCallId) {
-      const content = typeof m.content === "string" ? m.content : JSON.stringify(m.content);
-      return {
-        role: "user",
-        content: [
-          {
-            type: "tool_result",
-            tool_use_id: m.toolCallId,
-            content
-          }
-        ]
-      };
+  /**
+   * Converts unified messages to Anthropic format, coalescing consecutive
+   * tool-result messages into a single `user` turn.
+   *
+   * The unified message list carries one `role: "tool"` entry per tool call
+   * (mirroring OpenAI's shape). Anthropic's Messages API expects every
+   * `tool_result` block answering a single assistant turn's `tool_use`
+   * block(s) to be batched into ONE `user` message rather than sent as
+   * separate consecutive `user` messages.
+   */
+  toAnthropicMessages(messages) {
+    const result = [];
+    let mergingToolResults = false;
+    for (const m of messages) {
+      if (m.role === "tool" && m.toolCallId) {
+        const toolResult = this.toAnthropicToolResult(m);
+        if (mergingToolResults) {
+          result[result.length - 1].content.push(toolResult);
+        } else {
+          result.push({ role: "user", content: [toolResult] });
+          mergingToolResults = true;
+        }
+        continue;
+      }
+      mergingToolResults = false;
+      result.push(this.toAnthropicMessage(m));
     }
+    return result;
+  }
+  toAnthropicToolResult(m) {
+    const content = typeof m.content === "string" ? m.content : JSON.stringify(m.content);
+    return {
+      type: "tool_result",
+      tool_use_id: m.toolCallId,
+      content
+    };
+  }
+  toAnthropicMessage(m) {
     if (m.role === "assistant" && m.toolCalls?.length) {
       const content = [];
       appendReasoningBlocks(content, m.reasoning?.blocks);
@@ -9068,7 +9645,7 @@ var BedrockProvider = class extends BaseProvider {
   buildConverseBody(request) {
     const { system, messages } = this.splitSystemMessages(request.messages);
     const body = {
-      messages: messages.map((m) => this.toBedrockMessage(m))
+      messages: this.toBedrockMessages(messages)
     };
     if (system.length > 0) {
       const systemBlocks = system.map((s) => ({ text: s }));
@@ -9118,22 +9695,47 @@ var BedrockProvider = class extends BaseProvider {
     }
     return { system, messages: rest };
   }
-  toBedrockMessage(m) {
-    if (m.role === "tool" && m.toolCallId) {
-      const text = typeof m.content === "string" ? m.content : JSON.stringify(m.content);
-      return {
-        role: "user",
-        content: [
-          {
-            toolResult: {
-              toolUseId: m.toolCallId,
-              content: [{ text }],
-              status: "success"
-            }
-          }
-        ]
-      };
+  /**
+   * Converts unified messages to Bedrock Converse format, coalescing
+   * consecutive tool-result messages into a single `user` turn.
+   *
+   * The unified message list carries one `role: "tool"` entry per tool call
+   * (mirroring OpenAI's shape). Bedrock's Converse API requires every
+   * `toolResult` block answering a single assistant turn's `toolUse`
+   * block(s) to be batched into ONE `user` message — sending them as
+   * separate consecutive `user` messages triggers: "Expected toolResult
+   * blocks at messages.N.content for the following Ids: ...".
+   */
+  toBedrockMessages(messages) {
+    const result = [];
+    let mergingToolResults = false;
+    for (const m of messages) {
+      if (m.role === "tool" && m.toolCallId) {
+        const toolResult = this.toBedrockToolResult(m);
+        if (mergingToolResults) {
+          result[result.length - 1].content.push(toolResult);
+        } else {
+          result.push({ role: "user", content: [toolResult] });
+          mergingToolResults = true;
+        }
+        continue;
+      }
+      mergingToolResults = false;
+      result.push(this.toBedrockMessage(m));
     }
+    return result;
+  }
+  toBedrockToolResult(m) {
+    const text = typeof m.content === "string" ? m.content : JSON.stringify(m.content);
+    return {
+      toolResult: {
+        toolUseId: m.toolCallId,
+        content: [{ text }],
+        status: "success"
+      }
+    };
+  }
+  toBedrockMessage(m) {
     if (m.role === "assistant" && m.toolCalls?.length) {
       const content2 = [];
       appendBedrockReasoning(content2, m.reasoning?.blocks);
@@ -9439,12 +10041,24 @@ var VertexProvider = class extends BaseProvider {
   buildContents(messages) {
     const systemParts = [];
     const contents = [];
+    let mergingToolResults = false;
     for (const m of messages) {
       if (m.role === "system") {
         const text = typeof m.content === "string" ? m.content : m.content.filter((p) => p.type === "text").map((p) => p.text).join("\n");
         if (text) systemParts.push(text);
         continue;
       }
+      if (m.role === "tool" && m.toolCallId) {
+        const part = this.toGeminiFunctionResponsePart(m);
+        if (mergingToolResults) {
+          contents[contents.length - 1].parts.push(part);
+        } else {
+          contents.push({ role: "user", parts: [part] });
+          mergingToolResults = true;
+        }
+        continue;
+      }
+      mergingToolResults = false;
       contents.push(this.toGeminiContent(m));
     }
     return {
@@ -9452,27 +10066,22 @@ var VertexProvider = class extends BaseProvider {
       contents
     };
   }
-  toGeminiContent(m) {
-    if (m.role === "tool" && m.toolCallId) {
-      const text = typeof m.content === "string" ? m.content : JSON.stringify(m.content);
-      let response;
-      try {
-        response = JSON.parse(text);
-      } catch {
-        response = { result: text };
-      }
-      return {
-        role: "user",
-        parts: [
-          {
-            functionResponse: {
-              name: m.name ?? m.toolCallId,
-              response
-            }
-          }
-        ]
-      };
+  toGeminiFunctionResponsePart(m) {
+    const text = typeof m.content === "string" ? m.content : JSON.stringify(m.content);
+    let response;
+    try {
+      response = JSON.parse(text);
+    } catch {
+      response = { result: text };
     }
+    return {
+      functionResponse: {
+        name: m.name ?? m.toolCallId,
+        response
+      }
+    };
+  }
+  toGeminiContent(m) {
     if (m.role === "assistant" && m.toolCalls?.length) {
       const parts2 = [];
       if (typeof m.content === "string" && m.content) {
@@ -10133,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;
@@ -10158,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;
@@ -10165,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;
@@ -10190,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;
@@ -10224,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;