import type { CacheWarmingAction, CacheWarmingDecisionEvent } from "../cache-warmer.ts";
import type { ExtensionToolContext } from "./context-types.ts";
/**
 * Extension runner - executes extensions and manages their lifecycle.
 */
import type { Provider, ProviderHeaders } from "@bastani/pi-ai";
import type { ImageContent } from "@bastani/pi-ai/compat";
import type { AgentMessage } from "@earendil-works/pi-agent-core";
import type { KeyId } from "@earendil-works/pi-tui";
import type { ResourceDiagnostic } from "../diagnostics.ts";
import type { KeybindingsConfig } from "../keybindings.ts";
import type { ModelRegistry } from "../model-registry.ts";
import type { SessionManager } from "../session-manager.ts";
import type { BuildSystemPromptOptions } from "../system-prompt.ts";
import { type HostDiagnostic, type HostInput } from "./host-input.js";
import { type BeforeAgentStartCombinedResult, type BoundaryBaseEvent, type BoundaryDispatchResult, type ResourcesDiscoverCombinedResult, type RunnerEmitEvent, type RunnerEmitResult, type SessionRecoveryCombinedResult } from "./runner-events.ts";
import type { ExtensionErrorListener } from "./runner-handlers.ts";
import type { BoundaryContextPreview, EntryRenderer, Extension, ExtensionActions, ExtensionCommandContext, ExtensionCommandContextActions, ExtensionContext, ExtensionContextActions, ExtensionError, ExtensionFlag, ExtensionMode, ExtensionRuntime, ExtensionShortcut, ExtensionUIContext, InputEventResult, InputSource, MarkdownTransformer, MessageEndEvent, MessageRenderer, OrchestrationContext, ProviderConfig, RegisteredTool, ResolvedCommand, ResourcesDiscoverEvent, SessionBoundaryDraft, SessionRecoveryReplayEvent, SessionRecoveryRestoreEvent, SessionShutdownEvent, SubagentChildPolicy, ToolCallEvent, ToolCallEventResult, ToolRenderers, ToolResultEvent, ToolResultEventResult, UIPromptKind, UserBashEvent, UserBashEventResult } from "./types.ts";
import type { WorkflowActivityObserver, WorkflowActivitySnapshotFrame, WorkflowActivitySubscription } from "./workflow-events.js";
import type { WorkflowRunControl } from "./workflow-run-control.js";
export type { ExtensionErrorListener, ForkHandler, NavigateTreeHandler, NewSessionHandler, ReloadHandler, ShutdownHandler, SwitchSessionHandler, } from "./runner-handlers.ts";
export { emitProjectTrustEvent } from "./runner-project-trust.ts";
/**
 * Helper function to emit session_shutdown event to extensions.
 * Returns true if the event was emitted, false if there were no handlers.
 */
