import { type AgentTelemetryConfig, type ThinkingLevel } from "@oh-my-pi/pi-agent-core";
import { type Model } from "@oh-my-pi/pi-ai";
import { type Rule } from "./capability/rule";
import { ModelRegistry } from "./config/model-registry";
import { type PromptTemplate } from "./config/prompt-templates";
import { Settings, type SkillsSettings } from "./config/settings";
import "./discovery";
import { type CustomCommandsLoadResult } from "./extensibility/custom-commands";
import type { CustomTool } from "./extensibility/custom-tools/types";
import { type ExtensionFactory, type ExtensionUIContext, type LoadExtensionsResult, type ToolDefinition } from "./extensibility/extensions";
import { type Skill, type SkillWarning } from "./extensibility/skills";
import { type FileSlashCommand } from "./extensibility/slash-commands";
import type { HindsightSessionState } from "./hindsight/state";
import { type LocalProtocolOptions } from "./internal-urls";
import { MCPManager, type MCPToolsLoadResult } from "./mcp";
import { AgentRegistry } from "./registry/agent-registry";
import { AgentSession } from "./session/agent-session";
import { AuthStorage } from "./session/auth-storage";
import { SessionManager } from "./session/session-manager";
import { type BuildSystemPromptResult } from "./system-prompt";
import { BashTool, BUILTIN_TOOLS, createTools, EditTool, EvalTool, FindTool, HIDDEN_TOOLS, type LspStartupServerInfo, loadSshTool, ReadTool, ResolveTool, SearchTool, type Tool, type ToolSession, WebSearchTool, WriteTool } from "./tools";
import { EventBus } from "./utils/event-bus";
import { type WorkspaceTree } from "./workspace-tree";
export interface CreateAgentSessionOptions {
    /** Working directory for project-local discovery. Default: getProjectDir() */
    cwd?: string;
    /** Global config directory. Default: ~/.omp/agent */
    agentDir?: string;
    /** Spawns to allow. Default: "*" */
    spawns?: string;
    /** Auth storage for credentials. Default: discoverAuthStorage(agentDir) */
    authStorage?: AuthStorage;
    /** Model registry. Default: discoverModels(authStorage, agentDir) */
    modelRegistry?: ModelRegistry;
    /** Model to use. Default: from settings, else first available */
    model?: Model;
    /** Raw model pattern string (e.g. from --model CLI flag) to resolve after extensions load.
     * Used when model lookup is deferred because extension-provided models aren't registered yet. */
    modelPattern?: string;
    /** Thinking selector. Default: from settings, else unset */
    thinkingLevel?: ThinkingLevel;
    /** Models available for cycling (Ctrl+P in interactive mode) */
    scopedModels?: Array<{
        model: Model;
        thinkingLevel?: ThinkingLevel;
    }>;
    /** System prompt blocks. Array replaces default, function receives default blocks and returns final blocks. */
    systemPrompt?: string[] | ((defaultPrompt: string[]) => string[]);
    /** Optional provider-facing session identifier for prompt caches and sticky auth selection.
     * Keeps persisted session files isolated while reusing provider-side caches. */
    providerSessionId?: string;
    /** Custom tools to register (in addition to built-in tools). Accepts both CustomTool and ToolDefinition. */
    customTools?: (CustomTool | ToolDefinition)[];
    /** Inline extensions (merged with discovery). */
    extensions?: ExtensionFactory[];
    /** Additional extension paths to load (merged with discovery). */
    additionalExtensionPaths?: string[];
    /** Disable extension discovery (explicit paths still load). */
    disableExtensionDiscovery?: boolean;
    /**
     * Pre-loaded extensions (skips file discovery).
     * @internal Used by CLI when extensions are loaded early to parse custom flags.
     */
    preloadedExtensions?: LoadExtensionsResult;
    /** Shared event bus for tool/extension communication. Default: creates new bus. */
    eventBus?: EventBus;
    /** Skills. Default: discovered from multiple locations */
    skills?: Skill[];
    /** Rules. Default: discovered from multiple locations */
    rules?: Rule[];
    /** Context files (AGENTS.md content). Default: discovered walking up from cwd */
    contextFiles?: Array<{
        path: string;
        content: string;
    }>;
    /** Pre-built workspace tree (skips re-scanning; passed by parents to subagents). */
    workspaceTree?: WorkspaceTree;
    /** Prompt templates. Default: discovered from cwd/.omp/prompts/ + agentDir/prompts/ */
    promptTemplates?: PromptTemplate[];
    /** File-based slash commands. Default: discovered from commands/ directories */
    slashCommands?: FileSlashCommand[];
    /** Enable MCP server discovery from .mcp.json files. Default: true */
    enableMCP?: boolean;
    /** Existing MCP manager to reuse (skips discovery, propagates to toolSession). */
    mcpManager?: MCPManager;
    /** Enable LSP integration (tool, formatting, diagnostics, warmup). Default: true */
    enableLsp?: boolean;
    /** Skip Python kernel availability check and prelude warmup */
    skipPythonPreflight?: boolean;
    /** Tool names explicitly requested (enables disabled-by-default tools) */
    toolNames?: string[];
    /** Output schema for structured completion (subagents) */
    outputSchema?: unknown;
    /** Whether to include the yield tool by default */
    requireYieldTool?: boolean;
    /** Task recursion depth (for subagent sessions). Default: 0 */
    taskDepth?: number;
    /** Parent Hindsight state to alias for subagent memory tools. */
    parentHindsightSessionState?: HindsightSessionState;
    /** Pre-allocated agent identity for IRC routing. Default: "0-Main" for top-level, parentTaskPrefix-derived for sub. */
    agentId?: string;
    /** Display name for the agent in IRC. Default: "main" or "sub". */
    agentDisplayName?: string;
    /** Optional shared agent registry for IRC routing. Default: AgentRegistry.global(). */
    agentRegistry?: AgentRegistry;
    /** Parent task ID prefix for nested artifact naming (e.g., "6-Extensions") */
    parentTaskPrefix?: string;
    /** Session manager. Default: session stored under the configured agentDir sessions root */
    sessionManager?: SessionManager;
    /** Override local:// protocol options for subagent local:// sharing. Default: uses the session's own artifacts dir and session ID. */
    localProtocolOptions?: LocalProtocolOptions;
    /** Settings instance. Default: Settings.init({ cwd, agentDir }) */
    settings?: Settings;
    /** Whether UI is available (enables interactive tools like ask). Default: false */
    hasUI?: boolean;
    /**
     * Opt-in OpenTelemetry instrumentation forwarded to the underlying Agent.
     * Passing `{}` enables the loop's GenAI-semantic-convention spans. See
     * {@link AgentTelemetryConfig} for the full surface (hooks, content capture,
     * cost estimator, agent identity).
     *
     * Safe to enable without an OTEL SDK registered in the host: the
     * `@opentelemetry/api` package returns a no-op tracer in that case.
     */
    telemetry?: AgentTelemetryConfig;
}
/** Result from createAgentSession */
export interface CreateAgentSessionResult {
    /** The created session */
    session: AgentSession;
    /** Extensions result (loaded extensions + runtime) */
    extensionsResult: LoadExtensionsResult;
    /** Update tool UI context (interactive mode) */
    setToolUIContext: (uiContext: ExtensionUIContext, hasUI: boolean) => void;
    /** MCP manager for server lifecycle management (undefined if MCP disabled) */
    mcpManager?: MCPManager;
    /** Warning if session was restored with a different model than saved */
    modelFallbackMessage?: string;
    /** LSP servers detected for startup; warmup may continue in the background */
    lspServers?: LspStartupServerInfo[];
    /** Shared event bus for tool/extension communication */
    eventBus: EventBus;
}
export type { PromptTemplate } from "./config/prompt-templates";
export { Settings, type SkillsSettings } from "./config/settings";
export type { CustomCommand, CustomCommandFactory } from "./extensibility/custom-commands/types";
export type { CustomTool, CustomToolFactory } from "./extensibility/custom-tools/types";
export type * from "./extensibility/extensions";
export type { Skill } from "./extensibility/skills";
export type { FileSlashCommand } from "./extensibility/slash-commands";
export type { MCPManager, MCPServerConfig, MCPServerConnection, MCPToolsLoadResult } from "./mcp";
export type { Tool } from "./tools";
export { buildDirectoryTree, buildWorkspaceTree, type DirectoryTree, type WorkspaceTree } from "./workspace-tree";
export { BashTool, BUILTIN_TOOLS, createTools, EditTool, EvalTool, FindTool, HIDDEN_TOOLS, loadSshTool, ReadTool, ResolveTool, SearchTool, type ToolSession, WebSearchTool, WriteTool, };
/**
 * Create an AuthStorage instance.
 *
 * Default: local SQLite store at `<agentDir>/agent.db`.
 *
 * Broker mode: when `OMP_AUTH_BROKER_URL` is set, credentials are pulled from
 * a remote auth-broker over the wire. Refresh tokens never leave the broker;
 * the client receives access tokens with `refresh = "__remote__"` and calls
 * back into the broker through the {@link AuthStorageOptions.refreshOAuthCredential}
 * override to re-mint access tokens when needed.
 */
