/**
 * Extension runtime binding: the boundary between {@link AgentSession} and the {@link
 * ExtensionRunner} it hosts. Owns the public `bindExtensions()` entry point (stores the
 * host-supplied UI/mode/callback bindings, applies them to the runner, fires the session-start
 * event, discovers extension-contributed resources, and initializes memory), the resource
 * discovery pass that turns extension-reported skill/prompt/theme paths into labeled {@link
 * ResourceExtensionPaths}, and `bindExtensionCore` — the ~30-method translation of the session's
 * own public surface (send message, set model, compact, abort, reload, …) into the `ExtensionActions`
 * / `ExtensionContextActions` shape `ExtensionRunner.bindCore` expects.
 *
 * Extracted verbatim from agent-session.ts (god-file decomposition). All logic here is pure code
 * motion — no behavior changes. State that other collaborators (RuntimeBuilder, LocalRuntimeController,
 * HumanInputController) also read (`_extensionUIContext`, `_extensionMode`, `_extensionCommandContextActions`,
 * `_extensionShutdownHandler`, `_extensionErrorListener`) stays host-owned and is reached through the
 * same get/set deps accessors those collaborators already use; `_extensionAbortHandler` and the
 * error-unsubscribe callback are touched only within this binding boundary, so they are owned here.
 *
 * Host-binding boundary note (see runtime-builder.ts): `bindExtensionCore` exposes session identity
 * to the extension runner, not tool-registry build logic, which is why it lives in its own dedicated
 * module rather than inside RuntimeBuilder; RuntimeBuilder still invokes it (and `applyExtensionBindings`
 * / `extendResourcesFromExtensions`) through {@link RuntimeBuilderDeps}, one level further delegated.
 */
import type { Agent, ThinkingLevel } from "@caupulican/pi-agent-core";
import type { CustomMessage } from "@caupulican/pi-agent-core/messages";
import type { SessionManager } from "@caupulican/pi-agent-core/node";
import type { Api, ImageContent, Model, TextContent, Usage } from "@caupulican/pi-ai";
import type { ExtensionBindings } from "./agent-session-contracts.ts";
import type { MemoryProvider as ContextMemoryProvider } from "./context/memory-provider-contract.ts";
import type { CompactOptions, ContextUsage, ExtensionCommandContextActions, ExtensionContext, ExtensionErrorListener, ExtensionRunner, ExtensionUIContext, SessionStartEvent, ShutdownHandler, ToolInfo } from "./extensions/index.ts";
import type { ManagedLaneEvent } from "./extensions/types.ts";
import type { MemoryProvider } from "./memory/memory-provider.ts";
import type { ModelRegistry } from "./model-registry.ts";
import type { PromptTemplate } from "./prompt-templates.ts";
import type { ResourceLoader } from "./resource-loader.ts";
import type { ResourceProfileSettings, SettingsManager } from "./settings-manager.ts";
export interface ExtensionBindingControllerDeps {
    getAgent(): Agent;
    getExtensionRunner(): ExtensionRunner;
    getSessionStartEvent(): SessionStartEvent;
    getCwd(): string;
    getResourceLoader(): ResourceLoader;
    getSessionManager(): SessionManager;
    getSettingsManager(): SettingsManager;
    getModelRegistry(): ModelRegistry;
    getModel(): Model<Api> | undefined;
    getActiveToolNames(): string[];
    getAllTools(): ToolInfo[];
    setActiveToolsByName(toolNames: string[]): void;
    refreshToolRegistry(): void;
    rebuildSystemPrompt(toolNames: string[]): string;
    setBaseSystemPrompt(prompt: string): void;
    getPromptTemplates(): ReadonlyArray<PromptTemplate>;
    getThinkingLevel(): ThinkingLevel;
    setThinkingLevel(level: ThinkingLevel): void;
    setModel(model: Model<Api>): Promise<void>;
    sendCustomMessage(message: Pick<CustomMessage, "customType" | "content" | "display" | "details">, options?: {
        triggerTurn?: boolean;
        deliverAs?: "steer" | "followUp" | "nextTurn";
    }): Promise<void>;
    sendUserMessage(content: string | (TextContent | ImageContent)[], options?: {
        deliverAs?: "steer" | "followUp";
        processSlashCommands?: boolean;
    }): Promise<void>;
    setSessionName(name: string): void;
    registerMemoryProvider(provider: MemoryProvider): void;
    registerContextMemoryProvider(provider: ContextMemoryProvider): void;
    addSpawnedUsage(usage: Usage, opts?: {
        label?: string;
        sourceSessionId?: string;
        reportId?: string;
    }): string | undefined;
    recordManagedLane(event: ManagedLaneEvent): void;
    isForegroundBusy(): boolean;
    getPendingMessageCount(): number;
    isStreaming(): boolean;
    isCompacting(): boolean;
    getContextUsage(): ContextUsage | undefined;
    compactForExtension(options?: CompactOptions): void;
    reload(): Promise<void>;
    abort(): Promise<void>;
    getSystemPrompt(): string;
    getExtensionCommandContextActions(): ExtensionCommandContextActions | undefined;
    refreshCurrentModelFromRegistry(): void;
    initializeMemory(): Promise<void>;
    getExtensionUIContext(): ExtensionUIContext | undefined;
    setExtensionUIContext(uiContext: ExtensionUIContext | undefined): void;
    getExtensionMode(): ExtensionContext["mode"];
    setExtensionMode(mode: ExtensionContext["mode"]): void;
    setExtensionCommandContextActions(actions: ExtensionCommandContextActions | undefined): void;
    getExtensionShutdownHandler(): ShutdownHandler | undefined;
    setExtensionShutdownHandler(handler: ShutdownHandler | undefined): void;
    getExtensionErrorListener(): ExtensionErrorListener | undefined;
    setExtensionErrorListener(listener: ExtensionErrorListener | undefined): void;
}
/** Compile the current session's effective resource authority into a self-contained profile.
 * Empty allows become explicit wildcards so activating this snapshot in a child preserves the
 * parent's unrestricted kinds instead of triggering strict-profile deny-all semantics. */
export declare function compileEffectiveResourceProfileSnapshot(settingsManager: Pick<SettingsManager, "getResourceProfileFilter">): ResourceProfileSettings;
export declare class ExtensionBindingController {
    private readonly deps;
    private extensionAbortHandler?;
    private extensionErrorUnsubscriber?;
    constructor(deps: ExtensionBindingControllerDeps);
    bindExtensions(bindings: ExtensionBindings): Promise<void>;
    extendResourcesFromExtensions(reason: "startup" | "reload"): Promise<void>;
    private buildExtensionResourcePaths;
    private getExtensionSourceLabel;
    applyExtensionBindings(runner: ExtensionRunner): void;
    bindExtensionCore(runner: ExtensionRunner): void;
}
//# sourceMappingURL=extension-binding-controller.d.ts.map