@cognipeer/agent-sdk 0.6.4 → 0.6.5

package/dist/index.cjs

@@ -18,7 +18,99 @@ var path__default = /*#__PURE__*/_interopDefault(path);
 var crypto__default = /*#__PURE__*/_interopDefault(crypto);
 var AjvModule__default = /*#__PURE__*/_interopDefault(AjvModule);
 
-// src/adapters/langchain.ts
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/utils/utilTokens.ts
+var utilTokens_exports = {};
+__export(utilTokens_exports, {
+  countApproxTokens: () => countApproxTokens,
+  countMessagesTokens: () => countMessagesTokens,
+  defaultTokenCounter: () => defaultTokenCounter,
+  getTokenCounter: () => getTokenCounter,
+  setTokenCounter: () => setTokenCounter
+});
+function defaultTokenCounter(text) {
+  if (!text) return 0;
+  const nonAsciiCount = (text.match(/[^\x00-\x7F]/g) || []).length;
+  const asciiCount = text.length - nonAsciiCount;
+  return Math.ceil(asciiCount / 4 + nonAsciiCount / 1.5);
+}
+function setTokenCounter(counter) {
+  activeTokenCounter = typeof counter === "function" ? counter : defaultTokenCounter;
+}
+function getTokenCounter() {
+  return activeTokenCounter;
+}
+function countApproxTokens(text) {
+  return activeTokenCounter(text || "");
+}
+function extractMessageText(m) {
+  if (!m) return "";
+  const parts = [];
+  parts.push(m.role || "");
+  if (m.name) parts.push(m.name);
+  if (typeof m.content === "string") {
+    parts.push(m.content);
+  } else if (Array.isArray(m.content)) {
+    for (const c of m.content) {
+      if (typeof c === "string") parts.push(c);
+      else if (c?.text) parts.push(c.text);
+      else if (c?.content) parts.push(c.content);
+      else if (c?.type === "tool_use" && c?.input) {
+        parts.push(c.name || "");
+        parts.push(typeof c.input === "string" ? c.input : JSON.stringify(c.input));
+      } else if (c != null && typeof c === "object") {
+        parts.push(JSON.stringify(c));
+      }
+    }
+  } else if (m.content != null && typeof m.content === "object") {
+    parts.push(JSON.stringify(m.content));
+  }
+  if (Array.isArray(m.tool_calls)) {
+    for (const tc of m.tool_calls) {
+      if (tc?.function?.name) parts.push(tc.function.name);
+      if (tc?.function?.arguments) {
+        parts.push(
+          typeof tc.function.arguments === "string" ? tc.function.arguments : JSON.stringify(tc.function.arguments)
+        );
+      }
+      if (tc?.name && !tc?.function?.name) parts.push(tc.name);
+      if (tc?.args && !tc?.function?.arguments) {
+        parts.push(typeof tc.args === "string" ? tc.args : JSON.stringify(tc.args));
+      }
+    }
+  }
+  if (Array.isArray(m.additional_kwargs?.tool_calls)) {
+    for (const tc of m.additional_kwargs.tool_calls) {
+      if (tc?.function?.name) parts.push(tc.function.name);
+      if (tc?.function?.arguments) {
+        parts.push(
+          typeof tc.function.arguments === "string" ? tc.function.arguments : JSON.stringify(tc.function.arguments)
+        );
+      }
+    }
+  }
+  return parts.join("\n");
+}
+function countMessagesTokens(messages) {
+  if (!Array.isArray(messages) || messages.length === 0) return 0;
+  const allText = messages.map(extractMessageText).join("\n");
+  return countApproxTokens(allText) + messages.length * 4;
+}
+var activeTokenCounter;
+var init_utilTokens = __esm({
+  "src/utils/utilTokens.ts"() {
+    activeTokenCounter = defaultTokenCounter;
+  }
+});
 var moduleName = "@langchain/core/tools";
 var cachedToolFactory;
 var cachedHasAttemptedFactory = false;
