declare class Destructive

declare class Idempotent

declare class OpenWorld

declare class Readonly

declare class Title

declare const isAiTool: (u: unknown) => u is AiTool<any, any, any, any, any>

export interface AiTool<
  out Name extends string,
  out Parameters extends AnyStructSchema = Schema.Struct<{}>,
  out Success extends Schema.Schema.Any = typeof Schema.Void,
  out Failure extends Schema.Schema.All = typeof Schema.Never,
  out Requirements = never
> extends Pipeable {
  readonly [TypeId]: {
    readonly _Requirements: Types.Covariant<Requirements>
  }

  /**
   * The name of the tool.
   */
  readonly name: Name

  /**
   * The optional description of the tool.
   */
  readonly description?: string | undefined

  /**
   * A key for the tool, used to identify the tool within a `Context`.
   */
  readonly key: string

  /**
   * A `Schema` representing the type of the parameters that a tool handler
   * must be called with.
   */
  readonly parametersSchema: Parameters

  /**
   * A `Schema` representing the type that a tool returns from its handler
   * if successful.
   */
  readonly successSchema: Success

  /**
   * A `Schema` representing the type that a tool returns from its handler
   * if it fails.
   */
  readonly failureSchema: Failure

  readonly annotations: Context_.Context<never>

  /**
   * Adds a requirement on a particular service for the tool call to be able to
   * be executed.
   */
  addRequirement<Requirement>(): AiTool<Name, Parameters, Success, Failure, Requirements | Requirement>

  /**
   * Set the schema to use for tool handler success.
   */
  setSuccess<SuccessSchema extends Schema.Schema.Any>(
    schema: SuccessSchema
  ): AiTool<Name, Parameters, SuccessSchema, Failure, Requirements>

  /**
   * Set the schema to use for tool handler failure.
   */
  setFailure<FailureSchema extends Schema.Schema.Any>(
    schema: FailureSchema
  ): AiTool<Name, Parameters, Success, FailureSchema, Requirements>

  /**
   * Set the schema for the tool parameters.
   */
  setParameters<ParametersSchema extends Schema.Struct<any> | Schema.Struct.Fields>(
    schema: ParametersSchema
  ): AiTool<
    Name,
    ParametersSchema extends Schema.Struct<infer _>
      ? ParametersSchema
      : ParametersSchema extends Schema.Struct.Fields
        ? Schema.Struct<ParametersSchema>
        : never,
    Success,
    Failure,
    Requirements
  >

  /**
   * Add an annotation to the tool.
   */
  annotate<I, S>(tag: Context_.Tag<I, S>, value: S): AiTool<Name, Parameters, Success, Failure, Requirements>

  /**
   * Add many annotations to the tool.
   */
  annotateContext<I>(context: Context_.Context<I>): AiTool<Name, Parameters, Success, Failure, Requirements>
}

export interface Any extends Pipeable {
  readonly [TypeId]: {
    readonly _Requirements: Types.Covariant<any>
  }
  readonly name: string
  readonly description?: string | undefined
  readonly key: string
  readonly parametersSchema: AnyStructSchema
  readonly annotations: Context_.Context<never>
}

export interface AnyWithProtocol extends Any {
  readonly successSchema: Schema.Schema.Any
  readonly failureSchema: Schema.Schema.All
}

export interface Handler<Name extends string> {
  readonly _: unique symbol
  readonly name: Name
  readonly handler: (params: any) => Effect.Effect<any, any>
  readonly context: Context_.Context<never>
}

export interface HandlerResult<Tool extends Any> {
  /**
   * The result of executing the handler for a particular tool.
   */
  readonly result: Success<Tool>
  /**
   * The encoded result of executing the handler for a particular tool, which
   * is suitable for returning back to the large language model for
   * incorporation into further responses.
   */
  readonly encodedResult: unknown
}

declare const TypeId: unique symbol

type TypeId = typeof TypeId

export interface AnyStructSchema extends Pipeable {
  readonly [Schema.TypeId]: any
  readonly make: any
  readonly Type: any
  readonly Encoded: any
  readonly Context: any
  readonly ast: AST.AST
  readonly fields: Schema.Struct.Fields
  readonly annotations: any
}

export interface AnyTaggedRequestSchema extends AnyStructSchema {
  readonly _tag: string
  readonly success: Schema.Schema.Any
  readonly failure: Schema.Schema.All
}

type ByName<Tools> = {
  readonly [Tool in Tools as Tool["name"]]: Tool
}

type Context<Tool> =
  Tool extends AiTool<infer _Name, infer _Parameters, infer _Success, infer _Failure, infer _Requirements>
    ? _Parameters["Context"] | _Success["Context"] | _Failure["Context"] | _Requirements
    : never

type Failure<Tool> =
  Tool extends AiTool<infer _Name, infer _Parameters, infer _Success, infer _Failure, infer _Requirements>
    ? _Failure["Type"]
    : never

type FailureSchema<Tool> =
  Tool extends AiTool<infer _Name, infer _Parameters, infer _Success, infer _Failure, infer _Requirements>
    ? _Failure
    : never

export interface FromTaggedRequest<S extends AnyTaggedRequestSchema>
  extends AiTool<S["_tag"], S, S["success"], S["failure"]> {}

type HandlerEffect<Tool> = [Tool] extends [
  AiTool<infer _Name, infer _Parameters, infer _Success, infer _Failure, infer _Requirements>
]
  ? Effect.Effect<
      _Success["Type"],
      AiError | _Failure["Type"],
      _Parameters["Context"] | _Success["Context"] | _Failure["Context"] | _Requirements
    >
  : never

type Name<Tool> =
  Tool extends AiTool<infer _Name, infer _Parameters, infer _Success, infer _Failure, infer _Requirements>
    ? _Name
    : never

type Parameters<Tool> =
  Tool extends AiTool<infer _Name, infer _Parameters, infer _Success, infer _Failure, infer _Requirements>
    ? _Parameters["Type"]
    : never

type ParametersSchema<Tool> =
  Tool extends AiTool<infer _Name, infer _Parameters, infer _Success, infer _Failure, infer _Requirements>
    ? _Parameters
    : never

type Success<Tool> =
  Tool extends AiTool<infer _Name, infer _Parameters, infer _Success, infer _Failure, infer _Requirements>
    ? _Success["Type"]
    : never

type SuccessSchema<Tool> =
  Tool extends AiTool<infer _Name, infer _Parameters, infer _Success, infer _Failure, infer _Requirements>
    ? _Success
    : never

type ToHandler<Tool> =
  Tool extends AiTool<infer _Name, infer _Parameters, infer _Success, infer _Failure, infer _Requirements>
    ? Handler<_Name>
    : never

declare const fromTaggedRequest: <S extends AnyTaggedRequestSchema>(schema: S) => FromTaggedRequest<S>

declare const make: <
  const Name extends string,
  Parameters extends Schema.Struct.Fields = {},
  Success extends Schema.Schema.Any = typeof Schema.Void,
  Failure extends Schema.Schema.All = typeof Schema.Never
>(
  name: Name,
  options?: {
    readonly description?: string | undefined
    readonly parameters?: Parameters
    readonly success?: Success
    readonly failure?: Failure
  }
) => AiTool<Name, Schema.Struct<Parameters>, Success, Failure>