import { Session, Agent, Tool } from '@openai/agents';

interface Message {
    id: number;
    version: number;
    type: 'prompt' | 'user' | 'agent' | 'tool' | 'interrupted';
    handled?: boolean;
    text: string;
    args?: string;
    callId?: string;
}

type PlanItemStatus = 'todo' | 'in-progress' | 'done' | 'not-needed';
interface PlanItemPersisted {
    id: number;
    text: string;
    status: PlanItemStatus;
}
interface PlanState {
    planDescription: string;
    planItems: PlanItemPersisted[];
    progress?: number;
}
interface WithPlanState {
    /**
     * Returns the persisted plan state for the current session, or null if none exists.
     */
    getPlanState(): Promise<PlanState>;
    /**
     * Merges and persists a partial plan state for the current session.
     */
    setPlanState(state: Partial<PlanState>): Promise<void> | void;
}

type WithRunCompaction = {
    runCompaction: (args?: any) => Promise<any>;
};

interface WithSkillsRead {
    addSkillRead(skill: string): Promise<void> | void;
    getSkillsRead(): Promise<string[]>;
}

interface WithLatestAddedTimestamp {
    getLatestAddedTimestamp(): Promise<number | null>;
}
type CombinedSession = Session & WithRunCompaction & WithSkillsRead & WithPlanState & WithLatestAddedTimestamp;

declare class AgentManager {
    private isInitialized;
    private controller;
    private queuedUserInputs;
    private resumeState;
    agent: Agent | null;
    session: CombinedSession | null;
    initialMessages: Message[];
    static instantiateAgent(tools: Tool[], instructions?: string): Agent<unknown, "text">;
    initialize(agent?: Agent, session?: CombinedSession): Promise<void>;
    enqueueUserInput(text: string): void;
    runTask(task: string, isPrompt?: boolean): Promise<void>;
    private runCompactionIfWeWereIdle;
    interrupt(): void;
}

export { AgentManager };