import { Context, Effect, Layer, Schema } from "effect";
import { Response, Tool, Toolkit } from "effect/unstable/ai";
import type { AgentToolToolkit } from "../agent/agent-tool.js";
import { ToolContext } from "./tool-context.js";
import type { Route, RouteInput } from "./tool-placement.js";
import { client, mcp, remote, route, sandbox } from "./tool-executor-routes.js";
export { client, mcp, remote, route, sandbox };
import type { SchemaTool, ToolSchemaServices } from "./tool-result-codec.js";
/** @experimental */
export interface Request {
    readonly call: Response.ToolCallPart<string, unknown>;
    readonly toolCallBatch: {
        readonly calls: ReadonlyArray<Response.ToolCallPart<string, unknown>>;
    };
    readonly turn: number;
    readonly toolCallIndex: number;
    readonly agentName: string;
    readonly sessionId: string;
}
/** @experimental */
export interface Success {
    readonly _tag: "Success";
    readonly result: unknown;
    readonly encodedResult: unknown;
}
/** @experimental */
export interface DomainFailure {
    readonly _tag: "DomainFailure";
    readonly failure: unknown;
    readonly encodedFailure: unknown;
}
/** @experimental */
export interface Suspend {
    readonly _tag: "Suspend";
    readonly token: string;
}
/** @experimental */
export type Outcome = Success | DomainFailure | Suspend;
/** @experimental */
export declare const FrameworkStage: Schema.Literals<readonly ["decode-input", "handler", "encode-success", "encode-domain-failure", "missing-handler", "route", "placement", "authorization"]>;
/** @experimental */
export type FrameworkStage = typeof FrameworkStage.Type;
declare const FrameworkFailure_base: Schema.Class<FrameworkFailure, Schema.TaggedStruct<"@batonfx/core/FrameworkFailure", {
    readonly stage: Schema.Literals<readonly ["decode-input", "handler", "encode-success", "encode-domain-failure", "missing-handler", "route", "placement", "authorization"]>;
    readonly tool: Schema.String;
    readonly message: Schema.String;
}>, import("effect/Cause").YieldableError>;
/** @experimental */
export declare class FrameworkFailure extends FrameworkFailure_base {
}
declare const RemoteRetryMisconfigured_base: Schema.Class<RemoteRetryMisconfigured, Schema.TaggedStruct<"@batonfx/core/RemoteRetryMisconfigured", {
    readonly reason: Schema.Literals<readonly ["invalid-max-retries", "missing-operation-key", "changed-operation-key"]>;
    readonly message: Schema.String;
}>, import("effect/Cause").YieldableError>;
/** @experimental An idempotent remote route supplied an invalid or unstable operation key or retry bound. */
export declare class RemoteRetryMisconfigured extends RemoteRetryMisconfigured_base {
}
/** @experimental */
export interface Interface<R = ToolContext> {
    readonly execute: (request: Request) => Effect.Effect<Outcome, FrameworkFailure | RemoteRetryMisconfigured, R>;
}
declare const ToolExecutor_base: Context.ServiceClass<ToolExecutor, "@batonfx/core/tools/tool-executor/ToolExecutor", Interface<ToolContext>>;
/** @experimental */
export declare class ToolExecutor extends ToolExecutor_base {
}
/** @experimental */
export type ToolkitInput<Tools extends Record<string, Tool.Any>> = Toolkit.Toolkit<Tools> | Toolkit.WithHandler<Tools>;
/** @experimental A schema-backed tool set with a closed name-based invocation. */
export interface ClosedToolSet<R = unknown, T extends SchemaTool = SchemaTool> {
    readonly tools: Readonly<Record<string, T>>;
    readonly invoke: (name: string, params: unknown) => Effect.Effect<unknown, unknown, R>;
}
/** @experimental */
export declare function executeToolkit<R, T extends SchemaTool>(toolkit: ClosedToolSet<R, T>, request: Request): Effect.Effect<Outcome, FrameworkFailure, R | ToolContext | ToolSchemaServices<T>>;
export declare function executeToolkit<Name extends string, Parameters extends Schema.Top, SuccessSchema extends Schema.Top, R>(toolkit: AgentToolToolkit<Name, Parameters, SuccessSchema, R>, request: Request): Effect.Effect<Outcome, FrameworkFailure, R | ToolContext>;
export declare function executeToolkit<Tools extends Record<string, Tool.Any>>(toolkit: Toolkit.WithHandler<Tools>, request: Request): Effect.Effect<Outcome, FrameworkFailure, Tool.HandlerServices<Tools[keyof Tools]>>;
export declare function executeToolkit<Tools extends Record<string, Tool.Any>>(toolkit: Toolkit.Toolkit<Tools>, request: Request): Effect.Effect<Outcome, FrameworkFailure, Tool.HandlersFor<Tools> | Tool.HandlerServices<Tools[keyof Tools]>>;
export declare function executeToolkit(request: Request): (<Name extends string, Parameters extends Schema.Top, SuccessSchema extends Schema.Top, R>(toolkit: AgentToolToolkit<Name, Parameters, SuccessSchema, R>) => Effect.Effect<Outcome, FrameworkFailure, R | ToolContext>) & (<Tools extends Record<string, Tool.Any>>(toolkit: Toolkit.WithHandler<Tools>) => Effect.Effect<Outcome, FrameworkFailure, Tool.HandlerServices<Tools[keyof Tools]>>) & (<Tools extends Record<string, Tool.Any>>(toolkit: Toolkit.Toolkit<Tools>) => Effect.Effect<Outcome, FrameworkFailure, Tool.HandlersFor<Tools> | Tool.HandlerServices<Tools[keyof Tools]>>);
/** @experimental */
export declare function layerToolkit<Name extends string, Parameters extends Schema.Top, SuccessSchema extends Schema.Top, R>(toolkit: AgentToolToolkit<Name, Parameters, SuccessSchema, R>): Layer.Layer<ToolExecutor, never, R>;
export declare function layerToolkit<R>(toolkit: ClosedToolSet<R, Tool.Any>): Layer.Layer<ToolExecutor, never, R>;
export declare function layerToolkit<R, T extends SchemaTool>(toolkit: ClosedToolSet<R, T>): Layer.Layer<ToolExecutor, never, R | ToolSchemaServices<T>>;
export declare function layerToolkit<Tools extends Record<string, Tool.Any>>(toolkit: Toolkit.WithHandler<Tools>): Layer.Layer<ToolExecutor>;
export declare function layerToolkit<Tools extends Record<string, Tool.Any>>(toolkit: Toolkit.Toolkit<Tools>): Layer.Layer<ToolExecutor, never, Tool.HandlersFor<Tools>>;
/** @experimental */
export declare function routeToolkit<Name extends string, Parameters extends Schema.Top, SuccessSchema extends Schema.Top, R>(toolkit: AgentToolToolkit<Name, Parameters, SuccessSchema, R>): Route<R | ToolContext>;
export declare function routeToolkit<R, T extends SchemaTool>(toolkit: ClosedToolSet<R, T>): RouteInput<R | ToolContext | ToolSchemaServices<T>>;
export declare function routeToolkit<Tools extends Record<string, Tool.Any>>(toolkit: Toolkit.WithHandler<Tools>): Route;
export declare function routeToolkit<Tools extends Record<string, Tool.Any>>(toolkit: Toolkit.Toolkit<Tools>): Effect.Effect<Route, never, Tool.HandlersFor<Tools>>;
/** @experimental */
export declare function layerRouter(routes: Iterable<Route<ToolContext>>): Layer.Layer<ToolExecutor, never, ToolContext>;
export declare function layerRouter<R>(routes: Iterable<Route<ToolContext> | Effect.Effect<Route<ToolContext>, never, R>>): Layer.Layer<ToolExecutor, never, ToolContext | R>;
export declare function layerRouter<R>(routes: Iterable<RouteInput<ToolContext> | RouteInput<R>>): Layer.Layer<ToolExecutor, never, ToolContext | R>;
export declare function layerRouter<R1, R2>(routes: Iterable<RouteInput<R1> | RouteInput<R2>>): Layer.Layer<ToolExecutor, never, R1 | R2>;
export declare function layerRouter<R>(routes: Iterable<RouteInput<R>>): Layer.Layer<ToolExecutor, never, R>;
/** @experimental */
export declare const layerTest: (implementation: Interface) => Layer.Layer<ToolExecutor>;