@wrongstack/core 0.284.1 → 0.285.0

package/dist/index--Gm41aBJ.d.ts

@@ -1,671 +0,0 @@
-import { s as TextBlock, g as Tool, B as ToolUseBlock, d as Context, D as ToolResultBlock, n as RiskTier, c as Request, e as Response, P as Provider, i as ContentBlock, ay as WrongStackError } from './tool-BNlnIJvo.js';
-import { L as Logger } from './logger-B63L5bTg.js';
-import { B as BuildContext, H as HookRegistry, a as Renderer, P as Pipeline, C as Container } from './pipeline-DGDyIohT.js';
-import { a as PermissionDecision, P as PermissionPolicy } from './permission-ByDKXEcG.js';
-import { ac as ToolDescriptionMode, ad as ToolDescriptionModeConfig, H as HookEvent, ae as ToolResultRenderModeConfig, W as WireFamily, P as ProviderConfig, $ as LoopDetectionConfig } from './config-MRqn1V-u.js';
-import { T as Tracer } from './observability-D-HZN_mF.js';
-import { E as EventBus } from './events-Bgnh43r9.js';
-import { S as SecretScrubber } from './secret-scrubber-3MHDDAtm.js';
-
-/**
- * A contributor that injects additional TextBlocks into the system prompt.
- *
- * Contributors are called on every `build()` in registration order.
- * Their output is inserted after the core blocks (identity, tool usage,
- * environment) but before the mode and plan blocks. This lets plugins
- * inject ephemeral context — current state, recent events, plugin-specific
- * instructions — without replacing the entire system prompt builder.
- *
- * @example
- * ```ts
- * api.extensions.registerSystemPromptContributor(async (ctx) => {
- *   return [{ type: 'text', text: '## My Plugin Context\n...' }];
- * });
- * ```
- */
-type SystemPromptContributor = (ctx: BuildContext) => Promise<TextBlock[]>;
-
-/**
- * A function that wraps (decorates) an existing tool. Receives the
- * original tool and returns a modified version — typically the same
- * tool with a wrapped `execute` / `executeStream`, or with modified
- * metadata (description, permission).
- *
- * Use `ToolRegistry.wrap()` to apply; the wrapper is called immediately
- * and the result replaces the registered tool. Multiple wraps stack —
- * each wrapper receives the output of the previous.
- *
- * @example
- * ```ts
- * registry.wrap('read', (original) => ({
- *   ...original,
- *   async execute(input, ctx, opts) {
- *     console.log('read called');
- *     return original.execute(input, ctx, opts);
- *   }
- * }));
- * ```
- */
-type ToolWrapper = (tool: Tool) => Tool;
-declare class ToolRegistry {
-    private readonly tools;
-    private readonly descriptionModes;
-    /**
-     * Set of tool names that are disabled (hidden from list(), get() and all
-     * other public accessors). The underlying tool data stays in `_tools` so
-     * re-enable is a constant-time operation.
-     */
-    private readonly _disabled;
-    /** Monotonic version bumped on every registry mutation. */
-    private _version;
-    /** Cached `list()` result, frozen after build. Invalidated on _version change. */
-    private _listSnapshot;
-    private _listSnapshotVersion;
-    /** Pre-compute tool definition token estimate once at registration time. */
-    private _stampDefTokens;
-    /** Apply the description mode transform and stamp token estimates. */
-    private _prepareForStorage;
-    register(tool: Tool, owner?: string): void;
-    /**
-     * Attempt to register a tool. Returns true if successful, false if a tool
-     * with the same name is already registered. Useful in multi-agent or plugin
-     * scenarios where duplicate registration may be intentional.
-     */
-    tryRegister(tool: Tool, owner?: string): boolean;
-    /**
-     * Bulk-register multiple tools at once. Each tool that conflicts with an
-     * existing registration is silently skipped — use `registerAllOrThrow`
-     * if you want it to throw on conflicts.
-     */
-    registerAll(tools: Tool[], owner?: string): void;
-    /**
-     * Bulk-register and throw on the first conflict. Use when you need
-     * strict registration (e.g. at boot time).
-     */
-    registerAllOrThrow(tools: Tool[], owner?: string): void;
-    /**
-     * Register a tool as a default. If the tool name is already registered,
-     * this is a no-op — the existing registration (from core or another
-     * plugin) takes precedence. Use `override` to intentionally replace.
-     */
-    registerDefault(tool: Tool, owner?: string): void;
-    unregister(name: string): boolean;
-    /**
-     * Override an existing tool. Throws if the tool is not already registered.
-     * Plugins use this to replace built-in tools with custom implementations.
-     */
-    override(name: string, tool: Tool, owner?: string): void;
-    /**
-     * Wrap (decorate) an existing tool. The wrapper receives the current
-     * tool and must return a new tool — typically the same tool with a
-     * wrapped `execute` or `executeStream`. Throws if the tool is not
-     * registered.
-     *
-     * Multiple wraps stack: each wrapper gets the output of the previous.
-     *
-     * @example
-     * registry.wrap('bash', (t) => ({ ...t, permission: 'confirm' }));
-     */
-    wrap(name: string, wrapper: ToolWrapper, owner?: string): void;
-    setDescriptionMode(name: string, mode: ToolDescriptionMode): boolean;
-    getDescriptionMode(name: string): ToolDescriptionMode;
-    applyDescriptionModes(modes?: ToolDescriptionModeConfig): {
-        applied: number;
-        missing: string[];
-    };
-    get(name: string): Tool | undefined;
-    ownerOf(name: string): string | undefined;
-    /**
-     * Disable a tool by name. The tool is removed from all public accessors
-     * (list(), get(), listByCategory(), listWithOwner()) so it does NOT
-     * appear in the system prompt or provider request. The underlying
-     * registration is preserved in memory — use `enable()` to restore it.
-     *
-     * @returns `true` if the tool was found and disabled; `false` if the
-     *          tool is not registered or is already disabled.
-     */
-    disable(name: string): boolean;
-    /**
-     * Re-enable a previously disabled tool. The tool reappears in all
-     * public accessors and will be included in the next system prompt /
-     * provider request.
-     *
-     * @returns `true` if the tool was disabled and is now re-enabled;
-     *          `false` if the tool was not disabled.
-     */
-    enable(name: string): boolean;
-    /**
-     * Re-enable ALL currently disabled tools at once. Returns the number
-     * of tools that were re-enabled.
-     */
-    enableAll(): number;
-    /**
-     * Check whether a tool is currently disabled.
-     */
-    isDisabled(name: string): boolean;
-    /**
-     * Apply a list of tool names to disable. Tools not in the registry
-     * are silently ignored so config can reference future tools without
-     * error. Returns the number of tools actually disabled.
-     */
-    applyDisabled(names: readonly string[]): number;
-    /**
-     * Return the list of all disabled tool entries (tool + owner). Useful
-     * for the /tools slash command to show disabled tools alongside
-     * enabled ones.
-     */
-    listDisabled(): {
-        tool: Tool;
-        owner: string;
-    }[];
-    list(): Tool[];
-    /**
-     * Group tools by their `category` field. Tools without a category
-     * are placed under the key `""` (empty string). Returns a Map of
-     * category → tools, sorted by registration order within each category.
-     */
-    listByCategory(): Map<string, Tool[]>;
-    listWithOwner(): {
-        tool: Tool;
-        owner: string;
-    }[];
-    clear(): void;
-    /**
-     * Return a new ToolRegistry with the same registered tools and owners.
-     * Useful for creating filtered copies in multi-agent scenarios.
-     */
-    clone(): ToolRegistry;
-}
-
-/** Minimal run-state the runner reads. `Context` structurally satisfies it. */
-interface HookRunEnv {
-    cwd: string;
-    signal?: AbortSignal | undefined;
-}
-interface HookRunnerOptions {
-    registry: HookRegistry;
-    logger?: Logger | undefined;
-    /**
-     * When false, ordinary hooks are skipped across every transport;
-     * `policy: true` enforcement hooks still run.
-     */
-    allowNonPolicy?: boolean | undefined;
-    /** @deprecated Use `allowNonPolicy`; retained for API compatibility. */
-    allowShell?: boolean | undefined;
-    /** Resolves the active session id for the `HookInput` payload. */
-    sessionId?: (() => string) | undefined;
-}
-interface PreToolUseResult {
-    block?: boolean | undefined;
-    reason?: string | undefined;
-    /** Present only when a hook replaced the tool input. */
-    input?: Record<string, unknown>;
-}
-interface PromptResult {
-    block?: boolean | undefined;
-    reason?: string | undefined;
-    additionalContext?: string | undefined;
-}
-/**
- * Drives the registered hooks at each lifecycle phase. Pure orchestration —
- * the executor / pipeline / agent extension call the matching method and act on
- * the returned decision. Fail-open hooks are skipped on failure; fail-closed
- * policy hooks turn failures into explicit denials without prompting the user.
- */
-declare class HookRunner {
-    private readonly opts;
-    private readonly registry;
-    constructor(opts: HookRunnerOptions);
-    /** Cheap guard so callers can skip building payloads when nothing listens. */
-    has(event: HookEvent): boolean;
-    preToolUse(toolName: string, toolInput: Record<string, unknown>, env: HookRunEnv): Promise<PreToolUseResult>;
-    postToolUse(toolName: string, toolInput: unknown, result: {
-        content: string;
-        isError: boolean;
-    }, env: HookRunEnv): Promise<{
-        additionalContext?: string | undefined;
-        contextAs?: 'inline' | 'separate';
-    }>;
-    userPromptSubmit(prompt: string, env: HookRunEnv): Promise<PromptResult>;
-    sessionStart(env: HookRunEnv): Promise<{
-        additionalContext?: string | undefined;
-    }>;
-    stop(env: HookRunEnv): Promise<void>;
-    private base;
-    private matching;
-    private invoke;
-    private invokeInProcess;
-    private failureOutcome;
-    private collectContext;
-}
-
-/**
- * Output from a single tool execution.
- */
-interface ToolExecutionOutput {
-    result: ToolResultBlock | ToolConfirmPendingResult;
-    tool?: Tool | undefined;
-    durationMs: number;
-}
-/**
- * Result of running a batch of tools for a single agent iteration.
- */
-interface ToolBatchResult {
-    outputs: ToolExecutionOutput[];
-    remainingBudget: number;
-}
-type ConfirmAwaiter = (tool: Tool, input: unknown, toolUseId: string, suggestedPattern: string) => Promise<'yes' | 'no' | 'always' | 'deny'>;
-interface ToolExecutorOptions {
-    permissionPolicy: PermissionPolicy;
-    secretScrubber: SecretScrubber;
-    renderer?: Renderer | undefined;
-    /**
-     * Optional event bus. When provided, the executor emits `tool.started`
-     * before invoking each tool's `execute()`. Closes the observability gap
-     * between "model decided to call tool" and "tool finished".
-     */
-    events?: EventBus | undefined;
-    /**
-     * Optional tracer. When provided, every tool execution opens a
-     * `tool.<name>` span with attributes for tool name, permission decision,
-     * input size, output size, and outcome. Spans are no-op by default.
-     */
-    tracer?: Tracer | undefined;
-    /**
-     * Optional structured logger for production diagnostics. Tool execution logs
-     * include correlation IDs and metadata only — never raw tool inputs or output.
-     */
-    logger?: Logger | undefined;
-    /**
-     * Async callback invoked when a tool needs user confirmation.
-     * When omitted and confirmation is required, the executor returns a
-     * failure result immediately (TUI path). When provided (CLI path),
-     * the callback handles the interactive prompt and returns a decision.
-     */
-    confirmAwaiter?: ConfirmAwaiter | undefined;
-    iterationTimeoutMs?: number | undefined;
-    /** Hard upper bound for a single tool call timeout. Defaults to 5 minutes. */
-    maxToolTimeoutMs?: number | undefined;
-    perIterationOutputCapBytes?: number | undefined;
-    /**
-     * Optional lifecycle hook runner. When present, `PreToolUse` hooks run
-     * before the permission check (and can block the call or rewrite its input)
-     * and `PostToolUse` hooks run after the tool returns (and can append context
-     * to the result the model sees).
-     */
-    hookRunner?: HookRunner | undefined;
-    /**
-     * Per-tool on-screen result render mode map (`tools.resultRenderMode[name]`).
-     * When set, the executor reads this map to decide whether the next
-     * `writeToolResult` call should render in `simple` (meta only) or `extend`
-     * (full preview) mode. Independent of the LLM-side `descriptionMode`.
-     */
-    resultRenderModes?: ToolResultRenderModeConfig | undefined;
-}
-/**
- * Result returned by executeBatch when a tool needs confirmation and
- * no confirmAwaiter is available. The TUI catches this and surfaces a
- * confirmation dialog; once resolved the tool is re-executed.
- * The string tag identifies it as a "pending confirm" result so callers
- * can distinguish it from an error without inspecting content strings.
- */
-interface ToolConfirmPendingResult {
-    type: 'tool_confirm_pending';
-    toolUseId: string;
-    toolName: string;
-    input: unknown;
-    suggestedPattern: string;
-    decisionSource?: PermissionDecision['source'] | undefined;
-    riskTier?: RiskTier | undefined;
-}
-type ToolExecutorStrategy = 'parallel' | 'sequential' | 'smart';
-/**
- * Minimal contract for tool execution.
- *
- * Defined here (in `types/`) so `core/` does not need to import the
- * concrete `ToolExecutor` class from `execution/`. Callers that create
- * the executor (e.g. CLI wiring) implement this interface.
- *
- * Only the methods actually called by `Agent` are included — keeping the
- * interface narrow prevents unnecessary coupling.
- */
-interface ToolExecutorLike {
-    /**
-     * Execute a batch of tool uses. The strategy controls whether tools run
-     * sequentially, in parallel, or smart (parallel non-mutating + sequential mutating).
-     */
-    executeBatch(toolUses: ToolUseBlock[], ctx: Context, strategy: ToolExecutorStrategy): Promise<ToolBatchResult>;
-    /**
-     * Clear the interactive confirm awaiter so the executor returns
-     * `ToolConfirmPendingResult` instead of blocking.
-     */
-    clearConfirmAwaiter(): void;
-    /**
-     * Execute a single tool with timeout and output capping.
-     * Used by the agent when it needs to run one tool at a time.
-     *
-     * Returns the rendered `ToolResultBlock` plus the exact byte count it
-     * consumed against the iteration output cap. The caller subtracts
-     * `bytes` from the running budget — no second `Buffer.byteLength`
-     * walk, and no `JSON.stringify` fallback for structured results.
-     */
-    executeTool(tool: Tool, use: ToolUseBlock, ctx: Context, budget: number): Promise<{
-        block: ToolResultBlock;
-        bytes: number;
-    }>;
-}
-
-/**
- * Extension points for the Agent lifecycle.
- *
- * Each extension point is a hook that gets called at a specific phase.
- * Extensions are always optional and failures are isolated — a failing
- * extension never aborts the agent run.
- *
- * Plugins register extensions via `PluginAPI.extensions`, not by
- * directly importing this module. The Agent calls the registry in
- * order at each phase.
- */
-
-/**
- * Called before Agent.run() begins the main iteration loop.
- * Returns `false` or throws to prevent the run from starting.
- */
-type BeforeRunHook = (ctx: Context, input: UserInputPayload) => void | Promise<void>;
-/**
- * Called after Agent.run() completes (or fails/aborts).
- * Receives the final RunResult, always called regardless of outcome.
- */
-type AfterRunHook = (ctx: Context, result: RunResult) => void | Promise<void>;
-/**
- * Called right before each iteration of the agent loop.
- * The context is live (messages, signal, etc.) and can be inspected.
- * Modifications to ctx (e.g. ctx.messages, ctx.model) take effect
- * for the upcoming iteration.
- */
-type BeforeIterationHook = (ctx: Context, iterationIndex: number) => void | Promise<void>;
-/**
- * Called after each iteration completes (tool results appended,
- * compaction done, but before the next loop iteration check).
- */
-type AfterIterationHook = (ctx: Context, iterationIndex: number) => void | Promise<void>;
-/**
- * Called when the agent encounters an error during the provider call
- * or tool execution phase. The hook can return a modified context
- * or signal that recovery should be attempted.
- *
- * Return `{ action: 'retry', model?: string | undefined }` to retry the turn
- * (possibly with a different model).
- * Return `{ action: 'fail' }` to propagate the error.
- * Return `{ action: 'continue' }` to skip and continue the loop.
- */
-type OnErrorHook = (ctx: Context, err: unknown, phase: 'provider' | 'tool' | 'agent', iterationIndex: number) => {
-    action: 'retry';
-    model?: string | undefined;
-} | {
-    action: 'fail';
-} | {
-    action: 'continue';
-} | void | Promise<{
-    action: 'retry';
-    model?: string | undefined;
-} | {
-    action: 'fail';
-} | {
-    action: 'continue';
-} | void>;
-/**
- * The default provider runner function signature — what the Agent's
- * built-in provider runner looks like. Extensions that wrap the provider
- * runner receive this as the `inner` parameter they can delegate to.
- */
-type ProviderRunnerFn = (ctx: Context, request: Request) => Promise<Response>;
-/**
- * Wrap or replace the provider call in the agent loop.
- *
- * The `inner` function is the default provider runner (with retries).
- * The extension can call it, modify the request/response, add caching,
- * or bypass it entirely.
- */
-type ProviderRunnerWrapper = (ctx: Context, request: Request, inner: ProviderRunnerFn) => Promise<Response>;
-/**
- * Called before a batch of tools is executed. Can modify or reject
- * the tool list. Return the (possibly filtered/modified) tool uses.
- */
-type BeforeToolExecutionHook = (ctx: Context, toolUses: ToolUseBlock[]) => ToolUseBlock[] | Promise<ToolUseBlock[]>;
-/**
- * Called after a batch of tools has been executed and results
- * are available. The extension can inspect or transform results
- * before they're appended to context.
- */
-type AfterToolExecutionHook = (ctx: Context, outputs: ToolExecutionOutput[]) => void | Promise<void>;
-/**
- * An extension registered by a plugin or the host application.
- *
- * Every hook is optional — implement only the phases you need.
- * Hooks are called in registration order. A hook failure is
- * caught, logged, and does not prevent subsequent hooks from running.
- *
- * @example
- * ```ts
- * const myExt: AgentExtension = {
- *   name: 'my-plugin-ext',
- *   beforeIteration: async (ctx, idx) => {
- *     console.log('Starting iteration', idx);
- *   },
- * };
- * api.extensions.register(myExt);
- * ```
- */
-interface AgentExtension {
-    /** Unique name for this extension. Used in diagnostics and logging. */
-    name: string;
-    /** Optional owner tag (plugin name or host identifier). */
-    owner?: string | undefined;
-    beforeRun?: BeforeRunHook | undefined;
-    afterRun?: AfterRunHook | undefined;
-    beforeIteration?: BeforeIterationHook | undefined;
-    afterIteration?: AfterIterationHook | undefined;
-    onError?: OnErrorHook | undefined;
-    wrapProviderRunner?: ProviderRunnerWrapper | undefined;
-    beforeToolExecution?: BeforeToolExecutionHook | undefined;
-    afterToolExecution?: AfterToolExecutionHook | undefined;
-}
-
-/**
- * ExtensionRegistry — manages AgentExtension registrations.
- *
- * Extensions are called in registration order at each lifecycle phase.
- * Each extension hook failure is caught and logged independently so
- * one bad extension can't take down the agent.
- */
-
-declare class ExtensionRegistry {
-    private readonly extensions;
-    private readonly promptContributors;
-    private log;
-    setLogger(log: Logger): void;
-    /**
-     * Register a system prompt contributor. Returns an unregister function.
-     * Contributors are called on every system prompt build in registration
-     * order. Their output blocks are inserted after the core environment
-     * block, before the mode and plan blocks.
-     */
-    registerSystemPromptContributor(c: SystemPromptContributor): () => void;
-    /**
-     * Build all registered system prompt contributions.
-     * Failures are caught and logged — one bad contributor doesn't
-     * break the prompt assembly.
-     */
-    buildSystemPromptContributions(ctx: Parameters<SystemPromptContributor>[0]): Promise<TextBlock[]>;
-    /**
-     * Returns the live array of contributors (readonly snapshot for
-     * passing to DefaultSystemPromptBuilder at build time).
-     */
-    listSystemPromptContributors(): readonly SystemPromptContributor[];
-    /**
-     * Register an extension. Duplicate names are rejected.
-     * Returns an unregister function.
-     */
-    register(ext: AgentExtension): () => void;
-    /**
-     * Register an extension, silently replacing any previous registration
-     * with the same name. Use this when overriding a default extension.
-     */
-    registerOrReplace(ext: AgentExtension): () => void;
-    /**
-     * Unregister an extension by name. Returns true if found.
-     */
-    unregister(name: string): boolean;
-    /**
-     * List registered extension names in order.
-     */
-    list(): readonly string[];
-    /**
-     * Check if an extension with the given name is registered.
-     */
-    has(name: string): boolean;
-    /**
-     * Remove all registered extensions and contributors.
-     */
-    clear(): void;
-    runBeforeRun(...args: Parameters<BeforeRunHook>): Promise<void>;
-    runAfterRun(...args: Parameters<AfterRunHook>): Promise<void>;
-    runBeforeIteration(...args: Parameters<BeforeIterationHook>): Promise<void>;
-    runAfterIteration(...args: Parameters<AfterIterationHook>): Promise<void>;
-    /**
-     * Run onError hooks in order. The first hook that returns a non-void
-     * result wins; subsequent hooks are skipped.
-     */
-    runOnError(...args: Parameters<OnErrorHook>): Promise<{
-        action: 'retry';
-        model?: string | undefined;
-    } | {
-        action: 'fail';
-    } | {
-        action: 'continue';
-    } | void>;
-    /**
-     * Build a composed provider runner. Extensions with `wrapProviderRunner`
-     * form a middleware-style chain: the innermost extension wraps the
-     * default runner, each subsequent wrapper wraps the previous.
-     */
-    wrapProviderRunner(inner: ProviderRunnerFn): ProviderRunnerFn;
-    runBeforeToolExecution(...args: Parameters<BeforeToolExecutionHook>): Promise<Parameters<BeforeToolExecutionHook>[1]>;
-    runAfterToolExecution(...args: Parameters<AfterToolExecutionHook>): Promise<void>;
-}
-
-/**
- * Factory for constructing a Provider instance. The `family` field
- * declares the wire protocol so callers can route without inspecting
- * the returned instance. The `type` is the registry key (e.g. a
- * provider's models.dev id or a user-chosen alias).
- */
-interface ProviderFactory {
-    /**
-     * Unique identifier used as the registry key. When registered via
-     * a plugin, this becomes `cfg.type` in `ProviderRegistry.create(cfg)`.
-     */
-    type: string;
-    /**
-     * Declares the wire protocol family so consumers can route based on
-     * capability (e.g. which tool-format converter to use) without
-     * instantiating the provider.
-     */
-    family: WireFamily;
-    create(cfg: ProviderConfig): Provider;
-}
-declare class ProviderRegistry {
-    private readonly factories;
-    /**
-     * Register a provider factory. If a factory with the same type already
-     * exists, it is replaced. Use this for both initial registration and
-     * runtime overrides (e.g. from plugins or CLI flags).
-     */
-    register(f: ProviderFactory): void;
-    /**
-     * Bulk-register multiple provider factories at once.
-     */
-    registerAll(factories: ProviderFactory[]): void;
-    /**
-     * Override an existing factory. Throws if no factory is registered
-     * for the given type. Use this to safely replace a provider at runtime
-     * (e.g. in tests or when a plugin provides a custom implementation).
-     */
-    override(type: string, f: ProviderFactory): void;
-    has(type: string): boolean;
-    /**
-     * Unregister a provider factory by type. Returns true if a factory was
-     * removed, false if none was registered for that type.
-     */
-    unregister(type: string): boolean;
-    create(cfg: ProviderConfig): Provider;
-    list(): string[];
-}
-
-/** Default iteration cap. Use 0 or Infinity via config to disable. */
-declare const DEFAULT_MAX_ITERATIONS = 100;
-interface RunResult {
-    status: 'done' | 'failed' | 'max_iterations' | 'aborted';
-    error?: WrongStackError | undefined;
-    finalText?: string | undefined;
-    iterations: number;
-    delegateSummaries?: Array<{
-        summary: string | undefined;
-        ok: boolean;
-    }>;
-    /** Human-readable reason for abort (e.g. "user interrupt", "tool timeout", "stream hang"). */
-    abortReason?: string | undefined;
-}
-interface AgentInit {
-    container: Container;
-    tools: ToolRegistry;
-    providers: ProviderRegistry;
-    events: EventBus;
-    pipelines: AgentPipelines;
-    context: Context;
-    maxIterations?: number | undefined;
-    iterationTimeoutMs?: number | undefined;
-    executionStrategy?: 'parallel' | 'sequential' | 'smart' | undefined;
-    perIterationOutputCapBytes?: number | undefined;
-    autoExtendLimit?: boolean | undefined;
-    autonomousContinue?: boolean | undefined;
-    confirmAwaiter?: ConfirmAwaiter | undefined;
-    permissionPolicy?: PermissionPolicy | undefined;
-    tracer?: Tracer | undefined;
-    extensions?: ExtensionRegistry | undefined;
-    toolExecutor: ToolExecutorLike;
-    /** Loop-detector tuning (`tools.loopDetection`). Omitted fields use defaults. */
-    loopDetection?: LoopDetectionConfig | undefined;
-}
-/** Fully-resolved loop-detector settings (defaults applied, bounds clamped). */
-interface ResolvedLoopDetectionConfig {
-    mode: 'steer-then-cut' | 'cut' | 'off';
-    steerThreshold: number;
-    cutThreshold: number;
-    windowSize: number;
-    callRepeatThreshold: number;
-}
-interface AgentPipelines {
-    request: Pipeline<Request>;
-    response: Pipeline<Response>;
-    toolCall: Pipeline<ToolCallPipelinePayload>;
-    userInput: Pipeline<UserInputPayload>;
-    assistantOutput: Pipeline<TextBlock>;
-    contextWindow: Pipeline<Context>;
-}
-interface UserInputPayload {
-    content: ContentBlock[];
-    text: string;
-    ctx: Context;
-}
-type AgentInput = string | ContentBlock[];
-interface ToolCallPipelinePayload {
-    toolUse: ToolUseBlock;
-    result: ToolResultBlock;
-    ctx: Context;
-    tool?: Tool | undefined;
-}
-declare function createDefaultPipelines(): AgentPipelines;
-
-export { type AgentPipelines as A, type BeforeIterationHook as B, DEFAULT_MAX_ITERATIONS as D, ExtensionRegistry as E, type HookRunEnv as H, type OnErrorHook as O, ProviderRegistry as P, type ResolvedLoopDetectionConfig as R, type SystemPromptContributor as S, type ToolCallPipelinePayload as T, type UserInputPayload as U, type ToolWrapper as a, ToolRegistry as b, type ToolExecutorLike as c, type AgentInit as d, type AgentInput as e, type RunResult as f, type ToolExecutorOptions as g, type ToolExecutorStrategy as h, type ToolBatchResult as i, type AgentExtension as j, type AfterIterationHook as k, type AfterRunHook as l, type AfterToolExecutionHook as m, type BeforeRunHook as n, type BeforeToolExecutionHook as o, HookRunner as p, type HookRunnerOptions as q, type PreToolUseResult as r, type PromptResult as s, type ProviderFactory as t, type ProviderRunnerWrapper as u, createDefaultPipelines as v, type ProviderRunnerFn as w };