import { Cause, Effect, Layer, Schema } from "effect";
import { LanguageModel, Prompt, Tool } from "effect/unstable/ai";
import { type Agent, type Result, type RunError, type RunOptions, type RunResult, type RunRequirements } from "../agent/agent.js";
import { type AgentToolToolkit } from "../agent/agent-tool.js";
import { type ClosedToolSet } from "../tools/tool-executor.js";
import { type TurnPolicy } from "../turn/turn-policy.js";
import { HandoffCatalog, type HandoffTarget } from "./handoff-target.js";
import type { ContextProjection } from "./handoff-projection.js";
declare const defaultDelegateParameters: Schema.Struct<{
    readonly prompt: Schema.String;
}>;
type DefaultDelegateParameters = typeof defaultDelegateParameters;
declare const RegistrationError_base: Schema.Class<RegistrationError, Schema.TaggedStruct<"@batonfx/core/RegistrationError", {
    readonly agent: Schema.String;
    readonly message: Schema.String;
    readonly cause: Schema.Unknown;
}>, Cause.YieldableError>;
export declare class RegistrationError extends RegistrationError_base {
}
export interface Registration<Tools extends Record<string, Tool.Any> = Record<string, Tool.Any>, R = never> {
    readonly name: string;
    readonly run: <O extends RunOptions>(options: O) => Effect.Effect<RunResult<O>, RunError | RegistrationError, Exclude<Exclude<RunRequirements<Tools, R, O>, R>, import("effect/Scope").Scope>>;
    readonly requirements: (value: R) => R;
}
export declare const register: {
    <R, E>(layer: Layer.Layer<R, E, never>): <Tools extends Record<string, Tool.Any>>(agent: Agent<Tools, R>) => Registration<Tools, R>;
    <Tools extends Record<string, Tool.Any>, R, E>(agent: Agent<Tools, R>, layer: Layer.Layer<R, E, never>): Registration<Tools, R>;
};
export interface DelegateOptions<Parameters extends Schema.Top = DefaultDelegateParameters, Success extends Schema.Top = typeof Schema.String> {
    readonly nameOverride?: string;
    readonly description?: string;
    readonly parameters?: Parameters;
    readonly success?: Success;
    readonly toPrompt?: (params: Parameters["Type"]) => Prompt.RawInput;
    readonly fromResult?: (result: Result) => Success["Type"];
}
export interface HandoffToolOptions {
    readonly nameOverride?: string;
    readonly description?: string;
    readonly projection?: ContextProjection;
    readonly maxRepeatedEdge?: number;
}
export interface FanOutChild<Tools extends Record<string, Tool.Any> = Record<string, Tool.Any>, R = never> {
    readonly registration: Registration<Tools, R>;
    readonly prompt: Prompt.RawInput;
    readonly options?: Omit<RunOptions, "prompt" | "output" | "memory" | "persistence">;
}
export type FanOutJoin = {
    readonly _tag: "AllSuccess";
} | {
    readonly _tag: "AllSettled";
} | {
    readonly _tag: "FirstSuccess";
} | {
    readonly _tag: "Quorum";
    readonly required: number;
} | {
    readonly _tag: "BestEffort";
};
export type FanOutRemainder = "await" | "request-cancel" | "terminate";
interface FanOutBaseOptions {
    readonly concurrency?: number;
    readonly remainder?: FanOutRemainder;
}
export interface FanOutAllSuccessOptions extends FanOutBaseOptions {
    readonly join?: {
        readonly _tag: "AllSuccess";
    };
}
export interface FanOutCollectOptions extends FanOutBaseOptions {
    readonly join: {
        readonly _tag: "AllSettled";
    } | {
        readonly _tag: "FirstSuccess";
    } | {
        readonly _tag: "Quorum";
        readonly required: number;
    } | {
        readonly _tag: "BestEffort";
    };
}
export type FanOutOptions = FanOutAllSuccessOptions | FanOutCollectOptions;
export type FanOutMemberResult = {
    readonly ordinal: number;
    readonly status: "succeeded";
    readonly result: Result;
} | {
    readonly ordinal: number;
    readonly status: "failed";
    readonly cause: Cause.Cause<RunError | RegistrationError>;
} | {
    readonly ordinal: number;
    readonly status: "cancelled";
    readonly cause?: Cause.Cause<RunError | RegistrationError>;
};
declare const FanOutUnsatisfied_base: Schema.Class<FanOutUnsatisfied, Schema.TaggedStruct<"@batonfx/core/FanOutUnsatisfied", {
    readonly join: Schema.Literals<readonly ["FirstSuccess", "Quorum"]>;
    readonly required: Schema.Int;
    readonly succeeded: Schema.Int;
    readonly settled: Schema.Int;
    readonly total: Schema.Int;
}>, Cause.YieldableError>;
export declare class FanOutUnsatisfied extends FanOutUnsatisfied_base {
}
export interface Supervisor<R, Tools extends Record<string, Tool.Any> = Record<string, Tool.Any>> {
    readonly agent: Agent<Tools, R | LanguageModel.LanguageModel>;
    readonly toolkit: ClosedToolSet<never, Tools[keyof Tools]>;
    readonly catalog: Layer.Layer<HandoffCatalog>;
}
export interface SupervisorOptions {
    readonly name: string;
    readonly instructions?: string;
    readonly specialists: ReadonlyArray<HandoffTarget>;
    readonly policy?: TurnPolicy;
    readonly handoffOptions?: HandoffToolOptions;
}
type HandoffToolkit = {
    readonly name: string;
    readonly tool: import("../policy/handoff-runtime.js").HandoffToolSpecResult["tool"];
    readonly tools: Record<string, import("../policy/handoff-runtime.js").HandoffToolSpecResult["tool"]>;
    readonly invoke: (params: unknown) => Effect.Effect<unknown, string>;
};
export declare const delegateTool: {
    <Tools extends Record<string, Tool.Any> = Record<string, Tool.Any>, R = never, Parameters extends Schema.Top = DefaultDelegateParameters, Success extends Schema.Top = typeof Schema.String>(options?: DelegateOptions<Parameters, Success>): (target: Registration<Tools, R>) => AgentToolToolkit<string, Parameters, Success, RunRequirements<Tools, R, {
        prompt: Prompt.RawInput;
    }>>;
    <Tools extends Record<string, Tool.Any> = Record<string, Tool.Any>, R = never, Parameters extends Schema.Top = DefaultDelegateParameters, Success extends Schema.Top = typeof Schema.String>(target: Registration<Tools, R>, options?: DelegateOptions<Parameters, Success>): AgentToolToolkit<string, Parameters, Success, RunRequirements<Tools, R, {
        prompt: Prompt.RawInput;
    }>>;
};
export declare const sameRunHandoffTool: {
    (options?: HandoffToolOptions): (handoffTarget: HandoffTarget) => HandoffToolkit;
    (handoffTarget: HandoffTarget, options?: HandoffToolOptions): HandoffToolkit;
};
export declare const fanOut: {
    <Tools extends Record<string, Tool.Any> = Record<string, Tool.Any>, R = never>(options: FanOutCollectOptions): (children: ReadonlyArray<FanOutChild<Tools, R>>) => Effect.Effect<ReadonlyArray<FanOutMemberResult>, RunError | RegistrationError | FanOutUnsatisfied>;
    <Tools extends Record<string, Tool.Any> = Record<string, Tool.Any>, R = never>(options?: FanOutAllSuccessOptions): (children: ReadonlyArray<FanOutChild<Tools, R>>) => Effect.Effect<ReadonlyArray<Result>, RunError | RegistrationError>;
    <Tools extends Record<string, Tool.Any> = Record<string, Tool.Any>, R = never>(options: FanOutOptions): (children: ReadonlyArray<FanOutChild<Tools, R>>) => Effect.Effect<ReadonlyArray<Result> | ReadonlyArray<FanOutMemberResult>, RunError | RegistrationError | FanOutUnsatisfied>;
    <Tools extends Record<string, Tool.Any> = Record<string, Tool.Any>, R = never>(): (children: ReadonlyArray<FanOutChild<Tools, R>>) => Effect.Effect<ReadonlyArray<Result>, RunError | RegistrationError>;
    <Tools extends Record<string, Tool.Any> = Record<string, Tool.Any>, R = never>(children: ReadonlyArray<FanOutChild<Tools, R>>, options: FanOutCollectOptions): Effect.Effect<ReadonlyArray<FanOutMemberResult>, RunError | RegistrationError | FanOutUnsatisfied>;
    <Tools extends Record<string, Tool.Any> = Record<string, Tool.Any>, R = never>(children: ReadonlyArray<FanOutChild<Tools, R>>, options?: FanOutAllSuccessOptions): Effect.Effect<ReadonlyArray<Result>, RunError | RegistrationError>;
    <Tools extends Record<string, Tool.Any> = Record<string, Tool.Any>, R = never>(children: ReadonlyArray<FanOutChild<Tools, R>>, options: FanOutOptions): Effect.Effect<ReadonlyArray<Result> | ReadonlyArray<FanOutMemberResult>, RunError | RegistrationError | FanOutUnsatisfied>;
};
export declare const supervisor: (options: SupervisorOptions) => Supervisor<Tool.Handler<string> | LanguageModel.LanguageModel, Record<string, Tool.Tool<string, {
    readonly parameters: typeof import("./handoff-projection.js").HandoffInput;
    readonly success: typeof import("../agent/handoff-state.js").HandoffAccepted;
    readonly failure: typeof Schema.String;
    readonly failureMode: "return";
}, never>>>;
export { target, layerCatalog, HandoffCatalog, type HandoffTarget } from "./handoff-target.js";
export { HandoffInput, HandoffOutput, defaultContextProjection, filterContextProjection, HandoffProjectionInvalid, } from "./handoff-projection.js";
export { executeSameRunHandoff, HandoffRejected } from "./handoff-runtime.js";
export { HandoffCommit, HandoffControlState } from "../agent/handoff-state.js";