export declare function discoverAuthStorage(agentDir?: string): Promise<AuthStorage>;
/**
 * Discover extensions from cwd.
 */
export declare function discoverExtensions(cwd?: string): Promise<LoadExtensionsResult>;
/**
 * Discover skills from cwd and agentDir.
 */
export declare function discoverSkills(cwd?: string, _agentDir?: string, settings?: SkillsSettings): Promise<{
    skills: Skill[];
    warnings: SkillWarning[];
}>;
/**
 * Discover context files (AGENTS.md) walking up from cwd.
 * Returns files sorted by depth (farther from cwd first, so closer files appear last/more prominent).
 */
export declare function discoverContextFiles(cwd?: string, _agentDir?: string): Promise<Array<{
    path: string;
    content: string;
    depth?: number;
}>>;
/**
 * Discover prompt templates from cwd and agentDir.
 */
export declare function discoverPromptTemplates(cwd?: string, agentDir?: string): Promise<PromptTemplate[]>;
/**
 * Discover file-based slash commands from commands/ directories.
 */
export declare function discoverSlashCommands(cwd?: string): Promise<FileSlashCommand[]>;
/**
 * Discover custom commands (TypeScript slash commands) from cwd and agentDir.
 */
export declare function discoverCustomTSCommands(cwd?: string, agentDir?: string): Promise<CustomCommandsLoadResult>;
/**
 * Discover MCP servers from .mcp.json files.
 * Returns the manager and loaded tools.
 */
