@cognipeer/agent-sdk 0.5.4 → 0.6.1

package/dist/index.cjs

@@ -1978,7 +1978,9 @@ function createAgentCoreNode(opts) {
     const cancellationToken = state.ctx?.__cancellationToken;
     const abortSignal = state.ctx?.__abortSignal;
     const responseFormat = runtime.responseFormat;
-    const extractText = (chunk) => {
+    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;
@@ -1996,7 +1998,7 @@ function createAgentCoreNode(opts) {
       if (streamingEnabled && typeof modelWithTools.stream === "function") {
         let streamedText = "";
         let streamedMessage;
-        const streamOptions = { signal: abortSignal, cancellationToken, ...responseFormat };
+        const streamOptions = { signal: abortSignal, cancellationToken, ...responseFormat, ...reasoningInvokeOpts };
         for await (const chunk of modelWithTools.stream(normalizedMessages, streamOptions)) {
           if (cancellationToken && cancellationToken.isCancellationRequested || abortSignal?.aborted) {
             break;
@@ -2004,7 +2006,7 @@ function createAgentCoreNode(opts) {
           if (chunk && typeof chunk === "object" && chunk.role) {
             streamedMessage = chunk;
           }
-          const text = extractText(chunk);
+          const text = extractText2(chunk);
           if (text) {
             streamedText += text;
             onStream?.({ text });
@@ -2020,7 +2022,7 @@ function createAgentCoreNode(opts) {
           response = { role: "assistant", content: streamedText };
         }
       } else {
-        response = await modelWithTools.invoke(normalizedMessages, { signal: abortSignal, cancellationToken, ...responseFormat });
+        response = await modelWithTools.invoke(normalizedMessages, { signal: abortSignal, cancellationToken, ...responseFormat, ...reasoningInvokeOpts });
       }
     } catch (err) {
       const durationMs2 = Date.now() - start;
@@ -2136,18 +2138,13 @@ var BASE_DEFAULTS = {
     requireJsonOutputContract: true
   },
   toolResponses: {
-    maxToolResponseChars: 3600,
-    maxToolResponseTokens: 1200,
-    smallResponseChars: 0,
-    smallResponsePolicy: "keep_full",
-    defaultPolicy: "keep_structured",
-    largeResponsePolicy: "summarize_archive",
+    maxToolResponseChars: 12e3,
+    maxToolResponseTokens: 3e3,
+    defaultPolicy: "summarize_archive",
     toolResponseRetentionByTool: {},
     criticalTools: [...DEFAULT_CRITICAL_TOOLS],
     schemaValidation: "strict",
-    retryOnSchemaError: true,
-    fallbackPolicy: "keep_full",
-    keepRecentFullCount: 0
+    retryOnSchemaError: true
   }
 };
 function buildProfile(overrides) {
@@ -2186,7 +2183,7 @@ var DEFAULT_PROFILE_CONFIGS = {
     },
     memory: { readPolicy: "recent_only" },
     delegation: { mode: "off", maxDelegationDepth: 1, maxChildCalls: 2, maxParallelChild: 1, childContextPolicy: "minimal" },
-    toolResponses: { maxToolResponseChars: 2400, maxToolResponseTokens: 800 }
+    toolResponses: { maxToolResponseChars: 8e3, maxToolResponseTokens: 2e3 }
   }),
   balanced: buildProfile({}),
   deep: buildProfile({
@@ -2203,7 +2200,7 @@ var DEFAULT_PROFILE_CONFIGS = {
     },
     memory: { scope: "workspace" },
     delegation: { maxDelegationDepth: 3, maxChildCalls: 6 },
-    toolResponses: { maxToolResponseChars: 5400, maxToolResponseTokens: 1800 }
+    toolResponses: { maxToolResponseChars: 16e3, maxToolResponseTokens: 4e3 }
   }),
   research: buildProfile({
     limits: { maxToolCalls: 20, maxParallelTools: 4, maxContextTokens: 56e3 },
@@ -2219,7 +2216,7 @@ var DEFAULT_PROFILE_CONFIGS = {
     },
     memory: { scope: "workspace" },
     delegation: { mode: "automatic", maxDelegationDepth: 4, maxChildCalls: 8, maxParallelChild: 3, childContextPolicy: "full" },
-    toolResponses: { maxToolResponseChars: 7200, maxToolResponseTokens: 2200 }
+    toolResponses: { maxToolResponseChars: 24e3, maxToolResponseTokens: 6e3 }
   })
 };
 function mergeLimits(base, override) {
@@ -2426,63 +2423,65 @@ function summarizeObject(value) {
   return safeStringify(value);
 }
 function classifyToolResponse(toolName, output, config) {
-  const serialized = safeStringify(output);
-  const tokenCount = countApproxTokens(serialized);
   const criticalTools = new Set(config.toolResponses.criticalTools);
   if (criticalTools.has(toolName)) return "critical";
-  if (serialized === "ok" || serialized === "true" || serialized === "null") {
-    return "redundant";
-  }
+  const serialized = safeStringify(output);
+  const tokenCount = countApproxTokens(serialized);
   if (tokenCount >= config.toolResponses.maxToolResponseTokens || serialized.length >= config.toolResponses.maxToolResponseChars) {
     return "verbose";
   }
-  const smallChars = config.toolResponses.smallResponseChars;
-  if (smallChars > 0 && serialized.length <= smallChars) {
-    return "small";
-  }
   return "informative";
 }
-function resolveToolResponsePolicy(toolName, output, config) {
+function applyToolResponseHardCap(toolName, output, executionId, config) {
   const serialized = safeStringify(output);
   const tokenCount = countApproxTokens(serialized);
   const classification = classifyToolResponse(toolName, output, config);
-  const byTool = config.toolResponses.toolResponseRetentionByTool[toolName];
-  let retentionPolicy = byTool || config.toolResponses.defaultPolicy;
-  if (byTool) ; else if (classification === "critical") {
-    retentionPolicy = config.toolResponses.fallbackPolicy;
-  } else if (classification === "verbose") {
-    retentionPolicy = config.toolResponses.largeResponsePolicy;
-  } else if (classification === "small") {
-    retentionPolicy = config.toolResponses.smallResponsePolicy;
-  } else if (classification === "redundant") {
-    retentionPolicy = "drop";
-  }
-  const summary = summarizeObject(output);
-  if (retentionPolicy === "keep_full") {
-    return { classification, retentionPolicy, content: serialized, rawOutput: output, summary, tokenCount };
-  }
-  if (retentionPolicy === "keep_structured") {
-    return { classification, retentionPolicy, content: summary, rawOutput: output, summary, tokenCount };
-  }
-  if (retentionPolicy === "summarize_archive") {
-    return {
-      classification,
-      retentionPolicy,
-      content: `ARCHIVED_TOOL_RESPONSE: ${summary}`,
-      rawOutput: output,
-      summary,
-      tokenCount
-    };
+  if (classification !== "verbose") {
+    return { classification, content: serialized, rawOutput: output, tokenCount, truncated: false };
   }
+  const cap = config.toolResponses.maxToolResponseChars;
+  const head = serialized.slice(0, cap);
+  const note = `
+... [TRUNCATED ${serialized.length - cap} chars by hard cap. Use get_tool_response with executionId="${executionId}" to fetch the full payload.]`;
   return {
     classification,
-    retentionPolicy,
-    content: `DROPPED_TOOL_RESPONSE: ${summary}`,
+    content: head + note,
     rawOutput: output,
-    summary,
-    tokenCount
+    tokenCount,
+    truncated: true
   };
 }
+function resolveSummarizationRetention(toolName, config) {
+  const criticalTools = new Set(config.toolResponses.criticalTools);
+  if (criticalTools.has(toolName)) return "keep_full";
+  const byTool = config.toolResponses.toolResponseRetentionByTool[toolName];
+  return byTool || config.toolResponses.defaultPolicy;
+}
+function renderRetainedToolMessage(args) {
+  const { policy, rawOutput, toolName, toolCallId, executionId, prebuiltSummary } = args;
+  if (policy === "keep_full") {
+    return typeof rawOutput === "string" ? rawOutput : safeStringify(rawOutput);
+  }
+  const summary = prebuiltSummary || summarizeObject(rawOutput);
+  const refs = [
+    `toolName=${toolName}`,
+    toolCallId ? `toolCallId=${toolCallId}` : null,
+    executionId ? `executionId=${executionId}` : null
+  ].filter(Boolean).join("; ");
+  const refId = executionId || toolCallId || "";
+  if (policy === "keep_structured") {
+    return `STRUCTURED_TOOL_RESPONSE [${refs}]
+Preview: ${summary}
+Use get_tool_response with executionId "${refId}" to fetch the full payload when a specific field is needed.`;
+  }
+  if (policy === "summarize_archive") {
+    return `ARCHIVED_TOOL_RESPONSE [${refs}]
+Summary: ${summary}
+Use get_tool_response with executionId "${refId}" to fetch the full payload.`;
+  }
+  return `DROPPED_TOOL_RESPONSE [${refs}]
+Use get_tool_response with executionId "${refId}" only if you must recover the original payload.`;
+}
 function validateToolArgs(tool, args) {
   const schema = tool.schema;
   if (!schema || typeof schema.parse !== "function") {
@@ -2761,52 +2760,25 @@ function createToolsNode(initialTools, opts) {
           state.ctx.__structuredOutputParsed = output.data;
           state.ctx.__finalizedDueToStructuredOutput = true;
         }
-        const responsePolicy = resolveToolResponsePolicy(toolName, output, resolved);
+        const responsePolicy = applyToolResponseHardCap(toolName, output, executionId, resolved);
         const timestamp = (/* @__PURE__ */ new Date()).toISOString();
-        const storedOutput = responsePolicy.retentionPolicy === "keep_full" ? output : responsePolicy.summary;
         toolHistory.push({
           executionId,
           toolName,
           args,
-          output: storedOutput,
+          output,
           rawOutput: output,
           timestamp,
           tool_call_id: tc.id,
-          summarized: responsePolicy.retentionPolicy !== "keep_full",
+          summarized: false,
           originalTokenCount: responsePolicy.tokenCount,
           classification: responsePolicy.classification,
-          retentionPolicy: responsePolicy.retentionPolicy,
-          summary: responsePolicy.summary,
-          archiveId: responsePolicy.retentionPolicy === "summarize_archive" || responsePolicy.retentionPolicy === "drop" ? executionId : void 0,
+          retentionPolicy: "keep_full",
+          summary: void 0,
+          archiveId: void 0,
           status: "success"
         });
-        if (resolved.context.archiveLargeToolResponses && (responsePolicy.retentionPolicy === "summarize_archive" || responsePolicy.retentionPolicy === "drop")) {
-          toolHistoryArchived.push({
-            executionId,
-            toolName,
-            args,
-            output,
-            rawOutput: output,
-            timestamp,
-            tool_call_id: tc.id,
-            summarized: true,
-            originalTokenCount: responsePolicy.tokenCount,
-            classification: responsePolicy.classification,
-            retentionPolicy: responsePolicy.retentionPolicy,
-            summary: responsePolicy.summary,
-            archiveId: executionId,
-            status: "success"
-          });
-        }
-        let toolMessageContent = responsePolicy.content;
-        if (responsePolicy.retentionPolicy === "summarize_archive") {
-          toolMessageContent = `ARCHIVED_TOOL_RESPONSE [executionId=${executionId}]: ${responsePolicy.summary}
-Only use get_tool_response with executionId "${executionId}" if this summary is missing a specific field, id, snippet, or exact payload you still need.`;
-        } else if (responsePolicy.retentionPolicy === "drop") {
-          toolMessageContent = `DROPPED_TOOL_RESPONSE [executionId=${executionId}]: ${responsePolicy.summary}
-Only use get_tool_response with executionId "${executionId}" if this summary is missing a specific field, id, snippet, or exact payload you still need.`;
-        }
-        appended.push({ role: "tool", content: toolMessageContent, tool_call_id: tc.id || `${tc.name}_${appended.length}`, name: tc.name });
+        appended.push({ role: "tool", content: responsePolicy.content, tool_call_id: tc.id || `${tc.name}_${appended.length}`, name: tc.name });
         onEvent?.({ type: "tool_call", phase: "success", name: toolName, id: tc.id, args, result: output, durationMs });
         onProgress?.({ stage: "tools", message: `Tool ${tc.name} completed`, detail: { durationMs } });
         if (needsApproval && approvalEntry) {
@@ -2850,8 +2822,9 @@ Only use get_tool_response with executionId "${executionId}" if this summary is
           messageList,
           debug: {
             classification: responsePolicy.classification,
-            retentionPolicy: responsePolicy.retentionPolicy,
-            originalTokenCount: responsePolicy.tokenCount
+            retentionPolicy: "keep_full",
+            originalTokenCount: responsePolicy.tokenCount,
+            truncated: responsePolicy.truncated
           }
         });
         toolCount += 1;
@@ -2968,6 +2941,246 @@ function createToolLimitFinalizeNode(_opts) {
     return { messages: [...state.messages, notice], ctx };
   };
 }
+var REFLECTION_SYSTEM_NAME = "agent_reflection";
+var REFLECTION_ASK_NAME = "agent_reflection_ask";
+var DEFAULT_REFLECT_PROMPT = `Reflect briefly \u2014 plain text, no JSON, no tool calls.
+Structure your note (1\u20132 sentences each):
+1) What the latest tool results actually tell us (facts, surprises).
+2) What is still missing or uncertain before we can finish the user's task.
+3) The single next step you plan to take, and why that step over alternatives.
+Be concrete. Do not repeat the task description. Do not apologize. Max ${"${maxChars}"} characters total.`;
+function trimToChars(text, maxChars) {
+  if (text.length <= maxChars) return text;
+  return text.slice(0, maxChars - 1).trimEnd() + "\u2026";
+}
+function countToolCallsInLastTurn(state) {
+  const ids = [];
+  const names = [];
+  for (let i = state.messages.length - 1; i >= 0; i--) {
+    const m = state.messages[i];
+    if (m?.role === "tool") {
+      if (m.tool_call_id) ids.push(m.tool_call_id);
+      if (m.name) names.push(m.name);
+    } else if (m?.role === "assistant") {
+      break;
+    }
+  }
+  return { ids, names };
+}
+function stripReflectionAskMessages(messages) {
+  return messages.filter((m) => !(m?.role === "user" && m?.name === REFLECTION_ASK_NAME));
+}
+function shouldRunReflection(cadence, state, ranToolsThisTurn) {
+  if (cadence === "off") return false;
+  if (cadence === "every_turn") return true;
+  if (cadence === "after_tool") return ranToolsThisTurn;
+  if (cadence === "on_branch") {
+    const reflections = state.reflections || [];
+    const lastReflectionTurn = reflections[reflections.length - 1]?.turn ?? -1;
+    const currentTurnId = state.toolCallCount ?? 0;
+    return currentTurnId - lastReflectionTurn >= 2;
+  }
+  return false;
+}
+function createReflectionNode(opts, resolved) {
+  return async function reflectNode(state, trigger) {
+    if (!resolved.enabled) return {};
+    const runtime = state.agent || {
+      model: opts.model,
+      name: opts.name,
+      version: opts.version
+    };
+    const model = runtime.model;
+    if (!model?.invoke && !model?.stream) return {};
+    const onEvent = state.ctx?.__onEvent;
+    const traceSession = state.ctx?.__traceSession;
+    const maxChars = resolved.maxChars;
+    const promptBody = (resolved.promptTemplate || DEFAULT_REFLECT_PROMPT).replace(/\$\{maxChars\}/g, String(maxChars));
+    const baseMessages = stripReflectionAskMessages([...state.messages]);
+    const askMessage = {
+      role: "user",
+      name: REFLECTION_ASK_NAME,
+      content: promptBody
+    };
+    const messagesForCall = resolved.mode === "piggyback" ? [...baseMessages, askMessage] : buildSeparateCallMessages(baseMessages, promptBody);
+    const start = Date.now();
+    let response;
+    try {
+      response = await model.invoke(messagesForCall, {
+        // tool_choice:"none" so the model won't try to call tools during reflection
+        tool_choice: "none",
+        toolChoice: "none",
+        // Override max_tokens for the reflection call. BaseChatModel passes this through
+        // to the adapter which forwards into the provider body.
+        max_tokens: resolved.maxTokens,
+        maxTokens: resolved.maxTokens
+      });
+    } catch (err) {
+      recordTraceEvent(traceSession, {
+        type: "reflection",
+        label: "Reflection error",
+        actor: { scope: "agent", name: opts.name || "agent", role: "reflection" },
+        status: "error",
+        error: { message: err?.message || String(err) }
+      });
+      return {};
+    }
+    const durationMs = Date.now() - start;
+    const rawText = extractText(response);
+    const text = trimToChars(String(rawText ?? "").trim(), maxChars);
+    if (!text) return {};
+    const rawUsage = response?.usage_metadata || response?.response_metadata?.usage || response?.usage || response?.additional_kwargs?.usage;
+    const usage = normalizeUsage(rawUsage);
+    const { ids, names } = countToolCallsInLastTurn(state);
+    const turn = state.toolCallCount ?? 0;
+    const record = {
+      id: safeRandomId(),
+      turn,
+      text,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      durationMs,
+      anchorMessageIndex: state.messages.length,
+      trigger,
+      usage: usage ? {
+        inputTokens: usage.prompt_tokens,
+        outputTokens: usage.completion_tokens,
+        cachedInputTokens: usage.prompt_tokens_details?.cached_tokens,
+        totalTokens: usage.total_tokens,
+        reasoningTokens: usage.completion_tokens_details?.reasoning_tokens
+      } : void 0,
+      toolCallIds: ids.length > 0 ? ids : void 0
+    };
+    recordTraceEvent(traceSession, {
+      type: "reflection",
+      label: `Reflection turn ${turn}`,
+      actor: { scope: "agent", name: opts.name || "agent", role: "reflection" },
+      status: "success",
+      durationMs,
+      inputTokens: record.usage?.inputTokens,
+      outputTokens: record.usage?.outputTokens,
+      cachedInputTokens: record.usage?.cachedInputTokens,
+      totalTokens: record.usage?.totalTokens,
+      debug: { text, toolNames: names }
+    });
+    if (resolved.emitEvents) {
+      try {
+        onEvent?.({
+          type: "reflection",
+          id: record.id,
+          turn,
+          text,
+          trigger,
+          durationMs,
+          usage: record.usage,
+          toolCallIds: record.toolCallIds
+        });
+      } catch (e) {
+      }
+    }
+    const nextMessages = stripReflectionAskMessages([...state.messages]);
+    const reflections = [...state.reflections || [], record];
+    const kept = reflections.slice(-Math.max(1, resolved.keepLast));
+    const prunedMessages = nextMessages.filter(
+      (m) => !(m?.role === "system" && m?.name === REFLECTION_SYSTEM_NAME)
+    );
+    for (const r of kept) {
+      prunedMessages.push({
+        role: "system",
+        name: REFLECTION_SYSTEM_NAME,
+        content: `<agent_reflection turn=${r.turn} at=${r.createdAt}>
+${r.text}
+</agent_reflection>`,
+        metadata: { reflectionId: r.id, reflectionTurn: r.turn, reflectionTrigger: r.trigger }
+      });
+    }
+    return { messages: prunedMessages, reflections };
+  };
+}
+function extractText(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;
+  return "";
+}
+function buildSeparateCallMessages(base, promptBody) {
+  const systemMessages = base.filter((m) => m?.role === "system");
+  const tail = base.slice(-8);
+  return [
+    ...systemMessages,
+    ...tail,
+    { role: "user", name: REFLECTION_ASK_NAME, content: promptBody }
+  ];
+}
+function safeRandomId() {
+  try {
+    return crypto.randomUUID();
+  } catch {
+    return `r_${Math.random().toString(36).slice(2, 10)}_${Date.now().toString(36)}`;
+  }
+}
+
+// src/smart/reasoning.ts
+var LEVEL_DEFAULTS = {
+  low: {
+    native: { effort: "low" },
+    reflection: { maxTokens: 200, maxChars: 600, cadence: "on_branch" }
+  },
+  medium: {
+    native: { effort: "medium" },
+    reflection: { maxTokens: 350, maxChars: 1200, cadence: "after_tool" }
+  },
+  high: {
+    native: { effort: "high" },
+    reflection: { maxTokens: 600, maxChars: 2e3, cadence: "after_tool" }
+  }
+};
+function resolveReasoning(input) {
+  if (!input || input.enabled === false) return void 0;
+  const enabled = input.enabled ?? (input.native !== void 0 || input.reflection !== void 0 || input.level !== void 0);
+  if (!enabled) return void 0;
+  const level = input.level ?? "medium";
+  const presets = LEVEL_DEFAULTS[level];
+  let native;
+  if (input.native === false) {
+    native = void 0;
+  } else {
+    native = { ...presets.native, ...input.native ?? {} };
+  }
+  const reflection = resolveReflection(input.reflection, presets.reflection);
+  return { enabled: true, level, native, reflection };
+}
+function resolveReflection(input, preset) {
+  if (input === false) {
+    return {
+      enabled: false,
+      cadence: "off",
+      mode: "piggyback",
+      maxTokens: preset.maxTokens,
+      maxChars: preset.maxChars,
+      keepLast: 3,
+      summarize: false,
+      emitEvents: true
+    };
+  }
+  const cfg = input ?? {};
+  const enabled = cfg.enabled ?? true;
+  const cadence = cfg.cadence ?? preset.cadence;
+  return {
+    enabled: enabled && cadence !== "off",
+    cadence: enabled ? cadence : "off",
+    mode: cfg.mode ?? "piggyback",
+    maxTokens: cfg.maxTokens ?? preset.maxTokens,
+    maxChars: cfg.maxChars ?? preset.maxChars,
+    keepLast: cfg.keepLast ?? 3,
+    summarize: cfg.summarize ?? false,
+    promptTemplate: cfg.promptTemplate,
+    emitEvents: cfg.emitEvents ?? true
+  };
+}
 function ensureArray(value) {
   return Array.isArray(value) ? value : [];
 }
@@ -3381,6 +3594,8 @@ function createAgent(opts) {
   }
   const toolsNode = createToolsNode(toolsBase, opts);
   const finalizeNode = createToolLimitFinalizeNode();
+  const resolvedReasoning = resolveReasoning(opts.reasoning);
+  const reflectNode = resolvedReasoning?.reflection.enabled ? createReflectionNode(opts, resolvedReasoning.reflection) : void 0;
   const mergeGuardrailOutcomes = (prev, next) => {
     if (!prev) return next;
     return {
@@ -3435,6 +3650,13 @@ function createAgent(opts) {
     if (summarizationThreshold === void 0) {
       state = clearNeedsSummarization(state);
     }
+    if (resolvedReasoning?.native) {
+      const ctx = { ...state.ctx || {} };
+      if (!ctx.__reasoning) {
+        ctx.__reasoning = resolvedReasoning.native;
+        state = { ...state, ctx };
+      }
+    }
     const mergedLimits = {
       ...opts.limits || {},
       ...config?.limits || {}
@@ -3663,6 +3885,18 @@ function createAgent(opts) {
       if (state.ctx?.__awaitingApproval) break;
       if (checkpointIfRequested("after_tools")) break;
       if (state.ctx?.__finalizedDueToStructuredOutput) break;
+      if (reflectNode && resolvedReasoning?.reflection.enabled) {
+        const cadence = resolvedReasoning.reflection.cadence;
+        if (shouldRunReflection(cadence, state, true)) {
+          try {
+            const patch = await reflectNode(state, cadence);
+            if (patch && Object.keys(patch).length > 0) {
+              state = { ...state, ...patch };
+            }
+          } catch {
+          }
+        }
+      }
     }
     if (soManager && !state.ctx?.__finalizedDueToStructuredOutput) {
       const lastForParse = state.messages[state.messages.length - 1];
@@ -3990,40 +4224,6 @@ function createAgentNode(opts) {
 }
 
 // src/smart/contextPolicy.ts
-function collectRecentFullToolCallIds(state, keepRecentFullCount) {
-  if (!keepRecentFullCount || keepRecentFullCount <= 0) return /* @__PURE__ */ new Set();
-  const history = state.toolHistory || [];
-  const ids = [];
-  for (let index = history.length - 1; index >= 0 && ids.length < keepRecentFullCount; index -= 1) {
-    const entry = history[index];
-    if (!entry || !entry.tool_call_id) continue;
-    if (entry.status && entry.status !== "success") continue;
-    ids.push(entry.tool_call_id);
-  }
-  return new Set(ids);
-}
-function applyRecentFullOverride(messages, state, config) {
-  const keepN = config.toolResponses.keepRecentFullCount;
-  if (!keepN || keepN <= 0) return messages;
-  const recentIds = collectRecentFullToolCallIds(state, keepN);
-  if (recentIds.size === 0) return messages;
-  const history = state.toolHistory || [];
-  const byCallId = /* @__PURE__ */ new Map();
-  for (const entry of history) {
-    if (entry?.tool_call_id) byCallId.set(entry.tool_call_id, entry);
-  }
-  return messages.map((message) => {
-    if (message.role !== "tool" || !message.tool_call_id) return message;
-    if (!recentIds.has(message.tool_call_id)) return message;
-    const entry = byCallId.get(message.tool_call_id);
-    if (!entry) return message;
-    const raw = entry.rawOutput ?? entry.output;
-    if (raw === void 0) return message;
-    const fullContent = typeof raw === "string" ? raw : safeStringify(raw);
-    if (!fullContent || fullContent === message.content) return message;
-    return { ...message, content: fullContent };
-  });
-}
 function collectRecentTurns(messages, lastTurnsToKeep) {
   if (lastTurnsToKeep <= 0) return [];
   const systemPrefix = messages.filter((message, index) => index === 0 && message.role === "system");
@@ -4124,7 +4324,7 @@ function clampToBudget(messages, maxContextTokens) {
 function buildModelMessages(state, config) {
   const rawMessages = state.messages || [];
   if (config.context.policy === "raw") {
-    return clampToBudget(applyRecentFullOverride(rawMessages, state, config), config.limits.maxContextTokens);
+    return clampToBudget(rawMessages, config.limits.maxContextTokens);
   }
   const recentMessages = collectRecentTurns(rawMessages, config.context.lastTurnsToKeep);
   const latestSummary = state.summaryRecords?.[state.summaryRecords.length - 1];
@@ -4144,7 +4344,7 @@ function buildModelMessages(state, config) {
     ...syntheticContextMessages,
     ...config.context.policy === "summary_only" ? body.filter((message) => message.role === "user" || message.role === "assistant").slice(-2) : body
   ];
-  return clampToBudget(applyRecentFullOverride(assembled, state, config), config.limits.maxContextTokens);
+  return clampToBudget(assembled, config.limits.maxContextTokens);
 }
 
 // src/nodes/contextSummarize.ts
@@ -4246,24 +4446,8 @@ function extractCanonicalFacts(messages) {
   }
   return [...facts.values()];
 }
-function flattenToolMessageContent(message) {
-  if (typeof message.content === "string") {
-    return message.content;
-  }
-  if (Array.isArray(message.content)) {
-    return message.content.map((part) => typeof part === "string" ? part : part?.text ?? part?.content ?? String(part ?? "")).join(" ");
-  }
-  return "";
-}
 function isSummarizedToolPlaceholder(content) {
-  return typeof content === "string" && (content === "SUMMARIZED" || content.startsWith("SUMMARIZED_TOOL_RESPONSE"));
-}
-function summarizeToolMessagePreview(message) {
-  const preview = flattenToolMessageContent(message).trim();
-  if (!preview) {
-    return "No summary available.";
-  }
-  return preview.length > 240 ? `${preview.slice(0, 240)}...` : preview;
+  return typeof content === "string" && (content === "SUMMARIZED" || content.startsWith("SUMMARIZED_TOOL_RESPONSE") || content.startsWith("ARCHIVED_TOOL_RESPONSE") || content.startsWith("STRUCTURED_TOOL_RESPONSE") || content.startsWith("DROPPED_TOOL_RESPONSE"));
 }
 function findToolHistoryEntry(state, toolCallId, toolName) {
   const entries = [
@@ -4289,29 +4473,6 @@ function findToolHistoryEntry(state, toolCallId, toolName) {
   }
   return void 0;
 }
-function buildSummarizedToolMessage(message, state) {
-  const toolName = message.name || "unknown_tool";
-  const toolCallId = message.tool_call_id;
-  const historyEntry = findToolHistoryEntry(state, toolCallId, toolName);
-  const executionId = historyEntry?.executionId;
-  const summary = historyEntry?.summary || summarizeToolMessagePreview(message);
-  const references = [
-    `toolName=${toolName}`,
-    toolCallId ? `toolCallId=${toolCallId}` : null,
-    executionId ? `executionId=${executionId}` : null
-  ].filter(Boolean).join("; ");
-  let retrievalHint = "Only use get_tool_response if this summary is missing a specific field, id, snippet, or exact payload you still need.";
-  if (executionId && toolCallId) {
-    retrievalHint = `Only use get_tool_response with executionId "${executionId}" or tool call id "${toolCallId}" if this summary is missing a specific field, id, snippet, or exact payload you still need.`;
-  } else if (executionId || toolCallId) {
-    retrievalHint = `Only use get_tool_response with executionId "${executionId || toolCallId}" if this summary is missing a specific field, id, snippet, or exact payload you still need.`;
-  }
-  return [
-    `SUMMARIZED_TOOL_RESPONSE [${references}]`,
-    `Summary: ${summary}`,
-    retrievalHint
-  ].join("\n");
-}
 function mergeStableFacts(summary, additionalFacts) {
   if (additionalFacts.length === 0) return summary;
   const merged = new Map(summary.stable_facts.map((fact) => [fact.key, fact]));
@@ -4369,20 +4530,13 @@ function createContextSummarizeNode(opts) {
     const messages = state.messages || [];
     const onEvent = state.ctx?.__onEvent;
     const traceSession = state.ctx?.__traceSession;
-    const toolResponsesConfigEarly = resolved.toolResponses;
-    const recentFullToolCallIdsEarly = collectRecentFullToolCallIds(state, toolResponsesConfigEarly.keepRecentFullCount);
     const compressableMessages = messages.filter(
       (m) => {
         if (m.role !== "tool") return false;
         if (isSummarizedToolPlaceholder(m.content)) return false;
         if (isSyntheticSummaryMessage(m)) return false;
-        if (m.tool_call_id && recentFullToolCallIdsEarly.has(m.tool_call_id)) return false;
-        const histEntry = findToolHistoryEntry(state, m.tool_call_id, m.name);
-        if (histEntry?.retentionPolicy === "keep_full") return false;
-        if (!histEntry?.retentionPolicy) {
-          const byTool = toolResponsesConfigEarly.toolResponseRetentionByTool?.[m.name || ""];
-          if ((byTool || toolResponsesConfigEarly.defaultPolicy) === "keep_full") return false;
-        }
+        const policy = resolveSummarizationRetention(m.name || "", resolved);
+        if (policy === "keep_full") return false;
         return true;
       }
     );
@@ -4562,8 +4716,8 @@ ${canonicalFacts.length > 0 ? canonicalFacts.map((fact) => `- ${fact.key}: ${fac
         break;
       }
     }
-    const toolResponsesConfig = resolved.toolResponses;
-    const recentFullToolCallIds = collectRecentFullToolCallIds(state, toolResponsesConfig.keepRecentFullCount);
+    const archivedExecutions = [...state.toolHistoryArchived || []];
+    const archivedIds = new Set(archivedExecutions.map((entry) => entry?.executionId).filter(Boolean));
     const newMessages = messages.map((m) => {
       if (m.role === "tool") {
         if (isSyntheticSummaryMessage(m)) {
@@ -4575,25 +4729,39 @@ ${canonicalFacts.length > 0 ? canonicalFacts.map((fact) => `- ${fact.key}: ${fac
         }
         if (isSummarizedToolPlaceholder(m.content)) return m;
         if (toolCallId && protectedToolCallIds.has(toolCallId)) return m;
-        if (toolCallId && recentFullToolCallIds.has(toolCallId)) return m;
         const toolName = m.name || "";
+        const policy = resolveSummarizationRetention(toolName, resolved);
+        if (policy === "keep_full") return m;
         const historyEntry = findToolHistoryEntry(state, toolCallId, toolName);
-        const entryRetention = historyEntry?.retentionPolicy;
-        if (entryRetention === "keep_full") return m;
-        if (!entryRetention) {
-          const byTool = toolResponsesConfig.toolResponseRetentionByTool?.[toolName];
-          const configPolicy = byTool || toolResponsesConfig.defaultPolicy;
-          if (configPolicy === "keep_full") return m;
+        const rawOutput = historyEntry?.rawOutput ?? historyEntry?.output ?? m.content;
+        const executionId = historyEntry?.executionId;
+        const prebuiltSummary = historyEntry?.summary || summarizeObject(rawOutput);
+        if ((policy === "summarize_archive" || policy === "drop") && historyEntry && executionId && !archivedIds.has(executionId)) {
+          archivedExecutions.push({
+            ...historyEntry,
+            summarized: true,
+            retentionPolicy: policy,
+            archiveId: executionId,
+            summary: prebuiltSummary
+          });
+          archivedIds.add(executionId);
         }
         return {
           ...m,
-          content: buildSummarizedToolMessage(m, state)
+          content: renderRetainedToolMessage({
+            policy,
+            rawOutput,
+            toolName,
+            toolCallId,
+            executionId,
+            prebuiltSummary
+          })
         };
       }
       return m;
     }).filter((m) => m !== null);
     const actuallyCompressed = newMessages.filter(
-      (m) => m.role === "tool" && typeof m.content === "string" && m.content.startsWith("SUMMARIZED_TOOL_RESPONSE") && !messages.some((orig) => orig.tool_call_id === m.tool_call_id && isSummarizedToolPlaceholder(orig.content))
+      (m) => m.role === "tool" && isSummarizedToolPlaceholder(m.content) && !messages.some((orig) => orig.tool_call_id === m.tool_call_id && isSummarizedToolPlaceholder(orig.content))
     );
     if (actuallyCompressed.length === 0) {
       return {};
@@ -4672,7 +4840,8 @@ ${canonicalFacts.length > 0 ? canonicalFacts.map((fact) => `- ${fact.key}: ${fac
     return {
       messages: finalMessages,
       summaries,
-      summaryRecords
+      summaryRecords,
+      toolHistoryArchived: archivedExecutions
     };
   };
 }
@@ -5737,6 +5906,52 @@ function parseSSEBlock(block) {
   return { event, data: dataLines.join("\n"), id, retry };
 }
 
+// src/providers/utils/reasoning.ts
+function applyOpenAIReasoning(body, reasoning, mode = "legacy_effort") {
+  if (!reasoning) return;
+  const effort = normalizeEffort(reasoning.effort);
+  if (mode === "responses") {
+    const obj = {};
+    if (effort) obj.effort = effort;
+    if (reasoning.includeThoughts) obj.summary = "auto";
+    if (reasoning.providerExtras) Object.assign(obj, reasoning.providerExtras);
+    if (Object.keys(obj).length > 0) body.reasoning = obj;
+  } else {
+    if (effort) body.reasoning_effort = effort;
+    if (reasoning.providerExtras) Object.assign(body, reasoning.providerExtras);
+  }
+}
+function applyAnthropicReasoning(body, reasoning) {
+  if (!reasoning) return;
+  const budget = resolveBudget(reasoning, { low: 2048, medium: 8192, high: 16384, minimal: 1024 });
+  if (!budget) return;
+  const thinking = { type: "enabled", budget_tokens: budget };
+  if (reasoning.providerExtras) Object.assign(thinking, reasoning.providerExtras);
+  body.thinking = thinking;
+}
+function applyGeminiReasoning(generationConfig, reasoning) {
+  if (!reasoning) return;
+  const budget = resolveBudget(reasoning, { low: 1024, medium: 4096, high: 12e3, minimal: 512 });
+  if (budget == null) return;
+  const thinkingConfig = { thinkingBudget: budget };
+  if (reasoning.includeThoughts) thinkingConfig.includeThoughts = true;
+  if (reasoning.providerExtras) Object.assign(thinkingConfig, reasoning.providerExtras);
+  generationConfig.thinkingConfig = thinkingConfig;
+}
+function normalizeEffort(effort) {
+  if (!effort) return void 0;
+  const allowed = ["minimal", "low", "medium", "high"];
+  return allowed.includes(effort) ? effort : void 0;
+}
+function resolveBudget(reasoning, effortBudget) {
+  if (typeof reasoning.budgetTokens === "number" && reasoning.budgetTokens > 0) {
+    return Math.floor(reasoning.budgetTokens);
+  }
+  const effort = normalizeEffort(reasoning.effort);
+  if (effort && effortBudget[effort]) return effortBudget[effort];
+  return void 0;
+}
+
 // src/providers/openai.ts
 var OpenAIProvider = class extends BaseProvider {
   constructor(config) {
@@ -5852,6 +6067,7 @@ var OpenAIProvider = class extends BaseProvider {
     if (request.extra) {
       Object.assign(body, request.extra);
     }
+    applyOpenAIReasoning(body, request.reasoning, "legacy_effort");
     return body;
   }
   toOpenAIMessage(m) {
@@ -6110,6 +6326,7 @@ var AnthropicProvider = class extends BaseProvider {
     if (request.extra) {
       Object.assign(body, request.extra);
     }
+    applyAnthropicReasoning(body, request.reasoning);
     return body;
   }
   splitSystemMessages(messages) {
@@ -6764,6 +6981,7 @@ var VertexProvider = class extends BaseProvider {
         }
       }
     }
+    applyGeminiReasoning(generationConfig, request.reasoning);
     if (Object.keys(generationConfig).length > 0) body.generationConfig = generationConfig;
     if (request.tools?.length) {
       body.tools = [
@@ -7102,6 +7320,13 @@ function fromNativeProvider(provider, options) {
     if (opts?.maxTokens != null) req.maxTokens = opts.maxTokens;
     if (tools?.length) req.tools = tools;
     if (opts?.extra) req.extra = opts.extra;
+    const reasoningOverride = invokeOptions?.reasoning;
+    const reasoningCfg = reasoningOverride ?? opts?.reasoning;
+    if (reasoningCfg) req.reasoning = reasoningCfg;
+    const tc = invokeOptions?.tool_choice ?? invokeOptions?.toolChoice;
+    if (tc) {
+      req.toolChoice = tc;
+    }
     const rf = invokeOptions?.response_format;
     if (rf && typeof rf === "object" && rf.type) {
       if (rf.type === "json_schema" && rf.json_schema) {