import type { Context as RuntimeContext } from "@steve.kite/stdlib";
import type { AgentContext } from "./context/AgentContext.js";
import { type AgentLoopEvent, type AgentLoopResult } from "./loop.js";
import { type DebugLog } from "../debug/index.js";
import { type AgentConsole } from "./impl/printAgentMessageToConsole.js";
import type { AnyDefinedTool, ContentBlock, Message, SteeringMessage, SystemMessage, UserMessage } from "./types.js";
import type { Model, Provider, ServiceTier } from "@slopus/rig-execution";
import type { PermissionMode, PermissionReviewAgent } from "../permissions/index.js";
import type { DurableSkillDefinition } from "../external-skills/types.js";
export type AgentStatus = "idle" | "running" | "aborted";
export interface QueuedAgentMessage {
    id: string;
    message: Message;
}
export type AgentToolSelector = (options: {
    model: Model;
    provider: Provider;
}) => readonly AnyDefinedTool[];
export interface AgentSnapshot {
    appendSystemPrompt?: string;
    id: string;
    providerId: string;
    modelId: string;
    effort?: string;
    serviceTier?: ServiceTier;
    status: AgentStatus;
    instructions?: string;
    messages: readonly Message[];
    /** Compacted model-facing history. Omitted while it matches the visible transcript. */
    contextMessages?: readonly Message[];
    queue: readonly QueuedAgentMessage[];
    tools: readonly string[];
    lastRunId?: string;
    systemPrompt?: string;
}
export interface AgentOptions {
    /** Allows this dedicated side agent to use the provider's hidden permission-review model. */
    allowReviewerModel?: boolean;
    appendSystemPrompt?: string;
    provider: Provider;
    /** Creates the sister agent that reviews Auto permission decisions, on first use. */
    createPermissionReviewAgent?: () => PermissionReviewAgent;
    /**
     * Delivers the project's AGENTS.md instructions to the model. The permission reviewer turns
     * this off, because repository content must never instruct the agent judging an action.
     */
    projectInstructions?: "include" | "exclude";
    /**
     * Reads the user's global AGENTS.md. It is consulted before every turn, so instructions the
     * user changes mid-session reach the model without restarting anything.
     */
    readGlobalInstructions?: () => Promise<string | undefined>;
    modelId: string;
    context: AgentContext;
    id?: string;
    effort?: string;
    serviceTier?: ServiceTier;
    startDate?: string;
    messages?: readonly Message[];
    contextMessages?: readonly Message[];
    instructions?: string;
    systemPrompt?: string;
    /** Stable owning session identity used by plugin lifecycle tracing. */
    traceSessionId?: string;
    /** Omit for a tool-free agent; product runtimes compose provider tools explicitly. */
    tools?: readonly AnyDefinedTool[];
    durableSkills?: readonly DurableSkillDefinition[];
    /** Selects default tools without coupling the generic agent to provider tool registries. */
    toolSelector?: AgentToolSelector;
    idFactory?: () => string;
    now?: () => number;
    console?: AgentConsole;
    printToConsole?: boolean;
    onEvent?: (event: AgentLoopEvent) => void | Promise<void>;
    onMessage?: (message: Message) => void | Promise<void>;
}
export interface AgentRunOptions {
    /** Refreshes an explicitly supplied tool array before each inference iteration. */
    beforeInference?: () => Promise<void>;
    clientSubmissionId?: string;
    debug?: DebugLog;
    displayText?: string;
    signal?: AbortSignal;
    onEvent?: (event: AgentLoopEvent) => void | Promise<void>;
    onMessage?: (message: Message) => void | Promise<void>;
}
export type AgentRunResult = AgentLoopResult & {
    debugDirectory?: string;
    runId: string;
};
export interface AgentCompactionResult {
    compacted: boolean;
    compactedMessageCount: number;
    estimatedTokensAfter: number;
    estimatedTokensBefore: number;
    retainedMessageCount: number;
}
export declare class Agent {
    #private;
    readonly id: string;
    readonly provider: Provider;
    readonly context: AgentContext;
    constructor(options: AgentOptions);
    get status(): AgentStatus;
    get model(): Model;
    get messages(): readonly Message[];
    get queue(): readonly QueuedAgentMessage[];
    get tools(): readonly AnyDefinedTool[];
    get permissionMode(): PermissionMode;
    get canChangeModel(): boolean;
    get confirmedServiceTier(): ServiceTier | undefined;
    setInstructions(instructions: string | undefined): void;
    setAppendSystemPrompt(appendSystemPrompt: string | undefined): void;
    setSystemPrompt(systemPrompt: string | undefined): void;
    setEffort(effort: string | undefined): void;
    setServiceTier(serviceTier: ServiceTier | undefined): void;
    setModel(modelId: string, effort: string | undefined): void;
    setTools(tools: readonly AnyDefinedTool[]): void;
    setDurableSkills(skills: readonly DurableSkillDefinition[]): void;
    setPermissionMode(mode: PermissionMode): Promise<void>;
    reset(): Promise<void>;
    close(): Promise<void>;
    addSteering(text: string): SystemMessage;
    enqueueSystemMessage(text: string): SystemMessage;
    enqueueUserMessage(text: string | readonly ContentBlock[]): UserMessage;
    enqueueMessage(message: Message): QueuedAgentMessage;
    /**
     * Adds a durable message after a run failed outside the normal loop result.
     *
     * This is only valid once the run has unwound; mutating the transcript held
     * by an active loop would create two competing context owners.
     */
    recordMessage(message: Message): void;
    /**
     * Replaces only the model-facing conversation while preserving durable visible history.
     *
     * The next provider run receives the complete replacement and naturally rebuilds any cached
     * prefix that no longer matches. An active loop owns its context, so replacing it mid-run
     * would create two competing histories and is rejected.
     */
    replaceContextMessages(messages: readonly Message[]): void;
    send(ctx: RuntimeContext, text: string | readonly ContentBlock[], options?: AgentRunOptions): Promise<AgentRunResult>;
    steer(content: string | readonly ContentBlock[]): Promise<void>;
    steerMessage(message: SteeringMessage): void;
    compact(ctx: RuntimeContext, signal?: AbortSignal, onEvent?: AgentRunOptions["onEvent"], onMessage?: AgentRunOptions["onMessage"]): Promise<AgentCompactionResult>;
    run(ctx: RuntimeContext, options?: AgentRunOptions): Promise<AgentRunResult>;
    snapshot(): AgentSnapshot;
}