export declare function discoverMCPServers(cwd?: string): Promise<MCPToolsLoadResult>;
export interface BuildSystemPromptOptions {
    tools?: Tool[];
    skills?: Skill[];
    contextFiles?: Array<{
        path: string;
        content: string;
    }>;
    cwd?: string;
    appendPrompt?: string;
    repeatToolDescriptions?: boolean;
}
/**
 * Build the default provider-facing system prompt blocks.
 *
 * The returned `systemPrompt` preserves the stable harness prompt and dynamic project context
 * as separate entries so providers can cache prompt prefixes without concatenating blocks.
 */
export declare function buildSystemPrompt(options?: BuildSystemPromptOptions): Promise<BuildSystemPromptResult>;
/**
 * Create an AgentSession with the specified options.
 *
 * @example
 * ```typescript
 * // Minimal - uses defaults
 * const { session } = await createAgentSession();
 *
 * // With explicit model
 * import { getModel } from '@oh-my-pi/pi-ai';
 * const { session } = await createAgentSession({
 *   model: getModel('anthropic', 'claude-opus-4-5'),
 *   thinkingLevel: 'high',
 * });
 *
 * // Continue previous session
 * const { session, modelFallbackMessage } = await createAgentSession({
 *   continueSession: true,
 * });
 *
 * // Full control
 * const { session } = await createAgentSession({
 *   model: myModel,
 *   getApiKey: async () => Bun.env.MY_KEY,
 *   systemPrompt: ['You are helpful.'],
 *   tools: codingTools({ cwd: getProjectDir() }),
 *   skills: [],
 *   sessionManager: SessionManager.inMemory(),
 * });
 * ```
 */
export declare function createAgentSession(options?: CreateAgentSessionOptions): Promise<CreateAgentSessionResult>;