@cuylabs/agent-core 0.9.0 → 0.10.0

package/dist/{chunk-J4QDGZIA.js → chunk-WBPOZ7CL.js}

@@ -1,27 +1,31 @@
 import {
-  DEFAULT_CONTEXT_LIMITS
-} from "./chunk-WWYYNWEW.js";
-import {
-  Inference
-} from "./chunk-WKHDSSXG.js";
-import {
-  executeAgentToolCall
-} from "./chunk-H3FUYU52.js";
-import {
-  LLMError
-} from "./chunk-4QFNWPIF.js";
+  Inference,
+  buildModelCallContext
+} from "./chunk-CMYN2RCB.js";
 import {
+  PRUNE_PROTECTED_TOOLS,
+  accumulateUsage,
   currentScope,
+  executeAgentToolCall,
   snapshotScope,
   streamWithinScope,
   withinScope
-} from "./chunk-N7P4PN3O.js";
+} from "./chunk-5NVVNXPQ.js";
+import {
+  LLMError
+} from "./chunk-N3VX7FEE.js";
 import {
   extractModelId,
   extractProvider
 } from "./chunk-I6PKJ7XQ.js";
+import {
+  resolveCapability
+} from "./chunk-FII65CN7.js";
+import {
+  silentLogger
+} from "./chunk-T4UIX5D7.js";
 
