@cognipeer/agent-sdk 0.6.4 → 0.6.6

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;
@@ -653,6 +753,7 @@ function createResolverNode() {
       toolHistory: state.toolHistory || [],
       toolHistoryArchived: state.toolHistoryArchived || [],
       pendingApprovals: state.pendingApprovals || [],
+      pendingUserQuestions: state.pendingUserQuestions || [],
       plan: state.plan || null,
       planVersion: state.planVersion || 0
     };
@@ -1892,7 +1993,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 +2196,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 +2323,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 +2404,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) {
@@ -2548,16 +2595,20 @@ function createToolsNode(initialTools, opts) {
     const traceSession = state.ctx?.__traceSession;
     const pendingApprovals = Array.isArray(state.pendingApprovals) ? state.pendingApprovals.map((entry) => ({ ...entry })) : [];
     const pendingByCallId = new Map(pendingApprovals.map((entry) => [entry.toolCallId, entry]));
+    const pendingUserQuestions = Array.isArray(state.pendingUserQuestions) ? state.pendingUserQuestions.map((entry) => ({ ...entry })) : [];
     let awaitingApproval = false;
+    let awaitingUserQuestion = false;
     for (const tool of toolByName.values()) {
       const anyTool = tool;
       if (anyTool._stateRef && typeof anyTool._stateRef === "object") {
         anyTool._stateRef.toolHistory = state.toolHistory;
         anyTool._stateRef.toolHistoryArchived = state.toolHistoryArchived;
         anyTool._stateRef.pendingApprovals = pendingApprovals;
+        anyTool._stateRef.pendingUserQuestions = pendingUserQuestions;
         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 +2619,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 +2636,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 +2649,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 +2665,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;
@@ -2624,6 +2678,7 @@ function createToolsNode(initialTools, opts) {
       const toolStateRef = tool._stateRef && typeof tool._stateRef === "object" ? tool._stateRef : null;
       if (toolStateRef) {
         toolStateRef.pendingApprovals = pendingApprovals;
+        toolStateRef.pendingUserQuestions = pendingUserQuestions;
         toolStateRef.ctx = state.ctx || (state.ctx = {});
         toolStateRef.__currentToolCallId = toolCallId;
         delete toolStateRef.__awaitingApproval;
@@ -2633,7 +2688,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 +2748,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 +2766,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 });
@@ -2756,6 +2890,22 @@ function createToolsNode(initialTools, opts) {
             approval: pendingApproval
           };
         }
+        if (output && typeof output === "object" && output.__awaitingUserQuestion) {
+          if (toolStateRef?.ctx && typeof toolStateRef.ctx === "object") {
+            state.ctx = toolStateRef.ctx;
+          }
+          const pendingQuestion = pendingUserQuestions.find(
+            (entry) => entry.toolCallId === output.toolCallId || entry.id === output.id
+          );
+          if (!pendingQuestion) {
+            throw new Error(`Tool ${toolName} requested a user question but no pending question entry was recorded.`);
+          }
+          awaitingUserQuestion = true;
+          return {
+            status: "awaiting_user_question",
+            userQuestion: pendingQuestion
+          };
+        }
         if (output && typeof output === "object" && output.__finalStructuredOutput) {
           if (!state.ctx) state.ctx = {};
           state.ctx.__structuredOutputParsed = output.data;
@@ -2779,7 +2929,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 +2985,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,21 +3022,74 @@ 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 || awaitingUserQuestion || shouldStop) break;
+      if (checkCancellationStop()) break;
+      const result = await runOne(planned[idx], orderedSlots[idx]);
       if (result.status === "awaiting_approval") {
         awaitingApproval = true;
         break;
       }
+      if (result.status === "awaiting_user_question") {
+        awaitingUserQuestion = true;
+        break;
+      }
+    }
+    if (!awaitingApproval && !awaitingUserQuestion && !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 || awaitingUserQuestion) 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;
+              }
+              if (result.status === "awaiting_user_question") {
+                awaitingUserQuestion = 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 });
@@ -2923,13 +3126,26 @@ 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 / __awaitingUserQuestion /
+      // __structuredOutputParsed are made on this object during execution.
+      ctx: state.ctx,
       agent: state.agent,
-      pendingApprovals
+      pendingApprovals,
+      pendingUserQuestions
     };
   };
 }
