import { Effect, Schema } from "effect";
import type { Prompt } from "effect/unstable/ai";
import type { AgentPin, CapabilityPin } from "../durable/pin.js";
import type { AgentRunResult, ProgramAuthorizationFailure, ProgramCapabilityDenied, ProgramOperationName } from "./program-capabilities.js";
import { ProgramCancelled, ProgramInvocationFailure, ProgramSuspended } from "./program-capabilities.js";
/** @experimental Replay behavior selected by the host, never by program source. */
export declare const ProgramReplayPolicy: Schema.Literals<readonly ["recorded", "idempotent", "non-idempotent"]>;
/** @experimental */
export type ProgramReplayPolicy = typeof ProgramReplayPolicy.Type;
/** @experimental Host-owned authorization callback for one decoded invocation. */
export type Authorize<I> = (request: {
    readonly operation: ProgramOperationName;
    readonly input: I;
}) => Effect.Effect<boolean, ProgramAuthorizationFailure | ProgramCapabilityDenied | ProgramSuspended>;
/** @experimental One live typed tool implementation and its exact identity. */
export interface ToolBinding<I, IE, O, OE, E = never> {
    readonly name: string;
    readonly pin: CapabilityPin;
    readonly input: Schema.Codec<I, IE>;
    readonly output: Schema.Codec<O, OE>;
    readonly replay: ProgramReplayPolicy;
    readonly authorize: Authorize<I>;
    readonly execute: (input: I) => Effect.Effect<O, E>;
}
/** @experimental One live typed named step implementation and its exact identity. */
export interface StepBinding<I, IE, O, OE, E = never> extends Omit<ToolBinding<I, IE, O, OE, E>, "name"> {
    readonly name: string;
}
/** @experimental One exact Agent implementation callable by a program host. */
export interface AgentBinding<I extends Prompt.RawInput, IE, E = never> {
    readonly selection: string;
    readonly agent: AgentPin;
    readonly inputPin: CapabilityPin;
    readonly input: Schema.Codec<I, IE>;
    readonly replay: ProgramReplayPolicy;
    readonly authorize: Authorize<I>;
    readonly execute: (input: I) => Effect.Effect<AgentRunResult, ProgramSuspended | E>;
}
/**
 * @experimental One decoded invocation of a bound tool or step. The decoded input stays inside the binding, so
 * authorization and execution keep the exact type the binding declared.
 */
export interface Invocation<O = unknown, E = ProgramInvocationFailure | ProgramSuspended | ProgramCancelled> {
    readonly authorize: (operation: ProgramOperationName) => Effect.Effect<boolean, ProgramAuthorizationFailure | ProgramCapabilityDenied | ProgramSuspended>;
    readonly execute: Effect.Effect<O, E>;
}
/** @experimental One decoded Agent invocation, exposing only the prompt every Agent input must produce. */
export interface AgentInvocation {
    readonly prompt: Prompt.RawInput;
    readonly authorize: (operation: ProgramOperationName) => Effect.Effect<boolean, ProgramAuthorizationFailure | ProgramCapabilityDenied | ProgramSuspended>;
    readonly execute: Effect.Effect<AgentRunResult, ProgramInvocationFailure | ProgramSuspended | ProgramCancelled>;
}
/**
 * @experimental Host-facing view of one bound tool in a heterogeneous binding set. Its identity, replay policy, and
 * boundary codecs stay observable; its decoded input type is reachable only through {@link Invocation}.
 */
export interface AnyTool {
    readonly name: string;
    readonly pin: CapabilityPin;
    readonly input: Schema.Codec<unknown, unknown>;
    readonly output: Schema.Codec<unknown, unknown>;
    readonly replay: ProgramReplayPolicy;
    readonly decode: (encoded: unknown) => Effect.Effect<Invocation, Schema.SchemaError>;
}
/** @experimental Host-facing view of one bound named step, with the same hidden input as {@link AnyTool}. */
export interface AnyStep extends AnyTool {
}
/** @experimental A bound tool retaining its exact decoded invocation types. */
export type TypedTool = AnyTool & {
    readonly decode: (encoded: unknown) => Effect.Effect<Invocation, Schema.SchemaError>;
};
/** @experimental A bound step retaining its exact decoded invocation types. */
export type TypedStep = TypedTool;
/** @experimental Host-facing view of one bound Agent, with its decoded input hidden behind {@link AgentInvocation}. */
export interface AnyAgent {
    readonly selection: string;
    readonly agent: AgentPin;
    readonly inputPin: CapabilityPin;
    readonly input: Schema.Codec<unknown, unknown>;
    readonly replay: ProgramReplayPolicy;
    readonly decode: (encoded: unknown) => Effect.Effect<AgentInvocation, Schema.SchemaError>;
}
/** @experimental Complete live authority available to a ProgramHost. */
export interface Bindings {
    readonly tools: ReadonlyArray<TypedTool>;
    readonly steps: ReadonlyArray<TypedStep>;
    readonly agents: ReadonlyArray<AnyAgent>;
}
/** @experimental Construct a typed tool binding. */
export declare const tool: <I, IE, O, OE, E>(binding: ToolBinding<I, IE, O, OE, E>) => TypedTool & {
    readonly decode: (encoded: unknown) => Effect.Effect<Invocation<O>, Schema.SchemaError>;
};
/** @experimental Construct a typed named step binding. */
export declare const step: <I, IE, O, OE, E>(binding: StepBinding<I, IE, O, OE, E>) => TypedStep & {
    readonly decode: (encoded: unknown) => Effect.Effect<Invocation<O>, Schema.SchemaError>;
};
/** @experimental Construct an exact typed Agent binding. */
export declare const agent: <I extends Prompt.RawInput, IE, E>(binding: AgentBinding<I, IE, E>) => AnyAgent;
/** @experimental Construct the host's complete live Program binding set. */
export declare const make: (bindings: Bindings) => Bindings;