import { Cause, Effect, Option, Queue, Ref, Stream } from "effect";
import { Chat, Prompt, Tool } from "effect/unstable/ai";
import { AgentError, type Event, type ToolProgress, ProgressOverflow, type ToolNameCollision } from "./agent-event.js";
import { type AnyToolCall, type PendingToolResult } from "./agent-tool-result.js";
import type { Agent, ProgressOverflowPolicy, RunError, RunOptions } from "./agent.js";
import type { AgentRunState } from "./agent-run-state.js";
import type { HandoffRunState } from "./handoff-state.js";
import { type AuthorizationError, type ToolAuthorizer } from "../tools/tool-authorization.js";
import { FrameworkFailure, type Outcome, type Request, type Success, ToolExecutor } from "../tools/tool-executor.js";
import { type Registry } from "../tools/tool-registry.js";
import { ToolContext } from "../tools/tool-context.js";
import { type ToolState } from "./tool-skill-activation.js";
import type { Skill, SkillSourceError } from "../context/skill-source.js";
type StaticToolServices<T extends Record<string, Tool.Any>> = Tool.HandlersFor<T> | Exclude<Tool.HandlerServices<T[keyof T]>, ToolContext>;
interface ToolExecutionContext<T extends Record<string, Tool.Any>, R> {
    readonly options: RunOptions;
    readonly state: AgentRunState;
    readonly isSkillActivationCall: (call: AnyToolCall, registry: Registry) => boolean;
    readonly agent: Agent<T, R>;
    readonly chat: Chat.Service;
    readonly sessionId: string;
    readonly executor: Option.Option<typeof ToolExecutor.Service>;
    readonly authorizer: ToolAuthorizer<R>;
    readonly skillRuntime: {
        readonly source: {
            readonly get: (name: string) => Effect.Effect<Skill | undefined, SkillSourceError>;
        };
    } | undefined;
    readonly toolState: Ref.Ref<ToolState>;
    readonly handoffState?: Ref.Ref<HandoffRunState>;
    readonly progressPolicy: ProgressOverflowPolicy;
    readonly activeSession: Option.Option<unknown>;
    readonly memoryRuntime: unknown | undefined;
    readonly errorMessage: (error: unknown) => string;
    readonly skillError: (turn: number, error: SkillSourceError) => AgentError;
}
export declare const makeToolExecution: <T extends Record<string, Tool.Any>, R = never>(inputContext: ToolExecutionContext<T, R>) => {
    boundedSuccessResult: (call: AnyToolCall, outcome: Success) => Effect.Effect<PendingToolResult>;
    outcomeEvent: (turn: number, toolCallBatch: Request["toolCallBatch"], toolCallIndex: number, call: AnyToolCall, outcome: Outcome, droppedProgress: number, registry: Registry) => Effect.Effect<Event, RunError>;
    defaultExecute: (request: Request, registry: Registry) => Effect.Effect<Outcome, FrameworkFailure, Tool.HandlersFor<T> | Tool.HandlerServices<T[keyof T]>>;
    makeProgressQueue: () => Effect.Effect<Queue.Queue<ToolProgress, Cause.Done | ProgressOverflow>>;
    executeApproved: (turn: number, call: AnyToolCall, request: Request, registry: Registry) => Stream.Stream<Event, RunError, StaticToolServices<T> | import("../durable/driver-interpreter.js").DriverInterpreter>;
    activateSkillOutcome: (turn: number, call: AnyToolCall) => Effect.Effect<Outcome, AgentError | ToolNameCollision | FrameworkFailure>;
    authorizationError: (turn: number, error: AuthorizationError) => AgentError;
    resumeApproved: (turn: number, toolCallBatch: Request["toolCallBatch"], toolCallIndex: number, call: AnyToolCall, registry: Registry) => Stream.Stream<Event, RunError, StaticToolServices<T> | R | import("../durable/driver-interpreter.js").DriverInterpreter>;
    toolCallEvents: (turn: number, toolCallBatch: Request["toolCallBatch"], toolCallIndex: number, call: AnyToolCall, messages: ReadonlyArray<Prompt.Message>, registry: Registry) => Stream.Stream<Event, RunError, StaticToolServices<T> | R | import("../durable/driver-interpreter.js").DriverInterpreter>;
};
export {};