import { StateGraph } from "../graph.js";
import type { ONISkeletonV3 } from "../graph.js";
import { END } from "../types.js";
import type { ChannelSchema } from "../types.js";
import type { SwarmAgentDef, SupervisorConfig, AgentCapability } from "./types.js";
import { AgentRegistry } from "./registry.js";
import type { BaseSwarmState, HierarchicalConfig, FanOutConfig, PipelineConfig, PeerNetworkConfig, MapReduceConfig, DebateConfig, HierarchicalMeshConfig, SwarmCompileOpts, SwarmExtensions, CritiqueRefineConfig, StepwiseVerifyConfig, EnsembleVoteConfig, SpeculativeExecutionConfig, RedTeamConfig, SocraticElicitConfig, AutoResearchConfig, TreeOfThoughtConfig, AdversarialDevConfig } from "./config.js";
export declare class SwarmGraph<S extends BaseSwarmState> {
    /** @internal */ inner: StateGraph<S>;
    /** @internal */ registry: AgentRegistry<S>;
    /** @internal */ channels: ChannelSchema<S>;
    /** @internal */ agentIds: Set<string>;
    /** @internal */ supervisorNodeName: string;
    /** @internal */ hasSupervisor: boolean;
    /** @internal */ onErrorPolicy: "fallback" | "throw";
    private _broker?;
    private _pubsub?;
    private subGraphs;
    private get broker();
    private get pubsub();
    constructor(channels?: Partial<ChannelSchema<S>>);
    /**
     * Create a complete supervisor-workers swarm from a config object.
     * Registers all agents, wires a supervisor node, and returns the
     * ready-to-compile SwarmGraph.
     */
    static hierarchical<S extends BaseSwarmState>(config: HierarchicalConfig<S>): SwarmGraph<S>;
    /**
     * Create a fan-out swarm that runs all agents in parallel via Send
     * and collects results through a reducer node.
     */
    static fanOut<S extends BaseSwarmState>(config: FanOutConfig<S>): SwarmGraph<S>;
    /**
     * Create a linear agent pipeline: stage1 → stage2 → … → END.
     * Optionally override any stage's outgoing edge with a conditional
     * transition (e.g. loop back for review cycles).
     */
    static pipeline<S extends BaseSwarmState>(config: PipelineConfig<S>): SwarmGraph<S>;
    /**
     * Create a decentralized peer network: agents route to each other
     * via conditional handoffs, with no supervisor.
     */
    static peerNetwork<S extends BaseSwarmState>(config: PeerNetworkConfig<S>): SwarmGraph<S>;
    /**
     * Distribute N inputs across poolSize copies of a mapper agent,
     * fan-out via Send, and collect results through a reducer node.
     */
    static mapReduce<S extends BaseSwarmState>(config: MapReduceConfig<S>): SwarmGraph<S>;
    /**
     * Create a multi-round parallel debate with judge termination.
     * All debaters argue in parallel each round; a judge evaluates
     * and decides whether consensus has been reached.
     */
    static debate<S extends BaseSwarmState>(config: DebateConfig<S>): SwarmGraph<S>;
    /**
     * Create a hierarchical mesh with a coordinator routing to team
     * sub-graphs. Each team is built using pipeline() or peerNetwork()
     * and compiled into a single node in the outer graph.
     */
    static hierarchicalMesh<S extends BaseSwarmState>(config: HierarchicalMeshConfig<S>): SwarmGraph<S>;
    /**
     * Race all agents in parallel — first acceptable result wins.
     * Optionally filter results with an `accept` predicate.
     */
    static race<S extends BaseSwarmState>(config: {
        agents: SwarmAgentDef<S>[];
        accept?: (result: unknown) => boolean;
        timeoutMs?: number;
        channels?: Partial<ChannelSchema<S>>;
    }): SwarmGraph<S>;
    /**
     * Execute agents in dependency order (directed acyclic graph).
     * Agents with no dependencies run in parallel.
     */
    static dag<S extends BaseSwarmState>(config: {
        agents: SwarmAgentDef<S>[];
        dependencies: Record<string, string[]>;
        channels?: Partial<ChannelSchema<S>>;
    }): SwarmGraph<S>;
    /**
     * Distribute N input items across poolSize copies of a single agent,
     * then reduce all results.
     */
    static pool<S extends BaseSwarmState>(config: {
        agent: SwarmAgentDef<S>;
        poolSize: number;
        inputField: keyof S;
        reducer: (results: Record<string, unknown>) => Partial<S>;
        channels?: Partial<ChannelSchema<S>>;
    }): SwarmGraph<S>;
    /**
     * Compose multiple sub-swarms as pipeline stages.
     * Each stage runs a compiled sub-swarm, passing state through.
     */
    static compose<S extends BaseSwarmState>(config: {
        stages: Array<{
            id: string;
            swarm: SwarmGraph<S>;
        }>;
        channels?: Partial<ChannelSchema<S>>;
    }): SwarmGraph<S>;
    /**
     * Create a generator/critic refinement loop.
     * Generator produces output, critic evaluates it, loop continues
     * until approval (freeform) or all rubric dimensions pass (rubric).
     */
    static critiqueRefine<S extends BaseSwarmState>(config: CritiqueRefineConfig<S>): SwarmGraph<S>;
    /**
     * Create a sequential multi-stage pipeline where each stage's output
     * is verified before proceeding. Supports halt or skip failure modes
     * and per-stage retry with optional delay.
     */
    static stepwiseVerify<S extends BaseSwarmState>(config: StepwiseVerifyConfig<S>): SwarmGraph<S>;
    /**
     * Run all agents in parallel and aggregate results via vote (judge picks best),
     * synthesize (a synthesizer agent merges all outputs), or a custom aggregator function.
     */
    static ensembleVote<S extends BaseSwarmState>(config: EnsembleVoteConfig<S>): SwarmGraph<S>;
    /**
     * Race multiple strategy agents — first valid result wins, all others are cancelled.
     * Supports per-strategy and global timeouts, an async validator, and an onCancel callback.
     */
    static speculativeExecution<S extends BaseSwarmState>(config: SpeculativeExecutionConfig<S>): SwarmGraph<S>;
    /**
     * Create an adversarial security loop.
     * An attacker agent finds vulnerabilities, a builder agent patches them.
     * Repeats until the attacker finds nothing significant or maxRounds is exhausted.
     * Optionally filter low-severity findings with severityThreshold.
     */
    static redTeam<S extends BaseSwarmState>(config: RedTeamConfig<S>): SwarmGraph<S>;
    /**
     * Create a Socratic elicitation loop.
     * An interviewer asks questions to a respondent (agent or human interrupt),
     * tracking coverage across defined dimensions. When enough dimensions are
     * covered or maxQuestions is reached, a synthesizer produces a final output.
     */
    static socraticElicit<S extends BaseSwarmState>(config: SocraticElicitConfig<S>): SwarmGraph<S>;
    /**
     * Create a recursive research loop.
     * A decomposer breaks the question into sub-questions, a researcher
     * investigates each in parallel, and a synthesizer merges findings,
     * scores confidence, and identifies gaps. The loop recurses on gaps
     * until confidence >= threshold, no gaps remain, or maxDepth is hit.
     */
    static autoResearch<S extends BaseSwarmState>(config: AutoResearchConfig<S>): SwarmGraph<S>;
    /**
     * Create a branching Tree-of-Thought topology.
     * At each depth, surviving branches are expanded by branchFactor, scored,
     * and pruned via a dual strategy (topK cap + pruneThreshold floor).
     * The highest-scoring surviving branch is selected as the final answer.
     */
    static treeOfThought<S extends BaseSwarmState>(config: TreeOfThoughtConfig<S>): SwarmGraph<S>;
    /**
     * Create an adversarial development topology with sprint contracts and retry budget.
     * A planner produces sprint scope, generator and evaluator negotiate acceptance criteria,
     * then generator builds and evaluator scores (0–10). Retries up to maxRetriesPerSprint
     * before declaring the sprint failed. Repeats for maxSprints or until planner sets done.
     */
    static adversarialDev<S extends BaseSwarmState>(config: AdversarialDevConfig<S>): SwarmGraph<S>;
    addAgent(def: SwarmAgentDef<S>): this;
    addSupervisor(config: SupervisorConfig<S>, nodeName?: string): this;
    /**
     * Wire two agents to hand off directly to each other.
     * The "from" agent's node will inspect its output for a Handoff
     * and route accordingly.
     */
    addHandoffEdge(fromAgentId: string, toAgentId: string): this;
    /**
     * Add a conditional handoff: fromAgent routes to different agents
     * based on state.
     */
    addConditionalHandoff(fromAgentId: string, condition: (state: S) => string | typeof END): this;
    addEdge(from: string, to: string): this;
    /**
     * Check the swarm topology for common issues like orphan agents.
     * Returns an array of issue strings (empty = valid).
     */
    validateTopology(): string[];
    /**
     * Wire agents as a linear pipeline: A → B → C → END
     */
    pipeline(...agentIds: string[]): this;
    /**
     * Create a generator/evaluator loop (GAN-inspired).
     * Generator produces output → evaluator scores it → loop decides
     * refine, pivot, or accept. Returns a StateGraph that can be compiled.
     */
    static ganLoop<TState extends Record<string, unknown> = Record<string, unknown>>(config: GANLoopConfig<TState>): StateGraph<GANState<TState>>;
    /**
     * Dispose the swarm graph, cleaning up broker timeouts, pubsub
     * subscribers, and any tracked sub-graphs created by
     * hierarchicalMesh() or compose().
     */
    dispose(): void;
    compile(opts?: SwarmCompileOpts<S>): ONISkeletonV3<S> & SwarmExtensions<S>;
}
/**
 * Create a SwarmAgentDef from just an id and a handler function.
 * Builds a single-node StateGraph internally so the agent is fully
 * functional in any SwarmGraph topology.
 */
