@cuylabs/agent-core 4.8.1 → 4.10.0

package/dist/chunk-V6ETEYST.js

@@ -1,2091 +0,0 @@
-import {
-  Inference,
-  buildModelCallContext
-} from "./chunk-NS7D7JJU.js";
-import {
-  currentScope,
-  executeAgentToolCall,
-  snapshotScope,
-  streamWithinScope,
-  withinScope
-} from "./chunk-MWPU2EVV.js";
-import {
-  LLMError
-} from "./chunk-STDJYXYK.js";
-import {
-  extractModelId,
-  extractProvider
-} from "./chunk-I6PKJ7XQ.js";
-import {
-  resolveCapability
-} from "./chunk-FII65CN7.js";
-import {
-  silentLogger
-} from "./chunk-S6AKEPAX.js";
-
-// src/execution/task/observer.ts
-function defaultAgentTaskCheckpointStrategy(input) {
-  switch (input.event.type) {
-    case "step-finish":
-      return "step-finish";
-    case "tool-result":
-      return "tool-result";
-    case "tool-error":
-      return "tool-error";
-    case "turn-boundary":
-      return input.event.boundary;
-    case "complete":
-      return "task-complete";
-    default:
-      return void 0;
-  }
-}
-
-// src/execution/task/runner.ts
-import { randomUUID } from "crypto";
-
-// 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 normalizeUsage(usage) {
-  if (!usage) {
-    return cloneUsage(EMPTY_USAGE);
-  }
-  return {
-    inputTokens: usage.inputTokens ?? 0,
-    outputTokens: usage.outputTokens ?? 0,
-    totalTokens: usage.totalTokens ?? 0
-  };
-}
-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: restore?.step ?? 0,
-    response: restore?.response ?? "",
-    usage: restore?.usage ? cloneUsage(restore.usage) : cloneUsage(EMPTY_USAGE),
-    eventCount: restore?.eventCount ?? 0,
-    activeToolCalls: [],
-    resolvedToolCalls: [],
-    startedAt: options.startedAt,
-    updatedAt: options.startedAt
-  };
-}
-function advanceAgentTurnState(state, event, updatedAt, options = {}) {
-  const next = {
-    ...state,
-    usage: cloneUsage(state.usage),
-    activeToolCalls: state.activeToolCalls.map((toolCall) => ({ ...toolCall })),
-    resolvedToolCalls: state.resolvedToolCalls.map((toolCall) => ({
-      ...toolCall,
-      ...toolCall.metadata ? { metadata: structuredClone(toolCall.metadata) } : {}
-    })),
-    eventCount: state.eventCount + 1,
-    lastEvent: event,
-    updatedAt
-  };
-  switch (event.type) {
-    case "step-start":
-      next.phase = "running-model";
-      next.step = event.step;
-      next.maxSteps = event.maxSteps;
-      next.activeToolCalls = [];
-      next.resolvedToolCalls = [];
-      next.lastFinishReason = void 0;
-      delete next.error;
-      break;
-    case "text-delta":
-      next.response += event.text;
-      break;
-    case "tool-start":
-      next.phase = "running-tools";
-      next.activeToolCalls = [
-        ...removeActiveToolCall(next.activeToolCalls, event.toolCallId),
-        {
-          toolCallId: event.toolCallId,
-          toolName: event.toolName,
-          input: event.input,
-          startedAt: updatedAt,
-          ...options.toolReplayPolicy ? { replayPolicy: options.toolReplayPolicy } : {}
-        }
-      ];
-      break;
-    case "tool-result":
-      next.phase = "running-tools";
-      next.activeToolCalls = removeActiveToolCall(
-        next.activeToolCalls,
-        event.toolCallId
-      );
-      next.resolvedToolCalls = [
-        ...next.resolvedToolCalls,
-        {
-          toolCallId: event.toolCallId,
-          toolName: event.toolName,
-          outcome: "result",
-          value: event.result,
-          ...event.metadata ? { metadata: structuredClone(event.metadata) } : {},
-          resolvedAt: updatedAt,
-          ...options.toolReplayPolicy ? { replayPolicy: options.toolReplayPolicy } : {}
-        }
-      ];
-      break;
-    case "tool-error":
-      next.phase = "running-tools";
-      next.activeToolCalls = removeActiveToolCall(
-        next.activeToolCalls,
-        event.toolCallId
-      );
-      next.resolvedToolCalls = [
-        ...next.resolvedToolCalls,
-        {
-          toolCallId: event.toolCallId,
-          toolName: event.toolName,
-          outcome: "error",
-          value: event.error,
-          resolvedAt: updatedAt,
-          ...options.toolReplayPolicy ? { replayPolicy: options.toolReplayPolicy } : {}
-        }
-      ];
-      break;
-    case "step-finish":
-      next.phase = "committing-step";
-      next.step = event.step;
-      next.usage = normalizeUsage(event.usage ?? next.usage);
-      next.lastFinishReason = event.finishReason;
-      break;
-    case "turn-boundary":
-      next.lastBoundary = {
-        kind: event.boundary,
-        createdAt: updatedAt,
-        ...event.step !== void 0 ? { step: event.step } : {},
-        ...event.messageRole ? { messageRole: event.messageRole } : {},
-        ...event.pendingToolCallCount !== void 0 ? { pendingToolCallCount: event.pendingToolCallCount } : {}
-      };
-      switch (event.boundary) {
-        case "input-commit-start":
-        case "input-commit-finish":
-        case "intervention-commit-start":
-        case "intervention-commit-finish":
-          next.phase = "committing-input";
-          break;
-        case "step-commit-start":
-        case "step-commit-finish":
-          next.phase = "committing-step";
-          break;
-        case "output-commit-start":
-        case "output-commit-finish":
-          next.phase = "committing-output";
-          break;
-      }
-      break;
-    case "complete":
-      next.phase = "completed";
-      next.usage = normalizeUsage(event.usage ?? next.usage);
-      break;
-    case "error":
-      next.phase = "failed";
-      next.error = event.error.message;
-      break;
-    default:
-      break;
-  }
-  return next;
-}
-function failAgentTurnState(state, error, updatedAt) {
-  return {
-    ...state,
-    usage: cloneUsage(state.usage),
-    activeToolCalls: state.activeToolCalls.map((toolCall) => ({ ...toolCall })),
-    resolvedToolCalls: state.resolvedToolCalls.map((toolCall) => ({
-      ...toolCall,
-      ...toolCall.metadata ? { metadata: structuredClone(toolCall.metadata) } : {}
-    })),
-    phase: "failed",
-    error: error.message,
-    updatedAt
-  };
-}
-
-// src/execution/task/runner.ts
-function normalizeNonEmpty(value, label) {
-  const normalized = value.trim();
-  if (!normalized) {
-    throw new Error(`${label} must not be empty`);
-  }
-  return normalized;
-}
-function sanitizeSegment(input) {
-  return input.trim().toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
-}
-function buildRuntimeSessionId(prefix, key) {
-  const timestamp = Date.now().toString(36);
-  const suffix = randomUUID().slice(0, 8);
-  const normalizedPrefix = sanitizeSegment(prefix) || "runtime";
-  const normalizedKey = key ? sanitizeSegment(key) : "";
-  if (normalizedKey) {
-    return `${normalizedPrefix}:${normalizedKey}:${timestamp}:${suffix}`;
-  }
-  return `${normalizedPrefix}:${timestamp}:${suffix}`;
-}
-function nowIso() {
-  return (/* @__PURE__ */ new Date()).toISOString();
-}
-async function notifyObservers(observers, invoke, logger) {
-  for (const observer of observers) {
-    try {
-      await invoke(observer);
-    } catch (error) {
-      logger.warn("observer error", {
-        error: error instanceof Error ? error.message : String(error)
-      });
-    }
-  }
-}
-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",
-        name: "agent-task",
-        sessionId,
-        taskId: context.fallbackSessionKey ?? sessionId,
-        attributes: {
-          ...context.trigger ? { trigger: context.trigger } : {}
-        }
-      },
-      async () => {
-        const run = {
-          payload,
-          context,
-          sessionId,
-          executionId,
-          startedAt: context.restoreFrom?.startedAt ?? startedAt,
-          scope: snapshotScope()
-        };
-        const toolCalls = context.restoreFrom?.toolCalls.map((tc) => ({ ...tc })) ?? [];
-        let turnState = createAgentTurnState({
-          sessionId,
-          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,
-          response: turnState.response,
-          usage: { ...turnState.usage },
-          toolCalls: toolCalls.map((toolCall) => ({ ...toolCall })),
-          eventCount: turnState.eventCount,
-          activeStep: turnState.step > 0 ? turnState.step : void 0,
-          lastEvent: turnState.lastEvent,
-          error: turnState.error,
-          startedAt: turnState.startedAt,
-          updatedAt: turnState.updatedAt,
-          turnState,
-          scope: currentScope() ?? run.scope
-        });
-        const emitCheckpoint = async (reason, event) => {
-          if (baseObservers.length === 0) {
-            return;
-          }
-          const checkpoint = {
-            run,
-            reason,
-            snapshot: createSnapshot(),
-            event,
-            createdAt: turnState.updatedAt
-          };
-          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, executionId);
-        try {
-          const processChatStream = async () => {
-            for await (const event of agent.chat(sessionId, message, {
-              abort: context.signal,
-              system: payload.system
-            })) {
-              turnState = advanceAgentTurnState(turnState, event, nowIso());
-              if (event.type === "tool-result") {
-                toolCalls.push({ name: event.toolName, result: event.result });
-              }
-              const snapshot = createSnapshot();
-              await notifyObservers(
-                baseObservers,
-                async (observer) => {
-                  await observer.onTaskEvent?.(run, event, snapshot);
-                },
-                log
-              );
-              const checkpointReason = checkpointStrategy({
-                run,
-                event,
-                snapshot
-              });
-              if (checkpointReason) {
-                await emitCheckpoint(checkpointReason, event);
-              }
-              if (event.type === "error") {
-                throw event.error;
-              }
-            }
-          };
-          if (activateCtx) {
-            await activateCtx(processChatStream);
-          } else {
-            await processChatStream();
-          }
-          const result = {
-            response: turnState.response,
-            sessionId,
-            usage: { ...turnState.usage },
-            toolCalls
-          };
-          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;
-        }
-      }
-    );
-  };
-}
-
-// src/execution/turn-engine/commit-batch.ts
-import { randomUUID as randomUUID2 } 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 ?? randomUUID2(),
-    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] ?? randomUUID2(),
-      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 ?? randomUUID2(),
-    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 ?? randomUUID2(),
-    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/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/types/compaction.ts
-var PRUNE_PROTECTED_TOOLS = ["skill"];
-
-// 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 {
-    step: options.step,
-    messages: options.messages,
-    modelMessages,
-    inferenceInput: {
-      sessionID: options.sessionId,
-      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/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/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/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);
-    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),
-        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/types/messages.ts
-function accumulateUsage(current, next) {
-  if (!next) return current;
-  if (!current) {
-    return {
-      inputTokens: next.inputTokens ?? 0,
-      outputTokens: next.outputTokens ?? 0,
-      totalTokens: next.totalTokens ?? 0,
-      cacheReadTokens: (next.cacheReadTokens ?? 0) || void 0,
-      cacheWriteTokens: (next.cacheWriteTokens ?? 0) || void 0
-    };
-  }
-  const cacheRead = (current.cacheReadTokens ?? 0) + (next.cacheReadTokens ?? 0);
-  const cacheWrite = (current.cacheWriteTokens ?? 0) + (next.cacheWriteTokens ?? 0);
-  return {
-    inputTokens: (current.inputTokens ?? 0) + (next.inputTokens ?? 0),
-    outputTokens: (current.outputTokens ?? 0) + (next.outputTokens ?? 0),
-    totalTokens: (current.totalTokens ?? 0) + (next.totalTokens ?? 0),
-    cacheReadTokens: cacheRead || void 0,
-    cacheWriteTokens: cacheWrite || void 0
-  };
-}
-
-// 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;
-    })()
-  );
-}
-
-// src/execution/workflow-state.ts
-function cloneMessageSnapshot(message) {
-  return {
-    ...message,
-    ...message.role === "assistant" && message.toolCalls ? {
-      toolCalls: message.toolCalls.map((toolCall) => ({ ...toolCall }))
-    } : {},
-    ...message.role === "assistant" && message.tokens ? {
-      tokens: { ...message.tokens }
-    } : {},
-    ...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":
-      return {
-        id: message.id,
-        role: "user",
-        createdAt: message.createdAt.toISOString(),
-        content: message.content,
-        ...message.system ? { system: message.system } : {}
-      };
-    case "assistant":
-      return {
-        id: message.id,
-        role: "assistant",
-        createdAt: message.createdAt.toISOString(),
-        content: message.content,
-        ...message.finish ? { finish: message.finish } : {},
-        ...message.tokens ? { tokens: { ...message.tokens } } : {},
-        ...message.cost !== void 0 ? { cost: message.cost } : {},
-        ...message.error ? { error: { ...message.error } } : {},
-        ...message.toolCalls ? {
-          toolCalls: message.toolCalls.map((toolCall) => ({
-            toolCallId: toolCall.toolCallId,
-            toolName: toolCall.toolName,
-            args: toolCall.args
-          }))
-        } : {}
-      };
-    case "tool":
-      return {
-        id: message.id,
-        role: "tool",
-        createdAt: message.createdAt.toISOString(),
-        content: message.content,
-        toolCallId: message.toolCallId,
-        toolName: message.toolName,
-        result: message.result,
-        ...message.metadata ? { metadata: structuredClone(message.metadata) } : {},
-        ...message.compactedAt !== void 0 ? { compactedAt: message.compactedAt } : {}
-      };
-    case "system":
-      return {
-        id: message.id,
-        role: "system",
-        createdAt: message.createdAt.toISOString(),
-        content: message.content
-      };
-  }
-}
-function snapshotAgentWorkflowMessages(messages) {
-  return messages.map((message) => snapshotAgentWorkflowMessage(message));
-}
-function restoreAgentWorkflowMessage(snapshot) {
-  const createdAt = new Date(snapshot.createdAt);
-  switch (snapshot.role) {
-    case "user":
-      return {
-        id: snapshot.id,
-        role: "user",
-        createdAt,
-        content: snapshot.content,
-        ...snapshot.system ? { system: snapshot.system } : {}
-      };
-    case "assistant":
-      return {
-        id: snapshot.id,
-        role: "assistant",
-        createdAt,
-        content: snapshot.content,
-        ...snapshot.finish ? { finish: snapshot.finish } : {},
-        ...snapshot.tokens ? { tokens: { ...snapshot.tokens } } : {},
-        ...snapshot.cost !== void 0 ? { cost: snapshot.cost } : {},
-        ...snapshot.error ? { error: { ...snapshot.error } } : {},
-        ...snapshot.toolCalls ? {
-          toolCalls: snapshot.toolCalls.map((toolCall) => ({
-            toolCallId: toolCall.toolCallId,
-            toolName: toolCall.toolName,
-            args: toolCall.args
-          }))
-        } : {}
-      };
-    case "tool":
-      return {
-        id: snapshot.id,
-        role: "tool",
-        createdAt,
-        content: snapshot.content,
-        toolCallId: snapshot.toolCallId,
-        toolName: snapshot.toolName,
-        result: snapshot.result,
-        ...snapshot.metadata ? { metadata: structuredClone(snapshot.metadata) } : {},
-        ...snapshot.compactedAt !== void 0 ? { compactedAt: snapshot.compactedAt } : {}
-      };
-    case "system":
-      return {
-        id: snapshot.id,
-        role: "system",
-        createdAt,
-        content: snapshot.content
-      };
-  }
-}
-function restoreAgentWorkflowMessages(snapshots) {
-  return snapshots.map(restoreAgentWorkflowMessage);
-}
-
-// src/execution/workflow-planner/helpers.ts
-function cloneRelevantReplayDecisions(state, snapshot) {
-  return Object.fromEntries(
-    snapshot.toolCalls.flatMap((toolCall) => {
-      const decision = state.replayDecisions[toolCall.toolCallId];
-      return decision ? [[toolCall.toolCallId, { ...decision }]] : [];
-    })
-  );
-}
-function findAllUnresolvedToolCalls(snapshot) {
-  const resolvedIds = new Set(
-    snapshot.toolResults.map((toolResult) => toolResult.toolCallId)
-  );
-  return snapshot.toolCalls.filter(
-    (toolCall) => !resolvedIds.has(toolCall.toolCallId)
-  );
-}
-
-// 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",
-        sessionId: state.sessionId,
-        step: state.step,
-        maxSteps: state.maxSteps,
-        systemPrompts: [...state.systemPrompts],
-        messages: state.messages.map((message) => structuredClone(message))
-      };
-    case "tool-batch": {
-      if (!state.lastModelStep?.stepCommit) {
-        throw new Error(
-          `Workflow state for session '${state.sessionId}' is in tool-batch phase without a stepCommit snapshot`
-        );
-      }
-      const allUnresolved = findAllUnresolvedToolCalls(
-        state.lastModelStep.stepCommit
-      );
-      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-batch",
-        step: state.step,
-        sessionId: state.sessionId,
-        toolCalls: allUnresolved.map((tc) => structuredClone(tc)),
-        turnState: state.turnState ? structuredClone(state.turnState) : void 0,
-        replayDecisions: cloneRelevantReplayDecisions(
-          state,
-          state.lastModelStep.stepCommit
-        )
-      };
-    }
-    case "step-commit":
-      if (!state.lastModelStep?.stepCommit) {
-        throw new Error(
-          `Workflow state for session '${state.sessionId}' is in step-commit phase without a stepCommit snapshot`
-        );
-      }
-      return {
-        kind: "step-commit",
-        sessionId: state.sessionId,
-        step: state.step,
-        snapshot: structuredClone(state.lastModelStep.stepCommit)
-      };
-    case "output-commit":
-      if (!state.lastModelStep) {
-        throw new Error(
-          `Workflow state for session '${state.sessionId}' is in output-commit phase without a last model step`
-        );
-      }
-      return {
-        kind: "output-commit",
-        sessionId: state.sessionId,
-        text: state.lastModelStep.text,
-        ...state.lastModelStep.usage ? { usage: { ...state.lastModelStep.usage } } : {}
-      };
-    case "completed":
-    case "failed":
-      return void 0;
-  }
-}
-
-// 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 = accumulateUsage(next.usage, result.usage);
-  next.updatedAt = updatedAt;
-  next.phase = result.finishReason === "tool-calls" ? "tool-batch" : "output-commit";
-  return next;
-}
-function applyAgentWorkflowToolBatchResult(state, result, updatedAt) {
-  if (state.phase !== "tool-batch") {
-    throw new Error(
-      `Cannot apply a tool-batch result while workflow state is in '${state.phase}' phase`
-    );
-  }
-  const next = cloneAgentWorkflowTurnState(state);
-  next.updatedAt = updatedAt;
-  next.phase = "step-commit";
-  if (!next.lastModelStep) {
-    throw new Error(
-      `Workflow state for session '${state.sessionId}' has no model step to update after tool-batch`
-    );
-  }
-  next.lastModelStep.stepCommit = structuredClone(result.stepCommit);
-  if (result.turnState) {
-    next.turnState = structuredClone(result.turnState);
-  }
-  return next;
-}
-function applyAgentWorkflowToolCallResult(state, result, updatedAt) {
-  if (state.phase !== "tool-batch") {
-    throw new Error(
-      `Cannot apply a tool-call result while workflow state is in '${state.phase}' phase`
-    );
-  }
-  if (!state.lastModelStep?.stepCommit) {
-    throw new Error(
-      `Workflow state for session '${state.sessionId}' has no stepCommit snapshot in tool-batch phase`
-    );
-  }
-  const next = cloneAgentWorkflowTurnState(state);
-  const snapshot = structuredClone(state.lastModelStep.stepCommit);
-  const existingResultIndex = snapshot.toolResults.findIndex(
-    (toolResult) => toolResult.toolCallId === result.toolResult.toolCallId
-  );
-  if (existingResultIndex >= 0) {
-    snapshot.toolResults[existingResultIndex] = structuredClone(
-      result.toolResult
-    );
-  } else {
-    snapshot.toolResults.push(structuredClone(result.toolResult));
-  }
-  next.lastModelStep = {
-    ...next.lastModelStep,
-    stepCommit: snapshot
-  };
-  next.updatedAt = updatedAt;
-  if (result.turnState) {
-    next.turnState = structuredClone(result.turnState);
-  }
-  next.phase = snapshot.toolResults.length >= snapshot.toolCalls.length ? "step-commit" : "tool-batch";
-  return next;
-}
-function applyAgentWorkflowCommitResult(state, result, updatedAt) {
-  const next = cloneAgentWorkflowTurnState(state);
-  next.messages = [
-    ...next.messages,
-    ...result.messages.map((message) => structuredClone(message))
-  ];
-  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";
-      delete next.lastModelStep;
-      return next;
-    case "output-commit":
-      next.phase = "completed";
-      next.finalResponse = state.lastModelStep?.text ?? state.finalResponse;
-      delete next.lastModelStep;
-      return next;
-    default:
-      throw new Error(
-        `Cannot apply a commit result while workflow state is in '${state.phase}' phase`
-      );
-  }
-}
-function recordAgentWorkflowReplayDecision(state, decision, updatedAt) {
-  const next = cloneAgentWorkflowTurnState(state);
-  next.replayDecisions[decision.toolCallId] = { ...decision };
-  next.updatedAt = updatedAt;
-  return next;
-}
-function failAgentWorkflowTurnState(state, error, updatedAt) {
-  const next = cloneAgentWorkflowTurnState(state);
-  next.phase = "failed";
-  next.error = error.message;
-  next.updatedAt = updatedAt;
-  return next;
-}
-
-export {
-  createAgentTurnStepCommitBatch,
-  createAgentTurnState,
-  advanceAgentTurnState,
-  failAgentTurnState,
-  AgentTurnEngine,
-  createAgentTurnEngine,
-  estimateTokens,
-  estimateMessageTokens,
-  estimateConversationTokens,
-  PRUNE_PROTECTED_TOOLS,
-  DEFAULT_CONTEXT_LIMITS,
-  getUsableTokenLimit,
-  findCutPoint,
-  ContextManager,
-  prepareModelStep,
-  DoomLoopError,
-  ContextOverflowError,
-  processStepStream,
-  runModelStep,
-  accumulateUsage,
-  runToolBatch,
-  commitStep,
-  commitOutput,
-  defaultAgentTaskCheckpointStrategy,
-  createAgentTaskRunner,
-  createAgentWorkflowTurnState,
-  cloneAgentWorkflowTurnState,
-  applyWorkflowInterventions,
-  drainWorkflowInterventions,
-  queueWorkflowFollowUps,
-  snapshotAgentWorkflowMessage,
-  snapshotAgentWorkflowMessages,
-  restoreAgentWorkflowMessage,
-  restoreAgentWorkflowMessages,
-  planNextAgentWorkflowOperation,
-  applyAgentWorkflowModelStepResult,
-  applyAgentWorkflowToolBatchResult,
-  applyAgentWorkflowToolCallResult,
-  applyAgentWorkflowCommitResult,
-  recordAgentWorkflowReplayDecision,
-  failAgentWorkflowTurnState
-};