import type { Api, Model } from "@bastani/pi-ai/compat";
import type { ThinkingLevel } from "@earendil-works/pi-agent-core";
import type { ProjectTrustContext, SessionStartEvent, ToolDefinition } from "./extensions/index.js";
import { ModelRuntime } from "./model-runtime.js";
import { type DefaultResourceLoaderOptions, type ResourceLoader, type ResourceLoaderReloadOptions } from "./resource-loader.ts";
import { type CreateAgentSessionOptions, type CreateAgentSessionResult } from "./sdk.ts";
import type { SessionManager } from "./session-manager.ts";
import { SettingsManager } from "./settings-manager.ts";
/**
 * Non-fatal issues collected while creating services or sessions.
 *
 * Runtime creation returns diagnostics to the caller instead of printing or
 * exiting. The app layer decides whether warnings should be shown and whether
 * errors should abort startup.
 */
export interface AgentSessionRuntimeDiagnostic {
    type: "info" | "warning" | "error";
    message: string;
}
/**
 * Inputs for creating cwd-bound runtime services.
 *
 * These services are recreated whenever the effective session cwd changes.
 * CLI-provided resource paths should be resolved to absolute paths before they
 * reach this function, so later cwd switches do not reinterpret them.
 */
export interface CreateAgentSessionServicesOptions {
    cwd: string;
    agentDir?: string;
    settingsManager?: SettingsManager;
    modelRuntime?: ModelRuntime;
    extensionFlagValues?: Map<string, boolean | string>;
    resourceLoaderOptions?: Omit<DefaultResourceLoaderOptions, "cwd" | "agentDir" | "settingsManager">;
    resourceLoaderReloadOptions?: ResourceLoaderReloadOptions;
}
/**
 * Inputs for creating an AgentSession from already-created services.
 *
 * Use this after services exist and any cwd-bound model/tool/session options
 * have been resolved against those services.
 */
export interface CreateAgentSessionFromServicesOptions {
    services: AgentSessionServices;
    sessionManager: SessionManager;
    sessionStartEvent?: SessionStartEvent;
    model?: Model<Api>;
    thinkingLevel?: ThinkingLevel;
    fallbackModels?: CreateAgentSessionOptions["fallbackModels"];
    isFallbackModelAllowed?: CreateAgentSessionOptions["isFallbackModelAllowed"];
    scopedModels?: Array<{
        model: Model<Api>;
        thinkingLevel?: ThinkingLevel;
    }>;
    tools?: string[];
    builtins?: CreateAgentSessionOptions["builtins"];
    excludedTools?: CreateAgentSessionOptions["excludedTools"];
    noTools?: CreateAgentSessionOptions["noTools"];
    customTools?: ToolDefinition[];
    extensionBindings?: CreateAgentSessionOptions["extensionBindings"];
}
/**
 * Coherent cwd-bound runtime services for one effective session cwd.
 *
 * This is infrastructure only. The AgentSession itself is created separately so
 * session options can be resolved against these services first.
 */
export interface AgentSessionServices {
    cwd: string;
    agentDir: string;
    modelRuntime: ModelRuntime;
    settingsManager: SettingsManager;
    resourceLoader: ResourceLoader;
    diagnostics: AgentSessionRuntimeDiagnostic[];
    /** Complete interactive trust after the safe session has a live UI binding. */
    completeStartup?: (context: ProjectTrustContext) => Promise<void>;
}
/**
 * Create cwd-bound runtime services.
 *
 * Returns services plus diagnostics. It does not create an AgentSession.
 */
export declare function createAgentSessionServices(options: CreateAgentSessionServicesOptions): Promise<AgentSessionServices>;
/** Prepare trust now; construct approved resources and register providers on continuation. */
export declare function prepareAgentSessionServices(options: CreateAgentSessionServicesOptions): Promise<() => Promise<AgentSessionServices>>;
/**
 * Create an AgentSession from previously created services.
 *
 * This keeps session creation separate from service creation so callers can
 * resolve model, thinking, tools, and other session inputs against the target
 * cwd before constructing the session.
 */
export declare function createAgentSessionFromServices(options: CreateAgentSessionFromServicesOptions): Promise<CreateAgentSessionResult>;
/** Internal CLI assembly only; the UI starts the session after mounting. */
export declare function createUnstartedAgentSessionFromServices(options: CreateAgentSessionFromServicesOptions, persistInitialState?: boolean): Promise<CreateAgentSessionResult>;
//# sourceMappingURL=agent-session-services.d.ts.map