import { Effect, Layer, Schema } from "effect";
import { LanguageModel, Prompt, Response } from "effect/unstable/ai";
/** @experimental Snapshot given to a policy before each follow-up turn. */
export interface TurnInfo {
    readonly turn: number;
    readonly history: Prompt.Prompt;
    readonly pendingToolResults: ReadonlyArray<Response.ToolResultPart<string, unknown, unknown>>;
}
/** @experimental Per-turn overrides applied when a policy continues. */
export interface TurnOverrides {
    readonly instructions?: string;
    readonly model?: Layer.Layer<LanguageModel.LanguageModel>;
    readonly activeTools?: ReadonlyArray<string>;
}
/** @experimental */
export interface Continue {
    readonly _tag: "Continue";
    readonly overrides?: TurnOverrides;
}
/** @experimental */
export interface Stop {
    readonly _tag: "Stop";
    readonly reason: StopReason;
}
/** @experimental */
export type Decision = Continue | Stop;
/** @experimental A configured follow-up turn cap was exhausted. */
export interface TurnLimit {
    readonly _tag: "TurnLimit";
    readonly limit: number;
}
/** @experimental The policy determined that the run's goal is satisfied. */
export interface GoalSatisfied {
    readonly _tag: "GoalSatisfied";
}
/** @experimental A named policy budget was exhausted. */
export interface BudgetExhausted {
    readonly _tag: "BudgetExhausted";
    readonly budget: string;
}
/** @experimental A custom policy stopped for a host-defined detail. */
export interface Policy {
    readonly _tag: "Policy";
    readonly detail: string;
}
/** @experimental Schema-backed reason for a successful policy stop. */
export declare const StopReason: Schema.Union<readonly [Schema.Struct<{
    readonly _tag: Schema.tag<"TurnLimit">;
    readonly limit: Schema.Finite;
}>, Schema.Struct<{
    readonly _tag: Schema.tag<"GoalSatisfied">;
}>, Schema.Struct<{
    readonly _tag: Schema.tag<"BudgetExhausted">;
    readonly budget: Schema.String;
}>, Schema.Struct<{
    readonly _tag: Schema.tag<"Policy">;
    readonly detail: Schema.String;
}>]>;
/** @experimental Schema-backed reason for a successful policy stop. */
export type StopReason = typeof StopReason.Type;
declare const TurnPolicyError_base: Schema.Class<TurnPolicyError, Schema.TaggedStruct<"@batonfx/core/TurnPolicyError", {
    readonly message: Schema.String;
    readonly cause: Schema.optionalKey<Schema.Defect>;
}>, import("effect/Cause").YieldableError>;
/** @experimental A turn policy could not evaluate its decision. */
export declare class TurnPolicyError extends TurnPolicyError_base {
}
/** @experimental A turn policy in the spirit of `Schedule`. */
export interface TurnPolicy<R = never> {
    readonly decide: (info: TurnInfo) => Effect.Effect<Decision, TurnPolicyError, R>;
    readonly snapshot?: Snapshot;
}
/** @experimental Portable constructor data for unbounded continuation. */
export interface ForeverSnapshot {
    readonly _tag: "Forever";
}
/** @experimental Portable constructor data for a recursive follow-up cap. */
export interface RecursSnapshot {
    readonly _tag: "Recurs";
    readonly count: number;
}
/** @experimental Portable constructor data for a named-tool stop policy. */
export interface UntilToolCallSnapshot {
    readonly _tag: "UntilToolCall";
    readonly name: string;
}
/** @experimental Portable constructor data for two composed portable policies. */
export interface BothSnapshot {
    readonly _tag: "Both";
    readonly first: Snapshot;
    readonly second: Snapshot;
}
/** @experimental Portable constructor data exposed by built-in turn policies. */
export type Snapshot = ForeverSnapshot | RecursSnapshot | UntilToolCallSnapshot | BothSnapshot;
/** @experimental */
export declare const decision: {
    readonly continue: (overrides?: TurnOverrides) => Continue;
    readonly stop: (reason: StopReason) => Stop;
};
/** @experimental Construct a policy from a decide function. */
export declare const make: <R = never>(decide: (info: TurnInfo) => Effect.Effect<Decision, TurnPolicyError, R>) => TurnPolicy<R>;
/** @experimental Continue after every turn; a run still completes naturally without pending tool results. */
export declare const forever: TurnPolicy;
/** @experimental Continue for at most `n` follow-up turns after the first. */
export declare const recurs: (n: number) => TurnPolicy;
/** @experimental Continue while a named tool has not yet been called this run. */
export declare const untilToolCall: (name: string) => TurnPolicy;
/** @experimental Both must continue; overrides merge with `second` winning. */
export declare const both: {
    <R2>(second: TurnPolicy<R2>): <R1>(first: TurnPolicy<R1>) => TurnPolicy<R1 | R2>;
    <R1, R2>(first: TurnPolicy<R1>, second: TurnPolicy<R2>): TurnPolicy<R1 | R2>;
};
/** @experimental Default policy: `forever` — no framework-imposed follow-up cap. */
export declare const defaultPolicy: TurnPolicy;
export {};