@cuylabs/agent-core 0.6.0 → 0.7.0

package/dist/{chunk-3C4VKG4P.js → chunk-3HNO5SVI.js}

@@ -1,12 +1,18 @@
-import {
-  executeAgentToolCall
-} from "./chunk-FG4MD5MU.js";
 import {
   DEFAULT_CONTEXT_LIMITS
-} from "./chunk-QAQADS4X.js";
+} from "./chunk-BNSHUWCV.js";
+import {
+  Inference
+} from "./chunk-5K7AQVOU.js";
+import {
+  executeAgentToolCall
+} from "./chunk-IEFIQENH.js";
 import {
-  buildReasoningOptionsSync
-} from "./chunk-X635CM2F.js";
+  currentScope,
+  snapshotScope,
+  streamWithinScope,
+  withinScope
+} from "./chunk-N7P4PN3O.js";
 
 // src/runtime/task/observer.ts
 function defaultAgentTaskCheckpointStrategy(input) {
@@ -242,101 +248,116 @@ function createAgentTaskRunner(agent, options = {}) {
     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 });
+    return withinScope(
+      {
+        kind: "task",
+        name: "agent-task",
+        sessionId,
+        taskId: context.fallbackSessionKey ?? sessionId,
+        attributes: {
+          ...context.trigger ? { trigger: context.trigger } : {}
+        }
+      },
+      async () => {
+        const run = {
+          payload,
+          context,
+          sessionId,
+          startedAt,
+          scope: snapshotScope()
+        };
+        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,
+          scope: currentScope() ?? run.scope
+        });
+        const emitCheckpoint = async (reason, event) => {
+          if (baseObservers.length === 0) {
+            return;
           }
-          const snapshot = createSnapshot();
-          await notifyObservers(baseObservers, async (observer) => {
-            await observer.onTaskEvent?.(run, event, snapshot);
-          });
-          const checkpointReason = checkpointStrategy({
+          const checkpoint = {
             run,
+            reason,
+            snapshot: createSnapshot(),
             event,
-            snapshot
+            createdAt: turnState.updatedAt
+          };
+          await notifyObservers(baseObservers, async (observer) => {
+            await observer.onCheckpoint?.(checkpoint);
           });
-          if (checkpointReason) {
-            await emitCheckpoint(checkpointReason, event);
-          }
-          if (event.type === "error") {
-            throw event.error;
+        };
+        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;
         }
-      };
-      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;
-    }
+    );
   };
 }
 