@@ -326,7 +418,9 @@ function createTool({
   needsApproval,
   approvalPrompt,
   approvalDefaults,
-  maxExecutionsPerRun
+  maxExecutionsPerRun,
+  cache,
+  retry
 }) {
   const execute = async (input) => func(input);
   const toolRecord = {
@@ -351,6 +445,12 @@ function createTool({
   if (maxExecutionsPerRun !== void 0) {
     toolRecord.maxExecutionsPerRun = maxExecutionsPerRun;
   }
+  if (cache !== void 0) {
+    toolRecord.cache = cache;
+  }
+  if (retry !== void 0) {
+    toolRecord.retry = retry;
+  }
   toolRecord.__source = toolRecord.__source || "smart";
   toolRecord.__impl = func;
   return toolRecord;
@@ -1892,7 +1992,8 @@ function createAgentCoreNode(opts) {
       todoListPrompt: opts.todoListPrompt,
       limits: opts.limits,
       outputSchema: opts.outputSchema,
-      tracing: opts.tracing
+      tracing: opts.tracing,
+      responseFormat: void 0
     };
     const tools = runtime.tools ?? [];
     const shouldUseStrictToolCalling = Boolean(
@@ -2094,7 +2195,7 @@ function createAgentCoreNode(opts) {
 // src/smart/runtimeConfig.ts
 var DEFAULT_CRITICAL_TOOLS = ["response", "manage_todo_list", "get_tool_response"];
 var BASE_DEFAULTS = {
-  limits: { maxToolCalls: 8, maxParallelTools: 2, maxContextTokens: 24e3 },
+  limits: { maxToolCalls: 8, maxParallelTools: 2, maxContextTokens: 24e3, maxTotalOutputTokens: 0, maxCostUsd: 0, maxWallClockMs: 0 },
   summarization: {
     enable: true,
     maxTokens: 24e3,
@@ -2221,7 +2322,10 @@ function mergeLimits(base, override) {
   return {
     maxToolCalls: override?.maxToolCalls ?? base.maxToolCalls,
     maxParallelTools: override?.maxParallelTools ?? base.maxParallelTools,
-    maxContextTokens: override?.maxContextTokens ?? base.maxContextTokens
+    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) {
@@ -2299,66 +2403,8 @@ function getResolvedSmartConfig(opts, runtime) {
   return runtime?.smart || normalizeSmartAgentOptions(opts);
 }
 
-// src/utils/utilTokens.ts
-function countApproxTokens(text) {
-  if (!text) return 0;
-  const nonAsciiCount = (text.match(/[^\x00-\x7F]/g) || []).length;
-  const asciiCount = text.length - nonAsciiCount;
-  return Math.ceil(asciiCount / 4 + nonAsciiCount / 1.5);
-}
-function extractMessageText(m) {
-  if (!m) return "";
-  const parts = [];
-  parts.push(m.role || "");
-  if (m.name) parts.push(m.name);
-  if (typeof m.content === "string") {
-    parts.push(m.content);
-  } else if (Array.isArray(m.content)) {
-    for (const c of m.content) {
-      if (typeof c === "string") parts.push(c);
-      else if (c?.text) parts.push(c.text);
-      else if (c?.content) parts.push(c.content);
-      else if (c?.type === "tool_use" && c?.input) {
-        parts.push(c.name || "");
-        parts.push(typeof c.input === "string" ? c.input : JSON.stringify(c.input));
-      } else if (c != null && typeof c === "object") {
-        parts.push(JSON.stringify(c));
-      }
-    }
-  } else if (m.content != null && typeof m.content === "object") {
-    parts.push(JSON.stringify(m.content));
-  }
-  if (Array.isArray(m.tool_calls)) {
-    for (const tc of m.tool_calls) {
-      if (tc?.function?.name) parts.push(tc.function.name);
-      if (tc?.function?.arguments) {
-        parts.push(
-          typeof tc.function.arguments === "string" ? tc.function.arguments : JSON.stringify(tc.function.arguments)
-        );
-      }
-      if (tc?.name && !tc?.function?.name) parts.push(tc.name);
-      if (tc?.args && !tc?.function?.arguments) {
-        parts.push(typeof tc.args === "string" ? tc.args : JSON.stringify(tc.args));
-      }
-    }
-  }
-  if (Array.isArray(m.additional_kwargs?.tool_calls)) {
-    for (const tc of m.additional_kwargs.tool_calls) {
-      if (tc?.function?.name) parts.push(tc.function.name);
-      if (tc?.function?.arguments) {
-        parts.push(
-          typeof tc.function.arguments === "string" ? tc.function.arguments : JSON.stringify(tc.function.arguments)
-        );
-      }
-    }
-  }
-  return parts.join("\n");
-}
-function countMessagesTokens(messages) {
-  if (!Array.isArray(messages) || messages.length === 0) return 0;
-  const allText = messages.map(extractMessageText).join("\n");
-  return countApproxTokens(allText) + messages.length * 4;
-}
+// src/smart/toolResponses.ts
+init_utilTokens();
 
 // src/utils/content.ts
 function contentToString(content) {
@@ -2558,6 +2604,7 @@ function createToolsNode(initialTools, opts) {
         anyTool._stateRef.messages = state.messages;
         anyTool._stateRef.ctx = state.ctx || (state.ctx = {});
         anyTool._stateRef.__onEvent = onEvent;
+        anyTool._stateRef.parentRuntime = runtime;
       }
     }
     const last = state.messages[state.messages.length - 1];
@@ -2568,6 +2615,7 @@ function createToolsNode(initialTools, opts) {
     const remaining = Math.max(0, limits.maxToolCalls - toolCount);
     const planned = toolCalls.slice(0, remaining);
     const skipped = toolCalls.slice(remaining);
+    const orderedSlots = planned.map(() => []);
     const isCancelled = () => {
       if (abortSignal?.aborted) return { cancelled: true, reason: "aborted" };
       if (cancellationToken && cancellationToken.isCancellationRequested) return { cancelled: true, reason: "cancelled" };
@@ -2584,7 +2632,9 @@ function createToolsNode(initialTools, opts) {
       }
       state.ctx = ctx;
     };
-    const runOne = async (tc) => {
+    const runOne = async (tc, slot = appended) => {
+      var _a;
+      const push = (msg) => slot.push(msg);
       const cancelState = isCancelled();
       if (cancelState.cancelled) {
         const ctx = state.ctx = state.ctx || {};
@@ -2595,7 +2645,7 @@ function createToolsNode(initialTools, opts) {
       }
       const tool = toolByName.get(tc.name);
       if (!tool) {
-        appended.push({ role: "tool", content: `Tool not found: ${tc.name}`, tool_call_id: tc.id || `${tc.name}_${appended.length}`, name: tc.name });
+        push({ role: "tool", content: `Tool not found: ${tc.name}`, tool_call_id: tc.id || `${tc.name}_unknown`, name: tc.name });
         onEvent?.({ type: "tool_call", phase: "error", name: tc.name, id: tc.id, args: tc.args, error: { message: "Tool not found" } });
         toolCount += 1;
         return { status: "error" };
@@ -2611,7 +2661,7 @@ function createToolsNode(initialTools, opts) {
       const validatedArgs = validateToolArgs(tool, args);
       if (!validatedArgs.ok && resolved.toolResponses.schemaValidation === "strict") {
         const errorMessage = `Tool argument validation failed for ${tc.name}: ${validatedArgs.message}`;
-        appended.push({ role: "tool", content: errorMessage, tool_call_id: toolCallId, name: tc.name });
+        push({ role: "tool", content: errorMessage, tool_call_id: toolCallId, name: tc.name });
         markToolFailure(errorMessage, tc.name, toolCallId);
         onEvent?.({ type: "tool_call", phase: "error", name: tc.name, id: tc.id, args, error: { message: errorMessage } });
         toolCount += 1;
@@ -2633,7 +2683,7 @@ function createToolsNode(initialTools, opts) {
         const currentExecutions = countSuccessfulToolExecutions(toolHistory, toolName);
         if (currentExecutions >= maxExecutionsPerRun) {
           const limitMessage = `Skipped tool due to per-tool execution limit: ${toolName} (${maxExecutionsPerRun}/run)`;
-          appended.push({ role: "tool", content: limitMessage, tool_call_id: toolCallId, name: tc.name });
+          push({ role: "tool", content: limitMessage, tool_call_id: toolCallId, name: tc.name });
           onEvent?.({ type: "tool_call", phase: "skipped", name: toolName, id: tc.id, args });
           recordTraceEvent(traceSession, {
             type: "tool_call",
@@ -2693,7 +2743,7 @@ function createToolsNode(initialTools, opts) {
         }
         if (approvalEntry.status === "rejected") {
           const rejectionMessage = approvalEntry.comment || "Tool call rejected by reviewer.";
-          appended.push({ role: "tool", content: `Tool call rejected: ${rejectionMessage}`, tool_call_id: toolCallId, name: tc.name });
+          push({ role: "tool", content: `Tool call rejected: ${rejectionMessage}`, tool_call_id: toolCallId, name: tc.name });
           approvalEntry.metadata = { ...approvalEntry.metadata || {}, resolution: "rejected" };
           approvalEntry.status = "executed";
           approvalEntry.resolvedAt = (/* @__PURE__ */ new Date()).toISOString();
@@ -2711,23 +2761,102 @@ function createToolsNode(initialTools, opts) {
       const start = Date.now();
       const sanitizedArgs = sanitizeTracePayload(args);
       const inputBytes = traceSession?.resolvedConfig.logData ? estimatePayloadBytes(sanitizedArgs) : void 0;
+      const cacheCfg = tool.cache;
+      const cacheEnabled = cacheCfg === true || cacheCfg && typeof cacheCfg === "object";
+      const cacheKeyFn = cacheEnabled && typeof cacheCfg === "object" ? cacheCfg.keyFn : void 0;
+      const stableJson = (value) => {
+        try {
+          if (value === null || typeof value !== "object") return JSON.stringify(value);
+          if (Array.isArray(value)) return `[${value.map(stableJson).join(",")}]`;
+          const keys = Object.keys(value).sort();
+          return `{${keys.map((k) => JSON.stringify(k) + ":" + stableJson(value[k])).join(",")}}`;
+        } catch {
+          return String(value);
+        }
+      };
+      const cacheKey = cacheEnabled ? `${toolName}|${cacheKeyFn ? cacheKeyFn(args) : stableJson(args)}` : void 0;
+      const toolCache = state.toolCache = state.toolCache || {};
+      let cachedHit = void 0;
+      if (cacheKey && Object.prototype.hasOwnProperty.call(toolCache, cacheKey)) {
+        const entry = toolCache[cacheKey];
+        const ttl = cacheEnabled && typeof cacheCfg === "object" ? cacheCfg.ttlMs : void 0;
+        if (!ttl || entry?.timestamp && Date.now() - entry.timestamp <= ttl) {
+          cachedHit = entry?.value;
+        }
+      }
+      const retryCfg = tool.retry;
+      const failureStats = (_a = state.ctx).__toolFailureCounts || (_a.__toolFailureCounts = {});
+      if (retryCfg?.circuitBreakerThreshold && failureStats[toolName] >= retryCfg.circuitBreakerThreshold) {
+        const breakerMsg = `Tool ${toolName} circuit breaker open after ${failureStats[toolName]} consecutive failures`;
+        push({ role: "tool", content: breakerMsg, tool_call_id: toolCallId, name: tc.name });
+        markToolFailure(breakerMsg, toolName, toolCallId);
+        onEvent?.({ type: "tool_call", phase: "error", name: toolName, id: tc.id, args, error: { message: breakerMsg } });
+        toolCount += 1;
+        return { status: "error" };
+      }
       try {
+        if (cachedHit !== void 0) {
+          const executionId2 = nanoid.nanoid();
+          const responsePolicy2 = applyToolResponseHardCap(toolName, cachedHit, executionId2, resolved);
+          toolHistory.push({
+            executionId: executionId2,
+            toolName,
+            args,
+            output: cachedHit,
+            rawOutput: cachedHit,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+            tool_call_id: tc.id,
+            summarized: false,
+            originalTokenCount: responsePolicy2.tokenCount,
+            classification: responsePolicy2.classification,
+            retentionPolicy: "keep_full",
+            fromCache: true,
+            status: "success"
+          });
+          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 });
+          toolCount += 1;
+          return { status: "success" };
+        }
         onEvent?.({ type: "tool_call", phase: "start", name: toolName, id: tc.id, args });
         onProgress?.({ stage: "tools", message: `Running tool ${tc.name}` });
         const anyTool = tool;
         const callOptions = { cancellationToken, signal: abortSignal };
+        const invokeOnce = async () => {
+          if (typeof anyTool.func === "function") return anyTool.func(args, callOptions);
+          if (typeof anyTool.invoke === "function") return anyTool.invoke(args, callOptions);
+          if (typeof anyTool.call === "function") return anyTool.call(args, callOptions);
+          if (typeof anyTool._call === "function") return anyTool._call(args, callOptions);
+          if (typeof anyTool.run === "function") return anyTool.run(args, callOptions);
+          throw new Error("Tool is not invokable");
+        };
         let output;
-        if (typeof anyTool.func === "function") output = await anyTool.func(args, callOptions);
-        else if (typeof anyTool.invoke === "function") output = await anyTool.invoke(args, callOptions);
-        else if (typeof anyTool.call === "function") output = await anyTool.call(args, callOptions);
-        else if (typeof anyTool._call === "function") output = await anyTool._call(args, callOptions);
-        else if (typeof anyTool.run === "function") output = await anyTool.run(args, callOptions);
-        else throw new Error("Tool is not invokable");
+        const maxRetries = Math.max(0, Number(retryCfg?.maxRetries) || 0);
+        const backoffMs = Math.max(0, Number(retryCfg?.backoffMs) || 250);
+        let attempt = 0;
+        while (true) {
+          try {
+            output = await invokeOnce();
+            failureStats[toolName] = 0;
+            break;
+          } catch (retryErr) {
+            attempt += 1;
+            const shouldRetry = retryCfg?.shouldRetry ? retryCfg.shouldRetry(retryErr, attempt) : true;
+            if (attempt > maxRetries || !shouldRetry) {
+              failureStats[toolName] = (failureStats[toolName] || 0) + 1;
+              throw retryErr;
+            }
+            await new Promise((r) => setTimeout(r, backoffMs * Math.pow(2, attempt - 1)));
+          }
+        }
+        if (cacheKey) {
+          toolCache[cacheKey] = { value: output, timestamp: Date.now() };
+        }
         const durationMs = Date.now() - start;
         const executionId = nanoid.nanoid();
         if (output && typeof output === "object" && output.__handoff && output.__handoff.runtime) {
           toolHistory.push({ executionId, toolName, args, output: "handoff:ok", rawOutput: output, timestamp: (/* @__PURE__ */ new Date()).toISOString(), tool_call_id: tc.id, status: "handoff" });
-          appended.push({ role: "tool", content: "ok", tool_call_id: tc.id || `${tc.name}_${appended.length}`, name: tc.name });
+          push({ role: "tool", content: "ok", tool_call_id: tc.id || `${tc.name}_${toolCount}`, name: tc.name });
           state.agent = output.__handoff.runtime;
           onEvent?.({ type: "handoff", from: runtime.name, to: state.agent?.name, toolName });
           onEvent?.({ type: "tool_call", phase: "success", name: toolName, id: tc.id, args, result: "handoff", durationMs });
@@ -2779,7 +2908,7 @@ function createToolsNode(initialTools, opts) {
           archiveId: void 0,
           status: "success"
         });
-        appended.push({ role: "tool", content: responsePolicy.content, tool_call_id: tc.id || `${tc.name}_${appended.length}`, name: tc.name });
+        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 });
         onProgress?.({ stage: "tools", message: `Tool ${tc.name} completed`, detail: { durationMs } });
         if (needsApproval && approvalEntry) {
@@ -2835,7 +2964,7 @@ function createToolsNode(initialTools, opts) {
         const executionId = nanoid.nanoid();
         const message = error?.message || String(error);
         toolHistory.push({ executionId, toolName, args, output: `Error executing tool: ${message}`, rawOutput: null, timestamp: (/* @__PURE__ */ new Date()).toISOString(), tool_call_id: tc.id, status: "error" });
-        appended.push({ role: "tool", content: `Error executing tool: ${message}`, tool_call_id: tc.id || `${tc.name}_${appended.length}`, name: tc.name });
+        push({ role: "tool", content: `Error executing tool: ${message}`, tool_call_id: tc.id || `${tc.name}_${toolCount}`, name: tc.name });
         markToolFailure(message, toolName, toolCallId);
         onEvent?.({ type: "tool_call", phase: "error", name: toolName, id: tc.id, args, error: { message } });
         onProgress?.({ stage: "tools", message: `Tool ${tc.name} failed`, detail: { error: message } });
@@ -2872,22 +3001,67 @@ function createToolsNode(initialTools, opts) {
         return { status: "error", approval: approvalEntry };
       }
     };
-    for (const tc of planned) {
-      if (awaitingApproval) break;
+    const approvalIndices = [];
+    const parallelIndices = [];
+    planned.forEach((tc, idx) => {
+      const t = toolByName.get(tc.name);
+      if (t && t.needsApproval) approvalIndices.push(idx);
+      else parallelIndices.push(idx);
+    });
+    let shouldStop = false;
+    const checkCancellationStop = () => {
       const cancelState = isCancelled();
       if (cancelState.cancelled) {
         const ctx = state.ctx = state.ctx || {};
         ctx.__cancelled = { stage: "tools", reason: cancelState.reason, timestamp: (/* @__PURE__ */ new Date()).toISOString() };
         onEvent?.({ type: "cancelled", stage: "tools", reason: cancelState.reason });
         onProgress?.({ stage: "tools", message: "Cancelled", detail: { reason: cancelState.reason } });
-        break;
+        shouldStop = true;
+        return true;
       }
-      const result = await runOne(tc);
+      return false;
+    };
+    for (const idx of approvalIndices) {
+      if (awaitingApproval || shouldStop) break;
+      if (checkCancellationStop()) break;
+      const result = await runOne(planned[idx], orderedSlots[idx]);
       if (result.status === "awaiting_approval") {
         awaitingApproval = true;
         break;
       }
     }
+    if (!awaitingApproval && !shouldStop && parallelIndices.length > 0) {
+      const concurrency = Math.max(1, Math.min(limits.maxParallelTools, parallelIndices.length));
+      let cursor = 0;
+      const workerError = {};
+      const workers = [];
+      for (let w = 0; w < concurrency; w++) {
+        workers.push((async () => {
+          while (true) {
+            if (workerError.err || shouldStop || awaitingApproval) return;
+            const i = cursor++;
+            if (i >= parallelIndices.length) return;
+            if (checkCancellationStop()) return;
+            const idx = parallelIndices[i];
+            try {
+              const result = await runOne(planned[idx], orderedSlots[idx]);
+              if (result.status === "awaiting_approval") {
+                awaitingApproval = true;
+                return;
+              }
+            } catch (err) {
+              workerError.err = err;
+              return;
+            }
+          }
+        })());
+      }
+      await Promise.all(workers);
+      if (workerError.err) throw workerError.err;
+    }
+    for (const slot of orderedSlots) {
+      if (slot.length > 0) appended.push(...slot);
+    }
     for (const tc of skipped) {
       onEvent?.({ type: "tool_call", phase: "skipped", name: tc.name, id: tc.id, args: tc.args });
       const sanitizedArgs = sanitizeTracePayload(tc.args);
@@ -2923,11 +3097,23 @@ function createToolsNode(initialTools, opts) {
       }
       state.ctx = Object.keys(ctx).length > 0 ? ctx : void 0;
     }
+    const appendedHasToolResult = appended.some((m) => m.role === "tool");
+    if (appendedHasToolResult && state.ctx?.__summarizationExhausted) {
+      const ctx = { ...state.ctx };
+      delete ctx.__summarizationExhausted;
+      state.ctx = Object.keys(ctx).length > 0 ? ctx : void 0;
+    }
     return {
       messages: [...state.messages, ...appended],
       toolCallCount: toolCount,
       toolHistory,
       toolHistoryArchived,
+      toolCache: state.toolCache,
+      // Explicitly propagate ctx so callers using `{ ...state, ...delta }`
+      // do not silently capture a stale ctx reference. Mutations to
+      // __summarizationExhausted / __awaitingApproval / __structuredOutputParsed
+      // are made on this object during execution.
+      ctx: state.ctx,
       agent: state.agent,
       pendingApprovals
     };
@@ -3164,7 +3350,8 @@ function resolveReflection(input, preset) {
       maxChars: preset.maxChars,
       keepLast: 3,
       summarize: false,
-      emitEvents: true
+      emitEvents: true,
+      everyNTurns: 1
     };
   }
   const cfg = input ?? {};
@@ -3179,7 +3366,9 @@ function resolveReflection(input, preset) {
     keepLast: cfg.keepLast ?? 3,
     summarize: cfg.summarize ?? false,
     promptTemplate: cfg.promptTemplate,
-    emitEvents: cfg.emitEvents ?? true
+    emitEvents: cfg.emitEvents ?? true,
+    maxPerRun: typeof cfg.maxPerRun === "number" && cfg.maxPerRun >= 0 ? cfg.maxPerRun : void 0,
+    everyNTurns: Math.max(1, Math.trunc(cfg.everyNTurns ?? 1))
   };
 }
 function ensureArray(value) {
@@ -3392,6 +3581,9 @@ function resolveToolApprovalState(state, resolution) {
   };
 }
 
+// src/agent.ts
+init_utilTokens();
+
 // src/utils/syntheticMessages.ts
 function isSyntheticSummaryMessage(message) {
   if (!message) return false;
@@ -3570,6 +3762,21 @@ function getActiveSummarizationThreshold(opts) {
   }
   return summarization.summaryTriggerTokens || summarization.maxTokens || opts.limits?.maxContextTokens || 5e4;
 }
+function shouldSignalSummarization(state, threshold) {
+  const tokCountMessages = (state.messages || []).filter((message) => {
+    if (isSyntheticSummaryMessage(message)) return false;
+    if (message.role === "system" && (message.name === "context_summary" || message.name === "memory_context")) return false;
+    return true;
+  });
+  const tokenCount = countMessagesTokens(tokCountMessages);
+  if (tokenCount <= threshold) return "skip";
+  if (state.ctx?.__summarizationExhausted) return "skip";
+  const hasFreshSummary = (state.messages || []).some(
+    (m) => m.role === "tool" && typeof m.content === "string" && (m.content === "SUMMARIZED" || m.content.startsWith("SUMMARIZED_TOOL_RESPONSE"))
+  );
+  if (hasFreshSummary && tokenCount <= threshold * 1.15) return "skip";
+  return "trigger";
+}
 function clearNeedsSummarization(state) {
   if (!state.ctx?.__needsSummarization) {
     return state;
@@ -3664,6 +3871,45 @@ function createAgent(opts) {
     };
     const maxToolCalls = mergedLimits?.maxToolCalls === void 0 ? 50 : mergedLimits?.maxToolCalls;
     const iterationLimit = maxToolCalls === Infinity ? 100 : Math.max(maxToolCalls * 3 + 10, 40);
+    const wallClockStart = Date.now();
+    const maxWallClockMs = mergedLimits?.maxWallClockMs && mergedLimits.maxWallClockMs > 0 ? mergedLimits.maxWallClockMs : void 0;
+    const maxTotalOutputTokens = mergedLimits?.maxTotalOutputTokens && mergedLimits.maxTotalOutputTokens > 0 ? mergedLimits.maxTotalOutputTokens : void 0;
+    const maxCostUsd = mergedLimits?.maxCostUsd && mergedLimits.maxCostUsd > 0 ? mergedLimits.maxCostUsd : void 0;
+    const costEstimator = opts.costEstimator;
+    const checkBudgetBreached = () => {
+      if (maxWallClockMs && Date.now() - wallClockStart > maxWallClockMs) {
+        return { breached: true, reason: `maxWallClockMs (${maxWallClockMs}ms) exceeded` };
+      }
+      if (maxTotalOutputTokens) {
+        const totals = state.usage?.totals;
+        if (totals) {
+          let outputSum = 0;
+          for (const v of Object.values(totals)) outputSum += Number(v?.output) || 0;
+          if (outputSum > maxTotalOutputTokens) {
+            return { breached: true, reason: `maxTotalOutputTokens (${maxTotalOutputTokens}) exceeded` };
+          }
+        }
+      }
+      if (maxCostUsd && costEstimator) {
+        const perRequest = state.usage?.perRequest;
+        if (perRequest) {
+          let cost = 0;
+          for (const r of perRequest) {
+            cost += costEstimator({
+              modelName: r.modelName,
+              inputTokens: Number(r.usage?.prompt_tokens) || 0,
+              outputTokens: Number(r.usage?.completion_tokens) || 0,
+              cachedInputTokens: Number(r.usage?.prompt_tokens_details?.cached_tokens) || 0,
+              reasoningTokens: Number(r.usage?.completion_tokens_details?.reasoning_tokens) || 0
+            }) || 0;
+          }
+          if (cost > maxCostUsd) {
+            return { breached: true, reason: `maxCostUsd ($${maxCostUsd}) exceeded (actual: $${cost.toFixed(4)})` };
+          }
+        }
+      }
+      return { breached: false };
+    };
     let iterations = 0;
     const onStateChange = config?.onStateChange;
     const checkpointReason = config?.checkpointReason;
@@ -3712,6 +3958,13 @@ function createAgent(opts) {
     };
     while (iterations < iterationLimit) {
       iterations++;
+      const budget = checkBudgetBreached();
+      if (budget.breached) {
+        emit?.({ type: "metadata", limitBreached: budget.reason });
+        const ctx = { ...state.ctx || {}, __limitBreached: budget.reason };
+        state = { ...state, ctx };
+        break;
+      }
       const traceSession = state.ctx?.__traceSession;
       if (traceSession) {
         const iterEvent = recordTraceEvent(traceSession, {
@@ -3767,22 +4020,11 @@ function createAgent(opts) {
           }
         }
         if (summarizationThreshold !== void 0) {
-          const tokCountMessages = (state.messages || []).filter((message) => {
-            if (isSyntheticSummaryMessage(message)) return false;
-            if (message.role === "system" && (message.name === "context_summary" || message.name === "memory_context")) return false;
-            return true;
-          });
-          const tokenCount = countMessagesTokens(tokCountMessages);
-          if (tokenCount > summarizationThreshold) {
-            const summarizationExhausted = !!state.ctx?.__summarizationExhausted;
-            const hasFreshSummary = (state.messages || []).some(
-              (m) => m.role === "tool" && typeof m.content === "string" && (m.content === "SUMMARIZED" || m.content.startsWith("SUMMARIZED_TOOL_RESPONSE"))
-            );
-            if (hasFreshSummary && tokenCount <= summarizationThreshold * 1.15) ; else if (summarizationExhausted) ; else {
-              const ctx = { ...state.ctx || {}, __needsSummarization: true };
-              state = { ...state, ctx };
-              break;
-            }
+          const verdict = shouldSignalSummarization(state, summarizationThreshold);
+          if (verdict === "trigger") {
+            const ctx = { ...state.ctx || {}, __needsSummarization: true };
+            state = { ...state, ctx };
+            break;
           }
         }
         onProgress?.({ stage: "agent", message: "Invoking model" });
@@ -3888,7 +4130,13 @@ function createAgent(opts) {
       if (state.ctx?.__finalizedDueToStructuredOutput) break;
       if (reflectNode && resolvedReasoning?.reflection.enabled) {
         const cadence = resolvedReasoning.reflection.cadence;
-        if (shouldRunReflection(cadence, state, true)) {
+        const refl = resolvedReasoning.reflection;
+        const reflectionsSoFar = state.reflections?.length ?? 0;
+        const lastTurn = state.reflections?.at(-1)?.turn ?? -Infinity;
+        const currentTurn = state.toolCallCount || 0;
+        const budgetExceeded = typeof refl.maxPerRun === "number" && reflectionsSoFar >= refl.maxPerRun;
+        const cadenceGap = currentTurn - (Number.isFinite(lastTurn) ? lastTurn : -refl.everyNTurns) < refl.everyNTurns;
+        if (!budgetExceeded && !cadenceGap && shouldRunReflection(cadence, state, true)) {
           try {
             const patch = await reflectNode(state, cadence);
             if (patch && Object.keys(patch).length > 0) {
@@ -3948,7 +4196,7 @@ function createAgent(opts) {
     }
     const lastAfterLoop = state.messages[state.messages.length - 1];
     if (lastAfterLoop?.role === "tool" && !pausedStage) {
-      const isExpectedExit = state.ctx?.__awaitingApproval || state.ctx?.__cancelled || state.ctx?.__finalizedDueToStructuredOutput || state.ctx?.__finalizedDueToToolLimit || state.ctx?.__needsSummarization;
+      const isExpectedExit = state.ctx?.__awaitingApproval || state.ctx?.__cancelled || state.ctx?.__finalizedDueToStructuredOutput || state.ctx?.__finalizedDueToToolLimit || state.ctx?.__needsSummarization || state.ctx?.__limitBreached;
       if (!isExpectedExit) {
         throw new Error(
           "Agent loop terminated with a pending tool response but no subsequent model invocation. This usually indicates a model provider error or exhausted iteration budget."
@@ -3961,6 +4209,11 @@ function createAgent(opts) {
     return state;
   }
   const invokeAgent = async (input, config) => {
+    const userTokenCounter = opts.tokenCounter;
+    if (userTokenCounter) {
+      const { setTokenCounter: setTokenCounter2 } = await Promise.resolve().then(() => (init_utilTokens(), utilTokens_exports));
+      setTokenCounter2(userTokenCounter);
+    }
     const onEvent = config?.onEvent;
     const onProgress = config?.onProgress;
     const onStream = config?.onStream;
@@ -4018,7 +4271,19 @@ function createAgent(opts) {
         status: "error",
         error: { message: err?.message, stack: err?.stack }
       });
+      if (userTokenCounter) {
+        const { setTokenCounter: setTokenCounter2 } = await Promise.resolve().then(() => (init_utilTokens(), utilTokens_exports));
+        setTokenCounter2(void 0);
+      }
       throw err;
+    } finally {
+      if (userTokenCounter) {
+        try {
+          const { setTokenCounter: setTokenCounter2 } = await Promise.resolve().then(() => (init_utilTokens(), utilTokens_exports));
+          setTokenCounter2(void 0);
+        } catch {
+        }
+      }
     }
     await finalizeTraceSession(traceSession, {
       agentRuntime: res.agent || runtime,
@@ -4076,12 +4341,58 @@ function createAgent(opts) {
     resolveToolApproval,
     asTool: ({ toolName, description, inputDescription }) => {
       const schema = zod.z.object({ input: zod.z.string().describe(inputDescription || "Input for delegated agent") });
-      return createTool({
+      const delegatedTool = createTool({
         name: toolName,
         description: description || `Delegate task to agent ${opts.name || "Agent"}`,
         schema,
         func: async ({ input }) => {
-          const res = await instance.invoke({ messages: [{ role: "user", content: input }] });
+          const ref = delegatedTool._stateRef;
+          const parentCtx = ref.ctx || {};
+          const parentMessages = Array.isArray(ref.messages) ? ref.messages : [];
+          const parentRuntime = ref.parentRuntime;
+          const resolvedSmart = parentRuntime?.smart || opts.__resolvedSmart;
+          const delegationPolicy = resolvedSmart?.delegation || {
+            mode: "role_based",
+            maxDelegationDepth: 2,
+            maxChildCalls: 4,
+            childContextPolicy: "scoped"
+          };
+          const currentDepth = Number(parentCtx.__delegationDepth) || 0;
+          if (delegationPolicy.mode === "off") {
+            return { error: "Delegation disabled by runtime policy." };
+          }
+          if (currentDepth >= delegationPolicy.maxDelegationDepth) {
+            return {
+              error: `Delegation depth limit reached (${delegationPolicy.maxDelegationDepth}). Refusing nested call.`
+            };
+          }
+          parentCtx.__delegatedCallCount = (parentCtx.__delegatedCallCount || 0) + 1;
+          if (parentCtx.__delegatedCallCount > delegationPolicy.maxChildCalls) {
+            return {
+              error: `Child-call budget exhausted (${delegationPolicy.maxChildCalls}).`
+            };
+          }
+          let childMessages;
+          switch (delegationPolicy.childContextPolicy) {
+            case "full":
+              childMessages = [...parentMessages, { role: "user", content: input }];
+              break;
+            case "scoped": {
+              const systemPrefix = parentMessages[0]?.role === "system" ? [parentMessages[0]] : [];
+              const lastUser = [...parentMessages].reverse().find((m) => m?.role === "user");
+              childMessages = [
+                ...systemPrefix,
+                ...lastUser ? [lastUser] : [],
+                { role: "user", content: input }
+              ];
+              break;
+            }
+            case "minimal":
+            default:
+              childMessages = [{ role: "user", content: input }];
+          }
+          const childCtx = { __delegationDepth: currentDepth + 1 };
+          const res = await instance.invoke({ messages: childMessages, ctx: childCtx });
           return {
             content: res.content,
             output: res.output,
@@ -4089,6 +4400,8 @@ function createAgent(opts) {
           };
         }
       });
+      delegatedTool._stateRef = {};
+      return delegatedTool;
     },
     asHandoff: ({ toolName, description, schema }) => {
       const finalName = toolName || `handoff_to_${runtime.name || "agent"}`;
@@ -4228,7 +4541,11 @@ function createAgentNode(opts) {
   };
 }
 
+// src/nodes/contextSummarize.ts
+init_utilTokens();
+
 // src/smart/contextPolicy.ts
+init_utilTokens();
 function collectRecentTurns(messages, lastTurnsToKeep) {
   if (lastTurnsToKeep <= 0) return [];
   const systemPrefix = messages.filter((message, index) => index === 0 && message.role === "system");
@@ -4531,7 +4848,7 @@ function createContextSummarizeNode(opts) {
     const resolved = getResolvedSmartConfig(opts, state.agent);
     const config = resolved.summarization;
     if (!config.enable) return {};
-    const model = opts.model;
+    const model = state.agent?.model || opts.model;
     const messages = state.messages || [];
     const onEvent = state.ctx?.__onEvent;
     const traceSession = state.ctx?.__traceSession;
@@ -4850,6 +5167,10 @@ ${canonicalFacts.length > 0 ? canonicalFacts.map((fact) => `- ${fact.key}: ${fac
     };
   };
 }
+
+// src/index.ts
+init_utilTokens();
+init_utilTokens();
 var TOOL_RESPONSE_RECOVERY_MARKERS = [
   /ARCHIVED_TOOL_RESPONSE\s*\[/,
   /STRUCTURED_TOOL_RESPONSE\s*\[/,
@@ -5168,6 +5489,7 @@ function createContextTools(stateRef, opts) {
 }
 
 // src/graph/decisions.ts
+init_utilTokens();
 function needsSummarization(state, opts, summarizationEnabled) {
   if (!summarizationEnabled) {
     return false;
@@ -5330,12 +5652,24 @@ function createSmartAgent(opts) {
     toolResponses: resolved.toolResponses,
     useTodoList: planningEnabled
   };
-  const stateRef = { toolHistory: void 0, toolHistoryArchived: void 0, todoList: void 0, planVersion: 0, adherenceScore: 0 };
-  const contextTools = createContextTools(stateRef, { planningEnabled, includeGetToolResponse: false });
-  const getToolResponseTool = createGetToolResponseTool(stateRef);
-  const toolsWithoutRecovery = [...opts.tools ?? [], ...contextTools];
-  const toolsWithRecovery = [...toolsWithoutRecovery, getToolResponseTool];
-  const base = createAgent({ ...runtimeOpts, tools: toolsWithoutRecovery });
+  const userTools = opts.tools ?? [];
+  const factoryStateRef = { toolHistory: void 0, toolHistoryArchived: void 0, todoList: void 0, planVersion: 0, adherenceScore: 0 };
+  const factoryContextTools = createContextTools(factoryStateRef, { planningEnabled, includeGetToolResponse: false });
+  const factoryToolsWithoutRecovery = [...userTools, ...factoryContextTools];
+  const soManagerFactory = opts.outputSchema ? new StructuredOutputManager(opts.outputSchema, resolveStrategy(opts.model)) : void 0;
+  const modelCapabilities = opts.outputSchema ? getModelCapabilities(opts.model) : void 0;
+  const responseFinalizeTool = soManagerFactory && modelCapabilities?.structuredOutput !== "native" ? soManagerFactory.getResponseTool() : void 0;
+  const buildInvokeToolSet = () => {
+    const ref = { toolHistory: void 0, toolHistoryArchived: void 0, todoList: void 0, planVersion: 0, adherenceScore: 0 };
+    const ctxTools = createContextTools(ref, { planningEnabled, includeGetToolResponse: false });
+    const recoveryTool = createGetToolResponseTool(ref);
+    const base2 = [...userTools, ...ctxTools];
+    if (responseFinalizeTool) base2.push(responseFinalizeTool);
+    const without = base2;
+    const withRec = [...without, recoveryTool];
+    return { stateRef: ref, toolsWithoutRecovery: without, toolsWithRecovery: withRec };
+  };
+  const base = createAgent({ ...runtimeOpts, tools: factoryToolsWithoutRecovery });
   base.__runtime.runtimeProfile = resolved.runtimeProfile;
   base.__runtime.smart = resolved;
   const summarizationEnabled = resolved.summarization.enable !== false;
@@ -5371,17 +5705,17 @@ function createSmartAgent(opts) {
     const memoryFacts = await writeSummaryFactsToMemory(memoryStore, resolved, latestSummary, Math.max(1, (state.messages || []).filter((message) => message.role === "user").length));
     return { ...state, memoryFacts };
   }
-  function syncPlanState(state) {
-    if (!Array.isArray(stateRef.todoList)) return state;
+  function syncPlanStateWith(ref, state) {
+    if (!Array.isArray(ref.todoList)) return state;
     return {
       ...state,
       plan: {
-        version: stateRef.planVersion || state.planVersion || 1,
-        steps: stateRef.todoList,
+        version: ref.planVersion || state.planVersion || 1,
+        steps: ref.todoList,
         lastUpdated: (/* @__PURE__ */ new Date()).toISOString(),
-        adherenceScore: stateRef.adherenceScore || 0
+        adherenceScore: ref.adherenceScore || 0
       },
-      planVersion: stateRef.planVersion || state.planVersion || 1
+      planVersion: ref.planVersion || state.planVersion || 1
     };
   }
   function systemMessage2() {
@@ -5393,9 +5727,9 @@ function createSmartAgent(opts) {
     );
     return { role: "system", content: sys };
   }
-  function syncRuntimeTools(currentState, currentMessages) {
+  function syncRuntimeTools(currentState, currentMessages, toolSet) {
     const needsRecoveryTool = hasToolResponseRecoveryReference(currentMessages);
-    const nextTools = needsRecoveryTool ? toolsWithRecovery : toolsWithoutRecovery;
+    const nextTools = needsRecoveryTool ? toolSet.toolsWithRecovery : toolSet.toolsWithoutRecovery;
     const currentRuntime = currentState.agent || base.__runtime;
     if (currentRuntime.tools === nextTools) {
       return currentState;
@@ -5414,7 +5748,7 @@ function createSmartAgent(opts) {
     const toolCalls = Array.isArray(lastAssistant.tool_calls) ? lastAssistant.tool_calls : [];
     return toolCalls.length === 0;
   }
-  async function trySummarize(currentState, currentRawMessages) {
+  async function trySummarize(currentState, currentRawMessages, ref) {
     if (!summarizer) return { state: currentState, rawMessages: currentRawMessages, compressed: false };
     const delta = await summarizer(currentState);
     if (!delta || Object.keys(delta).length === 0) {
@@ -5423,28 +5757,31 @@ function createSmartAgent(opts) {
     }
     const ctx = { ...currentState.ctx || {} };
     delete ctx.__summarizationExhausted;
-    const updated = await persistLatestSummary(syncPlanState({ ...currentState, ...delta, ctx }));
+    const updated = await persistLatestSummary(syncPlanStateWith(ref, { ...currentState, ...delta, ctx }));
     return { state: updated, rawMessages: [...updated.messages || currentRawMessages], compressed: true };
   }
   const instance = {
     invoke: async (input, config) => {
+      const toolSet = buildInvokeToolSet();
+      const stateRef = toolSet.stateRef;
       stateRef.toolHistory = input.toolHistory;
       stateRef.toolHistoryArchived = input.toolHistoryArchived;
       stateRef.todoList = input.plan?.steps;
       stateRef.planVersion = input.planVersion || input.plan?.version || 0;
       stateRef.adherenceScore = input.plan?.adherenceScore || 0;
+      const syncPlanFromRef = (state2) => syncPlanStateWith(stateRef, state2);
       const alreadyHasSystem = Array.isArray(input.messages) && input.messages[0]?.role === "system";
       const seedMessages = alreadyHasSystem ? [...input.messages || []] : [systemMessage2(), ...input.messages || []];
-      let state = syncRuntimeTools(await syncMemory({ ...input, messages: seedMessages }), seedMessages);
+      let state = syncRuntimeTools(await syncMemory({ ...input, messages: seedMessages }), seedMessages, toolSet);
       let lastResult = null;
       let rawMessages = [...seedMessages];
       const effectiveMaxToolCalls = config?.limits?.maxToolCalls ?? resolved.limits.maxToolCalls ?? 10;
       const iterationLimit = Math.max(effectiveMaxToolCalls * 3 + 5, 30);
       for (let i = 0; i < iterationLimit; i++) {
-        state = syncRuntimeTools({ ...state, messages: rawMessages }, rawMessages);
+        state = syncRuntimeTools({ ...state, messages: rawMessages }, rawMessages, toolSet);
         const next = summarizationEnabled ? decideBefore(state) : "agent";
         if (next === "contextSummarize" && summarizer) {
-          const result = await trySummarize(state, rawMessages);
+          const result = await trySummarize(state, rawMessages, stateRef);
           state = result.state;
           rawMessages = result.rawMessages;
           if (result.compressed) continue;
@@ -5468,14 +5805,14 @@ function createSmartAgent(opts) {
         if (currentPlan && !state.plan) {
           state = { ...state, plan: currentPlan };
         }
-        state = syncRuntimeTools(syncPlanState(await syncMemory(state)), rawMessages);
+        state = syncRuntimeTools(syncPlanFromRef(await syncMemory(state)), rawMessages, toolSet);
         stateRef.toolHistory = state.toolHistory;
         stateRef.toolHistoryArchived = state.toolHistoryArchived;
         if (state.ctx?.__needsSummarization && summarizer) {
           const ctx = { ...state.ctx || {} };
           delete ctx.__needsSummarization;
           state = { ...state, ctx };
-          const result = await trySummarize(state, rawMessages);
+          const result = await trySummarize(state, rawMessages, stateRef);
           state = result.state;
           rawMessages = result.rawMessages;
           continue;
@@ -5486,7 +5823,7 @@ function createSmartAgent(opts) {
         if (summarizationEnabled) {
           const after = decideAfter(state);
           if (after === "contextSummarize" && summarizer) {
-            const result = await trySummarize(state, rawMessages);
+            const result = await trySummarize(state, rawMessages, stateRef);
             state = result.state;
             rawMessages = result.rawMessages;
             if (result.compressed) continue;
@@ -5925,7 +6262,50 @@ var ProviderError = class extends Error {
 };
 
 // src/providers/base.ts
+var DEFAULT_RETRY = {
+  maxRetries: 3,
+  baseDelayMs: 500,
+  maxDelayMs: 8e3
+};
 var BaseProvider = class {
+  constructor() {
+    this.retryPolicy = DEFAULT_RETRY;
+  }
+  /**
+   * Helper concrete providers can wrap their fetch with. Retries 429/5xx
+   * with exponential backoff and respects Retry-After if the response
+   * carries one.
+   */
+  async doFetchWithRetry(execute) {
+    const policy = this.retryPolicy;
+    const maxRetries = Math.max(0, policy.maxRetries ?? DEFAULT_RETRY.maxRetries);
+    const baseDelay = Math.max(0, policy.baseDelayMs ?? DEFAULT_RETRY.baseDelayMs);
+    const maxDelay = Math.max(baseDelay, policy.maxDelayMs ?? DEFAULT_RETRY.maxDelayMs);
+    let lastResp;
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+      const res = await execute();
+      const isRetryable = res.status === 429 || res.status >= 500 && res.status < 600;
+      if (!isRetryable) return res;
+      const predicate = policy.shouldRetry;
+      if (predicate && !predicate({ status: res.status }, attempt)) return res;
+      if (attempt === maxRetries) {
+        lastResp = res;
+        break;
+      }
+      const retryAfter = res.headers.get("retry-after");
+      let delay = Math.min(maxDelay, baseDelay * Math.pow(2, attempt));
+      if (retryAfter) {
+        const asNumber = Number(retryAfter);
+        if (!Number.isNaN(asNumber)) delay = Math.min(maxDelay, Math.max(delay, asNumber * 1e3));
+      }
+      try {
+        await res.text();
+      } catch {
+      }
+      await new Promise((r) => setTimeout(r, delay));
+    }
+    return lastResp;
+  }
 };
 
 // src/providers/utils/sse.ts
@@ -6052,6 +6432,7 @@ var OpenAIProvider = class extends BaseProvider {
       ...config.defaultHeaders,
       ...config.organization ? { "OpenAI-Organization": config.organization } : {}
     };
+    if (config.retry) this.retryPolicy = { ...this.retryPolicy, ...config.retry };
   }
   async complete(request) {
     const body = this.buildRequestBody(request, false);
@@ -6199,15 +6580,13 @@ var OpenAIProvider = class extends BaseProvider {
   }
   async doFetch(body) {
     const url = `${this.baseURL}/chat/completions`;
-    const res = await fetch(url, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${this.apiKey}`,
-        ...this.defaultHeaders
-      },
-      body: JSON.stringify(body)
-    });
+    const headers = {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${this.apiKey}`,
+      ...this.defaultHeaders
+    };
+    const payload = JSON.stringify(body);
+    const res = await this.doFetchWithRetry(() => fetch(url, { method: "POST", headers, body: payload }));
     if (!res.ok) {
       const text = await res.text().catch(() => "");
       throw new ProviderError(
@@ -6277,6 +6656,8 @@ var AnthropicProvider = class extends BaseProvider {
     this.defaultModel = config.defaultModel ?? "claude-sonnet-4-20250514";
     this.defaultHeaders = config.defaultHeaders ?? {};
     this.anthropicVersion = config.anthropicVersion ?? "2023-06-01";
+    this.promptCachingEnabled = config.prompt_caching?.enabled === true;
+    if (config.retry) this.retryPolicy = { ...this.retryPolicy, ...config.retry };
   }
   async complete(request) {
     const body = this.buildRequestBody(request, false);
@@ -6395,12 +6776,22 @@ var AnthropicProvider = class extends BaseProvider {
       max_tokens: request.maxTokens ?? 4096,
       stream
     };
-    if (system) body.system = system;
+    if (system) {
+      if (this.promptCachingEnabled) {
+        body.system = [{ type: "text", text: system, cache_control: { type: "ephemeral" } }];
+      } else {
+        body.system = system;
+      }
+    }
     if (request.temperature != null) body.temperature = request.temperature;
     if (request.topP != null) body.top_p = request.topP;
     if (request.stop) body.stop_sequences = request.stop;
     if (request.tools?.length) {
-      body.tools = request.tools.map((t) => this.toAnthropicTool(t));
+      const tools = request.tools.map((t) => this.toAnthropicTool(t));
+      if (this.promptCachingEnabled && tools.length > 0) {
+        tools[tools.length - 1] = { ...tools[tools.length - 1], cache_control: { type: "ephemeral" } };
+      }
+      body.tools = tools;
     }
     if (request.toolChoice != null) {
       if (request.toolChoice === "auto") {
@@ -6499,16 +6890,14 @@ var AnthropicProvider = class extends BaseProvider {
   }
   async doFetch(body) {
     const url = `${this.baseURL}/v1/messages`;
-    const res = await fetch(url, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        "x-api-key": this.apiKey,
-        "anthropic-version": this.anthropicVersion,
-        ...this.defaultHeaders
-      },
-      body: JSON.stringify(body)
-    });
+    const headers = {
+      "Content-Type": "application/json",
+      "x-api-key": this.apiKey,
+      "anthropic-version": this.anthropicVersion,
+      ...this.defaultHeaders
+    };
+    const payload = JSON.stringify(body);
+    const res = await this.doFetchWithRetry(() => fetch(url, { method: "POST", headers, body: payload }));
     if (!res.ok) {
       const text = await res.text().catch(() => "");
       throw new ProviderError(
@@ -6720,6 +7109,8 @@ var BedrockProvider = class extends BaseProvider {
     this.region = config.region;
     this.defaultModel = config.defaultModel ?? "anthropic.claude-sonnet-4-20250514-v1:0";
     this.defaultHeaders = config.defaultHeaders ?? {};
+    this.promptCachingEnabled = config.prompt_caching?.enabled === true;
+    if (config.retry) this.retryPolicy = { ...this.retryPolicy, ...config.retry };
     this.credentials = {
       accessKeyId: config.accessKeyId ?? process.env.AWS_ACCESS_KEY_ID ?? "",
       secretAccessKey: config.secretAccessKey ?? process.env.AWS_SECRET_ACCESS_KEY ?? "",
@@ -6758,7 +7149,9 @@ var BedrockProvider = class extends BaseProvider {
       messages: messages.map((m) => this.toBedrockMessage(m))
     };
     if (system.length > 0) {
-      body.system = system.map((s) => ({ text: s }));
+      const systemBlocks = system.map((s) => ({ text: s }));
+      if (this.promptCachingEnabled) systemBlocks.push({ cachePoint: { type: "default" } });
+      body.system = systemBlocks;
     }
     const inferenceConfig = {};
     if (request.maxTokens != null) inferenceConfig.maxTokens = request.maxTokens;
@@ -6767,8 +7160,12 @@ var BedrockProvider = class extends BaseProvider {
     if (request.stop) inferenceConfig.stopSequences = request.stop;
     if (Object.keys(inferenceConfig).length > 0) body.inferenceConfig = inferenceConfig;
     if (request.tools?.length) {
+      const tools = request.tools.map((t) => this.toBedrockTool(t));
+      if (this.promptCachingEnabled && tools.length > 0) {
+        tools.push({ cachePoint: { type: "default" } });
+      }
       body.toolConfig = {
-        tools: request.tools.map((t) => this.toBedrockTool(t))
+        tools
       };
       if (request.toolChoice != null) {
         if (request.toolChoice === "auto") {
@@ -6865,23 +7262,21 @@ var BedrockProvider = class extends BaseProvider {
     const host = `bedrock-runtime.${this.region}.amazonaws.com`;
     const url = `https://${host}/model/${encodeURIComponent(modelId)}/converse`;
     const bodyStr = JSON.stringify(body);
-    const headers = signRequest({
-      method: "POST",
-      url,
-      headers: {
-        "Content-Type": "application/json",
-        Accept: "application/json",
-        ...this.defaultHeaders
-      },
-      body: bodyStr,
-      region: this.region,
-      service: "bedrock",
-      credentials: this.credentials
-    });
-    const res = await fetch(url, {
-      method: "POST",
-      headers,
-      body: bodyStr
+    const res = await this.doFetchWithRetry(() => {
+      const headers = signRequest({
+        method: "POST",
+        url,
+        headers: {
+          "Content-Type": "application/json",
+          Accept: "application/json",
+          ...this.defaultHeaders
+        },
+        body: bodyStr,
+        region: this.region,
+        service: "bedrock",
+        credentials: this.credentials
+      });
+      return fetch(url, { method: "POST", headers, body: bodyStr });
     });
     if (!res.ok) {
       const text = await res.text().catch(() => "");
@@ -7795,6 +8190,7 @@ exports.createToolLimitFinalizeNode = createToolLimitFinalizeNode;
 exports.createToolsNode = createToolsNode;
 exports.customCallbackRule = customCallbackRule;
 exports.customSink = customSink;
+exports.defaultTokenCounter = defaultTokenCounter;
 exports.emptyUsage = emptyUsage;
 exports.evaluateGuardrails = evaluateGuardrails;
 exports.fileSink = fileSink;
@@ -7807,6 +8203,7 @@ exports.generateTraceId = generateTraceId;
 exports.getModelCapabilities = getModelCapabilities;
 exports.getNestedValue = getNestedValue;
 exports.getResolvedSmartConfig = getResolvedSmartConfig;
+exports.getTokenCounter = getTokenCounter;
 exports.hasToolResponseRecoveryReference = hasToolResponseRecoveryReference;
 exports.httpSink = httpSink;
 exports.isSmartModel = isSmartModel;
@@ -7820,6 +8217,7 @@ exports.resolveStrategy = resolveStrategy;
 exports.resolveToolApprovalState = resolveToolApprovalState;
 exports.restoreSnapshot = restoreSnapshot;
 exports.runSmartAgentEvalHarness = runSmartAgentEvalHarness;
+exports.setTokenCounter = setTokenCounter;
 exports.startStreamingSession = startStreamingSession;
 exports.traceSessionToOtlp = traceSessionToOtlp;
 exports.withTools = withTools;