@cuylabs/agent-core 0.3.0 → 0.5.0

package/dist/chunk-IMGQOTU2.js

@@ -0,0 +1,2019 @@
+import {
+  executeAgentToolCall
+} from "./chunk-FG4MD5MU.js";
+import {
+  DEFAULT_CONTEXT_LIMITS
+} from "./chunk-QAQADS4X.js";
+import {
+  buildReasoningOptionsSync
+} from "./chunk-X635CM2F.js";
+
+// src/runtime/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/runtime/task-runner.ts
+import { randomUUID } from "crypto";
+
+// src/runtime/turn-state.ts
+var EMPTY_USAGE = {
+  inputTokens: 0,
+  outputTokens: 0,
+  totalTokens: 0
+};
+function cloneUsage(usage) {
+  return { ...usage };
+}
+function normalizeUsage(usage) {
+  if (!usage) {
+    return cloneUsage(EMPTY_USAGE);
+  }
+  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) {
+  return {
+    sessionId: options.sessionId,
+    phase: "initializing",
+    step: 0,
+    response: "",
+    usage: cloneUsage(EMPTY_USAGE),
+    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
+    })),
+    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,
+          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
+    })),
+    phase: "failed",
+    error: error.message,
+    updatedAt
+  };
+}
+
+// src/runtime/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) {
+  for (const observer of observers) {
+    try {
+      await invoke(observer);
+    } catch (error) {
+      console.warn(
+        "[agent-task-runner] observer error:",
+        error instanceof Error ? error.message : String(error)
+      );
+    }
+  }
+}
+function createAgentTaskRunner(agent, options = {}) {
+  const prefix = options.sessionPrefix ?? "runtime";
+  const baseObservers = options.observers ?? [];
+  const checkpointStrategy = options.checkpointStrategy ?? defaultAgentTaskCheckpointStrategy;
+  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 run = {
+      payload,
+      context,
+      sessionId,
+      startedAt
+    };
+    const toolCalls = [];
+    let turnState = createAgentTurnState({
+      sessionId,
+      startedAt
+    });
+    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
+    });
+    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);
+      });
+    };
+    await notifyObservers(baseObservers, async (observer) => {
+      await observer.onTaskStart?.(run, createSnapshot());
+    });
+    await emitCheckpoint("task-start");
+    const activateCtx = baseObservers.find((o) => o.activateContext)?.activateContext?.bind(void 0, sessionId);
+    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);
+          });
+          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());
+      });
+      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());
+      });
+      await emitCheckpoint("task-error");
+      throw normalizedError;
+    }
+  };
+}
+
+// src/runtime/model-messages.ts
+function convertAgentMessagesToModelMessages(messages) {
+  return messages.flatMap((message) => {
+    switch (message.role) {
+      case "user":
+        return [{ role: "user", content: message.content }];
+      case "assistant": {
+        if (message.toolCalls && message.toolCalls.length > 0) {
+          const toolCallParts = message.toolCalls.map(
+            (toolCall) => ({
+              type: "tool-call",
+              toolCallId: toolCall.toolCallId,
+              toolName: toolCall.toolName,
+              input: toolCall.args
+            })
+          );
+          return [{ role: "assistant", content: toolCallParts }];
+        }
+        return [{ role: "assistant", content: message.content }];
+      }
+      case "tool":
+        return [
+          {
+            role: "tool",
+            content: [
+              {
+                type: "tool-result",
+                toolCallId: message.toolCallId ?? "",
+                toolName: message.toolName ?? "",
+                output: {
+                  type: "text",
+                  value: typeof message.result === "string" ? message.result : JSON.stringify(message.result)
+                }
+              }
+            ]
+          }
+        ];
+      case "system":
+        return [{ role: "system", content: message.content }];
+    }
+  });
+}
+
+// src/runtime/turn-engine/commit-batch.ts
+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 }) => ({
+      id: options.toolMessageIds?.[toolCallId] ?? randomUUID2(),
+      role: "tool",
+      content: typeof result === "string" ? result : JSON.stringify(result),
+      toolCallId,
+      toolName,
+      result,
+      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/runtime/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,
+          ...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,
+          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/runtime/turn-runner/prepare.ts
+function prepareModelStep(options) {
+  const modelMessages = Array.from(options.toModelMessages(options.messages));
+  return {
+    step: options.step,
+    messages: options.messages,
+    modelMessages,
+    llmInput: {
+      sessionID: options.sessionId,
+      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,
+      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
+    },
+    processor: {
+      maxSteps: options.config.maxSteps,
+      doomLoopThreshold: options.config.doomLoopThreshold,
+      enforceDoomLoop: options.config.enforceDoomLoop,
+      onDoomLoop: options.config.onDoomLoop,
+      contextTokenLimit: options.config.contextWindow ? options.config.contextWindow - DEFAULT_CONTEXT_LIMITS.reserveTokens : void 0
+    }
+  };
+}
+
+// src/execution/llm/toolset.ts
+import { tool, zodSchema } from "ai";
+async function buildToolSet(options) {
+  const toolSet = {};
+  const executionMode = options.executionMode ?? "auto";
+  for (const [id, info] of Object.entries(options.tools)) {
+    const initialized = await info.init({ cwd: options.cwd });
+    toolSet[id] = executionMode === "auto" ? tool({
+      description: initialized.description,
+      inputSchema: zodSchema(initialized.parameters),
+      execute: async (params) => (await executeAgentToolCall({
+        toolName: id,
+        tool: info,
+        params,
+        cwd: options.cwd,
+        abort: options.abort,
+        sessionID: options.sessionID,
+        messageID: options.messageID,
+        ...options.host ? { host: options.host } : {},
+        ...options.turnTracker ? { turnTracker: options.turnTracker } : {},
+        ...options.middleware ? { middleware: options.middleware } : {}
+      })).output
+    }) : tool({
+      description: initialized.description,
+      inputSchema: zodSchema(initialized.parameters)
+    });
+  }
+  return toolSet;
+}
+
+// src/execution/llm/stream.ts
+import {
+  stepCountIs,
+  streamText
+} from "ai";
+
+// src/errors/classify.ts
+function isRetryableCategory(category) {
+  switch (category) {
+    case "rate_limit":
+    case "overloaded":
+    case "network":
+    case "timeout":
+      return true;
+    case "auth":
+    case "invalid_request":
+    case "context_overflow":
+    case "content_filter":
+    case "cancelled":
+    case "unknown":
+      return false;
+  }
+}
+function classifyFromStatusAndMessage(status, message) {
+  const lowerMessage = message.toLowerCase();
+  if (status) {
+    if (status === 429) return "rate_limit";
+    if (status === 401 || status === 403) return "auth";
+    if (status === 400) {
+      if (lowerMessage.includes("context") || lowerMessage.includes("token")) {
+        return "context_overflow";
+      }
+      return "invalid_request";
+    }
+    if (status === 503 || status === 502) return "overloaded";
+    if (status >= 500) return "network";
+  }
+  if (lowerMessage.includes("rate") && lowerMessage.includes("limit")) {
+    return "rate_limit";
+  }
+  if (lowerMessage.includes("overload") || lowerMessage.includes("capacity")) {
+    return "overloaded";
+  }
+  if (lowerMessage.includes("too_many_requests")) {
+    return "rate_limit";
+  }
+  if (lowerMessage.includes("unauthorized") || lowerMessage.includes("invalid api key")) {
+    return "auth";
+  }
+  if (lowerMessage.includes("context") && lowerMessage.includes("length")) {
+    return "context_overflow";
+  }
+  if (lowerMessage.includes("content") && lowerMessage.includes("filter")) {
+    return "content_filter";
+  }
+  if (lowerMessage.includes("timeout") || lowerMessage.includes("timed out")) {
+    return "timeout";
+  }
+  if (lowerMessage.includes("network") || lowerMessage.includes("econnrefused") || lowerMessage.includes("econnreset")) {
+    return "network";
+  }
+  return "unknown";
+}
+function parseRetryDelay(headers) {
+  const retryAfterMs = headers["retry-after-ms"];
+  if (retryAfterMs) {
+    const parsed = parseFloat(retryAfterMs);
+    if (!Number.isNaN(parsed) && parsed > 0) {
+      return parsed;
+    }
+  }
+  const retryAfter = headers["retry-after"];
+  if (retryAfter) {
+    const seconds = parseFloat(retryAfter);
+    if (!Number.isNaN(seconds) && seconds > 0) {
+      return Math.ceil(seconds * 1e3);
+    }
+    const dateMs = Date.parse(retryAfter);
+    if (!Number.isNaN(dateMs)) {
+      const delayMs = dateMs - Date.now();
+      if (delayMs > 0) {
+        return Math.ceil(delayMs);
+      }
+    }
+  }
+  return void 0;
+}
+
+// src/errors/extract.ts
+function extractFromAISDKError(error) {
+  const result = {};
+  const anyError = error;
+  if (typeof anyError.status === "number") {
+    result.status = anyError.status;
+  } else if (typeof anyError.statusCode === "number") {
+    result.status = anyError.statusCode;
+  }
+  if (anyError.responseHeaders && typeof anyError.responseHeaders === "object") {
+    result.headers = anyError.responseHeaders;
+  } else if (anyError.headers && typeof anyError.headers === "object") {
+    result.headers = anyError.headers;
+  }
+  if (anyError.data && typeof anyError.data === "object") {
+    const data = anyError.data;
+    if (data.type === "error" && typeof data.error === "object") {
+      const innerError = data.error;
+      if (innerError.type === "too_many_requests") {
+        result.category = "rate_limit";
+      } else if (innerError.type === "overloaded") {
+        result.category = "overloaded";
+      }
+    }
+    if (typeof data.isRetryable === "boolean" && !data.isRetryable && !result.category) {
+      result.category = "invalid_request";
+    }
+  }
+  return result;
+}
+
+// src/errors/llm-error.ts
+var LLMError = class _LLMError extends Error {
+  category;
+  status;
+  headers;
+  provider;
+  model;
+  isRetryable;
+  retryDelayMs;
+  constructor(options) {
+    super(options.message, { cause: options.cause });
+    this.name = "LLMError";
+    this.status = options.status;
+    this.headers = options.headers;
+    this.provider = options.provider;
+    this.model = options.model;
+    this.category = options.category ?? classifyFromStatusAndMessage(
+      options.status,
+      options.message
+    );
+    this.isRetryable = isRetryableCategory(this.category);
+    this.retryDelayMs = this.headers ? parseRetryDelay(this.headers) : void 0;
+  }
+  static from(error, context) {
+    if (error instanceof _LLMError) {
+      return error;
+    }
+    if (error instanceof Error) {
+      if (error.name === "AbortError" || error.message.includes("abort")) {
+        return new _LLMError({
+          message: error.message,
+          category: "cancelled",
+          cause: error,
+          ...context
+        });
+      }
+      return new _LLMError({
+        message: error.message,
+        cause: error,
+        ...extractFromAISDKError(error),
+        ...context
+      });
+    }
+    return new _LLMError({
+      message: String(error),
+      category: "unknown",
+      ...context
+    });
+  }
+  get description() {
+    const parts = [this.message];
+    if (this.provider) parts.unshift(`[${this.provider}]`);
+    if (this.status) parts.push(`(HTTP ${this.status})`);
+    if (this.isRetryable && this.retryDelayMs) {
+      parts.push(`retry in ${Math.ceil(this.retryDelayMs / 1e3)}s`);
+    }
+    return parts.join(" ");
+  }
+};
+
+// src/errors/utils.ts
+function isRetryable(error) {
+  if (error instanceof LLMError) {
+    return error.isRetryable;
+  }
+  return LLMError.from(error).isRetryable;
+}
+function getRetryDelay(error) {
+  if (error instanceof LLMError) {
+    return error.isRetryable ? error.retryDelayMs : void 0;
+  }
+  const llmError = LLMError.from(error);
+  return llmError.isRetryable ? llmError.retryDelayMs : void 0;
+}
+function getErrorCategory(error) {
+  if (error instanceof LLMError) {
+    return error.category;
+  }
+  return LLMError.from(error).category;
+}
+
+// src/retry.ts
+var DEFAULT_RETRY_CONFIG = {
+  maxAttempts: 3,
+  initialDelayMs: 2e3,
+  backoffFactor: 2,
+  maxDelayMs: 3e4,
+  jitter: true
+};
+function createRetryState() {
+  return {
+    attempt: 0,
+    errors: [],
+    canRetry: true,
+    nextDelayMs: void 0
+  };
+}
+function calculateDelay(attempt, error, config) {
+  if (error?.retryDelayMs) {
+    return error.retryDelayMs;
+  }
+  const baseDelay = config.initialDelayMs * Math.pow(config.backoffFactor, attempt - 1);
+  const cappedDelay = Math.min(baseDelay, config.maxDelayMs);
+  if (config.jitter) {
+    const jitterRange = cappedDelay * 0.25;
+    const jitter = (Math.random() - 0.5) * 2 * jitterRange;
+    return Math.max(0, Math.round(cappedDelay + jitter));
+  }
+  return Math.round(cappedDelay);
+}
+async function sleep(ms, signal) {
+  return new Promise((resolve, reject) => {
+    if (signal?.aborted) {
+      reject(new DOMException("Aborted", "AbortError"));
+      return;
+    }
+    const timeoutId = setTimeout(() => {
+      cleanup();
+      resolve();
+    }, ms);
+    const abortHandler = () => {
+      clearTimeout(timeoutId);
+      cleanup();
+      reject(new DOMException("Aborted", "AbortError"));
+    };
+    const cleanup = () => {
+      signal?.removeEventListener("abort", abortHandler);
+    };
+    signal?.addEventListener("abort", abortHandler, { once: true });
+  });
+}
+async function withRetry(fn, config, signal) {
+  const mergedConfig = { ...DEFAULT_RETRY_CONFIG, ...config };
+  const state = createRetryState();
+  while (true) {
+    state.attempt++;
+    try {
+      return await fn(state.attempt);
+    } catch (error) {
+      const llmError = LLMError.from(error);
+      state.errors.push(llmError);
+      const shouldRetry2 = state.attempt < mergedConfig.maxAttempts && isRetryable(llmError) && !signal?.aborted;
+      if (!shouldRetry2) {
+        throw new LLMError({
+          message: `Failed after ${state.attempt} attempt(s): ${llmError.message}`,
+          category: llmError.category,
+          status: llmError.status,
+          headers: llmError.headers,
+          provider: llmError.provider,
+          model: llmError.model,
+          cause: llmError
+        });
+      }
+      const delayMs = calculateDelay(state.attempt, llmError, mergedConfig);
+      state.nextDelayMs = delayMs;
+      config?.onRetry?.(state.attempt, delayMs, llmError);
+      await sleep(delayMs, signal);
+    }
+  }
+}
+function createRetryHandler(options) {
+  const config = options ?? {};
+  const signal = options?.signal;
+  return async (createStream) => {
+    return withRetry(createStream, config, signal);
+  };
+}
+function shouldRetry(error, attempt, maxAttempts = DEFAULT_RETRY_CONFIG.maxAttempts) {
+  if (attempt >= maxAttempts) return false;
+  return isRetryable(error);
+}
+
+// src/execution/llm/types.ts
+var OUTPUT_TOKEN_MAX = 32e3;
+
+// src/execution/llm/stream.ts
+async function createCustomStream(input) {
+  const system = input.system.filter(Boolean).join("\n");
+  return input.customStreamProvider({
+    system,
+    messages: input.messages,
+    abortSignal: input.abort,
+    maxSteps: input.maxSteps
+  });
+}
+function getModelInfo(input) {
+  return {
+    provider: typeof input.model === "object" && "provider" in input.model ? String(input.model.provider) : void 0,
+    model: typeof input.model === "object" && "modelId" in input.model ? String(input.model.modelId) : String(input.model)
+  };
+}
+async function callStreamTextWithOtelContext(options) {
+  const { input, allTools, system, providerOptions } = options;
+  const callStreamText = () => streamText({
+    model: input.model,
+    system,
+    messages: input.messages,
+    tools: allTools,
+    stopWhen: stepCountIs(input.maxSteps ?? 50),
+    maxOutputTokens: input.maxOutputTokens ?? OUTPUT_TOKEN_MAX,
+    temperature: input.temperature,
+    topP: input.topP,
+    abortSignal: input.abort,
+    providerOptions,
+    experimental_telemetry: input.telemetry,
+    prepareStep: input.intervention ? async ({ messages }) => {
+      const pending = input.intervention.drainImmediate();
+      if (pending.length === 0) {
+        return void 0;
+      }
+      const injected = pending.map((item) => ({
+        role: "user",
+        content: item.message
+      }));
+      for (const item of pending) {
+        input.intervention.onApplied?.(item);
+      }
+      return { messages: [...messages, ...injected] };
+    } : void 0,
+    onStepFinish: async (step) => {
+      if (!input.onStepFinish) {
+        return;
+      }
+      await input.onStepFinish({
+        toolResults: step.toolResults?.map((toolResult) => ({
+          toolName: toolResult.toolName,
+          toolCallId: toolResult.toolCallId,
+          output: toolResult.output
+        })),
+        usage: step.usage,
+        finishReason: step.finishReason
+      });
+    }
+  });
+  const otelCtx = input.middleware?.getOtelContext(input.sessionID);
+  if (!otelCtx) {
+    return callStreamText();
+  }
+  try {
+    const otelApi = await import("@opentelemetry/api");
+    return otelApi.context.with(
+      otelCtx,
+      callStreamText
+    );
+  } catch {
+    return callStreamText();
+  }
+}
+async function stream(input) {
+  const messageID = crypto.randomUUID();
+  const system = input.system.filter(Boolean).join("\n");
+  if (input.customStreamProvider) {
+    const runCustomStream = async () => await createCustomStream(input);
+    if (!input.retry || input.retry.maxAttempts === 0) {
+      return await runCustomStream();
+    }
+    return await withRetry(
+      async () => await runCustomStream(),
+      input.retry,
+      input.abort
+    );
+  }
+  const toolSet = await buildToolSet({
+    tools: input.tools,
+    cwd: input.cwd,
+    sessionID: input.sessionID,
+    messageID,
+    abort: input.abort,
+    turnTracker: input.turnTracker,
+    host: input.host,
+    middleware: input.middleware,
+    executionMode: input.toolExecutionMode
+  });
+  const allTools = {
+    ...toolSet,
+    ...input.mcpTools ?? {}
+  };
+  const providerOptions = input.reasoningLevel ? buildReasoningOptionsSync(input.model, input.reasoningLevel) : void 0;
+  const modelInfo = getModelInfo(input);
+  const createStream = async () => {
+    try {
+      return await callStreamTextWithOtelContext({
+        input,
+        allTools,
+        system,
+        providerOptions
+      });
+    } catch (error) {
+      throw LLMError.from(error, modelInfo);
+    }
+  };
+  if (!input.retry || input.retry.maxAttempts === 0) {
+    return await createStream();
+  }
+  return await withRetry(
+    async () => await createStream(),
+    input.retry,
+    input.abort
+  );
+}
+async function streamOnce(input) {
+  return await stream({ ...input, retry: void 0 });
+}
+async function streamStep(input) {
+  return await stream({
+    ...input,
+    maxSteps: 1
+  });
+}
+
+// src/execution/llm/index.ts
+var LLM = {
+  buildToolSet,
+  stream,
+  streamOnce,
+  streamStep
+};
+
+// src/execution/processor/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?.(`[Processor] ${doomError.message}`);
+}
+
+// src/execution/processor/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/processor/process.ts
+async function processStream(stream2, options) {
+  const { abort, onEvent } = options;
+  const doomLoopThreshold = options.doomLoopThreshold ?? DEFAULT_DOOM_LOOP_THRESHOLD;
+  const maxSteps = options.maxSteps ?? 50;
+  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 stream2.fullStream) {
+      const chunk = rawChunk;
+      if (process.env.DEBUG_PROCESSOR) {
+        process.stderr.write(`[processor] 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":
+          toolResults.push({
+            toolName: chunk.toolName,
+            toolCallId: chunk.toolCallId,
+            result: chunk.output
+          });
+          await onEvent({
+            type: "tool-result",
+            toolName: chunk.toolName,
+            toolCallId: chunk.toolCallId,
+            result: chunk.output
+          });
+          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 = caught instanceof Error ? caught : new Error(String(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/runtime/turn-runner/stream-step.ts
+async function* runModelStep(options) {
+  const { preparedStep, turnEngine, applyCommitBatch } = options;
+  const stream2 = await LLM.streamStep(preparedStep.llmInput);
+  const eventQueue = [];
+  let resolveNext = null;
+  let streamDone = false;
+  let streamError;
+  const intervention = preparedStep.llmInput.intervention;
+  const middleware = preparedStep.llmInput.middleware;
+  if (intervention) {
+    intervention.onApplied = (item) => {
+      eventQueue.push({
+        type: "intervention-applied",
+        id: item.id,
+        message: item.message
+      });
+      if (resolveNext) {
+        resolveNext();
+        resolveNext = null;
+      }
+    };
+  }
+  const processPromise = processStream(stream2, {
+    sessionID: preparedStep.llmInput.sessionID,
+    abort: preparedStep.llmInput.abort,
+    currentStep: preparedStep.step,
+    maxSteps: preparedStep.processor.maxSteps,
+    doomLoopThreshold: preparedStep.processor.doomLoopThreshold ?? 3,
+    enforceDoomLoop: preparedStep.processor.enforceDoomLoop ?? true,
+    onDoomLoop: preparedStep.processor.onDoomLoop,
+    rememberedDoomLoopTools: options.rememberedDoomLoopTools,
+    contextTokenLimit: preparedStep.processor.contextTokenLimit,
+    onContextOverflow: async () => {
+    },
+    onEvent: async (event) => {
+      middleware?.emitEvent(event);
+      eventQueue.push(event);
+      if (resolveNext) {
+        resolveNext();
+        resolveNext = null;
+      }
+    }
+  }).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 processor result`
+    );
+  }
+  return result;
+}
+
+// src/runtime/turn-runner/tool-batch.ts
+import { randomUUID as randomUUID3 } from "crypto";
+function cloneToolResultRecord(options) {
+  return new Map(
+    options.snapshot.toolResults.map((toolResult) => [
+      toolResult.toolCallId,
+      structuredClone(toolResult)
+    ])
+  );
+}
+function createToolBatchErrorResult(options) {
+  return {
+    type: "tool-error",
+    toolName: options.toolName,
+    toolCallId: options.toolCallId,
+    error: options.errorMessage
+  };
+}
+function createToolBatchResultEvent(options) {
+  return {
+    type: "tool-result",
+    toolName: options.toolName,
+    toolCallId: options.toolCallId,
+    result: options.result
+  };
+}
+async function runToolBatch(options) {
+  const toolResultsByCallId = cloneToolResultRecord(options);
+  const events = [];
+  let turnState = options.turnState ? structuredClone(options.turnState) : void 0;
+  for (const toolCall of options.snapshot.toolCalls) {
+    if (toolResultsByCallId.has(toolCall.toolCallId)) {
+      continue;
+    }
+    const tool2 = options.tools[toolCall.toolName];
+    const updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    if (!tool2) {
+      const errorMessage = `Tool '${toolCall.toolName}' is not registered`;
+      const event = createToolBatchErrorResult({
+        toolCallId: toolCall.toolCallId,
+        toolName: toolCall.toolName,
+        errorMessage,
+        replayPolicy: toolCall.replayPolicy
+      });
+      events.push(event);
+      toolResultsByCallId.set(toolCall.toolCallId, {
+        toolCallId: toolCall.toolCallId,
+        toolName: toolCall.toolName,
+        result: `Error: ${errorMessage}`,
+        ...toolCall.replayPolicy ? { replayPolicy: toolCall.replayPolicy } : {}
+      });
+      if (turnState) {
+        turnState = advanceAgentTurnState(turnState, event, updatedAt, {
+          ...toolCall.replayPolicy ? { toolReplayPolicy: toolCall.replayPolicy } : {}
+        });
+      }
+      continue;
+    }
+    try {
+      const executed = await executeAgentToolCall({
+        toolName: toolCall.toolName,
+        tool: tool2,
+        params: toolCall.args,
+        cwd: options.cwd,
+        abort: options.abort,
+        sessionID: options.sessionId,
+        messageID: randomUUID3(),
+        ...options.host ? { host: options.host } : {},
+        ...options.turnTracker ? { turnTracker: options.turnTracker } : {},
+        ...options.middleware ? { middleware: options.middleware } : {}
+      });
+      const event = createToolBatchResultEvent({
+        toolCallId: toolCall.toolCallId,
+        toolName: toolCall.toolName,
+        result: executed.output
+      });
+      events.push(event);
+      toolResultsByCallId.set(toolCall.toolCallId, {
+        toolCallId: toolCall.toolCallId,
+        toolName: toolCall.toolName,
+        result: executed.output,
+        ...toolCall.replayPolicy ? { replayPolicy: toolCall.replayPolicy } : {}
+      });
+      if (turnState) {
+        turnState = advanceAgentTurnState(turnState, event, updatedAt, {
+          ...toolCall.replayPolicy ? { toolReplayPolicy: toolCall.replayPolicy } : {}
+        });
+      }
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      const event = createToolBatchErrorResult({
+        toolCallId: toolCall.toolCallId,
+        toolName: toolCall.toolName,
+        errorMessage,
+        replayPolicy: toolCall.replayPolicy
+      });
+      events.push(event);
+      toolResultsByCallId.set(toolCall.toolCallId, {
+        toolCallId: toolCall.toolCallId,
+        toolName: toolCall.toolName,
+        result: `Error: ${errorMessage}`,
+        ...toolCall.replayPolicy ? { replayPolicy: toolCall.replayPolicy } : {}
+      });
+      if (turnState) {
+        turnState = advanceAgentTurnState(turnState, event, updatedAt, {
+          ...toolCall.replayPolicy ? { toolReplayPolicy: toolCall.replayPolicy } : {}
+        });
+      }
+    }
+  }
+  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 ? { turnState } : {},
+    events
+  };
+}
+
+// src/runtime/turn-runner/commit.ts
+async function* commitStep(options) {
+  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) {
+  const batch = options.turnEngine.createOutputCommit({
+    text: options.text,
+    usage: options.usage
+  });
+  if (!batch) {
+    return false;
+  }
+  yield* options.applyCommitBatch(batch, { emitMessages: true });
+  return true;
+}
+
+// src/runtime/workflow-state.ts
+function cloneUsage2(usage) {
+  return usage ? { ...usage } : void 0;
+}
+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 }
+    } : {}
+  };
+}
+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.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(snapshotAgentWorkflowMessage);
+}
+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.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);
+}
+function createAgentWorkflowTurnState(options) {
+  return {
+    sessionId: options.sessionId,
+    systemPrompts: [...options.systemPrompts ?? []],
+    messages: (options.initialMessages ?? []).map(cloneMessageSnapshot),
+    phase: "model-step",
+    step: options.initialStep ?? 1,
+    maxSteps: options.maxSteps,
+    replayDecisions: {},
+    startedAt: options.startedAt,
+    updatedAt: options.startedAt
+  };
+}
+function cloneAgentWorkflowTurnState(state) {
+  return {
+    ...state,
+    systemPrompts: [...state.systemPrompts],
+    messages: state.messages.map(cloneMessageSnapshot),
+    ...state.usage ? { usage: cloneUsage2(state.usage) } : {},
+    ...state.turnState ? { turnState: structuredClone(state.turnState) } : {},
+    ...state.lastModelStep ? { lastModelStep: structuredClone(state.lastModelStep) } : {},
+    replayDecisions: Object.fromEntries(
+      Object.entries(state.replayDecisions).map(([toolCallId, decision]) => [
+        toolCallId,
+        { ...decision }
+      ])
+    )
+  };
+}
+
+// src/runtime/workflow-planner/helpers.ts
+function accumulateWorkflowUsage(current, next) {
+  if (!next) {
+    return current ? { ...current } : void 0;
+  }
+  if (!current) {
+    return { ...next };
+  }
+  return {
+    inputTokens: (current.inputTokens ?? 0) + (next.inputTokens ?? 0),
+    outputTokens: (current.outputTokens ?? 0) + (next.outputTokens ?? 0),
+    totalTokens: (current.totalTokens ?? 0) + (next.totalTokens ?? 0),
+    cacheReadTokens: (current.cacheReadTokens ?? 0) + (next.cacheReadTokens ?? 0),
+    cacheWriteTokens: (current.cacheWriteTokens ?? 0) + (next.cacheWriteTokens ?? 0)
+  };
+}
+function cloneRelevantReplayDecisions(state, snapshot) {
+  return Object.fromEntries(
+    snapshot.toolCalls.flatMap((toolCall) => {
+      const decision = state.replayDecisions[toolCall.toolCallId];
+      return decision ? [[toolCall.toolCallId, { ...decision }]] : [];
+    })
+  );
+}
+function findNextUnresolvedToolCall(snapshot) {
+  const resolvedIds = new Set(
+    snapshot.toolResults.map((toolResult) => toolResult.toolCallId)
+  );
+  return snapshot.toolCalls.find(
+    (toolCall) => !resolvedIds.has(toolCall.toolCallId)
+  );
+}
+
+// src/runtime/workflow-planner/plan.ts
+function planNextAgentWorkflowOperation(state) {
+  switch (state.phase) {
+    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 nextToolCall = findNextUnresolvedToolCall(
+        state.lastModelStep.stepCommit
+      );
+      if (!nextToolCall) {
+        throw new Error(
+          `Workflow state for session '${state.sessionId}' is in tool-batch phase without unresolved tool calls`
+        );
+      }
+      return {
+        kind: "tool-call",
+        step: state.step,
+        sessionId: state.sessionId,
+        toolCall: structuredClone(nextToolCall),
+        turnState: state.turnState ? structuredClone(state.turnState) : void 0,
+        replayDecision: cloneRelevantReplayDecisions(
+          state,
+          state.lastModelStep.stepCommit
+        )[nextToolCall.toolCallId]
+      };
+    }
+    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/runtime/workflow-planner/apply.ts
+function applyAgentWorkflowModelStepResult(state, result, updatedAt) {
+  const next = cloneAgentWorkflowTurnState(state);
+  next.lastModelStep = structuredClone(result);
+  next.turnState = structuredClone(result.turnState);
+  next.usage = accumulateWorkflowUsage(next.usage, result.usage);
+  next.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 "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 {
+  convertAgentMessagesToModelMessages,
+  createAgentTurnStepCommitBatch,
+  createAgentTurnState,
+  advanceAgentTurnState,
+  failAgentTurnState,
+  AgentTurnEngine,
+  createAgentTurnEngine,
+  prepareModelStep,
+  isRetryableCategory,
+  LLMError,
+  isRetryable,
+  getRetryDelay,
+  getErrorCategory,
+  DEFAULT_RETRY_CONFIG,
+  createRetryState,
+  calculateDelay,
+  sleep,
+  withRetry,
+  createRetryHandler,
+  shouldRetry,
+  OUTPUT_TOKEN_MAX,
+  LLM,
+  DoomLoopError,
+  ContextOverflowError,
+  processStream,
+  runModelStep,
+  runToolBatch,
+  commitStep,
+  commitOutput,
+  defaultAgentTaskCheckpointStrategy,
+  createAgentTaskRunner,
+  snapshotAgentWorkflowMessage,
+  snapshotAgentWorkflowMessages,
+  restoreAgentWorkflowMessage,
+  restoreAgentWorkflowMessages,
+  createAgentWorkflowTurnState,
+  cloneAgentWorkflowTurnState,
+  planNextAgentWorkflowOperation,
+  applyAgentWorkflowModelStepResult,
+  applyAgentWorkflowToolBatchResult,
+  applyAgentWorkflowToolCallResult,
+  applyAgentWorkflowCommitResult,
+  recordAgentWorkflowReplayDecision,
+  failAgentWorkflowTurnState
+};