@cuylabs/agent-core 0.3.0 → 0.5.0

package/dist/types-MM1JoX5T.d.ts

@@ -0,0 +1,810 @@
+import { StreamTextResult, ToolSet, Output, LanguageModel, ModelMessage, TelemetrySettings } from 'ai';
+import { T as Tool } from './tool-pFAnJc5Y.js';
+import { d as ToolHost, e as TurnTrackerContext, N as NormalizedToolReplayPolicy } from './tool-DYp6-cC3.js';
+import { d as ProcessorResult, A as AgentEvent, M as MiddlewareRunner, e as AgentTurnBoundaryKind } from './runner-C7aMP_x3.js';
+import { R as ReasoningLevel } from './types-CQaXbRsS.js';
+import { T as TokenUsage, M as Message } from './messages-BYWGn8TY.js';
+
+/**
+ * Stream types for @cuylabs/agent-core
+ *
+ * Defines the canonical StreamChunk union and related types
+ * for both AI SDK native and custom stream providers.
+ */
+/**
+ * Stream chunk types (AI SDK compatible + custom streams)
+ *
+ * This is the single canonical definition — used by both the
+ * streaming module and custom stream providers.
+ */
+type StreamChunk = {
+    type: "text-start";
+} | {
+    type: "text-delta";
+    text: string;
+} | {
+    type: "text-end";
+} | {
+    type: "reasoning-start";
+    id: string;
+} | {
+    type: "reasoning-delta";
+    id: string;
+    text: string;
+} | {
+    type: "reasoning-end";
+    id: string;
+} | {
+    type: "tool-call";
+    toolName: string;
+    toolCallId: string;
+    input: unknown;
+} | {
+    type: "tool-result";
+    toolName: string;
+    toolCallId: string;
+    output: unknown;
+} | {
+    type: "tool-error";
+    toolName: string;
+    toolCallId: string;
+    error: unknown;
+} | {
+    type: "finish-step";
+    usage?: {
+        inputTokens?: number;
+        outputTokens?: number;
+        totalTokens?: number;
+    };
+    finishReason?: string;
+} | {
+    type: "finish";
+    totalUsage?: {
+        inputTokens?: number;
+        outputTokens?: number;
+        totalTokens?: number;
+    };
+} | {
+    type: "error";
+    error: unknown;
+} | {
+    type: "start-step";
+} | {
+    type: "start";
+} | {
+    type: "abort";
+} | {
+    type: "computer-call";
+    callId: string;
+    action: unknown;
+    pendingSafetyChecks?: unknown[];
+} | {
+    type: "step-usage";
+    usage: {
+        inputTokens: number;
+        outputTokens: number;
+        totalTokens: number;
+    };
+};
+/**
+ * Custom stream provider function type.
+ *
+ * This matches the signature needed for agent-core's LLM module,
+ * returning a StreamProviderResult-compatible object.
+ */
+type StreamProvider = (input: StreamProviderInput) => Promise<StreamProviderResult>;
+/**
+ * Input for custom stream providers
+ */
+interface StreamProviderInput {
+    /** System prompt */
+    system: string;
+    /** Messages to send */
+    messages: Array<{
+        role: string;
+        content: unknown;
+    }>;
+    /** Abort signal */
+    abortSignal?: AbortSignal;
+    /** Max iterations */
+    maxSteps?: number;
+}
+/**
+ * Result from custom stream providers (AI SDK StreamTextResult compatible)
+ */
+interface StreamProviderResult {
+    /** Async iterable of stream chunks */
+    fullStream: AsyncIterable<StreamChunk>;
+    /** Promise resolving to final text */
+    text: Promise<string>;
+    /** Promise resolving to usage stats */
+    usage: Promise<{
+        inputTokens: number;
+        outputTokens: number;
+        totalTokens: number;
+    }>;
+    /** Promise resolving to finish reason */
+    finishReason: Promise<string>;
+}
+/**
+ * Configuration for stream provider factory.
+ * Contains everything needed to create a stream provider for a specific model.
+ */
+interface StreamProviderConfig {
+    /** API key to use */
+    apiKey?: string;
+    /** Display dimensions */
+    display?: {
+        width: number;
+        height: number;
+    };
+    /** Environment type */
+    environment?: string;
+    /** Enable debug logging */
+    debug?: boolean;
+}
+/**
+ * Stream provider factory - creates a stream provider for a given model.
+ *
+ * This is attached to enhanced tools (like computer tools) to allow
+ * the Agent to automatically configure the right stream provider
+ * when a model requires custom handling (e.g., OpenAI computer-use-preview).
+ */
+type StreamProviderFactory = (modelId: string, config: StreamProviderConfig) => StreamProvider;
+/**
+ * Enhanced tools array with additional capabilities.
+ *
+ * This extends the standard Tool.AnyInfo[] with optional metadata
+ * that the Agent can use for automatic configuration.
+ */
+interface EnhancedTools extends Array<unknown> {
+    /**
+     * Factory to create a stream provider for models that need custom streaming.
+     * Called by the Agent when it detects a model that requires special handling.
+     */
+    __streamProviderFactory?: StreamProviderFactory;
+    /**
+     * Model patterns that require the custom stream provider.
+     * Used by the Agent to detect when to use the factory.
+     * Default patterns: ["computer-use-preview"]
+     */
+    __customStreamModels?: string[];
+}
+
+/**
+ * Doom-loop handling contracts for repeated tool invocations.
+ */
+/**
+ * Response from a doom-loop handler.
+ */
+type DoomLoopAction = "allow" | "deny" | "remember";
+/**
+ * Doom-loop detection request.
+ */
+interface DoomLoopRequest {
+    /** The tool being called repeatedly */
+    tool: string;
+    /** How many times it has been called with the same input */
+    repeatCount: number;
+    /** The repeated input */
+    input: unknown;
+    /** Session ID */
+    sessionId: string;
+}
+/**
+ * Handler for doom-loop situations.
+ */
+type DoomLoopHandler = (request: DoomLoopRequest) => Promise<DoomLoopAction>;
+
+/**
+ * Intervention Controller for @cuylabs/agent-core
+ *
+ * Manages mid-turn message injection into running agent turns.
+ * Uses Vercel AI SDK v6's `prepareStep` hook for zero-overhead
+ * integration at step boundaries (between LLM calls in a multi-step turn).
+ *
+ * Instead of polling a queue after each tool execution, this leverages
+ * the SDK's native step lifecycle. The
+ * `prepareStep` callback fires before every LLM call, giving us a
+ * natural injection point with no custom loop machinery.
+ *
+ * Two injection modes:
+ * - **Immediate**: `intervene(msg)` — injected at the next step boundary
+ * - **Deferred**: `queueNext(msg)` — held until the turn completes
+ */
+/** A queued intervention message waiting to be applied */
+interface PendingIntervention {
+    /** Unique identifier for tracking */
+    readonly id: string;
+    /** The user message to inject */
+    readonly message: string;
+    /** When the intervention was created */
+    readonly createdAt: Date;
+}
+/**
+ * Callback fired when an intervention is applied to a step.
+ *
+ * The agent uses this to push `intervention-applied` events into
+ * the streaming event queue so they reach the consumer in the
+ * correct order relative to other events.
+ */
+type OnInterventionApplied = (intervention: PendingIntervention) => void;
+/**
+ * Manages mid-turn message injection for agents.
+ *
+ * This is the core primitive that connects user redirection intent
+ * to the AI SDK's multi-step loop. The flow:
+ *
+ * 1. Consumer calls `agent.intervene("focus on auth.ts")` from any async context
+ * 2. The message is queued as a `PendingIntervention`
+ * 3. At the next step boundary, `prepareStep` drains the queue
+ * 4. The message is appended to the LLM's input messages
+ * 5. The LLM responds to the redirect naturally
+ *
+ * Thread safety: All operations are synchronous and run on the
+ * same event loop. No locks needed — Node.js guarantees ordering.
+ *
+ * @example
+ * ```typescript
+ * const ctrl = new InterventionController();
+ *
+ * // Queue an intervention (from a UI handler, WebSocket, etc.)
+ * const id = ctrl.intervene("stop refactoring, fix the failing test first");
+ *
+ * // Later, in prepareStep:
+ * const pending = ctrl.drainImmediate();
+ * // → [{ id, message: "stop refactoring...", createdAt }]
+ * ```
+ */
+declare class InterventionController {
+    /** Immediate interventions — applied at the next step boundary */
+    private immediate;
+    /** Deferred messages — held until the turn completes */
+    private deferred;
+    /**
+     * Callback fired when an intervention is wired into a step.
+     * Set by the Agent before starting a chat turn, cleared after.
+     */
+    onApplied?: OnInterventionApplied;
+    /**
+     * Inject a message at the next LLM step boundary.
+     *
+     * The message is appended as a user message to the conversation
+     * before the next LLM call in the current multi-step turn. The
+     * LLM will see it and can adjust its behavior accordingly.
+     *
+     * Safe to call from any async context while `chat()` is running.
+     * If called when no turn is active, the message will be picked up
+     * by the first step of the next `chat()` call.
+     *
+     * @param message - The user message to inject
+     * @returns Intervention ID for tracking
+     */
+    intervene(message: string): string;
+    /**
+     * Drain and return all pending immediate interventions.
+     * The internal queue is cleared atomically.
+     *
+     * @internal Called by the LLM stream's `prepareStep` hook
+     */
+    drainImmediate(): PendingIntervention[];
+    /** Whether there are pending immediate interventions */
+    get hasPending(): boolean;
+    /** Number of pending immediate interventions */
+    get pendingCount(): number;
+    /**
+     * Queue a message for after the current turn completes.
+     *
+     * Unlike `intervene()`, this does **not** inject mid-turn. The
+     * message is held and available via `drainDeferred()` after
+     * `chat()` finishes. The consumer decides whether to send it
+     * as a new turn.
+     *
+     * @param message - The message to queue
+     * @returns Intervention ID for tracking
+     */
+    queueNext(message: string): string;
+    /**
+     * Drain and return all deferred messages.
+     * The internal queue is cleared atomically.
+     */
+    drainDeferred(): PendingIntervention[];
+    /** Whether there are deferred messages */
+    get hasDeferred(): boolean;
+    /** Number of deferred messages */
+    get deferredCount(): number;
+    /** Clear all queues (immediate + deferred) */
+    clear(): void;
+    /** Reset the controller for a new turn (clears onApplied, keeps queues) */
+    resetCallbacks(): void;
+}
+
+/**
+ * Options for processing a streamed model result.
+ */
+interface ProcessorOptions {
+    /** Session ID (optional - for tracking purposes) */
+    sessionID?: string;
+    /** Abort signal */
+    abort: AbortSignal;
+    /** Event callback */
+    onEvent: (event: AgentEvent) => void | Promise<void>;
+    /** Doom loop threshold (default: 3) */
+    doomLoopThreshold?: number;
+    /** Enforce doom loop (throw error vs warn) when no handler is provided */
+    enforceDoomLoop?: boolean;
+    /**
+     * Handler for doom loop detection.
+     * Allows user choice: allow, deny, or remember.
+     */
+    onDoomLoop?: DoomLoopHandler;
+    /** Tools that are "remembered" (allowed without asking) */
+    rememberedDoomLoopTools?: Set<string>;
+    /** Token limit for context overflow detection */
+    contextTokenLimit?: number;
+    /** Callback for context overflow */
+    onContextOverflow?: (tokens: number, limit: number) => void | Promise<void>;
+    /** Current step number */
+    currentStep?: number;
+    /** Max steps */
+    maxSteps?: number;
+}
+/**
+ * Result of stream processing.
+ */
+interface ProcessorOutput {
+    /** Processing result */
+    result: ProcessorResult;
+    /** Accumulated text */
+    text: string;
+    /** Tool results */
+    toolResults: Array<{
+        toolName: string;
+        toolCallId: string;
+        result: unknown;
+    }>;
+    /** Final usage */
+    usage?: TokenUsage;
+    /** Finish reason reported by the most recent completed step */
+    finishReason?: string;
+    /** Error if any */
+    error?: Error;
+}
+
+type ErrorCategory = "rate_limit" | "overloaded" | "auth" | "invalid_request" | "context_overflow" | "content_filter" | "network" | "timeout" | "cancelled" | "unknown";
+interface ResponseHeaders {
+    "retry-after"?: string;
+    "retry-after-ms"?: string;
+    "x-ratelimit-remaining"?: string;
+    "x-ratelimit-reset"?: string;
+    [key: string]: string | undefined;
+}
+interface LLMErrorOptions {
+    message: string;
+    category?: ErrorCategory;
+    status?: number;
+    headers?: ResponseHeaders;
+    cause?: Error;
+    provider?: string;
+    model?: string;
+}
+
+declare class LLMError extends Error {
+    readonly category: ErrorCategory;
+    readonly status?: number;
+    readonly headers?: ResponseHeaders;
+    readonly provider?: string;
+    readonly model?: string;
+    readonly isRetryable: boolean;
+    readonly retryDelayMs?: number;
+    constructor(options: LLMErrorOptions);
+    static from(error: unknown, context?: Partial<LLMErrorOptions>): LLMError;
+    get description(): string;
+}
+
+/**
+ * Retry logic with exponential backoff for @cuylabs/agent-core
+ *
+ * Provides configurable retry behavior with header-aware delays,
+ * exponential backoff, and abort signal support.
+ */
+
+/**
+ * Retry configuration
+ */
+interface RetryConfig {
+    /** Maximum number of retry attempts (default: 3) */
+    maxAttempts?: number;
+    /** Initial delay in ms (default: 2000) */
+    initialDelayMs?: number;
+    /** Backoff multiplier (default: 2) */
+    backoffFactor?: number;
+    /** Maximum delay without headers in ms (default: 30000) */
+    maxDelayMs?: number;
+    /** Whether to jitter delays (default: true) */
+    jitter?: boolean;
+    /** Callback when retrying */
+    onRetry?: (attempt: number, delayMs: number, error: LLMError) => void;
+}
+/**
+ * Default retry configuration
+ */
+declare const DEFAULT_RETRY_CONFIG: Required<Omit<RetryConfig, "onRetry">>;
+/**
+ * Tracks retry state across attempts
+ */
+interface RetryState {
+    /** Current attempt number (1-indexed) */
+    attempt: number;
+    /** Total errors encountered */
+    errors: LLMError[];
+    /** Whether more retries are available */
+    canRetry: boolean;
+    /** Delay until next retry (if applicable) */
+    nextDelayMs?: number;
+}
+/**
+ * Creates initial retry state
+ */
+declare function createRetryState(): RetryState;
+/**
+ * Calculate delay for a retry attempt
+ */
+declare function calculateDelay(attempt: number, error: LLMError | undefined, config: Required<Omit<RetryConfig, "onRetry">>): number;
+/**
+ * Sleep for a duration, respecting abort signal
+ */
+declare function sleep(ms: number, signal?: AbortSignal): Promise<void>;
+/**
+ * Execute a function with retry logic
+ */
+declare function withRetry<T>(fn: (attempt: number) => Promise<T>, config?: RetryConfig, signal?: AbortSignal): Promise<T>;
+/**
+ * Options for retry handler
+ */
+interface RetryHandlerOptions extends RetryConfig {
+    /** Abort signal */
+    signal?: AbortSignal;
+}
+/**
+ * Creates a retry handler that wraps stream creation
+ */
+declare function createRetryHandler(options?: RetryHandlerOptions): <T>(createStream: (attempt: number) => Promise<T>) => Promise<T>;
+/**
+ * Checks if more retries should be attempted
+ */
+declare function shouldRetry(error: unknown, attempt: number, maxAttempts?: number): boolean;
+
+/** Stream result type - uses default Output for text streaming. */
+type LLMStreamResult = StreamTextResult<ToolSet, Output.Output<string, string, never>>;
+
+/**
+ * Custom stream result type - compatible shape from external providers.
+ */
+type CustomStreamResult = {
+    fullStream: AsyncIterable<StreamChunk>;
+    text: Promise<string>;
+    usage: Promise<{
+        inputTokens: number;
+        outputTokens: number;
+        totalTokens: number;
+    }>;
+    finishReason: Promise<string>;
+};
+/** Union type for stream results - either AI SDK or custom. */
+type AnyStreamResult = LLMStreamResult | CustomStreamResult;
+/** Default max output tokens. */
+declare const OUTPUT_TOKEN_MAX = 32000;
+/**
+ * @deprecated Use StreamProvider from types instead.
+ */
+type CustomStreamProvider = StreamProvider;
+/** Control whether AI SDK tool definitions auto-execute or only expose calls. */
+type ToolExecutionMode = "auto" | "plan";
+/**
+ * Input for LLM stream creation.
+ */
+interface LLMStreamInput {
+    /** Session ID */
+    sessionID: string;
+    /** Model to use */
+    model: LanguageModel;
+    /** System prompt parts */
+    system: string[];
+    /** Messages to send */
+    messages: ModelMessage[];
+    /** Abort signal */
+    abort: AbortSignal;
+    /** Tools to use */
+    tools: Record<string, Tool.Info>;
+    /** Whether tools should auto-execute or only be surfaced as tool calls. */
+    toolExecutionMode?: ToolExecutionMode;
+    /** Working directory */
+    cwd: string;
+    /** Execution environment for tools */
+    host?: ToolHost;
+    /** Temperature */
+    temperature?: number;
+    /** Top-p */
+    topP?: number;
+    /** Max output tokens */
+    maxOutputTokens?: number;
+    /** Max steps (tool iterations) */
+    maxSteps?: number;
+    /** Reasoning level for extended-thinking models */
+    reasoningLevel?: ReasoningLevel;
+    /** Retry configuration */
+    retry?: RetryConfig;
+    /** Callback for step completion */
+    onStepFinish?: (step: StepInfo) => void | Promise<void>;
+    /** Custom stream provider */
+    customStreamProvider?: StreamProvider;
+    /** Turn tracker for automatic file baseline capture */
+    turnTracker?: TurnTrackerContext;
+    /** Pre-built MCP tools */
+    mcpTools?: ToolSet;
+    /** Intervention controller for mid-turn message injection */
+    intervention?: InterventionController;
+    /** Middleware runner for lifecycle hooks */
+    middleware?: MiddlewareRunner;
+    /** AI SDK telemetry settings */
+    telemetry?: TelemetrySettings;
+}
+/**
+ * Step information surfaced to callers.
+ */
+interface StepInfo {
+    toolResults?: Array<{
+        toolName: string;
+        toolCallId: string;
+        output: unknown;
+    }>;
+    usage?: {
+        inputTokens?: number;
+        outputTokens?: number;
+        totalTokens?: number;
+    };
+    finishReason?: string;
+}
+
+interface AgentTurnEngineOptions {
+    sessionId: string;
+    startedAt: string;
+    getToolReplayPolicy?: (toolName: string) => NormalizedToolReplayPolicy | undefined;
+}
+interface AgentTurnBoundaryMetadata {
+    step?: number;
+    messageRole?: Message["role"];
+    pendingToolCallCount?: number;
+}
+interface AgentTurnStepCommitToolCall {
+    toolCallId: string;
+    toolName: string;
+    args: unknown;
+    replayPolicy?: NormalizedToolReplayPolicy;
+}
+interface AgentTurnStepCommitToolResult {
+    toolCallId: string;
+    toolName: string;
+    result: unknown;
+    replayPolicy?: NormalizedToolReplayPolicy;
+}
+interface AgentTurnStepCommitSnapshot {
+    toolCalls: AgentTurnStepCommitToolCall[];
+    toolResults: AgentTurnStepCommitToolResult[];
+}
+interface CreateAgentTurnStepCommitBatchOptions {
+    assistantMessageId?: string;
+    toolMessageIds?: Record<string, string>;
+    createdAt?: Date;
+}
+interface AgentTurnCommitBatch {
+    startBoundary: AgentEvent & {
+        type: "turn-boundary";
+    };
+    finishBoundary: AgentEvent & {
+        type: "turn-boundary";
+    };
+    messages: Message[];
+}
+interface AgentTurnOutputCommitOptions {
+    text: string;
+    usage?: TokenUsage;
+    createdAt?: Date;
+    id?: string;
+}
+type AgentTurnBoundaryEvent = AgentEvent & {
+    type: "turn-boundary";
+};
+
+type AgentTurnPhase = "initializing" | "committing-input" | "running-model" | "running-tools" | "committing-step" | "committing-output" | "completed" | "failed";
+interface AgentTurnBoundarySnapshot {
+    kind: AgentTurnBoundaryKind;
+    createdAt: string;
+    step?: number;
+    messageRole?: "system" | "user" | "assistant" | "tool";
+    pendingToolCallCount?: number;
+}
+interface AgentTurnActiveToolCall {
+    toolCallId: string;
+    toolName: string;
+    input: unknown;
+    startedAt: string;
+    replayPolicy?: NormalizedToolReplayPolicy;
+}
+interface AgentTurnResolvedToolCall {
+    toolCallId: string;
+    toolName: string;
+    outcome: "result" | "error";
+    value: unknown;
+    resolvedAt: string;
+    replayPolicy?: NormalizedToolReplayPolicy;
+}
+/**
+ * Neutral state model for a single in-flight agent turn.
+ *
+ * This is intentionally infrastructure-agnostic. Runtime adapters can persist
+ * or inspect it without coupling `agent-core` to Dapr, queues, or workflow
+ * engines. The current shape is suitable for durable tracking and forms the
+ * basis for future workflow-level resume support.
+ */
+interface AgentTurnState {
+    sessionId: string;
+    phase: AgentTurnPhase;
+    step: number;
+    maxSteps?: number;
+    response: string;
+    usage: TokenUsage;
+    eventCount: number;
+    activeToolCalls: AgentTurnActiveToolCall[];
+    resolvedToolCalls: AgentTurnResolvedToolCall[];
+    lastFinishReason?: string;
+    lastBoundary?: AgentTurnBoundarySnapshot;
+    lastEvent?: AgentEvent;
+    error?: string;
+    startedAt: string;
+    updatedAt: string;
+}
+interface CreateAgentTurnStateOptions {
+    sessionId: string;
+    startedAt: string;
+}
+interface AgentTurnStateAdvanceOptions {
+    toolReplayPolicy?: NormalizedToolReplayPolicy;
+}
+/**
+ * Create the initial neutral state for a single agent turn.
+ */
+declare function createAgentTurnState(options: CreateAgentTurnStateOptions): AgentTurnState;
+/**
+ * Advance neutral turn state from a streamed `AgentEvent`.
+ *
+ * This reducer deliberately models coarse but deterministic boundaries:
+ * step start, tool activity, step finish, completion, and failure. Runtime
+ * adapters can persist the resulting state now, and future resume-capable
+ * engines can build on the same state transitions.
+ */
+declare function advanceAgentTurnState(state: AgentTurnState, event: AgentEvent, updatedAt: string, options?: AgentTurnStateAdvanceOptions): AgentTurnState;
+/**
+ * Mark the turn as failed when execution aborts without a terminal `error`
+ * event. This covers exceptions thrown by the stream itself or runtime
+ * wrappers around the loop.
+ */
+declare function failAgentTurnState(state: AgentTurnState, error: Error, updatedAt: string): AgentTurnState;
+
+/**
+ * Neutral internal turn engine for one in-flight agent turn.
+ */
+declare class AgentTurnEngine {
+    private turnState;
+    private readonly pendingToolCalls;
+    private readonly pendingToolResults;
+    private readonly getToolReplayPolicy?;
+    constructor(options: AgentTurnEngineOptions);
+    getState(): AgentTurnState;
+    hasPendingToolCalls(): boolean;
+    createStepCommitSnapshot(): AgentTurnStepCommitSnapshot | undefined;
+    recordEvent(event: AgentEvent, updatedAt: string): AgentTurnState;
+    createBoundaryEvent(boundary: AgentTurnBoundaryKind, metadata?: AgentTurnBoundaryMetadata): AgentTurnBoundaryEvent;
+    createInputCommit(options: {
+        content: string;
+        system?: string;
+        createdAt?: Date;
+        id?: string;
+    }): AgentTurnCommitBatch;
+    createInterventionCommit(options: {
+        id: string;
+        content: string;
+        createdAt?: Date;
+    }): AgentTurnCommitBatch;
+    consumeStepCommit(step: number): AgentTurnCommitBatch | undefined;
+    createOutputCommit(options: AgentTurnOutputCommitOptions): AgentTurnCommitBatch | undefined;
+}
+declare function createAgentTurnEngine(options: AgentTurnEngineOptions): AgentTurnEngine;
+
+interface AgentTurnCommitOptions {
+    emitMessages?: boolean;
+}
+type AgentTurnCommitApplier = (batch: AgentTurnCommitBatch, options?: AgentTurnCommitOptions) => AsyncGenerator<AgentEvent>;
+interface AgentTurnStepRuntimeConfig {
+    model: LanguageModel;
+    cwd: string;
+    temperature?: number;
+    topP?: number;
+    maxOutputTokens?: number;
+    maxSteps: number;
+    doomLoopThreshold?: number;
+    enforceDoomLoop?: boolean;
+    onDoomLoop?: DoomLoopHandler;
+    contextWindow?: number;
+    streamProvider?: StreamProvider;
+    telemetry?: TelemetrySettings;
+}
+interface PrepareModelStepOptions {
+    sessionId: string;
+    step: number;
+    systemPrompts: string[];
+    messages: Message[];
+    toModelMessages: (messages: Message[]) => ModelMessage[];
+    abort: AbortSignal;
+    tools: Record<string, Tool.Info>;
+    mcpTools?: ToolSet;
+    config: AgentTurnStepRuntimeConfig;
+    host?: ToolHost;
+    turnTracker?: TurnTrackerContext;
+    intervention?: InterventionController;
+    middleware?: MiddlewareRunner;
+    reasoningLevel?: ReasoningLevel;
+    toolExecutionMode?: ToolExecutionMode;
+}
+interface PreparedAgentModelStep {
+    step: number;
+    messages: Message[];
+    modelMessages: ModelMessage[];
+    llmInput: LLMStreamInput;
+    processor: {
+        maxSteps: number;
+        doomLoopThreshold?: number;
+        enforceDoomLoop?: boolean;
+        onDoomLoop?: DoomLoopHandler;
+        contextTokenLimit?: number;
+    };
+}
+interface RunModelStepOptions {
+    preparedStep: PreparedAgentModelStep;
+    turnEngine: AgentTurnEngine;
+    applyCommitBatch: AgentTurnCommitApplier;
+    rememberedDoomLoopTools?: Set<string>;
+}
+interface CommitStepOptions {
+    step: number;
+    finishReason?: string;
+    turnEngine: AgentTurnEngine;
+    applyCommitBatch: AgentTurnCommitApplier;
+}
+interface CommitOutputOptions {
+    text: string;
+    usage?: ProcessorOutput["usage"];
+    turnEngine: AgentTurnEngine;
+    applyCommitBatch: AgentTurnCommitApplier;
+}
+interface RunToolBatchOptions {
+    sessionId: string;
+    snapshot: AgentTurnStepCommitSnapshot;
+    tools: Record<string, Tool.Info>;
+    cwd: string;
+    abort: AbortSignal;
+    host?: ToolHost;
+    turnTracker?: TurnTrackerContext;
+    middleware?: MiddlewareRunner;
+    turnState?: AgentTurnState;
+}
+interface RunToolBatchResult {
+    snapshot: AgentTurnStepCommitSnapshot;
+    turnState?: AgentTurnState;
+    events: Array<Extract<AgentEvent, {
+        type: "tool-result" | "tool-error";
+    }>>;
+}
+
+export { type StreamProviderFactory as $, type AnyStreamResult as A, LLMError as B, type CommitOutputOptions as C, DEFAULT_RETRY_CONFIG as D, type ErrorCategory as E, type LLMErrorOptions as F, type LLMStreamResult as G, type OnInterventionApplied as H, InterventionController as I, type PendingIntervention as J, type PrepareModelStepOptions as K, type LLMStreamInput as L, type PreparedAgentModelStep as M, type RetryConfig as N, OUTPUT_TOKEN_MAX as O, type ProcessorOptions as P, type RetryHandlerOptions as Q, type ResponseHeaders as R, type RetryState as S, type ToolExecutionMode as T, type RunModelStepOptions as U, type RunToolBatchOptions as V, type RunToolBatchResult as W, type StepInfo as X, type StreamChunk as Y, type StreamProvider as Z, type StreamProviderConfig as _, type ProcessorOutput as a, type StreamProviderInput as a0, type StreamProviderResult as a1, advanceAgentTurnState as a2, calculateDelay as a3, createAgentTurnEngine as a4, createAgentTurnState as a5, createRetryHandler as a6, createRetryState as a7, failAgentTurnState as a8, shouldRetry as a9, sleep as aa, withRetry as ab, type AgentTurnActiveToolCall as b, type AgentTurnBoundaryMetadata as c, type AgentTurnBoundarySnapshot as d, type AgentTurnCommitApplier as e, type AgentTurnCommitBatch as f, type AgentTurnCommitOptions as g, AgentTurnEngine as h, type AgentTurnEngineOptions as i, type AgentTurnPhase as j, type AgentTurnResolvedToolCall as k, type AgentTurnState as l, type AgentTurnStateAdvanceOptions as m, type AgentTurnStepCommitSnapshot as n, type AgentTurnStepCommitToolCall as o, type AgentTurnStepCommitToolResult as p, type AgentTurnStepRuntimeConfig as q, type CommitStepOptions as r, type CreateAgentTurnStateOptions as s, type CreateAgentTurnStepCommitBatchOptions as t, type CustomStreamProvider as u, type CustomStreamResult as v, type DoomLoopAction as w, type DoomLoopHandler as x, type DoomLoopRequest as y, type EnhancedTools as z };