@cuylabs/agent-core 0.7.0 → 0.9.0

package/dist/tracking/index.js

@@ -3,7 +3,7 @@ import {
   clearCheckpoints,
   createCheckpointManager,
   createTurnTracker
-} from "../chunk-VBWWUHWI.js";
+} from "../chunk-OFDKHNCX.js";
 import {
   extractFilePathsFromArgs,
   shouldCaptureBaseline,

package/dist/{tool-Db1Ue-1U.d.ts → types-BfNpU8NS.d.ts}

@@ -1,6 +1,3 @@
-import { z } from 'zod';
-import { T as ToolMetadata, a as ToolReplayPolicy, b as ToolContext, F as FileOperationMeta, c as ToolResult } from './tool-HUtkiVBx.js';
-
 /**
  * Skill System Types
  *
@@ -270,150 +267,4 @@ interface SkillDiscoveryError {
     reason: string;
 }
 
-/**
- * Tool definition namespace for @cuylabs/agent-core
- *
- * Provides consistent tool creation via Tool.define.
- */
-
-/**
- * A schema type compatible with both Zod 3 and Zod 4.
- *
- * Uses structural typing so that schemas from either Zod version satisfy
- * the constraint. This avoids the problem where Zod 3's `ZodType` class
- * and Zod 4's `ZodType` class have incompatible internal shapes, causing
- * type errors when a library compiled against one version is consumed with
- * the other.
- *
- * Both Zod 3 and Zod 4 (classic API) schemas have `parse()` and `_output`.
- */
-interface CompatibleSchema<T = any> {
-    /** Parse and validate input data. Present in both Zod 3 and Zod 4. */
-    parse(data: unknown): T;
-    /**
-     * Type-level output marker used by both Zod versions:
-     * - Zod 3: `readonly _output!: T` (definite assignment assertion)
-     * - Zod 4 classic: `get _output(): T` (getter)
-     */
-    readonly _output: T;
-}
-/**
- * Infer the output type from a compatible schema.
- * Equivalent to `z.infer<T>` but works with both Zod 3 and Zod 4 schemas.
- */
-type InferSchemaOutput<T extends CompatibleSchema> = T["_output"];
-/**
- * Tool namespace - tool definition utilities
- */
-declare namespace Tool {
-    /**
-     * Tool info interface - the shape of a defined tool
-     */
-    interface Info<TParams extends CompatibleSchema = any, TMeta extends ToolMetadata = ToolMetadata> {
-        /** Unique tool identifier */
-        id: string;
-        /** Recovery semantics for resume-capable runtimes. */
-        replayPolicy?: ToolReplayPolicy;
-        /** Initialize the tool (can be async for dynamic descriptions) */
-        init: (ctx?: InitContext) => Promise<InitResult<TParams, TMeta>> | InitResult<TParams, TMeta>;
-    }
-    /**
-     * Any tool info - for use in arrays and collections where generic types vary
-     */
-    type AnyInfo = Info<any, any>;
-    /**
-     * Context passed during tool initialization
-     */
-    interface InitContext {
-        /** Working directory */
-        cwd?: string;
-        /** Agent name (if known) */
-        agent?: string;
-    }
-    /**
-     * Result of tool initialization
-     */
-    interface InitResult<TParams extends CompatibleSchema = any, TMeta extends ToolMetadata = ToolMetadata> {
-        /** Tool description for the LLM */
-        description: string;
-        /** Zod schema for parameters */
-        parameters: TParams;
-        /** Execute the tool */
-        execute: (params: InferSchemaOutput<TParams>, ctx: ToolContext) => Promise<ExecuteResult<TMeta>>;
-        /** Optional custom validation error formatter */
-        formatValidationError?: (error: z.ZodError) => string;
-        /**
-         * File operation metadata for automatic turn tracking.
-         * When set, the agent will automatically capture file baselines
-         * before tool execution for undo/diff capabilities.
-         *
-         * @example
-         * ```typescript
-         * // For a write tool
-         * fileOps: {
-         *   pathArgs: ['path'],
-         *   operationType: 'write'
-         * }
-         * ```
-         */
-        fileOps?: FileOperationMeta;
-        /** Optional replay metadata for resume-capable runtimes. */
-        replayPolicy?: ToolReplayPolicy;
-    }
-    /**
-     * Result of tool execution
-     */
-    interface ExecuteResult<TMeta extends ToolMetadata = ToolMetadata> {
-        /** Short title for display */
-        title: string;
-        /** Main output text */
-        output: string;
-        /** Metadata */
-        metadata: TMeta;
-    }
-    interface DefineOptions {
-        /** Static replay metadata exposed to higher-level runtimes. */
-        replayPolicy?: ToolReplayPolicy;
-    }
-    /**
-     * Define a tool with standard patterns
-     *
-     * @example
-     * ```typescript
-     * const myTool = Tool.define("my_tool", {
-     *   description: "Does something useful",
-     *   parameters: z.object({
-     *     input: z.string().describe("The input to process"),
-     *   }),
-     *   execute: async (params, ctx) => ({
-     *     title: "Processed",
-     *     output: `Result: ${params.input}`,
-     *     metadata: {},
-     *   }),
-     * });
-     * ```
-     */
-    function define<TParams extends CompatibleSchema, TMeta extends ToolMetadata = ToolMetadata>(id: string, init: Info<TParams, TMeta>["init"] | Awaited<ReturnType<Info<TParams, TMeta>["init"]>>, options?: DefineOptions): Info<TParams, TMeta>;
-    /**
-     * Simple define for static tools (no async init)
-     */
-    function defineSimple<TParams extends CompatibleSchema, TMeta extends ToolMetadata = ToolMetadata>(id: string, config: {
-        description: string;
-        parameters: TParams;
-        execute: (params: InferSchemaOutput<TParams>, ctx: ToolContext) => Promise<ExecuteResult<TMeta>>;
-        replayPolicy?: ToolReplayPolicy;
-    }): Info<TParams, TMeta>;
-}
-/**
- * Legacy helper - wraps to Tool.Info format
- *
- * @deprecated Use Tool.define instead
- */
-declare function defineTool<TParams extends CompatibleSchema>(definition: {
-    id: string;
-    description: string;
-    parameters: TParams;
-    execute: (params: InferSchemaOutput<TParams>, ctx: ToolContext) => Promise<ToolResult>;
-}): Tool.Info<TParams>;
-
-export { type CompatibleSchema as C, type InferSchemaOutput as I, type RemoteSkillEntry as R, type SkillDiscoveryResult as S, Tool as T, type SkillMetadata as a, type SkillContent as b, type SkillResource as c, type SkillConfig as d, type RemoteSkillIndex as e, type SkillDiscoveryError as f, type SkillResourceType as g, type SkillScope as h, type SkillSource as i, type SkillSourceType as j, defineTool as k };
+export type { RemoteSkillEntry as R, SkillDiscoveryResult as S, SkillMetadata as a, SkillContent as b, SkillResource as c, SkillConfig as d, RemoteSkillIndex as e, SkillDiscoveryError as f, SkillResourceType as g, SkillScope as h, SkillSource as i, SkillSourceType as j };

package/dist/{types-FRpzzg_9.d.ts → types-BlOKk-Bb.d.ts}

@@ -1,9 +1,11 @@
 import { StreamTextResult, ToolSet, Output, LanguageModel, ModelMessage, TelemetrySettings } from 'ai';
-import { T as Tool } from './tool-Db1Ue-1U.js';
+import { T as Tool } from './tool-CZWN3KbO.js';
 import { T as ToolHost } from './types-CHiPh8U2.js';
-import { S as StreamChunk, d as StreamProvider, M as MiddlewareRunner, e as ModelCallInput } from './runner-DSKaEz3z.js';
+import { M as MiddlewareRunner } from './runner-CI-XeR16.js';
+import { S as StreamChunk, f as StreamProvider, M as ModelCallInput } from './types-DTSkxakL.js';
 import { R as ReasoningLevel } from './types-CQaXbRsS.js';
-import { d as TurnTrackerContext } from './tool-HUtkiVBx.js';
+import { d as TurnTrackerContext } from './tool-DkhSCV2Y.js';
+import { L as LLMError } from './llm-error-D93FNNLY.js';
 
 /**
  * Intervention Controller for @cuylabs/agent-core
@@ -97,6 +99,8 @@ declare class InterventionController {
      * @internal Called by the LLM stream's `prepareStep` hook
      */
     drainImmediate(): PendingIntervention[];
+    /** Adopt existing immediate interventions without changing their IDs. */
+    adoptImmediate(items: PendingIntervention[]): void;
     /** Whether there are pending immediate interventions */
     get hasPending(): boolean;
     /** Number of pending immediate interventions */
@@ -118,6 +122,8 @@ declare class InterventionController {
      * The internal queue is cleared atomically.
      */
     drainDeferred(): PendingIntervention[];
+    /** Adopt existing deferred interventions without changing their IDs. */
+    adoptDeferred(items: PendingIntervention[]): void;
     /** Whether there are deferred messages */
     get hasDeferred(): boolean;
     /** Number of deferred messages */
@@ -128,37 +134,6 @@ declare class InterventionController {
     resetCallbacks(): void;
 }
 
-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
  *
@@ -352,4 +327,4 @@ type LLMStreamInput = InferenceStreamInput;
  */
 type StepInfo = InferenceStepInfo;
 
-export { type AnyInferenceResult as A, type CustomStreamProvider as C, DEFAULT_MAX_OUTPUT_TOKENS as D, type ErrorCategory as E, type InferenceStreamInput as I, type LLMStreamInput as L, OUTPUT_TOKEN_MAX as O, type PendingIntervention as P, type ResponseHeaders as R, type StepInfo as S, type ToolExecutionMode as T, type AnyStreamResult as a, type CustomStreamResult as b, type InferenceCustomResult as c, type InferenceStepInfo as d, type InferenceStreamResult as e, type LLMStreamResult as f, InterventionController as g, DEFAULT_RETRY_CONFIG as h, LLMError as i, type LLMErrorOptions as j, type OnInterventionApplied as k, type RetryConfig as l, type RetryHandlerOptions as m, type RetryState as n, calculateDelay as o, createRetryHandler as p, createRetryState as q, sleep as r, shouldRetry as s, withRetry as w };
+export { type AnyInferenceResult as A, type CustomStreamProvider as C, DEFAULT_MAX_OUTPUT_TOKENS as D, type InferenceStreamInput as I, type LLMStreamInput as L, OUTPUT_TOKEN_MAX as O, type PendingIntervention as P, type RetryConfig as R, type StepInfo as S, type ToolExecutionMode as T, type AnyStreamResult as a, type CustomStreamResult as b, DEFAULT_RETRY_CONFIG as c, type InferenceCustomResult as d, type InferenceStepInfo as e, type InferenceStreamResult as f, type LLMStreamResult as g, type RetryHandlerOptions as h, type RetryState as i, calculateDelay as j, createRetryHandler as k, createRetryState as l, sleep as m, InterventionController as n, type OnInterventionApplied as o, shouldRetry as s, withRetry as w };

package/dist/types-BlZwmnuW.d.ts

@@ -0,0 +1,50 @@
+import { LanguageModel } from 'ai';
+import { R as ReasoningLevel } from './types-CQaXbRsS.js';
+import { T as Tool } from './tool-CZWN3KbO.js';
+
+/**
+ * Agent preset - a reusable configuration profile.
+ */
+interface Preset {
+    /** Unique identifier for this preset */
+    name: string;
+    /** Human-readable description */
+    description: string;
+    /**
+     * Tool allow patterns (glob-like).
+     * If provided, only tools matching these patterns are candidates.
+     */
+    allowTools?: string[];
+    /**
+     * Tool deny patterns (glob-like).
+     * Deny patterns apply only after allow matching, so explicit allows win.
+     */
+    denyTools?: string[];
+    /**
+     * Override system prompt.
+     * Use `{basePrompt}` to include the parent's system prompt.
+     */
+    systemPrompt?: string;
+    /** Override temperature (0-1). */
+    temperature?: number;
+    /** Override max steps. */
+    maxSteps?: number;
+    /** Override reasoning level. */
+    reasoningLevel?: ReasoningLevel;
+    /** Override model. */
+    model?: LanguageModel;
+}
+/**
+ * Result of applying a preset - ready for `fork()`.
+ */
+interface AppliedPreset {
+    name: string;
+    systemPrompt?: string;
+    tools?: Tool.AnyInfo[];
+    temperature?: number;
+    maxSteps?: number;
+    reasoningLevel?: ReasoningLevel;
+    model?: LanguageModel;
+}
+
+export type { AppliedPreset as A, Preset as P };

package/dist/{types-9jGQUjqW.d.ts → types-CQL-SvTn.d.ts}

@@ -26,4 +26,4 @@ interface ScopeOptions {
     attributes?: ScopeAttributes;
 }
 
-export type { ScopeOptions as S, Scope as a, ScopeSnapshot as b, ScopeAttributeValue as c, ScopeAttributes as d, ScopeKind as e };
+export type { ScopeSnapshot as S, Scope as a, ScopeAttributeValue as b, ScopeAttributes as c, ScopeKind as d, ScopeOptions as e };

package/dist/types-CWm-7rvB.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Risk level for operations.
+ */
+type RiskLevel = "safe" | "moderate" | "dangerous";
+/**
+ * User response to an approval request.
+ */
+type ApprovalAction = "allow" | "deny" | "remember";
+/**
+ * Approval request sent to the UI/handler.
+ */
+interface ApprovalRequest {
+    /** Unique request ID */
+    id: string;
+    /** Session ID */
+    sessionId: string;
+    /** Tool name */
+    tool: string;
+    /** Tool arguments */
+    args: unknown;
+    /** Human-readable description */
+    description: string;
+    /** Risk level */
+    risk: RiskLevel;
+    /** Patterns that would be remembered if "remember" is chosen */
+    patterns: string[];
+    /** Timestamp */
+    timestamp: number;
+}
+/**
+ * Rule for auto-approving/denying operations.
+ */
+interface ApprovalRule {
+    /** Pattern to match (glob-style) */
+    pattern: string;
+    /** Tool to match (`*` for all) */
+    tool: string;
+    /** Action to take */
+    action: "allow" | "deny";
+}
+/**
+ * Configuration for the approval handler.
+ */
+interface ApprovalConfig {
+    /** Default action when no rule matches (default: "ask") */
+    defaultAction?: "allow" | "deny" | "ask";
+    /** Pre-configured rules */
+    rules?: ApprovalRule[];
+    /** Handler for approval requests */
+    onRequest?: (request: ApprovalRequest) => Promise<ApprovalAction>;
+    /** Timeout for approval requests in ms (default: 5 minutes) */
+    timeout?: number;
+}
+
+export type { ApprovalAction as A, RiskLevel as R, ApprovalConfig as a, ApprovalRequest as b, ApprovalRule as c };

package/dist/{runner-DSKaEz3z.d.ts → types-DTSkxakL.d.ts}

@@ -1,10 +1,11 @@
-import * as ai from 'ai';
 import { LanguageModel, ModelMessage, TelemetrySettings, SystemModelMessage } from 'ai';
 import { ProviderOptions } from '@ai-sdk/provider-utils';
-import { T as TokenUsage, M as Message } from './messages-BYWGn8TY.js';
-import { d as SkillConfig, T as Tool } from './tool-Db1Ue-1U.js';
-import { b as ScopeSnapshot } from './types-9jGQUjqW.js';
-import { b as ToolContext } from './tool-HUtkiVBx.js';
+import { A as AgentEvent } from './events-CE72w8W4.js';
+import { d as SkillConfig } from './types-BfNpU8NS.js';
+import { T as TokenUsage } from './messages-BYWGn8TY.js';
+import { S as ScopeSnapshot } from './types-CQL-SvTn.js';
+import { T as ToolContext } from './tool-DkhSCV2Y.js';
+import { T as Tool } from './tool-CZWN3KbO.js';
 import { R as ReasoningLevel } from './types-CQaXbRsS.js';
 
 /**
@@ -173,151 +174,6 @@ interface EnhancedTools extends Array<unknown> {
     __customStreamModels?: string[];
 }
 
-/** Agent status for UI display */
-type AgentStatus = "idle" | "processing" | "thinking" | "reasoning" | "calling-tool" | "waiting-approval" | "error";
-/** Approval request for UI */
-interface ApprovalEvent {
-    id: string;
-    tool: string;
-    args: unknown;
-    description: string;
-    risk: "safe" | "moderate" | "dangerous";
-}
-/** Neutral turn-commit boundaries for runtime/durability integrations */
-type AgentTurnBoundaryKind = "input-commit-start" | "input-commit-finish" | "intervention-commit-start" | "intervention-commit-finish" | "step-commit-start" | "step-commit-finish" | "output-commit-start" | "output-commit-finish";
-/**
- * Events emitted during agent execution
- *
- * These events are designed for UI consumption:
- * - status: Overall agent state for status indicators
- * - approval-request: User confirmation needed
- * - progress: Step counts for progress bars
- */
-type AgentEvent = {
-    type: "status";
-    status: AgentStatus;
-} | {
-    type: "approval-request";
-    request: ApprovalEvent;
-} | {
-    type: "approval-resolved";
-    id: string;
-    action: "allow" | "deny" | "remember";
-} | {
-    type: "step-start";
-    step: number;
-    maxSteps: number;
-} | {
-    type: "step-finish";
-    step: number;
-    usage?: TokenUsage;
-    finishReason?: string;
-} | {
-    type: "turn-boundary";
-    boundary: AgentTurnBoundaryKind;
-    step?: number;
-    messageRole?: Message["role"];
-    pendingToolCallCount?: number;
-} | {
-    type: "message";
-    message: Message;
-} | {
-    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-start";
-    toolName: string;
-    toolCallId: string;
-    input: unknown;
-} | {
-    type: "tool-result";
-    toolName: string;
-    toolCallId: string;
-    result: unknown;
-} | {
-    type: "tool-error";
-    toolName: string;
-    toolCallId: string;
-    error: string;
-} | {
-    type: "computer-call";
-    callId: string;
-    action: unknown;
-    pendingSafetyChecks?: unknown[];
-} | {
-    type: "computer-result";
-    callId: string;
-    result: unknown;
-} | {
-    type: "intervention-applied";
-    id: string;
-    message: string;
-} | {
-    type: "doom-loop";
-    toolName: string;
-    repeatCount: number;
-} | {
-    type: "context-overflow";
-    inputTokens: number;
-    limit: number;
-} | {
-    type: "turn-summary";
-    turnId: string;
-    files: Array<{
-        path: string;
-        type: "created" | "modified" | "deleted" | "unchanged";
-        additions: number;
-        deletions: number;
-    }>;
-    additions: number;
-    deletions: number;
-} | {
-    type: "retry";
-    attempt: number;
-    delayMs: number;
-    error: Error;
-} | {
-    type: "error";
-    error: Error;
-} | {
-    type: "complete";
-    usage?: TokenUsage;
-    output?: string;
-};
-/**
- * Step-processing result - what happens after reducing one streamed step
- */
-type StepProcessingResult = "continue" | "stop" | "compact";
-/**
- * @deprecated Use `StepProcessingResult`.
- */
-type ProcessorResult = StepProcessingResult;
-/**
- * Stream input for model inference
- */
-interface StreamInput {
-    sessionID: string;
-    model: ai.LanguageModel;
-    system: string[];
-    messages: ai.ModelMessage[];
-    abort: AbortSignal;
-    tools: Record<string, unknown>;
-}
-
 /**
  * Prompt Pipeline Types
  *
@@ -792,88 +648,4 @@ interface AgentMiddleware {
     getOtelContext?(sessionId: string): unknown;
 }
 
-/**
- * Middleware Runner
- *
- * Executes middleware hooks in the correct order with proper
- * error handling and short-circuit semantics.
- *
- * This is the internal engine — consumers never see it.
- * They interact with middleware through AgentConfig.middleware.
- */
-
-/**
- * Middleware runner — holds an ordered list of middleware and
- * exposes methods to run each hook type with correct semantics.
- *
- * Immutable after construction. Fork creates a new runner
- * (with inherited + additional middleware).
- */
-declare class MiddlewareRunner {
-    private readonly stack;
-    constructor(middleware?: AgentMiddleware[]);
-    /** Number of registered middleware */
-    get count(): number;
-    /** Whether any middleware is registered */
-    get hasMiddleware(): boolean;
-    /** Get the middleware list (for fork inheritance) */
-    getMiddleware(): readonly AgentMiddleware[];
-    runModelInput(input: ModelCallInput, ctx: ModelCallContext): Promise<ModelCallInput | BlockedModelCall>;
-    runModelChunk(chunk: StreamChunk, ctx: ModelCallContext): Promise<StreamChunk | undefined>;
-    runModelOutput(output: ModelCallOutput, ctx: ModelCallContext): Promise<ModelCallOutput>;
-    /**
-     * Run all `beforeToolCall` hooks in order.
-     *
-     * Returns `{ action: "allow" }` if all middleware allow (or have no hook).
-     * Returns `{ action: "deny", reason }` on first denial — remaining
-     * middleware are skipped.
-     */
-    runBeforeToolCall(tool: string, args: unknown, ctx: ToolContext): Promise<ToolCallDecision>;
-    /**
-     * Run all `afterToolCall` hooks in reverse order.
-     *
-     * Each hook receives the result from the previous hook (or the
-     * original tool result for the first hook). Errors are caught
-     * and logged — the original result passes through.
-     */
-    runAfterToolCall(tool: string, args: unknown, result: Tool.ExecuteResult, ctx: ToolContext): Promise<Tool.ExecuteResult>;
-    /**
-     * Collect prompt sections from all middleware.
-     *
-     * Returns a flat array of sections. Each middleware can return a single
-     * section, an array of sections, or undefined/empty.
-     */
-    collectPromptSections(ctx: PromptBuildContext): PromptSection[];
-    /**
-     * Broadcast an event to all middleware observers.
-     *
-     * Non-blocking — errors are caught and logged. This never
-     * slows down the streaming pipeline.
-     */
-    emitEvent(event: AgentEvent): void;
-    /**
-     * Get the OTel context for a session from the telemetry middleware.
-     * Returns undefined if no telemetry middleware is registered.
-     */
-    getOtelContext(sessionId: string): unknown | undefined;
-    /**
-     * Run all `onChatStart` hooks in order.
-     *
-     * Errors are caught and logged — a broken logger should not
-     * prevent the chat from starting.
-     */
-    runChatStart(sessionId: string, message: string): Promise<void>;
-    /**
-     * Run all `onChatEnd` hooks in order.
-     *
-     * Always called, even when the stream errored. Errors in handlers
-     * are caught and logged.
-     */
-    runChatEnd(sessionId: string, result: {
-        usage?: TokenUsage;
-        error?: Error;
-        output?: string;
-    }): Promise<void>;
-}
-
-export { type AgentEvent as A, type BlockedModelCall as B, type EnhancedTools as E, type InstructionFile as I, MiddlewareRunner as M, type PromptConfig as P, type StreamChunk as S, type ToolCallDecision as T, type PromptBuildContext as a, type PromptSection as b, type ModelFamily as c, type StreamProvider as d, type ModelCallInput as e, type StepProcessingResult as f, type AgentTurnBoundaryKind as g, type AgentMiddleware as h, type AgentModelHooks as i, type AgentStatus as j, type ApprovalEvent as k, type EnvironmentInfo as l, type ModelCallContext as m, type ModelCallOutput as n, type ProcessorResult as o, type StreamInput as p, type StreamProviderConfig as q, type StreamProviderFactory as r, type StreamProviderInput as s, type StreamProviderResult as t };
+export type { AgentMiddleware as A, BlockedModelCall as B, EnhancedTools as E, InstructionFile as I, ModelCallInput as M, PromptBuildContext as P, StreamChunk as S, ToolCallDecision as T, ModelCallContext as a, ModelCallOutput as b, PromptSection as c, PromptConfig as d, ModelFamily as e, StreamProvider as f, AgentModelHooks as g, EnvironmentInfo as h, StreamProviderConfig as i, StreamProviderFactory as j, StreamProviderInput as k, StreamProviderResult as l };

package/dist/{types-CqDZTh4d.d.ts → types-DmDwi2zI.d.ts}

@@ -1,11 +1,13 @@
 import { LanguageModel, TelemetrySettings, ModelMessage, ToolSet } from 'ai';
-import { T as Tool } from './tool-Db1Ue-1U.js';
+import { T as Tool } from './tool-CZWN3KbO.js';
 import { T as ToolHost } from './types-CHiPh8U2.js';
-import { f as StepProcessingResult, A as AgentEvent, g as AgentTurnBoundaryKind, d as StreamProvider, M as MiddlewareRunner } from './runner-DSKaEz3z.js';
-import { g as InterventionController, T as ToolExecutionMode, I as InferenceStreamInput } from './types-FRpzzg_9.js';
+import { M as MiddlewareRunner } from './runner-CI-XeR16.js';
+import { n as InterventionController, T as ToolExecutionMode, I as InferenceStreamInput } from './types-BlOKk-Bb.js';
 import { R as ReasoningLevel } from './types-CQaXbRsS.js';
-import { N as NormalizedToolReplayPolicy, d as TurnTrackerContext } from './tool-HUtkiVBx.js';
+import { N as NormalizedToolReplayPolicy, d as TurnTrackerContext } from './tool-DkhSCV2Y.js';
 import { T as TokenUsage, M as Message } from './messages-BYWGn8TY.js';
+import { f as StreamProvider } from './types-DTSkxakL.js';
+import { S as StepProcessingResult, A as AgentEvent, b as AgentTurnBoundaryKind } from './events-CE72w8W4.js';
 
 /**
  * Doom-loop handling contracts for repeated tool invocations.
@@ -40,6 +42,8 @@ interface StepProcessingOptions {
     sessionID?: string;
     /** Abort signal */
     abort: AbortSignal;
+    /** Normalize provider/runtime errors before emitting them as events */
+    normalizeError?: (error: unknown) => Error;
     /** Event callback */
     onEvent: (event: AgentEvent) => void | Promise<void>;
     /** Doom loop threshold (default: 3) */