import { type Duration, Effect, Schema, Stream, Types } from "effect";
import { AiError, Chat, LanguageModel, Prompt, Tool, Toolkit } from "effect/unstable/ai";
import { AgentError, AgentSuspended, DuplicateToolCallId, type Event, MiddlewareViolation, ProgressOverflow, ResumeMismatch, RunEndedWithoutOutput, ToolNameCollision, type ToolOrigin, TurnLimitExceeded, TurnPolicyStopped } from "./agent-event.js";
import type { DeliveryFailed, InvocationCoordinationFailed } from "../model/model-telemetry.js";
import type { BudgetLimits, RunBudget } from "../durable/run-budget.js";
import type { DriverCheckpoint } from "../durable/driver-contract.js";
import { RunBudgetExhausted } from "../durable/run-budget.js";
import type { DriverError, DriverStateInvalid } from "../durable/durable-driver.js";
import type { DriverUnknownReplay } from "../durable/driver-interpreter.js";
import type { ModelResilienceMisconfigured } from "../model/model-resilience.js";
import type { InvalidToolCallParameters, ToolJsonSchemaCompilerMissing } from "../model/model-tool-call-validation.js";
import { type Key, Memory } from "../context/memory.js";
import { type LanguageModelNotRegistered, type ModelSelection, ModelRegistry } from "../model/model-registry.js";
import type { ToolAuthorizer } from "../tools/tool-authorization.js";
import { ToolContext } from "../tools/tool-context.js";
import { FrameworkFailure } from "../tools/tool-executor.js";
import { HandoffLimitExceeded, HandoffRequirementsMissing, HandoffTargetMissing } from "./handoff-state.js";
import { HandoffProjectionInvalid } from "../policy/handoff-projection.js";
import { HandoffRejected } from "../policy/handoff-runtime.js";
import { type TurnPolicy, TurnPolicyError } from "../turn/turn-policy.js";
import { Runtime } from "./agent-persistence-lock.js";
export { Runtime, layerRuntime } from "./agent-persistence-lock.js";
export { close, withTools, type Any, type Closed, type ClosedServices, type Opened } from "./agent-closure.js";
export declare const AgentTypeId: unique symbol;
/** @experimental An agent definition: a plain value, not a service. */
export interface HandoffAgent<R> {
    readonly name: string;
    readonly description?: string;
    readonly requirements: (value: R) => R;
}
export interface Agent<Tools extends Record<string, Tool.Any> = {}, R = LanguageModel.LanguageModel, PolicyServices = R, AuthorizationServices = R> {
    readonly handoff: <A>(f: (agent: HandoffAgent<R>) => A) => A;
    readonly [AgentTypeId]: {
        readonly tools: Types.Invariant<Tools>;
        readonly requirements: Types.Invariant<R>;
    };
    readonly name: string;
    readonly instructions?: string;
    readonly supplemental?: string;
    readonly toolkit: Toolkit.Toolkit<Tools>;
    readonly policy: TurnPolicy<PolicyServices>;
    readonly model?: ModelSelection;
    readonly memory?: Key;
    readonly authorization?: ToolAuthorizer<AuthorizationServices>;
    readonly toolScheduling: ToolSchedulingPolicy;
    readonly metadata?: Readonly<Record<string, unknown>>;
    readonly budget?: BudgetLimits;
    readonly toolDeclarations?: ReadonlyArray<ToolDeclaration>;
}
/**
 * @experimental Safe scheduling policy for framework-executed calls emitted by one model turn. Tools not explicitly
 * listed as parallel-safe execute as authored-order exclusive barriers.
 */
