declare const make: (opts: {
  readonly generateText: (options: AiLanguageModelOptions) => Effect.Effect<AiResponse.AiResponse, AiError, Context>
  readonly streamText: (options: AiLanguageModelOptions) => Stream.Stream<AiResponse.AiResponse, AiError, Context>
}) => Effect.Effect<AiLanguageModel.Service>

declare class AiLanguageModel

type Context = CurrentToolCallIdGenerator

declare class CurrentToolCallIdGenerator

declare const generateObject: <A, I extends Record<string, unknown>, R>(
  options: GenerateObjectOptions<A, I, R>
) => Effect.Effect<AiResponse.WithStructuredOutput<A>, AiError, AiLanguageModel | R>

declare const generateText: <
  Tools extends AiTool.Any,
  Options extends NoExcessProperties<GenerateTextOptions<any>, Options>
>(
  options: Options & GenerateTextOptions<Tools>
) => Effect.Effect<ExtractSuccess<Options>, ExtractError<Options>, AiLanguageModel | ExtractContext<Options>>

declare const streamText: <
  Tools extends AiTool.Any,
  Options extends NoExcessProperties<GenerateTextOptions<any>, Options>
>(
  options: Options & GenerateTextOptions<Tools>
) => Stream.Stream<ExtractSuccess<Options>, ExtractError<Options>, AiLanguageModel | ExtractContext<Options>>

export interface Service {
  /**
   * Generate text using a large language model for the specified `prompt`.
   *
   * If a `toolkit` is specified, the large language model will additionally
   * be able to perform tool calls to augment its response.
   */
  readonly generateText: <
    Tools extends AiTool.Any,
    Options extends NoExcessProperties<GenerateTextOptions<any>, Options>
  >(
    options: Options & GenerateTextOptions<Tools>
  ) => Effect.Effect<ExtractSuccess<Options>, ExtractError<Options>, ExtractContext<Options>>
  /**
   * Generate text using a large language model for the specified `prompt`,
   * streaming output from the model as soon as it is available.
   *
   * If a `toolkit` is specified, the large language model will additionally
   * be able to perform tool calls to augment its response.
   */
  readonly streamText: <
    Tools extends AiTool.Any,
    Options extends NoExcessProperties<GenerateTextOptions<any>, Options>
  >(
    options: Options & GenerateTextOptions<Tools>
  ) => Stream.Stream<ExtractSuccess<Options>, ExtractError<Options>, ExtractContext<Options>>

  /**
   * Generate a structured object for the specified prompt and schema using a
   * large language model.
   */
  readonly generateObject: <A, I extends Record<string, unknown>, R>(
    options: GenerateObjectOptions<A, I, R>
  ) => Effect.Effect<AiResponse.WithStructuredOutput<A>, AiError, R>
}

export interface AiLanguageModelOptions {
  /**
   * The prompt messages to use to generate text.
   */
  readonly prompt: AiInput.AiInput
  /**
   * An optional system message that will be part of the prompt.
   */
  readonly system: Option.Option<string>
  /**
   * The tools to use to generate text in an encoded format suitable for
   * incorporation into requests to the large language model.
   */
  readonly tools: Array<{
    readonly name: string
    readonly description: string
    readonly parameters: JsonSchema.JsonSchema7
    readonly structured: boolean
  }>
  /**
   * The tool choice mode for the language model.
   *
   * - `auto` (default): The model can decide whether or not to call tools, as well as which tools to call.
   * - `required`: The model **must** call a tool but can decide which tool will be called.
   * - `none`: The model **must not** call a tool.
   * - `{ tool: <tool_name> }`: The model must call the specified tool.
   */
  readonly toolChoice: ToolChoice<any>
  /**
   * The span to use to trace interactions with the large language model.
   */
  readonly span: Span
}

export interface GenerateObjectOptions<A, I extends Record<string, unknown>, R> {
  /**
   * The prompt input to use to generate text.
   */
  readonly prompt: AiInput.Raw

