@cuylabs/agent-core 4.9.0 → 4.10.0

package/dist/chunk-LX4AHGI3.js

@@ -0,0 +1,960 @@
+import {
+  advanceAgentTurnState,
+  createAgentTurnState
+} from "./chunk-E66PKKDL.js";
+import {
+  DEFAULT_CONTEXT_LIMITS,
+  getUsableTokenLimit
+} from "./chunk-NMJNN6LS.js";
+import {
+  Inference,
+  buildModelCallContext
+} from "./chunk-K453AFTL.js";
+import {
+  LLMError
+} from "./chunk-STDJYXYK.js";
+import {
+  executeAgentToolCall
+} from "./chunk-JUIL2NJC.js";
+import {
+  streamWithinScope
+} from "./chunk-AHDCR7SX.js";
+import {
+  extractModelId,
+  extractProvider
+} from "./chunk-I6PKJ7XQ.js";
+import {
+  resolveCapability
+} from "./chunk-FII65CN7.js";
+
+// src/execution/turn/engine/commit-batch.ts
+import { randomUUID } from "crypto";
+function createAgentTurnBoundaryEvent(boundary, metadata = {}) {
+  return {
+    type: "turn-boundary",
+    boundary,
+    ...metadata.step !== void 0 ? { step: metadata.step } : {},
+    ...metadata.messageRole ? { messageRole: metadata.messageRole } : {},
+    ...metadata.pendingToolCallCount !== void 0 ? { pendingToolCallCount: metadata.pendingToolCallCount } : {}
+  };
+}
+function createAgentTurnStepCommitBatch(step, snapshot, options = {}) {
+  if (snapshot.toolCalls.length === 0) {
+    return void 0;
+  }
+  const createdAt = options.createdAt ?? /* @__PURE__ */ new Date();
+  const assistantMessage = {
+    id: options.assistantMessageId ?? randomUUID(),
+    role: "assistant",
+    content: "",
+    finish: "tool-calls",
+    toolCalls: snapshot.toolCalls.map(({ toolCallId, toolName, args }) => ({
+      toolCallId,
+      toolName,
+      args
+    })),
+    createdAt
+  };
+  const toolMessages = snapshot.toolResults.map(
+    ({ toolCallId, toolName, result, metadata }) => ({
+      id: options.toolMessageIds?.[toolCallId] ?? randomUUID(),
+      role: "tool",
+      content: typeof result === "string" ? result : JSON.stringify(result),
+      toolCallId,
+      toolName,
+      result,
+      ...metadata ? { metadata } : {},
+      createdAt
+    })
+  );
+  return {
+    startBoundary: createAgentTurnBoundaryEvent("step-commit-start", {
+      step,
+      pendingToolCallCount: snapshot.toolCalls.length
+    }),
+    finishBoundary: createAgentTurnBoundaryEvent("step-commit-finish", {
+      step
+    }),
+    messages: [assistantMessage, ...toolMessages]
+  };
+}
+function createAgentTurnInputCommit(options) {
+  const message = {
+    id: options.id ?? randomUUID(),
+    role: "user",
+    content: options.content,
+    createdAt: options.createdAt ?? /* @__PURE__ */ new Date(),
+    ...options.system ? { system: options.system } : {}
+  };
+  return {
+    startBoundary: createAgentTurnBoundaryEvent("input-commit-start", {
+      messageRole: "user"
+    }),
+    finishBoundary: createAgentTurnBoundaryEvent("input-commit-finish", {
+      messageRole: "user"
+    }),
+    messages: [message]
+  };
+}
+function createAgentTurnInterventionCommit(options) {
+  const message = {
+    id: options.id,
+    role: "user",
+    content: options.content,
+    createdAt: options.createdAt ?? /* @__PURE__ */ new Date()
+  };
+  return {
+    startBoundary: createAgentTurnBoundaryEvent("intervention-commit-start", {
+      messageRole: "user"
+    }),
+    finishBoundary: createAgentTurnBoundaryEvent("intervention-commit-finish", {
+      messageRole: "user"
+    }),
+    messages: [message]
+  };
+}
+function createAgentTurnOutputCommit(options) {
+  if (!options.text) {
+    return void 0;
+  }
+  const message = {
+    id: options.id ?? randomUUID(),
+    role: "assistant",
+    content: options.text,
+    ...options.usage ? { tokens: options.usage } : {},
+    createdAt: options.createdAt ?? /* @__PURE__ */ new Date()
+  };
+  return {
+    startBoundary: createAgentTurnBoundaryEvent("output-commit-start", {
+      messageRole: "assistant"
+    }),
+    finishBoundary: createAgentTurnBoundaryEvent("output-commit-finish", {
+      messageRole: "assistant"
+    }),
+    messages: [message]
+  };
+}
+
+// src/execution/turn/engine/engine.ts
+var AgentTurnEngine = class {
+  turnState;
+  pendingToolCalls = /* @__PURE__ */ new Map();
+  pendingToolResults = /* @__PURE__ */ new Map();
+  getToolReplayPolicy;
+  constructor(options) {
+    this.turnState = createAgentTurnState({
+      sessionId: options.sessionId,
+      startedAt: options.startedAt
+    });
+    this.getToolReplayPolicy = options.getToolReplayPolicy;
+  }
+  getState() {
+    return structuredClone(this.turnState);
+  }
+  hasPendingToolCalls() {
+    return this.pendingToolCalls.size > 0;
+  }
+  createStepCommitSnapshot() {
+    if (this.pendingToolCalls.size === 0) {
+      return void 0;
+    }
+    return {
+      toolCalls: Array.from(this.pendingToolCalls.entries()).map(
+        ([toolCallId, { toolName, input, replayPolicy }]) => ({
+          toolCallId,
+          toolName,
+          args: input,
+          ...replayPolicy ? { replayPolicy } : {}
+        })
+      ),
+      toolResults: Array.from(this.pendingToolCalls.entries()).map(([toolCallId, { toolName, replayPolicy }]) => {
+        const resultData = this.pendingToolResults.get(toolCallId);
+        if (!resultData) {
+          return void 0;
+        }
+        return {
+          toolCallId,
+          toolName,
+          result: resultData.result,
+          ...resultData.metadata ? { metadata: resultData.metadata } : {},
+          ...replayPolicy ? { replayPolicy } : {}
+        };
+      }).filter((result) => result !== void 0)
+    };
+  }
+  recordEvent(event, updatedAt) {
+    const toolReplayPolicy = "toolName" in event ? this.getToolReplayPolicy?.(event.toolName) : void 0;
+    this.turnState = advanceAgentTurnState(this.turnState, event, updatedAt, {
+      toolReplayPolicy
+    });
+    switch (event.type) {
+      case "tool-start":
+        this.pendingToolCalls.set(event.toolCallId, {
+          toolName: event.toolName,
+          input: event.input,
+          replayPolicy: toolReplayPolicy
+        });
+        break;
+      case "tool-result":
+        this.pendingToolResults.set(event.toolCallId, {
+          toolName: event.toolName,
+          result: event.result,
+          ...event.metadata ? { metadata: event.metadata } : {},
+          replayPolicy: toolReplayPolicy
+        });
+        break;
+      case "tool-error":
+        this.pendingToolResults.set(event.toolCallId, {
+          toolName: event.toolName,
+          result: `Error: ${event.error}`,
+          replayPolicy: toolReplayPolicy
+        });
+        break;
+      default:
+        break;
+    }
+    return this.getState();
+  }
+  createBoundaryEvent(boundary, metadata = {}) {
+    return createAgentTurnBoundaryEvent(boundary, metadata);
+  }
+  createInputCommit(options) {
+    return createAgentTurnInputCommit(options);
+  }
+  createInterventionCommit(options) {
+    return createAgentTurnInterventionCommit(options);
+  }
+  consumeStepCommit(step) {
+    const snapshot = this.createStepCommitSnapshot();
+    const batch = snapshot ? createAgentTurnStepCommitBatch(step, snapshot) : void 0;
+    if (!batch) {
+      return void 0;
+    }
+    this.pendingToolCalls.clear();
+    this.pendingToolResults.clear();
+    return batch;
+  }
+  createOutputCommit(options) {
+    return createAgentTurnOutputCommit(options);
+  }
+};
+function createAgentTurnEngine(options) {
+  return new AgentTurnEngine(options);
+}
+
+// src/execution/turn/runner/prepare.ts
+function prepareModelStep(options) {
+  const modelMessages = Array.from(options.toModelMessages(options.messages));
+  return {
+    step: options.step,
+    messages: options.messages,
+    ...options.contextReport ? { contextReport: options.contextReport } : {},
+    modelMessages,
+    inferenceInput: {
+      sessionID: options.sessionId,
+      turnID: options.turnId ?? options.turnTracker?.getCurrentTurnId?.() ?? void 0,
+      step: options.step,
+      model: options.config.model,
+      system: options.systemPrompts,
+      messages: modelMessages,
+      abort: options.abort,
+      tools: options.tools,
+      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,
+      maxSteps: options.config.maxSteps,
+      reasoningLevel: options.reasoningLevel,
+      customStreamProvider: options.config.streamProvider,
+      turnTracker: options.turnTracker,
+      intervention: options.intervention,
+      middleware: options.middleware,
+      toolExecutionMode: options.toolExecutionMode,
+      telemetry: options.config.telemetry
+    },
+    stepProcessing: {
+      maxSteps: options.config.maxSteps,
+      doomLoopThreshold: options.config.doomLoopThreshold,
+      enforceDoomLoop: options.config.enforceDoomLoop,
+      onDoomLoop: options.config.onDoomLoop,
+      contextTokenLimit: options.config.contextWindow ? getUsableTokenLimit({
+        contextWindow: options.config.contextWindow,
+        reserveTokens: options.config.reserveTokens ?? DEFAULT_CONTEXT_LIMITS.reserveTokens
+      }) : void 0
+    }
+  };
+}
+
+// src/execution/turn/step-processing/doom-loop.ts
+var DEFAULT_DOOM_LOOP_THRESHOLD = 3;
+var DoomLoopError = class extends Error {
+  toolName;
+  repeatCount;
+  input;
+  constructor(toolName, repeatCount, input) {
+    super(
+      `Doom loop detected: "${toolName}" called ${repeatCount} times with identical input`
+    );
+    this.name = "DoomLoopError";
+    this.toolName = toolName;
+    this.repeatCount = repeatCount;
+    this.input = input;
+  }
+};
+function hashInput(input) {
+  return JSON.stringify(input);
+}
+async function recordToolCallAndCheckDoomLoop(options) {
+  const {
+    recentToolCalls,
+    toolName,
+    input,
+    processorOptions,
+    threshold,
+    emitEvent
+  } = options;
+  recentToolCalls.push({
+    toolName,
+    inputHash: hashInput(input)
+  });
+  if (recentToolCalls.length > threshold) {
+    recentToolCalls.shift();
+  }
+  if (recentToolCalls.length !== threshold) {
+    return;
+  }
+  const first = recentToolCalls[0];
+  const isLoop = recentToolCalls.every(
+    (call) => call.toolName === first.toolName && call.inputHash === first.inputHash
+  );
+  if (!isLoop) {
+    return;
+  }
+  if (processorOptions.rememberedDoomLoopTools?.has(toolName)) {
+    return;
+  }
+  const doomError = new DoomLoopError(toolName, threshold, input);
+  await emitEvent({
+    type: "doom-loop",
+    toolName,
+    repeatCount: threshold
+  });
+  if (processorOptions.onDoomLoop) {
+    const action = await processorOptions.onDoomLoop({
+      tool: toolName,
+      repeatCount: threshold,
+      input,
+      sessionId: processorOptions.sessionID ?? "unknown"
+    });
+    switch (action) {
+      case "allow":
+        return;
+      case "remember":
+        processorOptions.rememberedDoomLoopTools?.add(toolName);
+        return;
+      case "deny":
+        throw doomError;
+    }
+  }
+  if (processorOptions.enforceDoomLoop ?? true) {
+    throw doomError;
+  }
+  options.warn?.(`[StepProcessing] ${doomError.message}`);
+}
+
+// src/execution/turn/step-processing/overflow.ts
+var ContextOverflowError = class extends Error {
+  inputTokens;
+  limit;
+  constructor(inputTokens, limit) {
+    super(`Context overflow: ${inputTokens} tokens exceeds limit of ${limit}`);
+    this.name = "ContextOverflowError";
+    this.inputTokens = inputTokens;
+    this.limit = limit;
+  }
+};
+async function handleContextOverflow(options) {
+  const limit = options.processorOptions.contextTokenLimit;
+  const inputTokens = options.usage?.inputTokens;
+  if (!limit || !inputTokens || inputTokens <= limit) {
+    return;
+  }
+  await options.emitEvent({
+    type: "context-overflow",
+    inputTokens,
+    limit
+  });
+  if (options.processorOptions.onContextOverflow) {
+    await options.processorOptions.onContextOverflow(inputTokens, limit);
+  }
+}
+
+// src/execution/turn/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 = "";
+  const toolResults = [];
+  const recentToolCalls = [];
+  let usage;
+  let finishReason;
+  let error;
+  let hasToolCalls = false;
+  await onEvent({ type: "step-start", step: stepCount, maxSteps });
+  await onEvent({ type: "status", status: "processing" });
+  try {
+    for await (const rawChunk of stream.fullStream) {
+      const chunk = rawChunk;
+      log?.debug(`Chunk received: ${chunk.type}`);
+      abort.throwIfAborted();
+      switch (chunk.type) {
+        case "start-step":
+          if (!sawStartStep) {
+            sawStartStep = true;
+            break;
+          }
+          stepCount++;
+          await onEvent({ type: "step-start", step: stepCount, maxSteps });
+          await onEvent({ type: "status", status: "processing" });
+          break;
+        case "text-start":
+          await onEvent({ type: "text-start" });
+          break;
+        case "text-delta":
+          text += chunk.text;
+          await onEvent({ type: "text-delta", text: chunk.text });
+          break;
+        case "text-end":
+          await onEvent({ type: "text-end" });
+          break;
+        case "reasoning-start":
+          await onEvent({ type: "status", status: "reasoning" });
+          await onEvent({ type: "reasoning-start", id: chunk.id });
+          break;
+        case "reasoning-delta":
+          await onEvent({
+            type: "reasoning-delta",
+            id: chunk.id,
+            text: chunk.text
+          });
+          break;
+        case "reasoning-end":
+          await onEvent({ type: "reasoning-end", id: chunk.id });
+          break;
+        case "tool-call":
+          hasToolCalls = true;
+          await onEvent({ type: "status", status: "calling-tool" });
+          await onEvent({
+            type: "tool-start",
+            toolName: chunk.toolName,
+            toolCallId: chunk.toolCallId,
+            input: chunk.input
+          });
+          await recordToolCallAndCheckDoomLoop({
+            recentToolCalls,
+            toolName: chunk.toolName,
+            input: chunk.input,
+            processorOptions: options,
+            threshold: doomLoopThreshold,
+            emitEvent: onEvent,
+            warn: (message) => process.stderr.write(`${message}
+`)
+          });
+          break;
+        case "tool-result": {
+          const normalized = normalizeToolResultChunk(chunk.output);
+          toolResults.push({
+            toolName: chunk.toolName,
+            toolCallId: chunk.toolCallId,
+            result: normalized.result,
+            ...normalized.metadata ? { metadata: normalized.metadata } : {}
+          });
+          await onEvent({
+            type: "tool-result",
+            toolName: chunk.toolName,
+            toolCallId: chunk.toolCallId,
+            result: normalized.result,
+            ...normalized.metadata ? { metadata: normalized.metadata } : {}
+          });
+          break;
+        }
+        case "tool-error":
+          await onEvent({
+            type: "tool-error",
+            toolName: chunk.toolName,
+            toolCallId: chunk.toolCallId,
+            error: String(chunk.error)
+          });
+          break;
+        case "computer-call":
+          hasToolCalls = true;
+          await onEvent({ type: "status", status: "calling-tool" });
+          await onEvent({
+            type: "computer-call",
+            callId: chunk.callId,
+            action: chunk.action,
+            pendingSafetyChecks: chunk.pendingSafetyChecks
+          });
+          break;
+        case "finish-step":
+          finishReason = chunk.finishReason;
+          if (chunk.usage) {
+            usage = {
+              inputTokens: chunk.usage.inputTokens,
+              outputTokens: chunk.usage.outputTokens,
+              totalTokens: chunk.usage.totalTokens
+            };
+            await handleContextOverflow({
+              usage,
+              processorOptions: options,
+              emitEvent: onEvent
+            });
+          }
+          await onEvent({
+            type: "step-finish",
+            step: stepCount,
+            usage,
+            finishReason
+          });
+          if (!sawStartStep) {
+            stepCount++;
+          }
+          break;
+        case "finish":
+          if (chunk.totalUsage) {
+            usage = {
+              inputTokens: chunk.totalUsage.inputTokens,
+              outputTokens: chunk.totalUsage.outputTokens,
+              totalTokens: chunk.totalUsage.totalTokens
+            };
+          }
+          break;
+        case "step-usage":
+          usage = {
+            inputTokens: chunk.usage.inputTokens,
+            outputTokens: chunk.usage.outputTokens,
+            totalTokens: chunk.usage.totalTokens
+          };
+          break;
+        case "error":
+          throw chunk.error;
+      }
+    }
+  } catch (caught) {
+    error = normalizeError(caught);
+    if (!options.deferErrorEvent?.(error)) {
+      await onEvent({ type: "status", status: "error" });
+      await onEvent({ type: "error", error });
+    }
+  }
+  if (!error) {
+    await onEvent({ type: "status", status: "idle" });
+  }
+  let result = "continue";
+  if (error || !hasToolCalls) {
+    result = "stop";
+  }
+  return {
+    result,
+    text,
+    toolResults,
+    usage,
+    finishReason,
+    error
+  };
+}
+
+// src/execution/turn/runner/stream-step.ts
+function buildStepModelCallContext(options) {
+  const input = options.preparedStep.inferenceInput;
+  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;
+  return LLMError.from(error, {
+    provider: extractProvider(model),
+    model: extractModelId(model)
+  });
+}
+async function* runModelStep(options) {
+  return yield* streamWithinScope(
+    {
+      kind: "model",
+      name: "model-step",
+      sessionId: options.preparedStep.inferenceInput.sessionID,
+      step: options.preparedStep.step
+    },
+    (async function* () {
+      const { preparedStep, turnEngine, applyCommitBatch } = options;
+      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({
+            type: "intervention-applied",
+            id: item.id,
+            message: item.message
+          });
+          if (resolveNext) {
+            resolveNext();
+            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,
+        normalizeError: (error) => normalizeModelStepError(options, error),
+        deferErrorEvent: options.deferErrorEvent,
+        currentStep: preparedStep.step,
+        maxSteps: preparedStep.stepProcessing.maxSteps,
+        doomLoopThreshold: preparedStep.stepProcessing.doomLoopThreshold ?? 3,
+        enforceDoomLoop: preparedStep.stepProcessing.enforceDoomLoop ?? true,
+        onDoomLoop: preparedStep.stepProcessing.onDoomLoop,
+        rememberedDoomLoopTools: options.rememberedDoomLoopTools,
+        contextTokenLimit: preparedStep.stepProcessing.contextTokenLimit,
+        onContextOverflow: async () => {
+        },
+        onEvent: emitQueuedEvent
+      }).then((result2) => {
+        streamDone = true;
+        if (resolveNext) {
+          resolveNext();
+          resolveNext = null;
+        }
+        return result2;
+      }).catch((error) => {
+        streamError = error instanceof Error ? error : new Error(String(error));
+        streamDone = true;
+        if (resolveNext) {
+          resolveNext();
+          resolveNext = null;
+        }
+        return null;
+      });
+      while (!streamDone || eventQueue.length > 0) {
+        while (eventQueue.length > 0) {
+          const event = eventQueue.shift();
+          turnEngine.recordEvent(event, (/* @__PURE__ */ new Date()).toISOString());
+          yield event;
+          if (event.type === "intervention-applied") {
+            yield* applyCommitBatch(
+              turnEngine.createInterventionCommit({
+                id: event.id,
+                content: event.message
+              })
+            );
+          }
+        }
+        if (!streamDone) {
+          await new Promise((resolve) => {
+            resolveNext = resolve;
+          });
+        }
+      }
+      if (streamError) {
+        throw streamError;
+      }
+      const result = await processPromise;
+      if (!result) {
+        throw new Error(
+          `Agent step ${preparedStep.step} produced no step-processing result`
+        );
+      }
+      if (middleware?.hasMiddleware) {
+        const revised = await middleware.runModelOutput(
+          {
+            text: result.text,
+            usage: result.usage,
+            finishReason: result.finishReason
+          },
+          buildStepModelCallContext(options)
+        );
+        result.text = revised.text;
+        result.usage = revised.usage;
+        result.finishReason = revised.finishReason;
+      }
+      return result;
+    })()
+  );
+}
+
+// src/execution/turn/runner/tool-batch.ts
+function cloneToolResultRecord(options) {
+  return new Map(
+    options.snapshot.toolResults.map((toolResult) => [
+      toolResult.toolCallId,
+      structuredClone(toolResult)
+    ])
+  );
+}
+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 } : {}
+      }
+    );
+  }
+}
+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 = [];
+  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];
+    if (!tool) {
+      serialGroup.push({ toolCall });
+      continue;
+    }
+    let safe = false;
+    let initialized;
+    try {
+      const result = await isParallelSafe(tool, 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: {
+      toolCalls: options.snapshot.toolCalls.map(
+        (toolCall) => structuredClone(toolCall)
+      ),
+      toolResults: options.snapshot.toolCalls.map((toolCall) => toolResultsByCallId.get(toolCall.toolCallId)).filter((toolResult) => toolResult !== void 0)
+    },
+    ...turnState.value ? { turnState: turnState.value } : {},
+    events
+  };
+}
+
+// src/execution/turn/runner/commit.ts
+async function* commitStep(options) {
+  return yield* streamWithinScope(
+    {
+      kind: "commit",
+      name: "step-commit",
+      step: options.step
+    },
+    (async function* () {
+      if (options.finishReason !== "tool-calls") {
+        return false;
+      }
+      const batch = options.turnEngine.consumeStepCommit(options.step);
+      if (!batch) {
+        return false;
+      }
+      yield* options.applyCommitBatch(batch);
+      return true;
+    })()
+  );
+}
+async function* commitOutput(options) {
+  return yield* streamWithinScope(
+    {
+      kind: "commit",
+      name: "output-commit"
+    },
+    (async function* () {
+      const batch = options.turnEngine.createOutputCommit({
+        text: options.text,
+        usage: options.usage
+      });
+      if (!batch) {
+        return false;
+      }
+      yield* options.applyCommitBatch(batch, { emitMessages: true });
+      return true;
+    })()
+  );
+}
+
+export {
+  createAgentTurnStepCommitBatch,
+  AgentTurnEngine,
+  createAgentTurnEngine,
+  prepareModelStep,
+  DoomLoopError,
+  ContextOverflowError,
+  processStepStream,
+  runModelStep,
+  runToolBatch,
+  commitStep,
+  commitOutput
+};