export declare function quickAgent(id: string, fn: (state: BaseSwarmState) => Promise<Partial<BaseSwarmState>> | Partial<BaseSwarmState>, opts?: {
    role?: string;
    capabilities?: AgentCapability[];
    hooks?: SwarmAgentDef["hooks"];
    maxRetries?: number;
    maxConcurrency?: number;
    systemPrompt?: string;
    timeout?: number;
    retryDelayMs?: number;
}): SwarmAgentDef<BaseSwarmState>;
export type { BaseSwarmState, SwarmCompileOpts, SwarmExtensions, PregelRunnerInternals } from "./config.js";
export { baseSwarmChannels } from "./config.js";
export type { HierarchicalConfig, FanOutConfig, PipelineConfig, PeerNetworkConfig, MapReduceConfig, DebateConfig, HierarchicalMeshConfig, CritiqueRefineConfig, EnsembleVoteConfig, EnsembleCustomAggregator, SpeculativeExecutionConfig, TreeOfThoughtConfig, AutoResearchConfig, AdversarialDevConfig, SocraticElicitConfig, RedTeamConfig, StepwiseVerifyConfig, StepwiseStage, } from "./config.js";
export interface AgentDefinition<TState> {
    /** Agent identifier, used as node name prefix */
    id: string;
    /** The agent's execution function */
    fn: (state: GANState<TState>) => Promise<Partial<GANState<TState>>> | Partial<GANState<TState>>;
}
export interface EvaluationCriterion {
    id: string;
    name: string;
    description: string;
    /** Weight 0-1, all weights must sum to 1.0 */
    weight: number;
    /** If set, failing this criterion fails the entire evaluation */
    hardThreshold?: number;
}
export interface CriterionScore {
    criterionId: string;
    score: number;
    rationale: string;
    passed: boolean;
}
export interface GANIterationResult<TState> {
    iteration: number;
    generatorOutput: TState;
    scores: CriterionScore[];
    compositeScore: number;
    decision: "refine" | "pivot" | "accept";
    evaluatorFeedback: string;
}
export interface GANLoopConfig<TState> {
    /** The agent that produces output */
    generator: AgentDefinition<TState>;
    /** The agent that evaluates and critiques output */
    evaluator: AgentDefinition<TState>;
    /** Scoring criteria passed to both agents */
    criteria: EvaluationCriterion[];
    /** Max iterations before forced termination. Default: 10 */
    maxIterations?: number;
    /** Composite score threshold for acceptance. Default: 0.80 */
    passingThreshold?: number;
    /** Called after each evaluation — return true to continue, false to stop */
    onIteration?: (iteration: number, scores: CriterionScore[], decision: "refine" | "pivot" | "accept") => Promise<boolean>;
    /** Score below this triggers a pivot (full approach change). Default: 0.40 */
    pivotThreshold?: number;
}
export type GANState<TState = Record<string, unknown>> = {
    iteration: number;
    decision: "refine" | "pivot" | "accept";
    done: boolean;
    generatorOutput: TState;
    scores: CriterionScore[];
    compositeScore: number;
    evaluatorFeedback: string;
    criteria: EvaluationCriterion[];
    bestIteration: GANIterationResult<TState> | null;
    bestCompositeScore: number;
    maxIterations: number;
    passingThreshold: number;
    pivotThreshold: number;
    [key: string]: unknown;
};
//# sourceMappingURL=graph.d.ts.map