@@ -602,7 +623,7 @@ function prepareModelStep(options) {
     step: options.step,
     messages: options.messages,
     modelMessages,
-    llmInput: {
+    inferenceInput: {
       sessionID: options.sessionId,
       step: options.step,
       model: options.config.model,
@@ -625,7 +646,7 @@ function prepareModelStep(options) {
       toolExecutionMode: options.toolExecutionMode,
       telemetry: options.config.telemetry
     },
-    processor: {
+    stepProcessing: {
       maxSteps: options.config.maxSteps,
       doomLoopThreshold: options.config.doomLoopThreshold,
       enforceDoomLoop: options.config.enforceDoomLoop,
@@ -635,578 +656,7 @@ function prepareModelStep(options) {
   };
 }
 
-// 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
-function buildModelCallContext(input) {
-  return {
-    sessionID: input.sessionID,
-    step: input.step ?? 1,
-    cwd: input.cwd,
-    abort: input.abort,
-    model: input.model,
-    toolNames: Object.keys(input.tools),
-    mcpToolNames: Object.keys(input.mcpTools ?? {})
-  };
-}
-function buildModelCallInput(input) {
-  return {
-    model: input.model,
-    system: [...input.system],
-    messages: [...input.messages],
-    temperature: input.temperature,
-    topP: input.topP,
-    maxOutputTokens: input.maxOutputTokens,
-    maxSteps: input.maxSteps,
-    reasoningLevel: input.reasoningLevel,
-    telemetry: input.telemetry,
-    customStreamProvider: input.customStreamProvider,
-    toolExecutionMode: input.toolExecutionMode
-  };
-}
-function applyModelCallInput(target, modelCall) {
-  target.model = modelCall.model;
-  target.system = [...modelCall.system];
-  target.messages = [...modelCall.messages];
-  target.temperature = modelCall.temperature;
-  target.topP = modelCall.topP;
-  target.maxOutputTokens = modelCall.maxOutputTokens;
-  target.maxSteps = modelCall.maxSteps;
-  target.reasoningLevel = modelCall.reasoningLevel;
-  target.telemetry = modelCall.telemetry;
-  target.customStreamProvider = modelCall.customStreamProvider;
-  target.toolExecutionMode = modelCall.toolExecutionMode;
-  target.activeModelCall = modelCall;
-}
-function isBlockedModelCall(value) {
-  return "block" in value && value.block === true;
-}
-async function resolveModelCallInput(input) {
-  if (!input.middleware?.hasMiddleware) {
-    const current = buildModelCallInput(input);
-    input.activeModelCall = current;
-    return current;
-  }
-  const next = await input.middleware.runModelInput(
-    buildModelCallInput(input),
-    buildModelCallContext(input)
-  );
-  if (isBlockedModelCall(next)) {
-    return next;
-  }
-  applyModelCallInput(input, next);
-  return next;
-}
-function wrapModelStream(stream2, input) {
-  const normalizedText = Promise.resolve(stream2.text);
-  const normalizedUsage = Promise.resolve(stream2.usage).then((usage) => ({
-    inputTokens: usage.inputTokens ?? 0,
-    outputTokens: usage.outputTokens ?? 0,
-    totalTokens: usage.totalTokens ?? 0
-  }));
-  const normalizedFinishReason = Promise.resolve(stream2.finishReason).then(
-    (reason) => String(reason)
-  );
-  if (!input.middleware?.hasMiddleware) {
-    return {
-      fullStream: stream2.fullStream,
-      text: normalizedText,
-      usage: normalizedUsage,
-      finishReason: normalizedFinishReason
-    };
-  }
-  return {
-    fullStream: (async function* () {
-      const ctx = buildModelCallContext(input);
-      for await (const rawChunk of stream2.fullStream) {
-        const chunk = await input.middleware.runModelChunk(
-          rawChunk,
-          ctx
-        );
-        if (chunk) {
-          yield chunk;
-        }
-      }
-    })(),
-    text: normalizedText,
-    usage: normalizedUsage,
-    finishReason: normalizedFinishReason
-  };
-}
-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 resolvedInput = await resolveModelCallInput(input);
-  const modelInfo = getModelInfo(input);
-  if (isBlockedModelCall(resolvedInput)) {
-    throw new LLMError({
-      message: resolvedInput.reason,
-      category: "invalid_request",
-      provider: modelInfo.provider,
-      model: modelInfo.model
-    });
-  }
-  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 wrapModelStream(await runCustomStream(), input);
-    }
-    return wrapModelStream(await withRetry(
-      async () => await runCustomStream(),
-      input.retry,
-      input.abort
-    ), input);
-  }
-  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 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 wrapModelStream(await createStream(), input);
-  }
-  return wrapModelStream(await withRetry(
-    async () => await createStream(),
-    input.retry,
-    input.abort
-  ), input);
-}
-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
+// src/runtime/step-processing/doom-loop.ts
 var DEFAULT_DOOM_LOOP_THRESHOLD = 3;
 var DoomLoopError = class extends Error {
   toolName;
@@ -1280,10 +730,10 @@ async function recordToolCallAndCheckDoomLoop(options) {
   if (processorOptions.enforceDoomLoop ?? true) {
     throw doomError;
   }
-  options.warn?.(`[Processor] ${doomError.message}`);
+  options.warn?.(`[StepProcessing] ${doomError.message}`);
 }
 
-// src/execution/processor/overflow.ts
+// src/runtime/step-processing/overflow.ts
 var ContextOverflowError = class extends Error {
   inputTokens;
   limit;
@@ -1310,8 +760,8 @@ async function handleContextOverflow(options) {
   }
 }
 
-// src/execution/processor/process.ts
-async function processStream(stream2, options) {
+// src/runtime/step-processing/process.ts
+async function processStepStream(stream, options) {
   const { abort, onEvent } = options;
   const doomLoopThreshold = options.doomLoopThreshold ?? DEFAULT_DOOM_LOOP_THRESHOLD;
   const maxSteps = options.maxSteps ?? 50;
@@ -1327,10 +777,10 @@ async function processStream(stream2, options) {
   await onEvent({ type: "step-start", step: stepCount, maxSteps });
   await onEvent({ type: "status", status: "processing" });
   try {
-    for await (const rawChunk of stream2.fullStream) {
+    for await (const rawChunk of stream.fullStream) {
       const chunk = rawChunk;
       if (process.env.DEBUG_PROCESSOR) {
-        process.stderr.write(`[processor] Chunk received: ${chunk.type}
+        process.stderr.write(`[step-processing] Chunk received: ${chunk.type}
 `);
       }
       abort.throwIfAborted();
@@ -1484,10 +934,11 @@ async function processStream(stream2, options) {
     error
   };
 }
+var processStream = processStepStream;
 
 // src/runtime/turn-runner/stream-step.ts
-function buildModelCallContext2(options) {
-  const input = options.preparedStep.llmInput;
+function buildModelCallContext(options) {
+  const input = options.preparedStep.inferenceInput;
   return {
     sessionID: input.sessionID,
     step: input.step ?? options.preparedStep.step,
@@ -1495,110 +946,121 @@ function buildModelCallContext2(options) {
     abort: input.abort,
     model: input.model,
     toolNames: Object.keys(input.tools),
-    mcpToolNames: Object.keys(input.mcpTools ?? {})
+    mcpToolNames: Object.keys(input.mcpTools ?? {}),
+    scope: snapshotScope()
   };
 }
 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
+  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 stream = await Inference.streamStep(preparedStep.inferenceInput);
+      const eventQueue = [];
+      let resolveNext = null;
+      let streamDone = false;
+      let streamError;
+      const intervention = preparedStep.inferenceInput.intervention;
+      const middleware = preparedStep.inferenceInput.middleware;
+      if (intervention) {
+        intervention.onApplied = (item) => {
+          eventQueue.push({
+            type: "intervention-applied",
+            id: item.id,
+            message: item.message
+          });
+          if (resolveNext) {
+            resolveNext();
+            resolveNext = null;
+          }
+        };
+      }
+      const processPromise = processStepStream(stream, {
+        sessionID: preparedStep.inferenceInput.sessionID,
+        abort: preparedStep.inferenceInput.abort,
+        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: 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;
       });
-      if (resolveNext) {
-        resolveNext();
-        resolveNext = 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;
+          });
+        }
       }
-    };
-  }
-  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;
+      if (streamError) {
+        throw streamError;
       }
-    }
-  }).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
-          })
+      const result = await processPromise;
+      if (!result) {
+        throw new Error(
+          `Agent step ${preparedStep.step} produced no step-processing result`
         );
       }
-    }
-    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`
-    );
-  }
-  if (middleware?.hasMiddleware) {
-    const revised = await middleware.runModelOutput(
-      {
-        text: result.text,
-        usage: result.usage,
-        finishReason: result.finishReason
-      },
-      buildModelCallContext2(options)
-    );
-    result.text = revised.text;
-    result.usage = revised.usage;
-    result.finishReason = revised.finishReason;
-  }
-  return result;
+      if (middleware?.hasMiddleware) {
+        const revised = await middleware.runModelOutput(
+          {
+            text: result.text,
+            usage: result.usage,
+            finishReason: result.finishReason
+          },
+          buildModelCallContext(options)
+        );
+        result.text = revised.text;
+        result.usage = revised.usage;
+        result.finishReason = revised.finishReason;
+      }
+      return result;
+    })()
+  );
 }
 
 // src/runtime/turn-runner/tool-batch.ts
@@ -1635,9 +1097,9 @@ async function runToolBatch(options) {
     if (toolResultsByCallId.has(toolCall.toolCallId)) {
       continue;
     }
-    const tool2 = options.tools[toolCall.toolName];
+    const tool = options.tools[toolCall.toolName];
     const updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-    if (!tool2) {
+    if (!tool) {
       const errorMessage = `Tool '${toolCall.toolName}' is not registered`;
       const event = createToolBatchErrorResult({
         toolCallId: toolCall.toolCallId,
@@ -1662,7 +1124,7 @@ async function runToolBatch(options) {
     try {
       const executed = await executeAgentToolCall({
         toolName: toolCall.toolName,
-        tool: tool2,
+        tool,
         params: toolCall.args,
         cwd: options.cwd,
         abort: options.abort,
@@ -1725,26 +1187,43 @@ async function runToolBatch(options) {
 
 // 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;
+  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) {
-  const batch = options.turnEngine.createOutputCommit({
-    text: options.text,
-    usage: options.usage
-  });
-  if (!batch) {
-    return false;
-  }
-  yield* options.applyCommitBatch(batch, { emitMessages: true });
-  return true;
+  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/runtime/workflow-state.ts
@@ -2110,22 +1589,9 @@ export {
   AgentTurnEngine,
   createAgentTurnEngine,
   prepareModelStep,
-  isRetryableCategory,
-  LLMError,
-  isRetryable,
-  getRetryDelay,
-  getErrorCategory,
-  DEFAULT_RETRY_CONFIG,
-  createRetryState,
-  calculateDelay,
-  sleep,
-  withRetry,
-  createRetryHandler,
-  shouldRetry,
-  OUTPUT_TOKEN_MAX,
-  LLM,
   DoomLoopError,
   ContextOverflowError,
+  processStepStream,
   processStream,
   runModelStep,
   runToolBatch,