export interface ToolSchedulingPolicy {
    readonly maxConcurrency: number;
    readonly parallelSafe: ReadonlyArray<string>;
}
/** @experimental One origin-preserving static or Handoff tool declaration. */
export interface ToolDeclaration {
    readonly tool: Tool.Any;
    readonly origin: Extract<ToolOrigin, {
        readonly _tag: "Static" | "Handoff";
    }>;
}
/** @experimental Extract an agent's runtime requirements. */
export type Requirements<A> = A extends Agent<infer _Tools, infer R> ? R : never;
/** @experimental */
export interface WithModelDefault {
    readonly model: ModelSelection;
}
/** @experimental */
export interface MakeOptions<Tools extends Record<string, Tool.Any> = {}, PolicyServices = never, AuthorizationServices = never> {
    readonly name: string;
    readonly instructions?: string;
    readonly supplemental?: string;
    readonly toolkit?: Toolkit.Toolkit<Tools>;
    readonly tools?: never;
    readonly policy?: TurnPolicy<PolicyServices>;
    readonly model?: ModelSelection;
    readonly memory?: Key;
    readonly authorization?: ToolAuthorizer<AuthorizationServices>;
    readonly toolScheduling?: ToolSchedulingPolicy;
    readonly metadata?: Readonly<Record<string, unknown>>;
    readonly budget?: BudgetLimits;
}
/** @experimental Agent options with ordered static declarations instead of a pre-built toolkit. */
export interface MakeToolsOptions<StaticTools extends ReadonlyArray<Tool.Any>, PolicyServices = never, AuthorizationServices = never> extends Omit<MakeOptions<{}, PolicyServices, AuthorizationServices>, "toolkit" | "tools"> {
    readonly tools: StaticTools;
    readonly toolkit?: never;
}
type OptionValue<O, K extends PropertyKey> = K extends keyof O ? O[K] : never;
type PresentOption<O, K extends PropertyKey> = O extends unknown ? Exclude<OptionValue<O, K>, undefined> : never;
type ModelRequirement<O> = [Exclude<OptionValue<O, "model">, undefined>] extends [never] ? LanguageModel.LanguageModel : undefined extends OptionValue<O, "model"> ? LanguageModel.LanguageModel | ModelRegistry : ModelRegistry;
type MemoryRequirement<O> = [Exclude<OptionValue<O, "memory">, undefined>] extends [never] ? never : Memory;
type PolicyRequirement<O> = O extends {
    readonly policy: TurnPolicy<infer R>;
} ? R : never;
type AuthorizationRequirement<O> = O extends {
    readonly authorization: ToolAuthorizer<infer R>;
} ? R : never;
type StaticToolServices<Tools extends Record<string, Tool.Any>> = Tool.HandlersFor<Tools> | Exclude<Tool.HandlerServices<Tools[keyof Tools]>, ToolContext>;
type OptionRequirements<Tools extends Record<string, Tool.Any>, O> = StaticToolServices<Tools> | ModelRequirement<O> | MemoryRequirement<O> | PolicyRequirement<O> | AuthorizationRequirement<O>;
/** @experimental Defaults: empty toolkit, `defaultPolicy`. */
export declare function make<const StaticTools extends ReadonlyArray<Tool.Any>, const O extends MakeToolsOptions<StaticTools, unknown, unknown> = MakeToolsOptions<StaticTools>>(options: MakeToolsOptions<StaticTools, unknown, unknown> & O): Agent<Toolkit.ToolsByName<StaticTools>, OptionRequirements<Toolkit.ToolsByName<StaticTools>, O>>;
export declare function make<Tools extends Record<string, Tool.Any> = {}, const O extends MakeOptions<Tools, unknown, unknown> = MakeOptions<Tools>>(options: MakeOptions<Tools, unknown, unknown> & O): Agent<Tools, OptionRequirements<Tools, O>>;
/** @experimental Re-entry bound to an authoritative `AgentSuspended` checkpoint. */
export declare const ResumeResolution: Schema.Union<readonly [Schema.TaggedStruct<"Approved", {}>, Schema.TaggedStruct<"Denied", {
    readonly reason: Schema.optionalKey<Schema.String>;
}>, Schema.TaggedStruct<"ToolResult", {
    readonly result: Schema.Unknown;
    readonly encodedResult: Schema.Unknown;
}>, Schema.TaggedStruct<"Signal", {
    readonly name: Schema.String;
    readonly payload: Schema.optionalKey<Schema.Unknown>;
}>]>;
export type ResumeResolution = typeof ResumeResolution.Type;
export interface Resume {
    readonly suspension: AgentSuspended;
    readonly resolution?: ResumeResolution;
}
/** @experimental Bounded buffering behavior for tool progress events. */
export type ProgressOverflowPolicy = {
    readonly _tag: "Backpressure";
    readonly capacity: number;
} | {
    readonly _tag: "Dropping";
    readonly capacity: number;
} | {
    readonly _tag: "Sliding";
    readonly capacity: number;
} | {
    readonly _tag: "Fail";
    readonly capacity: number;
};
/** @experimental Options for an agent run. Set `output` for structured output; set `persistence` for persisted chat. */
export interface RunOptions {
    /** User input for the first turn. Ignored when `resume` is set. */
    readonly prompt: Prompt.RawInput;
    /**
     * Prior transcript. When set it is used VERBATIM as the initial chat
     * history (no system message is prepended); otherwise the chat starts
     * with a system message derived from the agent (see below).
     */
    readonly history?: Prompt.RawInput;
    /** Overrides the derived system message when `history` is not set. */
    readonly system?: string;
    readonly resume?: Resume;
    /** @experimental Opaque host-assigned identity for this run/session. */
    readonly sessionId?: string;
    /** @experimental Stable host identity for the logical model operations in this run. */
    readonly logicalOperationId?: string;
    /** @experimental Authoritative invocation facts supplied by a durable host. */
    readonly invocation?: {
        readonly runId: string;
        readonly rootRunId: string;
        readonly attempt: number;
        readonly admittedAt?: string;
    };
    /** @experimental First model-call ordinal for a host resuming from a durable checkpoint. */
    readonly modelCallOrdinalStart?: number;
    /** @experimental First turn number for a host continuing an existing transcript. */
    readonly turnStart?: number;
    /** @experimental Runtime-owned checkpoint used to reconstruct the same durable driver. */
    readonly driverCheckpoint?: DriverCheckpoint;
    /** @experimental Pinned identity admitted by a durable host. */
    readonly executableRef?: import("../durable/executable-manifest.js").ExecutableRef;
    /** @experimental Complete pinned closure used to resolve same-run handoffs exactly. */
    readonly executableManifest?: import("../durable/executable-manifest.js").ExecutableManifest;
    /** @experimental Opaque host-assigned write-ownership token, forwarded on every Session append and checkpoint so durable hosts can fence stale writers. */
    readonly sessionOwnerToken?: string;
    readonly toolOutputMaxBytes?: number;
    /** @experimental Per-tool bounded buffering policy for progress events. Defaults to backpressure at capacity 64. */
    readonly toolProgress?: ProgressOverflowPolicy;
    /** @experimental Context-window hint for optional compaction. */
    readonly compaction?: {
        readonly contextWindow?: number;
        readonly reserveTokens?: number;
    };
    /** @experimental Per-run budget narrowing; dimensions omitted inherit the agent default. */
    readonly budget?: BudgetLimits;
    /** @experimental Pre-reserved child grant from a parent run; not for direct caller use. */
    readonly inheritedBudget?: RunBudget;
    readonly suspensionPropagation?: "propagate" | "collapse-to-domain-failure";
    /** @experimental Consult the Memory service for this run. */
    readonly memory?: {
        readonly key: Key;
    };
    readonly persistence?: {
        readonly chatId: string;
        readonly timeToLive?: Duration.Input;
    };
    readonly output?: {
        readonly schema: ObjectSchema;
        readonly name?: string;
        readonly prompt?: Prompt.RawInput;
    };
}
type OperationRequirements<O> = [PresentOption<O, "memory">] extends [never] ? never : Memory;
type ObjectSchema = Schema.Codec<unknown, Record<string, unknown>, any, any>;
/** @experimental Default prompt for the terminal structured-output turn. */
export declare const defaultObjectPrompt = "Return the final structured output for the task above.";
/** @experimental The error channel of `stream` and `generate`. */
export type RunError = DeliveryFailed | InvocationCoordinationFailed | AgentError | AgentSuspended | ResumeMismatch | TurnPolicyError | TurnPolicyStopped | TurnLimitExceeded | RunEndedWithoutOutput | MiddlewareViolation | ModelResilienceMisconfigured | InvalidToolCallParameters | ToolJsonSchemaCompilerMissing | DuplicateToolCallId | ProgressOverflow | ToolNameCollision | AiError.AiError | LanguageModelNotRegistered | FrameworkFailure | DriverError | DriverStateInvalid | DriverUnknownReplay | RunBudgetExhausted | HandoffTargetMissing | HandoffLimitExceeded | HandoffRequirementsMissing | HandoffProjectionInvalid | HandoffRejected;
/** @experimental Result of a non-streaming run. */
export interface Result {
    readonly text: string;
    readonly turns: number;
    readonly transcript: Prompt.Prompt;
}
/** @experimental Result of a non-streaming structured-output run. */
export interface ObjectResult<A> extends Result {
    readonly value: A;
}
type SchemaFromOutput<Output> = Output extends {
    readonly schema: infer S extends ObjectSchema;
} ? S : never;
type SchemaOf<O> = SchemaFromOutput<PresentOption<O, "output">>;
type PersistenceRequirement<O> = [PresentOption<O, "persistence">] extends [never] ? never : Chat.Persistence | Runtime;
type SchemaServicesD<S extends ObjectSchema> = [unknown] extends [S["DecodingServices"]] ? never : S["DecodingServices"];
type OutputRequirement<O> = [SchemaOf<O>] extends [never] ? never : SchemaServicesD<SchemaOf<O>>;
/** @experimental Services required by one run option set. */
export type RunRequirements<Tools extends Record<string, Tool.Any>, R, O> = R | StaticToolServices<Tools> | OperationRequirements<O> | PersistenceRequirement<O> | OutputRequirement<O>;
/** @experimental Result selected by one run option set. */
export type RunResult<O> = O extends unknown ? O extends {
    readonly output: {
        readonly schema: infer S extends ObjectSchema;
    };
} ? ObjectResult<S["Type"]> : [SchemaOf<O>] extends [never] ? Result : Result | ObjectResult<SchemaOf<O>["Type"]> : never;
/** @experimental Stream an agent run as Events. Set options.output for structured output; set options.persistence for persisted chat. */
export declare const stream: {
    <O extends RunOptions>(options: O): <Tools extends Record<string, Tool.Any>, R>(agent: Agent<Tools, R>) => Stream.Stream<Event, RunError, RunRequirements<Tools, R, O>>;
    <Tools extends Record<string, Tool.Any>, R, O extends RunOptions>(agent: Agent<Tools, R>, options: O): Stream.Stream<Event, RunError, RunRequirements<Tools, R, O>>;
};
/** @experimental Run an agent to completion. Returns ObjectResult when options.output is set, otherwise Result. */
export declare const generate: {
    <O extends RunOptions>(options: O): <Tools extends Record<string, Tool.Any>, R>(agent: Agent<Tools, R>) => Effect.Effect<RunResult<O>, RunError, RunRequirements<Tools, R, O>>;
    <Tools extends Record<string, Tool.Any>, R, O extends RunOptions>(agent: Agent<Tools, R>, options: O): Effect.Effect<RunResult<O>, RunError, RunRequirements<Tools, R, O>>;
};