@@ -3164,7 +3380,8 @@ function resolveReflection(input, preset) {
       maxChars: preset.maxChars,
       keepLast: 3,
       summarize: false,
-      emitEvents: true
+      emitEvents: true,
+      everyNTurns: 1
     };
   }
   const cfg = input ?? {};
@@ -3179,7 +3396,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 +3611,229 @@ function resolveToolApprovalState(state, resolution) {
   };
 }
 
+// src/utils/userQuestions.ts
+var cloneQuestions = (questions) => Array.isArray(questions) ? questions.map((entry) => ({ ...entry })) : [];
+function validateAnswers(entry, answers, cancelled) {
+  if (cancelled) {
+    return answers || {};
+  }
+  const allowFreeText = entry.allowFreeText !== false;
+  const out = {};
+  const provided = answers || {};
+  for (const question of entry.questions) {
+    const required = question.required !== false;
+    const key = question.question;
+    const answer = provided[key] ?? provided[question.header || ""];
+    if (!answer) {
+      if (required) {
+        throw new Error(`Missing answer for required question: "${key}".`);
+      }
+      continue;
+    }
+    const values = Array.isArray(answer.values) ? answer.values.filter((v) => typeof v === "string") : [];
+    const freeText = typeof answer.freeText === "string" ? answer.freeText.trim() : "";
+    const notes = typeof answer.notes === "string" ? answer.notes : void 0;
+    if (freeText && !allowFreeText) {
+      throw new Error(
+        `Free-text answers are disabled for this agent (question: "${key}"). Pick one of the provided options.`
+      );
+    }
+    if (values.length === 0 && !freeText) {
+      if (required) {
+        throw new Error(`Question "${key}" requires either a selected option or free-text answer.`);
+      }
+      continue;
+    }
+    if (values.length > 1 && !question.multiSelect) {
+      throw new Error(`Question "${key}" is single-select but received multiple values.`);
+    }
+    if (Array.isArray(question.options) && question.options.length > 0 && values.length > 0) {
+      const allowedValues = new Set(
+        question.options.map((option) => option.value ?? option.label)
+      );
+      for (const value of values) {
+        if (!allowedValues.has(value)) {
+          if (!allowFreeText) {
+            throw new Error(
+              `Value "${value}" is not one of the allowed options for question "${key}".`
+            );
+          }
+        }
+      }
+    }
+    out[key] = { values, ...freeText ? { freeText } : {}, ...notes ? { notes } : {} };
+  }
+  return out;
+}
+function buildToolResponseContent(entry, answers, cancelled, notes) {
+  if (cancelled) {
+    return JSON.stringify({
+      status: "cancelled",
+      message: notes || "User dismissed the question without answering."
+    });
+  }
+  const payload = {
+    status: "answered",
+    answers: entry.questions.map((question) => {
+      const key = question.question;
+      const ans = answers[key];
+      return {
+        question: key,
+        header: question.header,
+        values: ans?.values ?? [],
+        freeText: ans?.freeText,
+        notes: ans?.notes
+      };
+    }),
+    ...notes ? { reviewerNotes: notes } : {}
+  };
+  return JSON.stringify(payload);
+}
+function resolveUserQuestionState(state, resolution) {
+  const pending = cloneQuestions(state.pendingUserQuestions);
+  const matchIndex = pending.findIndex(
+    (entry2) => entry2.id === resolution.id || entry2.toolCallId === resolution.id
+  );
+  if (matchIndex === -1) {
+    throw new Error(`Pending user question not found for id: ${resolution.id}`);
+  }
+  const entry = { ...pending[matchIndex] };
+  if (entry.status === "answered" || entry.status === "executed" || entry.status === "cancelled") {
+    throw new Error(`User question ${entry.id} already resolved (status: ${entry.status}).`);
+  }
+  const cancelled = resolution.cancelled === true;
+  const validated = validateAnswers(entry, resolution.answers, cancelled);
+  entry.status = cancelled ? "cancelled" : "answered";
+  entry.answers = validated;
+  entry.cancelled = cancelled || void 0;
+  entry.answeredBy = resolution.answeredBy;
+  entry.notes = resolution.notes;
+  entry.answeredAt = (/* @__PURE__ */ new Date()).toISOString();
+  pending[matchIndex] = entry;
+  const ctx = { ...state.ctx || {} };
+  delete ctx.__awaitingUserQuestion;
+  if (ctx.__resumeStage === "tools") {
+    delete ctx.__resumeStage;
+  }
+  ctx.__userQuestionResolved = { id: entry.id, status: entry.status };
+  const toolMessage = {
+    role: "tool",
+    name: "ask_user_question",
+    tool_call_id: entry.toolCallId,
+    content: buildToolResponseContent(entry, validated, cancelled, resolution.notes)
+  };
+  return {
+    ...state,
+    pendingUserQuestions: pending,
+    messages: [...state.messages || [], toolMessage],
+    ctx
+  };
+}
+var DEFAULT_DESCRIPTION_WITH_FREETEXT = "Pause the agent and surface a structured prompt to the human user when you genuinely cannot proceed without their input. Group up to 4 closely related questions into a single call. Prefer concrete options the user can pick over open-ended free-text \u2014 list `options` whenever you can anticipate the choices. The user may type a custom answer for any question. Do not use this tool for things you can deduce from the conversation, the system prompt, or another tool. After the user answers, their selections come back as the tool result.";
+var DEFAULT_DESCRIPTION_NO_FREETEXT = "Pause the agent and surface a structured multi-choice prompt to the human user when you genuinely cannot proceed without their input. Group up to 4 closely related questions into a single call. Every question MUST include at least two `options` \u2014 free-text answers are disabled for this agent. Do not use this tool for things you can deduce from the conversation, the system prompt, or another tool. After the user picks, their selections come back as the tool result.";
+function buildOptionSchema() {
+  return zod.z.object({
+    label: zod.z.string().min(1).describe("Display text the user sees"),
+    value: zod.z.string().min(1).optional().describe("Value returned in the answer; defaults to label"),
+    description: zod.z.string().optional(),
+    preview: zod.z.string().optional().describe("Optional code / ASCII preview rendered when this option is focused")
+  }).strict();
+}
+function buildQuestionSchema(allowFreeText) {
+  const optionSchema = buildOptionSchema();
+  const baseShape = {
+    question: zod.z.string().min(1).describe("Full question shown to the user"),
+    header: zod.z.string().max(40).optional().describe("Short chip / tag rendered next to the question (max ~12 chars recommended)"),
+    multiSelect: zod.z.boolean().optional().describe("Allow multiple selections. Default: false"),
+    placeholder: zod.z.string().optional(),
+    required: zod.z.boolean().optional().describe("Default: true")
+  };
+  if (allowFreeText) {
+    return zod.z.object({
+      ...baseShape,
+      options: zod.z.array(optionSchema).min(2).max(12).optional()
+    }).strict();
+  }
+  return zod.z.object({
+    ...baseShape,
+    options: zod.z.array(optionSchema).min(2).max(12).describe("Required: free-text answers are disabled for this agent")
+  }).strict();
+}
+function createAskUserQuestionTool(stateRef, config) {
+  const allowFreeText = config.allowFreeText !== false;
+  const description = config.promptOverride ?? (allowFreeText ? DEFAULT_DESCRIPTION_WITH_FREETEXT : DEFAULT_DESCRIPTION_NO_FREETEXT);
+  const questionSchema = buildQuestionSchema(allowFreeText);
+  const askUser = createTool({
+    name: "ask_user_question",
+    description,
+    schema: zod.z.object({
+      questions: zod.z.array(questionSchema).min(1).max(4).describe("1-4 related questions to ask in a single pause.")
+    }).strict(),
+    func: async ({ questions }) => {
+      const ref = askUser._stateRef || (askUser._stateRef = {});
+      const onEvent = ref.__onEvent;
+      if (!ref.ctx) ref.ctx = {};
+      const ctx = ref.ctx;
+      const toolCallId = ref.__currentToolCallId || `ask_user_${nanoid.nanoid(6)}`;
+      if (!ref.pendingUserQuestions) ref.pendingUserQuestions = [];
+      const pendingList = ref.pendingUserQuestions;
+      const entry = {
+        id: nanoid.nanoid(),
+        toolCallId,
+        toolName: "ask_user_question",
+        questions,
+        status: "pending",
+        requestedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        allowFreeText
+      };
+      pendingList.push(entry);
+      ctx.__awaitingUserQuestion = {
+        id: entry.id,
+        toolCallId: entry.toolCallId,
+        requestedAt: entry.requestedAt
+      };
+      ctx.__resumeStage = "tools";
+      onEvent?.({
+        type: "user_question",
+        status: "pending",
+        id: entry.id,
+        toolCallId: entry.toolCallId,
+        questions: entry.questions,
+        allowFreeText
+      });
+      recordTraceEvent(ctx.__traceSession, {
+        type: "user_question",
+        label: "Ask User",
+        actor: { scope: "agent", name: "ask_user_question", role: "user_interaction" },
+        status: "success",
+        sections: [
+          {
+            kind: "metadata",
+            label: "Pending Question",
+            data: {
+              id: entry.id,
+              toolCallId: entry.toolCallId,
+              questions: entry.questions,
+              allowFreeText
+            }
+          }
+        ]
+      });
+      return {
+        __awaitingUserQuestion: true,
+        id: entry.id,
+        toolCallId: entry.toolCallId
+      };
+    }
+  });
+  askUser._stateRef = stateRef;
+  askUser.__source = "human-in-the-loop";
+  return askUser;
+}
+
+// src/agent.ts
+init_utilTokens();
+
 // src/utils/syntheticMessages.ts
 function isSyntheticSummaryMessage(message) {
   if (!message) return false;
@@ -3570,6 +4012,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;
@@ -3585,6 +4042,21 @@ function createAgent(opts) {
   const resolver = createResolverNode();
   const agentCore = createAgentCoreNode(opts);
   const toolsBase = [...opts.tools ?? []];
+  const askUserConfig = (() => {
+    const raw = opts.humanInTheLoop?.askUser;
+    if (!raw) return void 0;
+    if (raw === true) return { enabled: true, allowFreeText: true };
+    return {
+      enabled: true,
+      allowFreeText: raw.allowFreeText !== false,
+      promptOverride: raw.promptOverride
+    };
+  })();
+  const askUserOnQuestion = typeof opts.humanInTheLoop?.askUser === "object" ? opts.humanInTheLoop?.askUser?.onQuestion : void 0;
+  const askUserStateRef = askUserConfig ? { pendingUserQuestions: void 0, ctx: void 0, __onEvent: void 0, __currentToolCallId: void 0 } : void 0;
+  if (askUserConfig && askUserStateRef) {
+    toolsBase.push(createAskUserQuestionTool(askUserStateRef, askUserConfig));
+  }
   const soManager = opts.outputSchema ? new StructuredOutputManager(opts.outputSchema, resolveStrategy(opts.model)) : void 0;
   if (soManager) {
     const modelCapabilities = getModelCapabilities(opts.model);
@@ -3629,7 +4101,8 @@ function createAgent(opts) {
     useTodoList: void 0,
     outputSchema: opts.outputSchema,
     responseFormat: soManager?.getResponseFormat(),
-    tracing: opts.tracing
+    tracing: opts.tracing,
+    humanInTheLoop: askUserConfig ? { askUser: askUserConfig } : void 0
   };
   const summarizationThreshold = getActiveSummarizationThreshold(opts);
   async function runLoop(initial, config, emit) {
@@ -3664,6 +4137,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 +4224,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 +4286,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" });
@@ -3884,11 +4392,18 @@ function createAgent(opts) {
       state = { ...state, ...await toolsNode(state) };
       onProgress?.({ stage: "tools", message: "Tools finished" });
       if (state.ctx?.__awaitingApproval) break;
+      if (state.ctx?.__awaitingUserQuestion) 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)) {
+        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 +4463,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?.__awaitingUserQuestion || 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,7 +4476,22 @@ function createAgent(opts) {
     return state;
   }
   const invokeAgent = async (input, config) => {
-    const onEvent = config?.onEvent;
+    const userTokenCounter = opts.tokenCounter;
+    if (userTokenCounter) {
+      const { setTokenCounter: setTokenCounter2 } = await Promise.resolve().then(() => (init_utilTokens(), utilTokens_exports));
+      setTokenCounter2(userTokenCounter);
+    }
+    const callerOnEvent = config?.onEvent;
+    const onEvent = askUserOnQuestion ? (event) => {
+      if (event && event.type === "user_question") {
+        try {
+          askUserOnQuestion(event);
+        } catch (err) {
+          console.warn("[agent-sdk] humanInTheLoop.askUser.onQuestion error:", err);
+        }
+      }
+      callerOnEvent?.(event);
+    } : callerOnEvent;
     const onProgress = config?.onProgress;
     const onStream = config?.onStream;
     const streamEnabled = config?.stream === true;
@@ -4005,6 +4535,7 @@ function createAgent(opts) {
       metadata: input.metadata,
       ctx,
       pendingApprovals: input.pendingApprovals || [],
+      pendingUserQuestions: input.pendingUserQuestions || [],
       agent: input.agent || runtimeWithInvokeLimits,
       usage: input.usage || { perRequest: [], totals: {} }
     };
@@ -4018,7 +4549,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,
@@ -4069,19 +4612,67 @@ function createAgent(opts) {
     return invokeAgent(restoredState, config);
   };
   const resolveToolApproval = (state, resolution) => resolveToolApprovalState(state, resolution);
+  const resolveUserQuestion = (state, resolution) => resolveUserQuestionState(state, resolution);
   const instance = {
     invoke: invokeAgent,
     snapshot: snapshotState,
     resume: resumeAgent,
     resolveToolApproval,
+    resolveUserQuestion,
     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 +4680,8 @@ function createAgent(opts) {
           };
         }
       });
+      delegatedTool._stateRef = {};
+      return delegatedTool;
     },
     asHandoff: ({ toolName, description, schema }) => {
       const finalName = toolName || `handoff_to_${runtime.name || "agent"}`;
@@ -4228,7 +4821,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 +5128,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 +5447,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 +5769,7 @@ function createContextTools(stateRef, opts) {
 }
 
 // src/graph/decisions.ts
+init_utilTokens();
 function needsSummarization(state, opts, summarizationEnabled) {
   if (!summarizationEnabled) {
     return false;
@@ -5330,12 +5932,38 @@ 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 askUserConfig = (() => {
+    const raw = opts.humanInTheLoop?.askUser;
+    if (!raw) return void 0;
+    if (raw === true) return { enabled: true, allowFreeText: true };
+    return {
+      enabled: true,
+      allowFreeText: raw.allowFreeText !== false,
+      promptOverride: raw.promptOverride
+    };
+  })();
+  const factoryToolsWithoutRecovery = [...userTools, ...factoryContextTools];
+  if (askUserConfig) {
+    factoryToolsWithoutRecovery.push(createAskUserQuestionTool(factoryStateRef, askUserConfig));
+  }
+  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);
+    if (askUserConfig) base2.push(createAskUserQuestionTool(ref, askUserConfig));
+    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 +5999,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 +6021,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 +6042,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 +6051,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 +6099,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 +6117,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;
@@ -5512,6 +6143,7 @@ function createSmartAgent(opts) {
     snapshot: base.snapshot,
     resume: base.resume,
     resolveToolApproval: base.resolveToolApproval,
+    resolveUserQuestion: base.resolveUserQuestion,
     asTool: base.asTool,
     asHandoff: base.asHandoff,
     __runtime: base.__runtime
@@ -5925,7 +6557,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 +6727,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 +6875,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 +6951,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 +7071,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 +7185,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 +7404,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 +7444,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 +7455,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 +7557,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(() => "");
@@ -7779,6 +8469,7 @@ exports.countApproxTokens = countApproxTokens;
 exports.countMessagesTokens = countMessagesTokens;
 exports.createAgent = createAgent;
 exports.createAgentNode = createAgentNode;
+exports.createAskUserQuestionTool = createAskUserQuestionTool;
 exports.createCodeGuardrail = createCodeGuardrail;
 exports.createContextSummarizeNode = createContextSummarizeNode;
 exports.createContextTools = createContextTools;
@@ -7795,6 +8486,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 +8499,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;
@@ -7818,8 +8511,10 @@ exports.regexRule = regexRule;
 exports.resolveMemoryStore = resolveMemoryStore;
 exports.resolveStrategy = resolveStrategy;
 exports.resolveToolApprovalState = resolveToolApprovalState;
+exports.resolveUserQuestionState = resolveUserQuestionState;
 exports.restoreSnapshot = restoreSnapshot;
 exports.runSmartAgentEvalHarness = runSmartAgentEvalHarness;
+exports.setTokenCounter = setTokenCounter;
 exports.startStreamingSession = startStreamingSession;
 exports.traceSessionToOtlp = traceSessionToOtlp;
 exports.withTools = withTools;