  /**
   * An optional system message that will be part of the prompt.
   */
  readonly system?: string | undefined

  /**
   * The schema to be used to specify the structure of the object to generate.
   */
  readonly schema: Schema.Schema<A, I, R>

  /**
   * The identifier to use to associating the underlying tool call with the
   * generated output.
   */
  readonly toolCallId?: string | undefined
}

export interface GenerateTextOptions<Tools extends AiTool.Any> {
  /**
   * The prompt input to use to generate text.
   */
  readonly prompt: AiInput.Raw

  /**
   * An optional system message that will be part of the prompt.
   */
  readonly system?: string | undefined

  /**
   * A toolkit containing both the tools and the tool call handler to use to
   * augment text generation.
   */
  readonly toolkit?: AiToolkit.ToHandler<Tools> | Effect.Effect<AiToolkit.ToHandler<Tools>, any, any>

  /**
   * The tool choice mode for the language model.
   *
   * - `auto` (default): The model can decide whether or not to call tools, as well as which tools to call.
   * - `required`: The model **must** call a tool but can decide which tool will be called.
   * - `none`: The model **must not** call a tool.
   * - `{ tool: <tool_name> }`: The model must call the specified tool.
   */
  readonly toolChoice?: ToolChoice<Tools>

  /**
   * The concurrency level for resolving tool calls.
   */
  readonly concurrency?: Concurrency | undefined

  /**
   * When set to `true`, tool calls requested by the large language model
   * will not be auto-resolved by the framework.
   *
   * This option is useful when:
   *   1. The user wants to include tool call definitions from an `AiToolkit`
   *      in requests to the large language model so that the model has the
   *      capability to call tools.
   *   2. The user wants to control the execution of tool call resolvers
   *      instead of having the framework handle tool call resolution.
   */
  readonly disableToolCallResolution?: boolean | undefined
}

export interface IdentifiedSchema<A, I, R> extends Schema.Schema<A, I, R> {
  readonly identifier: string
}

type StructuredSchema<A, I, R> = TaggedSchema<A, I, R> | IdentifiedSchema<A, I, R>

export interface TaggedSchema<A, I, R> extends Schema.Schema<A, I, R> {
  readonly _tag: string
}

export interface ToolCallIdGenerator {
  generateId(): Effect.Effect<string>
}

type ToolChoice<Tool> =
  | "auto"
  | "none"
  | "required"
  | {
      readonly tool: Tool["name"]
    }

type ExtractContext<Options> = Options extends {
  disableToolCallResolution: true
}
  ? never
  : Options extends {
        toolkit: AiToolkit.ToHandler<infer _Tools>
      }
    ? AiTool.Context<_Tools>
    : Options extends {
          toolkit: Effect.Effect<AiToolkit.ToHandler<infer _Tools>, infer _E, infer _R>
        }
      ? AiTool.Context<_Tools> | _R
      : never

type ExtractError<Options> = Options extends {
  disableToolCallResolution: true
}
  ? AiError
  : Options extends {
        toolkit: AiToolkit.ToHandler<infer _Tools>
      }
    ? AiError | AiTool.Failure<_Tools>
    : Options extends {
          toolkit: Effect.Effect<AiToolkit.ToHandler<infer _Tools>, infer _E, infer _R>
        }
      ? AiError | AiTool.Failure<_Tools> | _E
      : AiError

type ExtractSuccess<Options> = Options extends {
  disableToolCallResolution: true
}
  ? AiResponse.AiResponse
  : Options extends {
        toolkit: AiToolkit.ToHandler<infer _Tools>
      }
    ? AiResponse.WithToolCallResults<_Tools>
    : Options extends {
          toolkit: Effect.Effect<AiToolkit.ToHandler<infer _Tools>, infer _E, infer _R>
        }
      ? AiResponse.WithToolCallResults<_Tools>
      : AiResponse.AiResponse