export declare function emitSessionShutdownEvent(extensionRunner: ExtensionRunner, event: SessionShutdownEvent): Promise<boolean>;
export declare class ExtensionRunner {
    private extensions;
    private runtime;
    private readonly reportedMcpServers;
    private mcpDiagnosticUnsubscriber?;
    private uiContext;
    private presentationUI?;
    private presentationInput?;
    private humanInput?;
    private humanInputBindingRevision;
    private inputBridge;
    private onDiagnostic?;
    private mode;
    private presentationOnly;
    private cwd;
    private sessionManager;
    private modelRegistry;
    private orchestrationContext;
    private subagentPolicy;
    private taskHostBinding;
    /** @internal Attach dispatch receipts to the owning session before startup. */
    bindWorkOwner(owner: object): void;
    bindTaskHost(binding: () => import("../tasks/agent-adapter.js").AgentTaskHost): void;
    bindChildSessionOptions(resolver: import("../child-session-options.ts").ChildSessionOptionsResolver | undefined): void;
    bindWorkflowJournal(journal: import("../storage/provider.js").RunJournalOption | undefined, storageAgentDir: string | undefined): void;
    /** The run-control implementation registered by the current extension generation, if any. */
    getWorkflowRunControl(): WorkflowRunControl | undefined;
    /** Observe this generation's workflow activity: snapshot first, then FIFO changes. */
    observeWorkflowActivity(observer: WorkflowActivityObserver): WorkflowActivitySubscription;
    /** This generation's current workflow activity snapshot. */
    getWorkflowActivitySnapshot(): WorkflowActivitySnapshotFrame;
    getChildHostBindings(): import("../agent-session-types.js").ExtensionBindings;
    private errorListeners;
    private getModel;
    private getScopedModels;
    private isIdleFn;
    private isProjectTrustedFn;
    private getSignalFn;
    private waitForIdleFn;
    private abortFn;
    private hasPendingMessagesFn;
    private isSessionSummaryEnabledFn;
    private generateWorkflowSummaryFn;
    private getContextUsageFn;
    private compactFn;
    private getSystemPromptFn;
    private getSystemPromptOptionsFn;
    private getSkillCatalogFn;
    private getRouterModelFn;
    private getModelRoutingFn;
    private getHttpIdleTimeoutMsFn;
    private executeToolFn;
    private getCallableToolsFn;
    private newSessionHandler;
    private forkHandler;
    private navigateTreeHandler;
    private switchSessionHandler;
    private reloadHandler;
    private shutdownHandler;
    private shortcutDiagnostics;
    private commandDiagnostics;
    private staleMessage;
    private authorityRevoked;
    private readonly contextOwner;
    private uiPromptBinding;
    private activeUIPrompt;
    constructor(extensions: Extension[], runtime: ExtensionRuntime, cwd: string, sessionManager: SessionManager, modelRegistry: ModelRegistry, orchestrationContext?: OrchestrationContext, subagentPolicy?: SubagentChildPolicy);
    bindCore(actions: ExtensionActions, contextActions: ExtensionContextActions, providerActions?: {
        registerProvider?: (providerOrName: Provider | string, config?: ProviderConfig) => Promise<void>;
        restoreProvider?: (providerOrName: Provider | string, config?: ProviderConfig) => void;
        unregisterProvider?: (name: string) => Promise<void>;
    }): void;
    bindCommandContext(actions?: ExtensionCommandContextActions): void;
    setHostBindings(humanInput: HostInput | null | undefined, onDiagnostic?: (diagnostic: HostDiagnostic) => void, bindingRevision?: number): void;
    cancelHostInput(): void;
    /** @internal Join this generation's callbacks without draining its reload caller. */
    drainWork(): Promise<void>;
    /** @internal Seal input admission without invalidating shutdown handlers. */
    sealHostInput(): void;
    /** @internal A rejected transaction retains the live runner, but never revives captured dialogs. */
    resumeAfterRejectedReload(): void;
    private refreshHostInput;
    setUIContext(uiContext?: ExtensionUIContext, mode?: ExtensionMode, isPresentationOnly?: boolean): void;
    private wrapUIPromptContext;
    /** Track a host-owned trust dialog using the current session's prompt lifecycle. */
    withProjectTrustPrompt<T>(kind: UIPromptKind, title: string, run: () => Promise<T>): Promise<T>;
    /** Begin a host-owned trust span whose end arrives as a separate control frame. */
    beginProjectTrustPrompt(kind: UIPromptKind, title: string): () => void;
    private withUIPrompt;
    private beginUIPrompt;
    private endActiveUIPrompt;
    private uiPromptObserver;
    setUIPromptObserver(observer: typeof this.uiPromptObserver): void;
    private readonly pendingUIPromptNotifications;
    private emitUIPromptEvent;
    /** Settle only the deliveries pending at this boundary, without delaying prompt UI. */
    flushUIPromptNotifications(timeoutMs: number): Promise<{
        timedOut: boolean;
    }>;
    getUIContext(): ExtensionUIContext;
    hasUI(): boolean;
    getExtensionPaths(): string[];
    /** Get all registered tools from all extensions (first registration per name wins). */
    getAllRegisteredTools(): RegisteredTool[];
    /** Get a tool definition by name. Returns undefined if not found. */
    getToolDefinition(toolName: string): RegisteredTool["definition"] | undefined;
    getFlags(): Map<string, ExtensionFlag>;
    setFlagValue(name: string, value: boolean | string): void;
    getFlagValues(): Map<string, boolean | string>;
    getExplicitFlagValues(): Map<string, boolean | string>;
    getShortcuts(resolvedKeybindings: KeybindingsConfig): Map<KeyId, ExtensionShortcut>;
    getShortcutDiagnostics(): ResourceDiagnostic[];
    retireObservation(): void;
    /** A retired session's late cleanup must not write into presentation its successor now owns. */
    detachPresentation(): void;
    revokeAuthority(): void;
    invalidate(message?: string): void;
    reportUnhandledMcpServers(): void;
    private assertActive;
    onError(listener: ExtensionErrorListener): () => void;
    emitError(error: ExtensionError): void;
    hasHandlers(eventType: string): boolean;
    getMessageRenderer(customType: string): MessageRenderer | undefined;
    getMarkdownTransformers(): MarkdownTransformer[];
    /** Renderers of calls to `toolName`: extension resolvers in load order, then `base`. */
    resolveToolRenderers(toolName: string, base: () => ToolRenderers | undefined): ToolRenderers | undefined;
    getEntryRenderer(customType: string): EntryRenderer | undefined;
    /** Invoke the session-owned registration without changing discovery identity. */
    renderEntry(customType: string, ...args: Parameters<EntryRenderer>): ReturnType<EntryRenderer>;
    getRegisteredCommands(): ResolvedCommand[];
    getCommandDiagnostics(): ResourceDiagnostic[];
    getCommand(name: string, quitSignal?: AbortSignal): ResolvedCommand | undefined;
    /**
     * Request a graceful shutdown. Called by extension tools and event handlers.
     * The actual shutdown behavior is provided by the mode via bindExtensions().
     */
    shutdown(): void;
    createContext(): ExtensionContext;
    /** Bound to the actual executing parent, not an extension-supplied caller identity. */
    createToolContext(toolCallId: string, signal: AbortSignal | undefined): ExtensionToolContext;
    createCommandContext(): ExtensionCommandContext;
    private createContextSource;
    /** Keep startup reporters bound while adding the now-authorized extension set. */
    attachStartupExtensions(extensions: Extension[]): () => Promise<void>;
    emit<TEvent extends RunnerEmitEvent>(event: TEvent, isCurrent?: () => boolean, admitted?: boolean): Promise<RunnerEmitResult<TEvent>>;
    emitMessageEnd(event: MessageEndEvent, admitted?: boolean): Promise<AgentMessage | undefined>;
    emitToolResult(event: ToolResultEvent, admitted?: boolean): Promise<ToolResultEventResult | undefined>;
    emitToolCall(event: ToolCallEvent): Promise<ToolCallEventResult | undefined>;
    emitUserBash(event: UserBashEvent): Promise<UserBashEventResult | undefined>;
    emitBoundary(baseEvent: BoundaryBaseEvent, buildContext: (entries: SessionBoundaryDraft[]) => BoundaryContextPreview | Promise<BoundaryContextPreview>): Promise<BoundaryDispatchResult>;
    emitContext(messages: AgentMessage[]): Promise<AgentMessage[]>;
    emitBeforeProviderRequest(payload: unknown): Promise<unknown>;
    emitCacheWarmingDecision(event: CacheWarmingDecisionEvent): Promise<CacheWarmingAction>;
    emitBeforeProviderHeaders(headers: ProviderHeaders): Promise<ProviderHeaders>;
    emitBeforeAgentStart(prompt: string, images: ImageContent[] | undefined, systemPromptOptions: BuildSystemPromptOptions, customMessage?: import("../messages.ts").CustomMessage): Promise<BeforeAgentStartCombinedResult>;
    emitResourcesDiscover(cwd: string, reason: ResourcesDiscoverEvent["reason"]): Promise<ResourcesDiscoverCombinedResult>;
    /** Collect recovery notices and replay decisions from every handler, in registration order. */
    emitSessionRecovery(event: SessionRecoveryRestoreEvent | SessionRecoveryReplayEvent): Promise<SessionRecoveryCombinedResult>;
    /** Emit input event. Transforms chain, "handled" short-circuits. */
    emitInput(text: string, images: ImageContent[] | undefined, source: InputSource, streamingBehavior?: "steer" | "followUp"): Promise<InputEventResult>;
}
//# sourceMappingURL=runner.d.ts.map