-// src/runtime/task/observer.ts
+// src/execution/task/observer.ts
 function defaultAgentTaskCheckpointStrategy(input) {
   switch (input.event.type) {
     case "step-finish":
@@ -39,18 +43,20 @@ function defaultAgentTaskCheckpointStrategy(input) {
   }
 }
 
-// src/runtime/task/runner.ts
+// src/execution/task/runner.ts
 import { randomUUID } from "crypto";
 
-// src/runtime/turn-state.ts
+// src/execution/clone-usage.ts
+function cloneUsage(usage) {
+  return { ...usage };
+}
+
+// src/execution/turn-state.ts
 var EMPTY_USAGE = {
   inputTokens: 0,
   outputTokens: 0,
   totalTokens: 0
 };
-function cloneUsage(usage) {
-  return { ...usage };
-}
 function normalizeUsage(usage) {
   if (!usage) {
     return cloneUsage(EMPTY_USAGE);
@@ -65,13 +71,14 @@ function removeActiveToolCall(toolCalls, toolCallId) {
   return toolCalls.filter((toolCall) => toolCall.toolCallId !== toolCallId);
 }
 function createAgentTurnState(options) {
+  const restore = options.restoreFrom;
   return {
     sessionId: options.sessionId,
     phase: "initializing",
-    step: 0,
-    response: "",
-    usage: cloneUsage(EMPTY_USAGE),
-    eventCount: 0,
+    step: restore?.step ?? 0,
+    response: restore?.response ?? "",
+    usage: restore?.usage ? cloneUsage(restore.usage) : cloneUsage(EMPTY_USAGE),
+    eventCount: restore?.eventCount ?? 0,
     activeToolCalls: [],
     resolvedToolCalls: [],
     startedAt: options.startedAt,
@@ -84,7 +91,8 @@ function advanceAgentTurnState(state, event, updatedAt, options = {}) {
     usage: cloneUsage(state.usage),
     activeToolCalls: state.activeToolCalls.map((toolCall) => ({ ...toolCall })),
     resolvedToolCalls: state.resolvedToolCalls.map((toolCall) => ({
-      ...toolCall
+      ...toolCall,
+      ...toolCall.metadata ? { metadata: structuredClone(toolCall.metadata) } : {}
     })),
     eventCount: state.eventCount + 1,
     lastEvent: event,
@@ -129,6 +137,7 @@ function advanceAgentTurnState(state, event, updatedAt, options = {}) {
           toolName: event.toolName,
           outcome: "result",
           value: event.result,
+          ...event.metadata ? { metadata: structuredClone(event.metadata) } : {},
           resolvedAt: updatedAt,
           ...options.toolReplayPolicy ? { replayPolicy: options.toolReplayPolicy } : {}
         }
@@ -202,7 +211,8 @@ function failAgentTurnState(state, error, updatedAt) {
     usage: cloneUsage(state.usage),
     activeToolCalls: state.activeToolCalls.map((toolCall) => ({ ...toolCall })),
     resolvedToolCalls: state.resolvedToolCalls.map((toolCall) => ({
-      ...toolCall
+      ...toolCall,
+      ...toolCall.metadata ? { metadata: structuredClone(toolCall.metadata) } : {}
     })),
     phase: "failed",
     error: error.message,
@@ -210,7 +220,7 @@ function failAgentTurnState(state, error, updatedAt) {
   };
 }
 
-// src/runtime/task/runner.ts
+// src/execution/task/runner.ts
 function normalizeNonEmpty(value, label) {
   const normalized = value.trim();
   if (!normalized) {
@@ -234,15 +244,14 @@ function buildRuntimeSessionId(prefix, key) {
 function nowIso() {
   return (/* @__PURE__ */ new Date()).toISOString();
 }
-async function notifyObservers(observers, invoke) {
+async function notifyObservers(observers, invoke, logger) {
   for (const observer of observers) {
     try {
       await invoke(observer);
     } catch (error) {
-      console.warn(
-        "[agent-task-runner] observer error:",
-        error instanceof Error ? error.message : String(error)
-      );
+      logger.warn("observer error", {
+        error: error instanceof Error ? error.message : String(error)
+      });
     }
   }
 }
@@ -250,11 +259,13 @@ function createAgentTaskRunner(agent, options = {}) {
   const prefix = options.sessionPrefix ?? "runtime";
   const baseObservers = options.observers ?? [];
   const checkpointStrategy = options.checkpointStrategy ?? defaultAgentTaskCheckpointStrategy;
+  const log = options.logger?.child("task-runner") ?? silentLogger;
   return async (payload, context = {}) => {
     const message = normalizeNonEmpty(payload.message, "payload.message");
     const resolvedSessionId = payload.sessionId?.trim() || options.resolveSessionId?.(payload, context)?.trim() || buildRuntimeSessionId(prefix, context.fallbackSessionKey);
     const sessionId = normalizeNonEmpty(resolvedSessionId, "sessionId");
     const startedAt = nowIso();
+    const executionId = context.executionId?.trim() || `${sessionId}:${startedAt}`;
     return withinScope(
       {
         kind: "task",
@@ -270,13 +281,20 @@ function createAgentTaskRunner(agent, options = {}) {
           payload,
           context,
           sessionId,
-          startedAt,
+          executionId,
+          startedAt: context.restoreFrom?.startedAt ?? startedAt,
           scope: snapshotScope()
         };
-        const toolCalls = [];
+        const toolCalls = context.restoreFrom?.toolCalls.map((tc) => ({ ...tc })) ?? [];
         let turnState = createAgentTurnState({
           sessionId,
-          startedAt
+          startedAt: context.restoreFrom?.startedAt ?? startedAt,
+          restoreFrom: context.restoreFrom ? {
+            response: context.restoreFrom.response,
+            usage: { ...context.restoreFrom.usage },
+            step: context.restoreFrom.step,
+            eventCount: context.restoreFrom.eventCount
+          } : void 0
         });
         const createSnapshot = () => ({
           sessionId,
@@ -305,13 +323,13 @@ function createAgentTaskRunner(agent, options = {}) {
           };
           await notifyObservers(baseObservers, async (observer) => {
             await observer.onCheckpoint?.(checkpoint);
-          });
+          }, log);
         };
         await notifyObservers(baseObservers, async (observer) => {
           await observer.onTaskStart?.(run, createSnapshot());
-        });
+        }, log);
         await emitCheckpoint("task-start");
-        const activateCtx = baseObservers.find((o) => o.activateContext)?.activateContext?.bind(void 0, sessionId);
+        const activateCtx = baseObservers.find((o) => o.activateContext)?.activateContext?.bind(void 0, sessionId, executionId);
         try {
           const processChatStream = async () => {
             for await (const event of agent.chat(sessionId, message, {
@@ -325,7 +343,7 @@ function createAgentTaskRunner(agent, options = {}) {
               const snapshot = createSnapshot();
               await notifyObservers(baseObservers, async (observer) => {
                 await observer.onTaskEvent?.(run, event, snapshot);
-              });
+              }, log);
               const checkpointReason = checkpointStrategy({
                 run,
                 event,
@@ -352,14 +370,14 @@ function createAgentTaskRunner(agent, options = {}) {
           };
           await notifyObservers(baseObservers, async (observer) => {
             await observer.onTaskComplete?.(run, result, createSnapshot());
-          });
+          }, log);
           return result;
         } catch (error) {
           const normalizedError = error instanceof Error ? error : new Error(String(error));
           turnState = failAgentTurnState(turnState, normalizedError, nowIso());
           await notifyObservers(baseObservers, async (observer) => {
             await observer.onTaskError?.(run, normalizedError, createSnapshot());
-          });
+          }, log);
           await emitCheckpoint("task-error");
           throw normalizedError;
         }
@@ -368,50 +386,7 @@ function createAgentTaskRunner(agent, options = {}) {
   };
 }
 
-// src/runtime/model-messages.ts
-function convertAgentMessagesToModelMessages(messages) {
-  return messages.flatMap((message) => {
-    switch (message.role) {
-      case "user":
-        return [{ role: "user", content: message.content }];
-      case "assistant": {
-        if (message.toolCalls && message.toolCalls.length > 0) {
-          const toolCallParts = message.toolCalls.map(
-            (toolCall) => ({
-              type: "tool-call",
-              toolCallId: toolCall.toolCallId,
-              toolName: toolCall.toolName,
-              input: toolCall.args
-            })
-          );
-          return [{ role: "assistant", content: toolCallParts }];
-        }
-        return [{ role: "assistant", content: message.content }];
-      }
-      case "tool":
-        return [
-          {
-            role: "tool",
-            content: [
-              {
-                type: "tool-result",
-                toolCallId: message.toolCallId ?? "",
-                toolName: message.toolName ?? "",
-                output: {
-                  type: "text",
-                  value: typeof message.result === "string" ? message.result : JSON.stringify(message.result)
-                }
-              }
-            ]
-          }
-        ];
-      case "system":
-        return [{ role: "system", content: message.content }];
-    }
-  });
-}
-
-// src/runtime/turn-engine/commit-batch.ts
+// src/execution/turn-engine/commit-batch.ts
 import { randomUUID as randomUUID2 } from "crypto";
 function createAgentTurnBoundaryEvent(boundary, metadata = {}) {
   return {
@@ -440,13 +415,14 @@ function createAgentTurnStepCommitBatch(step, snapshot, options = {}) {
     createdAt
   };
   const toolMessages = snapshot.toolResults.map(
-    ({ toolCallId, toolName, result }) => ({
+    ({ toolCallId, toolName, result, metadata }) => ({
       id: options.toolMessageIds?.[toolCallId] ?? randomUUID2(),
       role: "tool",
       content: typeof result === "string" ? result : JSON.stringify(result),
       toolCallId,
       toolName,
       result,
+      ...metadata ? { metadata } : {},
       createdAt
     })
   );
@@ -518,7 +494,7 @@ function createAgentTurnOutputCommit(options) {
   };
 }
 
-// src/runtime/turn-engine/engine.ts
+// src/execution/turn-engine/engine.ts
 var AgentTurnEngine = class {
   turnState;
   pendingToolCalls = /* @__PURE__ */ new Map();
@@ -559,6 +535,7 @@ var AgentTurnEngine = class {
           toolCallId,
           toolName,
           result: resultData.result,
+          ...resultData.metadata ? { metadata: resultData.metadata } : {},
           ...replayPolicy ? { replayPolicy } : {}
         };
       }).filter((result) => result !== void 0)
@@ -581,6 +558,7 @@ var AgentTurnEngine = class {
         this.pendingToolResults.set(event.toolCallId, {
           toolName: event.toolName,
           result: event.result,
+          ...event.metadata ? { metadata: event.metadata } : {},
           replayPolicy: toolReplayPolicy
         });
         break;
@@ -623,7 +601,251 @@ function createAgentTurnEngine(options) {
   return new AgentTurnEngine(options);
 }
 
-// src/runtime/turn-runner/prepare.ts
+// src/agent/context/estimation.ts
+function estimateTokens(text) {
+  return Math.ceil(text.length / 4);
+}
+function estimateMessageTokens(message) {
+  if (typeof message.content === "string") {
+    return estimateTokens(message.content);
+  }
+  if (Array.isArray(message.content)) {
+    let total = 0;
+    for (const part of message.content) {
+      if (typeof part === "string") {
+        total += estimateTokens(part);
+      } else if ("text" in part && typeof part.text === "string") {
+        total += estimateTokens(part.text);
+      } else if ("type" in part && part.type === "image") {
+        total += 765;
+      }
+    }
+    return total;
+  }
+  return 0;
+}
+function estimateConversationTokens(messages) {
+  let total = 0;
+  for (const message of messages) {
+    total += estimateMessageTokens(message);
+    total += 4;
+  }
+  return total;
+}
+
+// src/agent/context/pruning.ts
+var DEFAULT_CONTEXT_LIMITS = {
+  contextWindow: 128e3,
+  reserveTokens: 16e3,
+  // Reserve for output
+  protectedTokens: 4e4,
+  // Keep recent 40 k tokens
+  pruneMinimum: 2e4
+  // Don't prune until 20 k tokens
+};
+function getUsableTokenLimit(limits) {
+  return limits.contextWindow - limits.reserveTokens;
+}
+function isContextOverflowing(tokens, limits = DEFAULT_CONTEXT_LIMITS) {
+  return tokens > getUsableTokenLimit(limits);
+}
+function shouldPruneContext(tokens, limits = DEFAULT_CONTEXT_LIMITS) {
+  if (tokens < limits.pruneMinimum) return false;
+  return isContextOverflowing(tokens, limits);
+}
+function findCutPoint(messages, protectedTokens = DEFAULT_CONTEXT_LIMITS.protectedTokens) {
+  if (messages.length === 0) return 0;
+  let tokensFromEnd = 0;
+  let cutIndex = messages.length;
+  for (let i = messages.length - 1; i >= 0; i--) {
+    tokensFromEnd += estimateMessageTokens(messages[i]);
+    if (tokensFromEnd >= protectedTokens) {
+      cutIndex = i;
+      break;
+    }
+  }
+  if (cutIndex <= 1) return 0;
+  const startIndex = cutIndex >= messages.length ? messages.length - 1 : cutIndex;
+  for (let i = startIndex; i >= 1; i--) {
+    const msg = messages[i];
+    const prevMsg = messages[i - 1];
+    if (!msg || !prevMsg) continue;
+    if (msg.role === "tool") continue;
+    if (prevMsg.role === "assistant" || prevMsg.role === "user") {
+      return i;
+    }
+  }
+  return 0;
+}
+function pruneToolResults(messages, protectedTokens = DEFAULT_CONTEXT_LIMITS.protectedTokens, options) {
+  const protectedToolSet = /* @__PURE__ */ new Set([
+    ...PRUNE_PROTECTED_TOOLS,
+    ...options?.protectedTools ?? []
+  ]);
+  let tokensFromEnd = 0;
+  const tokenPositions = [];
+  for (let i = messages.length - 1; i >= 0; i--) {
+    tokensFromEnd += estimateMessageTokens(messages[i]);
+    tokenPositions[i] = tokensFromEnd;
+  }
+  return messages.map((msg, i) => {
+    if (tokenPositions[i] < protectedTokens) return msg;
+    if (!("role" in msg) || msg.role !== "tool") return msg;
+    const toolMsg = msg;
+    if ("compactedAt" in toolMsg && toolMsg.compactedAt) return msg;
+    if (toolMsg.toolName && protectedToolSet.has(toolMsg.toolName)) return msg;
+    const currentTokens = estimateTokens(toolMsg.content);
+    if (currentTokens < 500) return msg;
+    return {
+      ...toolMsg,
+      content: `[Output pruned - was ${currentTokens} tokens]`,
+      compactedAt: Date.now()
+    };
+  });
+}
+
+// src/agent/context/summarization.ts
+import { generateText } from "ai";
+var DEFAULT_SUMMARY_PROMPT = `You are summarizing a conversation to continue it with context.
+
+Create a structured summary that captures:
+1. **Goal**: What the user is trying to accomplish
+2. **Progress**: What has been done so far
+3. **Decisions**: Key decisions made during the conversation
+4. **Current State**: Where we left off
+5. **Next Steps**: What should happen next
+
+Be concise but comprehensive. Include specific file paths, function names, and technical details that would be lost otherwise.
+
+Format as a clear summary that could be given to another assistant to continue the work.`;
+async function generateSummary(messages, options) {
+  const conversationText = messages.map((m) => {
+    const role = m.role.toUpperCase();
+    const content = typeof m.content === "string" ? m.content : JSON.stringify(m.content);
+    return `[${role}]: ${content}`;
+  }).join("\n\n");
+  const prompt = options.customPrompt || DEFAULT_SUMMARY_PROMPT;
+  const { text } = await generateText({
+    model: options.model,
+    maxOutputTokens: options.maxTokens ?? 2e3,
+    system: prompt,
+    prompt: `Summarize this conversation:
+
+${conversationText}`
+  });
+  return text;
+}
+async function pruneContext(messages, options = {}) {
+  const limits = options.limits ?? DEFAULT_CONTEXT_LIMITS;
+  let currentMessages = [...messages];
+  let tokensRemoved = 0;
+  let removedCount = 0;
+  let summarized = false;
+  let summary;
+  const initialTokens = estimateConversationTokens(currentMessages);
+  if (!shouldPruneContext(initialTokens, limits)) {
+    return { messages: currentMessages, removedCount: 0, tokensRemoved: 0, summarized: false };
+  }
+  const prunedMessages = pruneToolResults(currentMessages, limits.protectedTokens);
+  const afterPruneTokens = estimateConversationTokens(prunedMessages);
+  tokensRemoved = initialTokens - afterPruneTokens;
+  currentMessages = prunedMessages;
+  if (!isContextOverflowing(afterPruneTokens, limits)) {
+    return { messages: currentMessages, removedCount: 0, tokensRemoved, summarized: false };
+  }
+  const cutIndex = findCutPoint(currentMessages, limits.protectedTokens);
+  if (cutIndex === 0) {
+    return { messages: currentMessages, removedCount: 0, tokensRemoved, summarized: false };
+  }
+  const toSummarize = currentMessages.slice(0, cutIndex);
+  const toKeep = currentMessages.slice(cutIndex);
+  removedCount = toSummarize.length;
+  tokensRemoved += estimateConversationTokens(toSummarize);
+  if (options.model) {
+    summary = await generateSummary(toSummarize, {
+      model: options.model,
+      customPrompt: options.summaryPrompt
+    });
+    summarized = true;
+    const summaryMessage = {
+      id: crypto.randomUUID(),
+      role: "system",
+      content: `## Previous Conversation Summary
+
+${summary}`,
+      createdAt: /* @__PURE__ */ new Date()
+    };
+    currentMessages = [summaryMessage, ...toKeep];
+  } else {
+    currentMessages = toKeep;
+  }
+  return { messages: currentMessages, removedCount, tokensRemoved, summarized, summary };
+}
+
+// src/agent/context/manager.ts
+var ContextManager = class {
+  limits;
+  model;
+  summaryPrompt;
+  constructor(options) {
+    this.limits = { ...DEFAULT_CONTEXT_LIMITS, ...options?.limits };
+    this.model = options?.model;
+    this.summaryPrompt = options?.summaryPrompt;
+  }
+  /** Get a copy of the current context limits. */
+  getLimits() {
+    return { ...this.limits };
+  }
+  /** Update context limits (e.g. when switching models). */
+  setLimits(limits) {
+    this.limits = { ...this.limits, ...limits };
+  }
+  /** Set the model used for summarisation. */
+  setModel(model) {
+    this.model = model;
+  }
+  /** Estimate total tokens for a message array. */
+  estimateTokens(messages) {
+    return estimateConversationTokens(messages);
+  }
+  /** Check whether the context is overflowing. */
+  isOverflowing(messages) {
+    const tokens = this.estimateTokens(messages);
+    return isContextOverflowing(tokens, this.limits);
+  }
+  /** Check whether pruning should be triggered. */
+  shouldPrune(messages) {
+    const tokens = this.estimateTokens(messages);
+    return shouldPruneContext(tokens, this.limits);
+  }
+  /** Prune context to fit within limits. */
+  async prune(messages) {
+    return pruneContext(messages, {
+      model: this.model,
+      limits: this.limits,
+      summaryPrompt: this.summaryPrompt
+    });
+  }
+  /**
+   * Get a snapshot of token statistics.
+   *
+   * Useful for dashboards, logging, or deciding whether to prune.
+   */
+  getStats(messages) {
+    const tokens = this.estimateTokens(messages);
+    const limit = getUsableTokenLimit(this.limits);
+    return {
+      tokens,
+      limit,
+      available: Math.max(0, limit - tokens),
+      utilizationPercent: Math.round(tokens / limit * 100),
+      isOverflowing: isContextOverflowing(tokens, this.limits),
+      shouldPrune: shouldPruneContext(tokens, this.limits)
+    };
+  }
+};
+
+// src/execution/turn-runner/prepare.ts
 function prepareModelStep(options) {
   const modelMessages = Array.from(options.toModelMessages(options.messages));
   return {
@@ -632,6 +854,7 @@ function prepareModelStep(options) {
     modelMessages,
     inferenceInput: {
       sessionID: options.sessionId,
+      turnID: options.turnTracker?.getCurrentTurnId?.() ?? void 0,
       step: options.step,
       model: options.config.model,
       system: options.systemPrompts,
@@ -641,6 +864,7 @@ function prepareModelStep(options) {
       mcpTools: options.mcpTools,
       cwd: options.config.cwd,
       host: options.host,
+      humanInputController: options.humanInputController,
       temperature: options.config.temperature,
       topP: options.config.topP,
       maxOutputTokens: options.config.maxOutputTokens,
@@ -658,12 +882,15 @@ function prepareModelStep(options) {
       doomLoopThreshold: options.config.doomLoopThreshold,
       enforceDoomLoop: options.config.enforceDoomLoop,
       onDoomLoop: options.config.onDoomLoop,
-      contextTokenLimit: options.config.contextWindow ? options.config.contextWindow - DEFAULT_CONTEXT_LIMITS.reserveTokens : void 0
+      contextTokenLimit: options.config.contextWindow ? getUsableTokenLimit({
+        contextWindow: options.config.contextWindow,
+        reserveTokens: options.config.reserveTokens ?? DEFAULT_CONTEXT_LIMITS.reserveTokens
+      }) : void 0
     }
   };
 }
 
-// src/runtime/step-processing/doom-loop.ts
+// src/execution/step-processing/doom-loop.ts
 var DEFAULT_DOOM_LOOP_THRESHOLD = 3;
 var DoomLoopError = class extends Error {
   toolName;
@@ -740,7 +967,7 @@ async function recordToolCallAndCheckDoomLoop(options) {
   options.warn?.(`[StepProcessing] ${doomError.message}`);
 }
 
-// src/runtime/step-processing/overflow.ts
+// src/execution/step-processing/overflow.ts
 var ContextOverflowError = class extends Error {
   inputTokens;
   limit;
@@ -767,12 +994,23 @@ async function handleContextOverflow(options) {
   }
 }
 
-// src/runtime/step-processing/process.ts
+// src/execution/step-processing/process.ts
+function normalizeToolResultChunk(output) {
+  if (output && typeof output === "object" && "__cuylabsAgentToolResult" in output && output.__cuylabsAgentToolResult === true) {
+    const structured = output;
+    return {
+      result: structured.output,
+      ...structured.metadata ? { metadata: structured.metadata } : {}
+    };
+  }
+  return { result: output };
+}
 async function processStepStream(stream, options) {
   const { abort, onEvent } = options;
   const normalizeError = options.normalizeError ?? ((error2) => error2 instanceof Error ? error2 : new Error(String(error2)));
   const doomLoopThreshold = options.doomLoopThreshold ?? DEFAULT_DOOM_LOOP_THRESHOLD;
   const maxSteps = options.maxSteps ?? 50;
+  const log = options.logger;
   let stepCount = options.currentStep ?? 1;
   let sawStartStep = false;
   let text = "";
@@ -787,10 +1025,7 @@ async function processStepStream(stream, options) {
   try {
     for await (const rawChunk of stream.fullStream) {
       const chunk = rawChunk;
-      if (process.env.DEBUG_PROCESSOR) {
-        process.stderr.write(`[step-processing] Chunk received: ${chunk.type}
-`);
-      }
+      log?.debug(`Chunk received: ${chunk.type}`);
       abort.throwIfAborted();
       switch (chunk.type) {
         case "start-step":
@@ -846,19 +1081,23 @@ async function processStepStream(stream, options) {
 `)
           });
           break;
-        case "tool-result":
+        case "tool-result": {
+          const normalized = normalizeToolResultChunk(chunk.output);
           toolResults.push({
             toolName: chunk.toolName,
             toolCallId: chunk.toolCallId,
-            result: chunk.output
+            result: normalized.result,
+            ...normalized.metadata ? { metadata: normalized.metadata } : {}
           });
           await onEvent({
             type: "tool-result",
             toolName: chunk.toolName,
             toolCallId: chunk.toolCallId,
-            result: chunk.output
+            result: normalized.result,
+            ...normalized.metadata ? { metadata: normalized.metadata } : {}
           });
           break;
+        }
         case "tool-error":
           await onEvent({
             type: "tool-error",
@@ -942,21 +1181,15 @@ async function processStepStream(stream, options) {
     error
   };
 }
-var processStream = processStepStream;
 
-// src/runtime/turn-runner/stream-step.ts
-function buildModelCallContext(options) {
+// src/execution/turn-runner/stream-step.ts
+function buildStepModelCallContext(options) {
   const input = options.preparedStep.inferenceInput;
-  return {
-    sessionID: input.sessionID,
-    step: input.step ?? options.preparedStep.step,
-    cwd: input.cwd,
-    abort: input.abort,
-    model: input.model,
-    toolNames: Object.keys(input.tools),
-    mcpToolNames: Object.keys(input.mcpTools ?? {}),
-    scope: snapshotScope()
-  };
+  const ctx = buildModelCallContext(input);
+  if (input.step == null) {
+    ctx.step = options.preparedStep.step;
+  }
+  return ctx;
 }
 function normalizeModelStepError(options, error) {
   const model = options.preparedStep.inferenceInput.model;
@@ -975,13 +1208,20 @@ async function* runModelStep(options) {
     },
     (async function* () {
       const { preparedStep, turnEngine, applyCommitBatch } = options;
-      const stream = await Inference.streamStep(preparedStep.inferenceInput);
       const eventQueue = [];
       let resolveNext = null;
       let streamDone = false;
       let streamError;
       const intervention = preparedStep.inferenceInput.intervention;
       const middleware = preparedStep.inferenceInput.middleware;
+      const emitQueuedEvent = async (event) => {
+        middleware?.emitEvent(event);
+        eventQueue.push(event);
+        if (resolveNext) {
+          resolveNext();
+          resolveNext = null;
+        }
+      };
       if (intervention) {
         intervention.onApplied = (item) => {
           eventQueue.push({
@@ -994,7 +1234,22 @@ async function* runModelStep(options) {
             resolveNext = null;
           }
         };
+        intervention.onDeferredQueued = (item) => {
+          eventQueue.push({
+            type: "follow-up-queued",
+            id: item.id,
+            message: item.message
+          });
+          if (resolveNext) {
+            resolveNext();
+            resolveNext = null;
+          }
+        };
       }
+      const stream = await Inference.streamStep({
+        ...preparedStep.inferenceInput,
+        onEvent: emitQueuedEvent
+      });
       const processPromise = processStepStream(stream, {
         sessionID: preparedStep.inferenceInput.sessionID,
         abort: preparedStep.inferenceInput.abort,
@@ -1008,14 +1263,7 @@ async function* runModelStep(options) {
         contextTokenLimit: preparedStep.stepProcessing.contextTokenLimit,
         onContextOverflow: async () => {
         },
-        onEvent: async (event) => {
-          middleware?.emitEvent(event);
-          eventQueue.push(event);
-          if (resolveNext) {
-            resolveNext();
-            resolveNext = null;
-          }
-        }
+        onEvent: emitQueuedEvent
       }).then((result2) => {
         streamDone = true;
         if (resolveNext) {
@@ -1068,7 +1316,7 @@ async function* runModelStep(options) {
             usage: result.usage,
             finishReason: result.finishReason
           },
-          buildModelCallContext(options)
+          buildStepModelCallContext(options)
         );
         result.text = revised.text;
         result.usage = revised.usage;
@@ -1079,8 +1327,7 @@ async function* runModelStep(options) {
   );
 }
 
-// src/runtime/turn-runner/tool-batch.ts
-import { randomUUID as randomUUID3 } from "crypto";
+// src/execution/turn-runner/tool-batch.ts
 function cloneToolResultRecord(options) {
   return new Map(
     options.snapshot.toolResults.map((toolResult) => [
@@ -1089,105 +1336,164 @@ function cloneToolResultRecord(options) {
     ])
   );
 }
-function createToolBatchErrorResult(options) {
-  return {
-    type: "tool-error",
-    toolName: options.toolName,
-    toolCallId: options.toolCallId,
-    error: options.errorMessage
-  };
+function recordToolResult(toolCall, event, result, accumulators, metadata) {
+  accumulators.events.push(event);
+  accumulators.toolResultsByCallId.set(toolCall.toolCallId, {
+    toolCallId: toolCall.toolCallId,
+    toolName: toolCall.toolName,
+    result,
+    ...metadata ? { metadata } : {},
+    ...toolCall.replayPolicy ? { replayPolicy: toolCall.replayPolicy } : {}
+  });
+  if (accumulators.turnState.value) {
+    accumulators.turnState.value = advanceAgentTurnState(
+      accumulators.turnState.value,
+      event,
+      (/* @__PURE__ */ new Date()).toISOString(),
+      {
+        ...toolCall.replayPolicy ? { toolReplayPolicy: toolCall.replayPolicy } : {}
+      }
+    );
+  }
 }
-function createToolBatchResultEvent(options) {
-  return {
-    type: "tool-result",
-    toolName: options.toolName,
-    toolCallId: options.toolCallId,
-    result: options.result
-  };
+async function isParallelSafe(tool, args, cwd) {
+  const initialized = await tool.init({ cwd });
+  const cap = initialized.capabilities?.parallelSafe;
+  const safe = resolveCapability(
+    cap,
+    args,
+    /* fallback */
+    false
+  );
+  return { safe, initialized };
+}
+async function executeBatchEntry(toolCall, options, accumulators, preInitialized) {
+  const tool = options.tools[toolCall.toolName];
+  if (!tool) {
+    const errorMessage = `Tool '${toolCall.toolName}' is not registered`;
+    recordToolResult(
+      toolCall,
+      {
+        type: "tool-error",
+        toolName: toolCall.toolName,
+        toolCallId: toolCall.toolCallId,
+        error: errorMessage
+      },
+      `Error: ${errorMessage}`,
+      accumulators
+    );
+    return;
+  }
+  try {
+    const executed = await executeAgentToolCall({
+      toolName: toolCall.toolName,
+      tool,
+      toolCallId: toolCall.toolCallId,
+      params: toolCall.args,
+      cwd: options.cwd,
+      abort: options.abort,
+      sessionID: options.sessionId,
+      turnID: options.turnTracker?.getCurrentTurnId?.() ?? void 0,
+      messageID: toolCall.toolCallId,
+      ...options.host ? { host: options.host } : {},
+      ...options.humanInputController ? { humanInputController: options.humanInputController } : {},
+      ...options.turnTracker ? { turnTracker: options.turnTracker } : {},
+      ...options.middleware ? { middleware: options.middleware } : {},
+      onEvent: async (event) => {
+        accumulators.events.push(event);
+      },
+      ...preInitialized ? { initialized: preInitialized } : {}
+    });
+    recordToolResult(
+      toolCall,
+      {
+        type: "tool-result",
+        toolName: toolCall.toolName,
+        toolCallId: toolCall.toolCallId,
+        result: executed.output,
+        ...executed.metadata ? { metadata: executed.metadata } : {}
+      },
+      executed.output,
+      accumulators,
+      executed.metadata
+    );
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    recordToolResult(
+      toolCall,
+      {
+        type: "tool-error",
+        toolName: toolCall.toolName,
+        toolCallId: toolCall.toolCallId,
+        error: errorMessage
+      },
+      `Error: ${errorMessage}`,
+      accumulators
+    );
+  }
 }
 async function runToolBatch(options) {
   const toolResultsByCallId = cloneToolResultRecord(options);
   const events = [];
-  let turnState = options.turnState ? structuredClone(options.turnState) : void 0;
-  for (const toolCall of options.snapshot.toolCalls) {
-    if (toolResultsByCallId.has(toolCall.toolCallId)) {
-      continue;
-    }
+  const turnState = {
+    value: options.turnState ? structuredClone(options.turnState) : void 0
+  };
+  const accumulators = { events, toolResultsByCallId, turnState };
+  const pending = options.snapshot.toolCalls.filter(
+    (tc) => !toolResultsByCallId.has(tc.toolCallId)
+  );
+  const parallelGroup = [];
+  const serialGroup = [];
+  for (const toolCall of pending) {
     const tool = options.tools[toolCall.toolName];
-    const updatedAt = (/* @__PURE__ */ new Date()).toISOString();
     if (!tool) {
-      const errorMessage = `Tool '${toolCall.toolName}' is not registered`;
-      const event = createToolBatchErrorResult({
-        toolCallId: toolCall.toolCallId,
-        toolName: toolCall.toolName,
-        errorMessage,
-        replayPolicy: toolCall.replayPolicy
-      });
-      events.push(event);
-      toolResultsByCallId.set(toolCall.toolCallId, {
-        toolCallId: toolCall.toolCallId,
-        toolName: toolCall.toolName,
-        result: `Error: ${errorMessage}`,
-        ...toolCall.replayPolicy ? { replayPolicy: toolCall.replayPolicy } : {}
-      });
-      if (turnState) {
-        turnState = advanceAgentTurnState(turnState, event, updatedAt, {
-          ...toolCall.replayPolicy ? { toolReplayPolicy: toolCall.replayPolicy } : {}
-        });
-      }
+      serialGroup.push({ toolCall });
       continue;
     }
+    let safe = false;
+    let initialized;
     try {
-      const executed = await executeAgentToolCall({
-        toolName: toolCall.toolName,
+      const result = await isParallelSafe(
         tool,
-        params: toolCall.args,
-        cwd: options.cwd,
-        abort: options.abort,
-        sessionID: options.sessionId,
-        messageID: randomUUID3(),
-        ...options.host ? { host: options.host } : {},
-        ...options.turnTracker ? { turnTracker: options.turnTracker } : {},
-        ...options.middleware ? { middleware: options.middleware } : {}
-      });
-      const event = createToolBatchResultEvent({
-        toolCallId: toolCall.toolCallId,
-        toolName: toolCall.toolName,
-        result: executed.output
-      });
-      events.push(event);
-      toolResultsByCallId.set(toolCall.toolCallId, {
-        toolCallId: toolCall.toolCallId,
-        toolName: toolCall.toolName,
-        result: executed.output,
-        ...toolCall.replayPolicy ? { replayPolicy: toolCall.replayPolicy } : {}
-      });
-      if (turnState) {
-        turnState = advanceAgentTurnState(turnState, event, updatedAt, {
-          ...toolCall.replayPolicy ? { toolReplayPolicy: toolCall.replayPolicy } : {}
-        });
-      }
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      const event = createToolBatchErrorResult({
-        toolCallId: toolCall.toolCallId,
-        toolName: toolCall.toolName,
-        errorMessage,
-        replayPolicy: toolCall.replayPolicy
-      });
-      events.push(event);
-      toolResultsByCallId.set(toolCall.toolCallId, {
-        toolCallId: toolCall.toolCallId,
-        toolName: toolCall.toolName,
-        result: `Error: ${errorMessage}`,
-        ...toolCall.replayPolicy ? { replayPolicy: toolCall.replayPolicy } : {}
-      });
-      if (turnState) {
-        turnState = advanceAgentTurnState(turnState, event, updatedAt, {
-          ...toolCall.replayPolicy ? { toolReplayPolicy: toolCall.replayPolicy } : {}
-        });
+        toolCall.args,
+        options.cwd
+      );
+      safe = result.safe;
+      initialized = result.initialized;
+    } catch {
+    }
+    if (safe && initialized) {
+      parallelGroup.push({ toolCall, initialized });
+    } else {
+      serialGroup.push({ toolCall, initialized });
+    }
+  }
+  if (parallelGroup.length > 0) {
+    await Promise.all(
+      parallelGroup.map(
+        ({ toolCall, initialized }) => executeBatchEntry(toolCall, options, accumulators, initialized)
+      )
+    );
+  }
+  for (const { toolCall, initialized } of serialGroup) {
+    if (options.intervention?.hasPending && initialized) {
+      const interruptPolicy = initialized.capabilities?.onInterrupt ?? "finish";
+      if (interruptPolicy === "cancel") {
+        recordToolResult(
+          toolCall,
+          {
+            type: "tool-error",
+            toolName: toolCall.toolName,
+            toolCallId: toolCall.toolCallId,
+            error: "Tool cancelled: user sent a new message"
+          },
+          "Error: Tool cancelled: user sent a new message",
+          accumulators
+        );
+        continue;
       }
     }
+    await executeBatchEntry(toolCall, options, accumulators, initialized);
   }
   return {
     snapshot: {
@@ -1196,12 +1502,12 @@ async function runToolBatch(options) {
       ),
       toolResults: options.snapshot.toolCalls.map((toolCall) => toolResultsByCallId.get(toolCall.toolCallId)).filter((toolResult) => toolResult !== void 0)
     },
-    ...turnState ? { turnState } : {},
+    ...turnState.value ? { turnState: turnState.value } : {},
     events
   };
 }
 
-// src/runtime/turn-runner/commit.ts
+// src/execution/turn-runner/commit.ts
 async function* commitStep(options) {
   return yield* streamWithinScope(
     {
@@ -1242,10 +1548,7 @@ async function* commitOutput(options) {
   );
 }
 
-// src/runtime/workflow-state.ts
-function cloneUsage2(usage) {
-  return usage ? { ...usage } : void 0;
-}
+// src/execution/workflow-state.ts
 function cloneMessageSnapshot(message) {
   return {
     ...message,
@@ -1257,9 +1560,96 @@ function cloneMessageSnapshot(message) {
     } : {},
     ...message.role === "assistant" && message.error ? {
       error: { ...message.error }
+    } : {},
+    ...message.role === "tool" && message.metadata ? {
+      metadata: structuredClone(message.metadata)
+    } : {}
+  };
+}
+function createAgentWorkflowTurnState(options) {
+  const pendingInput = options.initialInput ? cloneMessageSnapshot(options.initialInput) : void 0;
+  return {
+    sessionId: options.sessionId,
+    systemPrompts: [...options.systemPrompts ?? []],
+    messages: (options.initialMessages ?? []).map(cloneMessageSnapshot),
+    phase: pendingInput ? "input-commit" : "model-step",
+    ...pendingInput ? { pendingInput } : {},
+    step: options.initialStep ?? 1,
+    maxSteps: options.maxSteps,
+    replayDecisions: {},
+    startedAt: options.startedAt,
+    updatedAt: options.startedAt
+  };
+}
+function cloneAgentWorkflowTurnState(state) {
+  return {
+    ...state,
+    systemPrompts: [...state.systemPrompts],
+    messages: state.messages.map(cloneMessageSnapshot),
+    ...state.pendingInput ? { pendingInput: cloneMessageSnapshot(state.pendingInput) } : {},
+    ...state.usage ? { usage: cloneUsage(state.usage) } : {},
+    ...state.turnState ? { turnState: structuredClone(state.turnState) } : {},
+    ...state.lastModelStep ? { lastModelStep: structuredClone(state.lastModelStep) } : {},
+    replayDecisions: Object.fromEntries(
+      Object.entries(state.replayDecisions).map(([toolCallId, decision]) => [
+        toolCallId,
+        { ...decision }
+      ])
+    ),
+    ...state.pendingInterventions?.length ? {
+      pendingInterventions: state.pendingInterventions.map(
+        (intervention) => ({ ...intervention })
+      )
+    } : {},
+    ...state.queuedFollowUps?.length ? {
+      queuedFollowUps: state.queuedFollowUps.map((intervention) => ({
+        ...intervention
+      }))
     } : {}
   };
 }
+function applyWorkflowInterventions(state, interventions, updatedAt) {
+  if (interventions.length === 0) {
+    return state;
+  }
+  const injected = interventions.map((intervention) => ({
+    id: intervention.id,
+    role: "user",
+    createdAt: intervention.createdAt,
+    content: intervention.message
+  }));
+  return {
+    ...state,
+    messages: [...state.messages, ...injected],
+    pendingInterventions: void 0,
+    updatedAt
+  };
+}
+function drainWorkflowInterventions(state, updatedAt) {
+  if (!state.pendingInterventions?.length) {
+    return state;
+  }
+  return applyWorkflowInterventions(
+    state,
+    state.pendingInterventions,
+    updatedAt
+  );
+}
+function queueWorkflowFollowUps(state, followUps, updatedAt) {
+  if (followUps.length === 0) {
+    return state;
+  }
+  return {
+    ...state,
+    queuedFollowUps: [
+      ...state.queuedFollowUps ?? [],
+      ...followUps.map((followUp) => ({ ...followUp }))
+    ],
+    updatedAt
+  };
+}
+
+// src/execution/workflow-snapshot.ts
 function snapshotAgentWorkflowMessage(message) {
   switch (message.role) {
     case "user":
@@ -1297,6 +1687,7 @@ function snapshotAgentWorkflowMessage(message) {
         toolCallId: message.toolCallId,
         toolName: message.toolName,
         result: message.result,
+        ...message.metadata ? { metadata: structuredClone(message.metadata) } : {},
         ...message.compactedAt !== void 0 ? { compactedAt: message.compactedAt } : {}
       };
     case "system":
@@ -1309,7 +1700,7 @@ function snapshotAgentWorkflowMessage(message) {
   }
 }
 function snapshotAgentWorkflowMessages(messages) {
-  return messages.map(snapshotAgentWorkflowMessage);
+  return messages.map((message) => snapshotAgentWorkflowMessage(message));
 }
 function restoreAgentWorkflowMessage(snapshot) {
   const createdAt = new Date(snapshot.createdAt);
@@ -1349,6 +1740,7 @@ function restoreAgentWorkflowMessage(snapshot) {
         toolCallId: snapshot.toolCallId,
         toolName: snapshot.toolName,
         result: snapshot.result,
+        ...snapshot.metadata ? { metadata: structuredClone(snapshot.metadata) } : {},
         ...snapshot.compactedAt !== void 0 ? { compactedAt: snapshot.compactedAt } : {}
       };
     case "system":
@@ -1363,52 +1755,8 @@ function restoreAgentWorkflowMessage(snapshot) {
 function restoreAgentWorkflowMessages(snapshots) {
   return snapshots.map(restoreAgentWorkflowMessage);
 }
-function createAgentWorkflowTurnState(options) {
-  return {
-    sessionId: options.sessionId,
-    systemPrompts: [...options.systemPrompts ?? []],
-    messages: (options.initialMessages ?? []).map(cloneMessageSnapshot),
-    phase: "model-step",
-    step: options.initialStep ?? 1,
-    maxSteps: options.maxSteps,
-    replayDecisions: {},
-    startedAt: options.startedAt,
-    updatedAt: options.startedAt
-  };
-}
-function cloneAgentWorkflowTurnState(state) {
-  return {
-    ...state,
-    systemPrompts: [...state.systemPrompts],
-    messages: state.messages.map(cloneMessageSnapshot),
-    ...state.usage ? { usage: cloneUsage2(state.usage) } : {},
-    ...state.turnState ? { turnState: structuredClone(state.turnState) } : {},
-    ...state.lastModelStep ? { lastModelStep: structuredClone(state.lastModelStep) } : {},
-    replayDecisions: Object.fromEntries(
-      Object.entries(state.replayDecisions).map(([toolCallId, decision]) => [
-        toolCallId,
-        { ...decision }
-      ])
-    )
-  };
-}
 
-// src/runtime/workflow-planner/helpers.ts
-function accumulateWorkflowUsage(current, next) {
-  if (!next) {
-    return current ? { ...current } : void 0;
-  }
-  if (!current) {
-    return { ...next };
-  }
-  return {
-    inputTokens: (current.inputTokens ?? 0) + (next.inputTokens ?? 0),
-    outputTokens: (current.outputTokens ?? 0) + (next.outputTokens ?? 0),
-    totalTokens: (current.totalTokens ?? 0) + (next.totalTokens ?? 0),
-    cacheReadTokens: (current.cacheReadTokens ?? 0) + (next.cacheReadTokens ?? 0),
-    cacheWriteTokens: (current.cacheWriteTokens ?? 0) + (next.cacheWriteTokens ?? 0)
-  };
-}
+// src/execution/workflow-planner/helpers.ts
 function cloneRelevantReplayDecisions(state, snapshot) {
   return Object.fromEntries(
     snapshot.toolCalls.flatMap((toolCall) => {
@@ -1417,18 +1765,29 @@ function cloneRelevantReplayDecisions(state, snapshot) {
     })
   );
 }
-function findNextUnresolvedToolCall(snapshot) {
+function findAllUnresolvedToolCalls(snapshot) {
   const resolvedIds = new Set(
     snapshot.toolResults.map((toolResult) => toolResult.toolCallId)
   );
-  return snapshot.toolCalls.find(
+  return snapshot.toolCalls.filter(
     (toolCall) => !resolvedIds.has(toolCall.toolCallId)
   );
 }
 
-// src/runtime/workflow-planner/plan.ts
+// src/execution/workflow-planner/plan.ts
 function planNextAgentWorkflowOperation(state) {
   switch (state.phase) {
+    case "input-commit":
+      if (!state.pendingInput) {
+        throw new Error(
+          `Workflow state for session '${state.sessionId}' is in input-commit phase without a pending input message`
+        );
+      }
+      return {
+        kind: "input-commit",
+        sessionId: state.sessionId,
+        messages: [structuredClone(state.pendingInput)]
+      };
     case "model-step":
       return {
         kind: "model-step",
@@ -1444,24 +1803,37 @@ function planNextAgentWorkflowOperation(state) {
           `Workflow state for session '${state.sessionId}' is in tool-batch phase without a stepCommit snapshot`
         );
       }
-      const nextToolCall = findNextUnresolvedToolCall(
+      const allUnresolved = findAllUnresolvedToolCalls(
         state.lastModelStep.stepCommit
       );
-      if (!nextToolCall) {
+      if (allUnresolved.length === 0) {
         throw new Error(
           `Workflow state for session '${state.sessionId}' is in tool-batch phase without unresolved tool calls`
         );
       }
+      if (allUnresolved.length === 1) {
+        return {
+          kind: "tool-call",
+          step: state.step,
+          sessionId: state.sessionId,
+          toolCall: structuredClone(allUnresolved[0]),
+          turnState: state.turnState ? structuredClone(state.turnState) : void 0,
+          replayDecision: cloneRelevantReplayDecisions(
+            state,
+            state.lastModelStep.stepCommit
+          )[allUnresolved[0].toolCallId]
+        };
+      }
       return {
-        kind: "tool-call",
+        kind: "tool-batch",
         step: state.step,
         sessionId: state.sessionId,
-        toolCall: structuredClone(nextToolCall),
+        toolCalls: allUnresolved.map((tc) => structuredClone(tc)),
         turnState: state.turnState ? structuredClone(state.turnState) : void 0,
-        replayDecision: cloneRelevantReplayDecisions(
+        replayDecisions: cloneRelevantReplayDecisions(
           state,
           state.lastModelStep.stepCommit
-        )[nextToolCall.toolCallId]
+        )
       };
     }
     case "step-commit":
@@ -1494,12 +1866,12 @@ function planNextAgentWorkflowOperation(state) {
   }
 }
 
-// src/runtime/workflow-planner/apply.ts
+// src/execution/workflow-planner/apply.ts
 function applyAgentWorkflowModelStepResult(state, result, updatedAt) {
   const next = cloneAgentWorkflowTurnState(state);
   next.lastModelStep = structuredClone(result);
   next.turnState = structuredClone(result.turnState);
-  next.usage = accumulateWorkflowUsage(next.usage, result.usage);
+  next.usage = accumulateUsage(next.usage, result.usage);
   next.updatedAt = updatedAt;
   next.phase = result.finishReason === "tool-calls" ? "tool-batch" : "output-commit";
   return next;
@@ -1566,6 +1938,10 @@ function applyAgentWorkflowCommitResult(state, result, updatedAt) {
   ];
   next.updatedAt = updatedAt;
   switch (state.phase) {
+    case "input-commit":
+      next.phase = "model-step";
+      delete next.pendingInput;
+      return next;
     case "step-commit":
       next.step = state.step + 1;
       next.phase = "model-step";
@@ -1597,30 +1973,38 @@ function failAgentWorkflowTurnState(state, error, updatedAt) {
 }
 
 export {
-  convertAgentMessagesToModelMessages,
   createAgentTurnStepCommitBatch,
   createAgentTurnState,
   advanceAgentTurnState,
   failAgentTurnState,
   AgentTurnEngine,
   createAgentTurnEngine,
+  estimateTokens,
+  estimateMessageTokens,
+  estimateConversationTokens,
+  DEFAULT_CONTEXT_LIMITS,
+  getUsableTokenLimit,
+  findCutPoint,
+  ContextManager,
   prepareModelStep,
   DoomLoopError,
   ContextOverflowError,
   processStepStream,
-  processStream,
   runModelStep,
   runToolBatch,
   commitStep,
   commitOutput,
   defaultAgentTaskCheckpointStrategy,
   createAgentTaskRunner,
+  createAgentWorkflowTurnState,
+  cloneAgentWorkflowTurnState,
+  applyWorkflowInterventions,
+  drainWorkflowInterventions,
+  queueWorkflowFollowUps,
   snapshotAgentWorkflowMessage,
   snapshotAgentWorkflowMessages,
   restoreAgentWorkflowMessage,
   restoreAgentWorkflowMessages,
-  createAgentWorkflowTurnState,
-  cloneAgentWorkflowTurnState,
   planNextAgentWorkflowOperation,
   applyAgentWorkflowModelStepResult,
   applyAgentWorkflowToolBatchResult,