ai

type ActionMetadata struct {
	ActionType  string `json:"actionType,omitempty"`
	Description string `json:"description,omitempty"`
	// A JSON Schema Draft 7 (http://json-schema.org/draft-07/schema) object.
	InputJsonSchema any            `json:"inputJsonSchema,omitempty"`
	InputSchema     any            `json:"inputSchema,omitempty"`
	Key             string         `json:"key,omitempty"`
	Metadata        map[string]any `json:"metadata,omitempty"`
	Name            string         `json:"name,omitempty"`
	// A JSON Schema Draft 7 (http://json-schema.org/draft-07/schema) object.
	OutputJsonSchema any `json:"outputJsonSchema,omitempty"`
	OutputSchema     any `json:"outputSchema,omitempty"`
	StreamSchema     any `json:"streamSchema,omitempty"`
}

type AugmentWithContextOptions struct {
	Preface      *string                                                                // Preceding text to place before the rendered context documents.
	ItemTemplate func(d Document, index int, options *AugmentWithContextOptions) string // A function to render a document into a text part to be included in the message.
	CitationKey  *string                                                                // Metadata key to use for citation reference. Pass `nil` to provide no citations.
}

type BackgroundModel interface {
	// Name returns the registry name of the background model.
	Name() string
	// Register registers the model with the given registry.
	Register(r api.Registry)
	// Start starts a background operation.
	Start(ctx context.Context, req *ModelRequest) (*ModelOperation, error)
	// Check checks the status of a background operation.
	Check(ctx context.Context, op *ModelOperation) (*ModelOperation, error)
	// Cancel cancels a background operation.
	Cancel(ctx context.Context, op *ModelOperation) (*ModelOperation, error)
	// SupportsCancel returns whether the background action supports cancellation.
	SupportsCancel() bool
}

type BackgroundModelAction struct {
	// contains filtered or unexported fields
}

type BackgroundModelActionFunc[Config any] = func(ctx context.Context, req *ModelRequest, config Config) (*ModelOperation, error)

type BackgroundModelOptions struct {
	ModelOptions

	// Cancel cancels a running operation. Optional: nil means the model does
	// not support canceling operations.
	Cancel CancelModelOpFunc

	// Metadata is arbitrary key-value data attached to the action descriptor.
	// It is merged over [ModelOptions.Metadata]; this field wins on key
	// conflicts.
	Metadata map[string]any
}

type BatchEvaluatorActionFunc[Config any] = func(context.Context, *EvaluatorRequest, Config) (*EvaluatorResponse, error)

type BatchEvaluatorFunc = func(context.Context, *EvaluatorRequest) (*EvaluatorResponse, error)

type CancelModelOpFunc = func(ctx context.Context, op *ModelOperation) (*ModelOperation, error)

type CheckModelOpFunc = func(ctx context.Context, op *ModelOperation) (*ModelOperation, error)

type CommonGenOption interface {
	PromptOption
	GenerateOption
	PromptExecuteOption
	// contains filtered or unexported methods
}

type ConfigOption interface {
	CommonGenOption
	EmbedderOption
	RetrieverOption
	EvaluatorOption
	// contains filtered or unexported methods
}

type ConstrainedSupport string

type DataPrompt[In, Out any] struct {
	// contains filtered or unexported fields
}

type DocsFn = func(context.Context, any) ([]*Document, error)

type Document struct {
	// The data that is part of this document.
	Content []*Part `json:"content,omitempty"`
	// The metadata for this document.
	Metadata map[string]any `json:"metadata,omitempty"`
}

type DocumentOption interface {
	PromptOption
	GenerateOption
	PromptExecuteOption
	EmbedderOption
	RetrieverOption
	// contains filtered or unexported methods
}

type DownloadMediaOptions struct {
	MaxBytes int64                 // Maximum number of bytes to download.
	Filter   func(part *Part) bool // Filter to apply to parts that are media URLs.
}

type EmbedRequest struct {
	// Input is the array of documents to generate embeddings for.
	Input []*Document `json:"input,omitempty"`
	// Options contains embedder-specific configuration parameters.
	Options any `json:"options,omitempty"`
}

type EmbedResponse struct {
	// Embeddings is the array of generated embedding vectors with metadata.
	Embeddings []*Embedding `json:"embeddings,omitempty"`
}

type Embedder interface {
	// Name returns the registry name of the embedder.
	Name() string
	// Embed embeds to content as part of the [EmbedRequest].
	Embed(ctx context.Context, req *EmbedRequest) (*EmbedResponse, error)
	// Register registers the embedder with the given registry.
	Register(r api.Registry)
}

type EmbedderAction struct {
	// contains filtered or unexported fields
}

type EmbedderActionFunc[Config any] = func(context.Context, *EmbedRequest, Config) (*EmbedResponse, error)

type EmbedderArg interface {
	Name() string
}

type EmbedderFunc = func(context.Context, *EmbedRequest) (*EmbedResponse, error)

type EmbedderOption interface {
	// contains filtered or unexported methods
}

type EmbedderOptions struct {
	// ConfigSchema is the JSON schema for the embedder's config.
	ConfigSchema map[string]any `json:"configSchema,omitempty"`
	// Label is a user-friendly name for the embedder model (e.g., "Google AI - Gemini Pro").
	Label string `json:"label,omitempty"`
	// Supports defines the capabilities of the embedder, such as input types and multilingual support.
	Supports *EmbedderSupports `json:"supports,omitempty"`
	// Dimensions specifies the number of dimensions in the embedding vector.
	Dimensions int `json:"dimensions,omitempty"`
	// Metadata is arbitrary key-value data attached to the action descriptor.
	Metadata map[string]any `json:"-"`
}

type EmbedderRef struct {
	// contains filtered or unexported fields
}

type EmbedderSupports struct {
	// Input lists the types of data the model can process (e.g., "text", "image", "video").
	Input []string `json:"input,omitempty"`
	// Multilingual indicates whether the model supports multiple languages.
	Multilingual bool `json:"multilingual,omitempty"`
}

type Embedding struct {
	// Embedding is the vector representation of the input.
	Embedding []float32 `json:"embedding,omitempty"`
	// Metadata identifies which part of a document this embedding corresponds to.
	Metadata map[string]any `json:"metadata,omitempty"`
}

type EvaluationResult struct {
	TestCaseId string  `json:"testCaseId"`
	TraceID    string  `json:"traceId,omitempty"`
	SpanID     string  `json:"spanId,omitempty"`
	Evaluation []Score `json:"evaluation"`
}

type Evaluator interface {
	// Name returns the name of the evaluator.
	Name() string
	// Evaluates a dataset.
	Evaluate(ctx context.Context, req *EvaluatorRequest) (*EvaluatorResponse, error)
	// Register registers the evaluator with the given registry.
	Register(r api.Registry)
}

type EvaluatorAction struct {
	// contains filtered or unexported fields
}

type EvaluatorActionFunc[Config any] = func(context.Context, *EvaluatorCallbackRequest, Config) (*EvaluatorCallbackResponse, error)

type EvaluatorArg interface {
	Name() string
}

type EvaluatorCallbackRequest struct {
	Input   Example `json:"input"`
	Options any     `json:"options,omitempty"`
}

type EvaluatorCallbackResponse = EvaluationResult

type EvaluatorFunc = func(context.Context, *EvaluatorCallbackRequest) (*EvaluatorCallbackResponse, error)

type EvaluatorOption interface {
	// contains filtered or unexported methods
}

type EvaluatorOptions struct {
	// ConfigSchema is the JSON schema for the evaluator's config.
	ConfigSchema map[string]any `json:"configSchema,omitempty"`
	// Metadata is arbitrary key-value data attached to the action descriptor.
	Metadata map[string]any `json:"-"`
	// DisplayName is the name of the evaluator as it appears in the UI.
	DisplayName string `json:"displayName"`
	// Definition is the definition of the evaluator.
	Definition string `json:"definition"`
	// IsBilled is a flag indicating if the evaluator is billed.
	IsBilled bool `json:"isBilled,omitempty"`
}

type EvaluatorRef struct {
	// contains filtered or unexported fields
}

type EvaluatorRequest struct {
	Dataset      []*Example `json:"dataset"`
	EvaluationId string     `json:"evalRunId"`
	Options      any        `json:"options,omitempty"`
}

type EvaluatorResponse = []EvaluationResult

type Example struct {
	TestCaseId string   `json:"testCaseId,omitempty"`
	Input      any      `json:"input"`
	Output     any      `json:"output,omitempty"`
	Context    []any    `json:"context,omitempty"`
	Reference  any      `json:"reference,omitempty"`
	TraceIds   []string `json:"traceIds,omitempty"`
}

type ExecutionOption interface {
	GenerateOption
	PromptExecuteOption
	// contains filtered or unexported methods
}

type FinishReason string

type FormatHandler interface {
	// ParseMessage parses the message and returns a new formatted message.
	//
	// Legacy: New format handlers should implement this as a no-op passthrough and implement [StreamingFormatHandler] instead.
	ParseMessage(message *Message) (*Message, error)
	// Instructions returns the formatter instructions to embed in the prompt.
	Instructions() string
	// Config returns the output config for the model request.
	Config() ModelOutputConfig
}

type Formatter interface {
	// Name returns the name of the formatter.
	Name() string
	// Handler returns the handler for the formatter.
	Handler(schema map[string]any) (FormatHandler, error)
}

type GenerateActionOptions struct {
	// Config contains configuration parameters for the generation request.
	Config any `json:"config,omitempty"`
	// Docs provides retrieved documents to be used as context for this generation.
	Docs []*Document `json:"docs,omitempty"`
	// MaxTurns is the maximum number of tool call iterations that can be performed
	// in a single generate call. Defaults to 5.
	MaxTurns int `json:"maxTurns,omitempty"`
	// Messages contains the conversation history for multi-turn prompting when supported.
	Messages []*Message `json:"messages,omitempty"`
	// Model is a model name (e.g., "vertexai/gemini-flash-latest").
	Model string `json:"model,omitempty"`
	// Output specifies the desired output format. Defaults to the model's default if unspecified.
	Output    *GenerateActionOutputConfig `json:"output,omitempty"`
	Resources []string                    `json:"resources,omitempty"`
	// Resume provides options for resuming an interrupted generation.
	Resume *GenerateActionResume `json:"resume,omitempty"`
	// ReturnToolRequests, when true, returns tool calls for manual processing instead of
	// automatically resolving them.
	ReturnToolRequests bool `json:"returnToolRequests,omitempty"`
	// StepName is a custom step name for this generate call to display in trace views.
	// Defaults to "generate".
	StepName string `json:"stepName,omitempty"`
	// ToolChoice controls tool calling mode. Auto lets the model decide, required forces
	// the model to choose a tool, and none forces the model not to use any tools. Defaults to auto.
	ToolChoice ToolChoice `json:"toolChoice,omitempty"`
	// Tools is a list of registered tool names for this generation if supported.
	Tools []string `json:"tools,omitempty"`
	// Use is middleware to apply to this generation, referenced by name with optional config.
	Use []*MiddlewareRef `json:"use,omitempty"`
}

type GenerateActionOutputConfig struct {
	// Constrained indicates whether to enforce strict adherence to the schema.
	Constrained bool `json:"constrained,omitempty"`
	// ContentType specifies the MIME type of the output content.
	ContentType string `json:"contentType,omitempty"`
	// Format specifies the desired output format (e.g., "json", "text").
	Format string `json:"format,omitempty"`
	// Instructions provides additional guidance for the output format.
	Instructions *string `json:"instructions,omitempty"`
	// JsonSchema is a JSON Schema describing the desired structure of JSON output.
	JsonSchema map[string]any `json:"jsonSchema,omitempty"`
}

type GenerateActionResume struct {
	// Metadata contains additional context for resuming the generation.
	Metadata map[string]any `json:"metadata,omitempty"`
	// Respond contains tool response parts to send to the model when resuming.
	Respond []*Part `json:"respond,omitempty"`
	// Restart contains tool request parts to restart when resuming.
	Restart []*Part `json:"restart,omitempty"`
}

type GenerateNext = func(ctx context.Context, params *GenerateParams) (*ModelResponse, error)

type GenerateOption interface {
	// contains filtered or unexported methods
}

type GenerateParams struct {
	// Options is the original options passed to [Generate].
	Options *GenerateActionOptions
	// Request is the current model request for this iteration, with accumulated messages.
	Request *ModelRequest
	// Iteration is the current tool-loop iteration (0-indexed).
	Iteration int
	// MessageIndex is the index of the next message in the streamed response sequence.
	// Middleware that streams extra messages (e.g. injected user content) should emit
	// chunks at this index and advance it so downstream middleware and the model
	// receive the shifted value.
	MessageIndex int
	// Callback is the streaming callback supplied to [Generate], or nil if not streaming.
	// Middleware may invoke it to emit chunks, setting [ModelResponseChunk.Role] and
	// [ModelResponseChunk.Index] explicitly.
	Callback ModelStreamCallback
}

type GenerationCommonConfig struct {
	// API Key to use for the model call, overrides API key provided in plugin config.
	APIKey string `json:"apiKey,omitempty"`
	// MaxOutputTokens limits the maximum number of tokens generated in the response.
	MaxOutputTokens int `json:"maxOutputTokens,omitempty"`
	// StopSequences specifies sequences that will cause generation to stop when encountered.
	StopSequences []string `json:"stopSequences,omitempty"`
	// Temperature controls randomness in generation. Higher values (e.g., 0.9) make output more random,
	// while lower values (e.g., 0.1) make it more deterministic. Typical range is 0.0 to 1.0.
	Temperature float64 `json:"temperature,omitempty"`
	// TopK limits sampling to the K most likely tokens at each step.
	TopK int `json:"topK,omitempty"`
	// TopP (nucleus sampling) limits sampling to tokens whose cumulative probability exceeds P.
	TopP float64 `json:"topP,omitempty"`
	// Version specifies a particular version of a model family,
	// e.g., "gemini-3.5-flash-001" for the "gemini-3.5-flash" family.
	Version string `json:"version,omitempty"`
}

type GenerationUsage struct {
	// CachedContentTokens counts tokens that were served from cache.
	CachedContentTokens int `json:"cachedContentTokens,omitempty"`
	// Custom contains additional usage metrics specific to the model provider.
	Custom map[string]float64 `json:"custom,omitempty"`
	// InputAudioFiles is the number of audio files in the input.
	InputAudioFiles int `json:"inputAudioFiles,omitempty"`
	// InputCharacters is the number of characters in the input.
	InputCharacters int `json:"inputCharacters,omitempty"`
	// InputImages is the number of images in the input.
	InputImages int `json:"inputImages,omitempty"`
	// InputTokens is the number of tokens in the input prompt.
	InputTokens int `json:"inputTokens,omitempty"`
	// InputVideos is the number of videos in the input.
	InputVideos int `json:"inputVideos,omitempty"`
	// OutputAudioFiles is the number of audio files generated in the output.
	OutputAudioFiles int `json:"outputAudioFiles,omitempty"`
	// OutputCharacters is the number of characters generated in the output.
	OutputCharacters int `json:"outputCharacters,omitempty"`
	// OutputImages is the number of images generated in the output.
	OutputImages int `json:"outputImages,omitempty"`
	// OutputTokens is the number of tokens generated in the response.
	OutputTokens int `json:"outputTokens,omitempty"`
	// OutputVideos is the number of videos generated in the output.
	OutputVideos int `json:"outputVideos,omitempty"`
	// ThoughtsTokens counts tokens used in reasoning or thinking processes.
	ThoughtsTokens int `json:"thoughtsTokens,omitempty"`
	// TotalTokens is the sum of input and output tokens.
	TotalTokens int `json:"totalTokens,omitempty"`
}

type Hooks struct {
	// Tools are additional tools to register during the generation this
	// middleware is attached to. They are available to the model alongside
	// any user-supplied tools.
	Tools []Tool
	// WrapGenerate wraps each iteration of the tool loop. It sees the
	// accumulated request, the iteration index, and the streaming callback.
	// A single Generate() with N tool-call turns invokes this hook N+1 times.
	WrapGenerate func(ctx context.Context, params *GenerateParams, next GenerateNext) (*ModelResponse, error)
	// WrapModel wraps each model API call. Retry, fallback, and caching
	// middleware typically hook here.
	WrapModel func(ctx context.Context, params *ModelParams, next ModelNext) (*ModelResponse, error)
	// WrapTool wraps each tool execution. It may be called concurrently when
	// multiple tools execute in parallel for the same Generate() call; any
	// state closed over from the enclosing scope that this hook mutates must
	// be guarded with sync primitives.
	WrapTool func(ctx context.Context, params *ToolParams, next ToolNext) (*MultipartToolResponse, error)
}

type InputOption interface {
	PromptOption
	// contains filtered or unexported methods
}

type InputSchemaOption interface {
	InputOption
	ToolOption
}

type InterruptOptions struct {
	Metadata map[string]any
}

type Media struct {
	// ContentType specifies the MIME type of the media. Inferred from the data URI if not provided.
	ContentType string `json:"contentType,omitempty"`
	// Url is a "data:" or "https:" URI containing the media content.
	Url string `json:"url,omitempty"`
}

type Message struct {
	// Content holds the message parts (text, media, tool calls, etc.).
	Content []*Part `json:"content,omitempty"`
	// Metadata contains arbitrary key-value data associated with this message.
	Metadata map[string]any `json:"metadata,omitempty"`
	// Role indicates which entity (system, user, model, or tool) generated this message.
	Role Role `json:"role,omitempty"`
}

type MessagesFn = func(context.Context, any) ([]*Message, error)

type Middleware interface {
	// Name returns the registered middleware's unique identifier. Must be a
	// stable constant, since it is read from a zero value of the config type
	// during descriptor creation.
	Name() string
	// New produces a fresh [Hooks] bundle for one Generate() call. It is
	// invoked per-Generate, so any state the bundle's hooks need to share
	// (counters, caches) may be allocated in this method and closed over by
	// the returned hooks.
	New(ctx context.Context) (*Hooks, error)
}

type MiddlewareDesc struct {
	// ConfigSchema is a JSON Schema describing the middleware's configuration.
	ConfigSchema map[string]any `json:"configSchema,omitempty"`
	// Description explains what the middleware does.
	Description string `json:"description,omitempty"`
	// Metadata contains additional context for the middleware.
	Metadata map[string]any `json:"metadata,omitempty"`
	// Name is the middleware's unique identifier.
	Name string `json:"name,omitempty"`
	// contains filtered or unexported fields
}

type MiddlewareFunc func(ctx context.Context) (*Hooks, error)

type MiddlewarePlugin interface {
	Middlewares(ctx context.Context) ([]*MiddlewareDesc, error)
}

type MiddlewareRef struct {
	// Config contains the middleware configuration.
	Config any `json:"config,omitempty"`
	// Name is the name of the registered middleware.
	Name string `json:"name,omitempty"`
}

type Model interface {
	// Name returns the registry name of the model.
	Name() string
	// Generate applies the [Model] to provided request, handling tool requests and handles streaming.
	Generate(ctx context.Context, req *ModelRequest, cb ModelStreamCallback) (*ModelResponse, error)
	// Register registers the model with the given registry.
	Register(r api.Registry)
}

type ModelAction struct {
	// contains filtered or unexported fields
}

type ModelActionFunc[Config any] = func(context.Context, *ModelRequest, Config, ModelStreamCallback) (*ModelResponse, error)

type ModelArg interface {
	Name() string
}

type ModelFunc = core.StreamingFunc[*ModelRequest, *ModelResponse, *ModelResponseChunk]

type ModelInfo struct {
	// ConfigSchema defines the model-specific configuration schema.
	ConfigSchema map[string]any `json:"configSchema,omitempty"`
	// Label is a friendly display name for this model (e.g., "Google AI - Gemini Pro").
	Label string `json:"label,omitempty"`
	// Stage indicates the development stage of this model.
	// Featured models are recommended for general use, stable models are well-tested,
	// unstable models are experimental, legacy models are not recommended for new projects,
	// and deprecated models may be removed in future versions.
	Stage ModelStage `json:"stage,omitempty"`
	// Supports describes the capabilities that this model supports.
	Supports *ModelSupports `json:"supports,omitempty"`
	// Versions lists acceptable names for this model (e.g., different versions).
	Versions []string `json:"versions,omitempty"`
}

type ModelNext = func(ctx context.Context, params *ModelParams) (*ModelResponse, error)

type ModelOperation = core.Operation[*ModelResponse]

type ModelOptions struct {
	// ConfigSchema is the JSON schema for the model's config. Inferred from the
	// constructor's Config type parameter when nil.
	ConfigSchema map[string]any
	// Label is a user-friendly name for the model. Defaults to its name.
	Label string
	// Stage indicates the maturity stage of the model.
	Stage ModelStage
	// Supports describes what the model can do. A nil value claims nothing.
	Supports *ModelSupports
	// Versions lists the model versions a request may pin through its config.
	Versions []string
	// Metadata is arbitrary key-value data attached to the action descriptor.
	Metadata map[string]any
}

type ModelOutputConfig struct {
	// Constrained indicates whether to enforce strict adherence to the schema.
	Constrained bool `json:"constrained,omitempty"`
	// ContentType specifies the MIME type of the output content.
	ContentType string `json:"contentType,omitempty"`
	// Format specifies the desired output format (e.g., "json", "text").
	Format string `json:"format,omitempty"`
	// Schema is a JSON Schema describing the desired structure of the output.
	Schema map[string]any `json:"schema,omitempty"`
}

type ModelParams struct {
	// Request is the model request about to be sent.
	Request *ModelRequest
	// Callback is the streaming callback, or nil if not streaming.
	Callback ModelStreamCallback
}

type ModelRef struct {
	// contains filtered or unexported fields
}

type ModelReference struct {
	Config any    `json:"config,omitempty"`
	Name   string `json:"name,omitempty"`
}

type ModelRequest struct {
	// Config holds model-specific configuration parameters.
	Config any `json:"config,omitempty"`
	// Docs provides retrieved documents to be used as context for this generation.
	Docs []*Document `json:"docs,omitempty"`
	// Messages contains the conversation history for the model.
	Messages []*Message `json:"messages,omitempty"`
	// Output describes the desired response format.
	Output *ModelOutputConfig `json:"output,omitempty"`
	// ToolChoice controls how the model uses tools (auto, required, or none).
	ToolChoice ToolChoice `json:"toolChoice,omitempty"`
	// Tools lists the available tools that the model can ask the client to run.
	Tools []*ToolDefinition `json:"tools,omitempty"`
}

type ModelResponse struct {
	// Custom contains model-specific extra information. Deprecated: use Raw instead.
	Custom any `json:"custom,omitempty"`
	// FinishMessage provides additional details about why generation finished.
	FinishMessage string `json:"finishMessage,omitempty"`
	// FinishReason indicates why generation stopped (e.g., stop, length, blocked).
	FinishReason FinishReason `json:"finishReason,omitempty"`
	// LatencyMs is the time the request took in milliseconds.
	LatencyMs float64 `json:"latencyMs,omitempty"`
	// Message contains the generated response content.
	Message *Message `json:"message,omitempty"`
	// Operation provides information about a long-running background task if applicable.
	Operation *Operation `json:"operation,omitempty"`
	// Raw contains the unprocessed model-specific response data.
	Raw any `json:"raw,omitempty"`
	// Request is the ModelRequest struct used to trigger this response.
	Request *ModelRequest `json:"request,omitempty"`
	// Usage describes how many resources were used by this generation request.
	Usage *GenerationUsage `json:"usage,omitempty"`
	// contains filtered or unexported fields
}

type ModelResponseChunk struct {
	// Aggregated indicates whether the chunk includes all data from previous chunks.
	// If false, the chunk is considered incremental.
	Aggregated bool `json:"aggregated,omitempty"`
	// Content is the chunk of message parts to stream right now.
	Content []*Part `json:"content,omitempty"`
	// Custom contains model-specific extra information attached to this chunk.
	Custom any `json:"custom,omitempty"`
	// Index of the message this chunk belongs to.
	Index int `json:"index"`
	// Role indicates the entity that generated this chunk.
	Role Role `json:"role,omitempty"`
	// contains filtered or unexported fields
}

type ModelStage string

type ModelStreamCallback = func(context.Context, *ModelResponseChunk) error

type ModelStreamValue = StreamValue[struct{}, *ModelResponseChunk]

type ModelSupports struct {
	// Constrained indicates the level of constrained generation support (none, all, or no-tools).
	Constrained ConstrainedSupport `json:"constrained,omitempty"`
	// ContentType lists the content types the model supports for output.
	ContentType []string `json:"contentType,omitempty"`
	// Context indicates whether the model can natively support document-based context grounding.
	Context bool `json:"context,omitempty"`
	// LongRunning indicates whether the model supports long-running operations.
	LongRunning bool `json:"longRunning,omitempty"`
	// Media indicates whether the model can process media as part of the prompt (multimodal input).
	Media bool `json:"media,omitempty"`
	// Multiturn indicates whether the model can process historical messages passed with a prompt.
	Multiturn bool `json:"multiturn,omitempty"`
	// Output lists the types of data the model can generate.
	Output []string `json:"output,omitempty"`
	// SystemRole indicates whether the model can accept messages with role "system".
	SystemRole bool `json:"systemRole,omitempty"`
	// ToolChoice indicates whether the model supports controlling tool choice (e.g., forced tool calling).
	ToolChoice bool `json:"toolChoice,omitempty"`
	// Tools indicates whether the model can perform tool calls.
	Tools bool `json:"tools,omitempty"`
}

type MultipartToolFunc[In any] = func(ctx *ToolContext, input In) (*MultipartToolResponse, error)

type MultipartToolResponse struct {
	// Content holds additional message parts providing context or details.
	Content  []*Part        `json:"content,omitempty"`
	Metadata map[string]any `json:"metadata,omitempty"`
	// Output contains the structured output data from the tool.
	Output any `json:"output,omitempty"`
}

type Operation struct {
	// Action is the name of the action being performed by this operation.
	Action string `json:"action"`
	// Done indicates whether the operation has completed.
	Done bool `json:"done"`
	// Error contains error information if the operation failed.
	Error *OperationError `json:"error,omitempty"`
	// Id is the unique identifier for this operation.
	Id string `json:"id"`
	// Metadata contains additional information about the operation.
	Metadata map[string]any `json:"metadata,omitempty"`
	// Output contains the result of the operation if it has completed successfully.
	Output any `json:"output,omitempty"`
}

type OperationError struct {
	// Message describes the error that occurred.
	Message string `json:"message,omitempty"`
}

type OutputOption interface {
	PromptOption
	GenerateOption
	// contains filtered or unexported methods
}

type OutputSchemaOption interface {
	OutputOption
	ToolOption
}

type Part struct {
	Kind         PartKind       `json:"kind,omitempty"`
	ContentType  string         `json:"contentType,omitempty"`  // valid for kind==blob
	Text         string         `json:"text,omitempty"`         // valid for kind∈{text,blob}
	ToolRequest  *ToolRequest   `json:"toolRequest,omitempty"`  // valid for kind==partToolRequest
	ToolResponse *ToolResponse  `json:"toolResponse,omitempty"` // valid for kind==partToolResponse
	Resource     *ResourcePart  `json:"resource,omitempty"`     // valid for kind==partResource
	Custom       map[string]any `json:"custom,omitempty"`       // valid for plugin-specific custom parts
	Metadata     map[string]any `json:"metadata,omitempty"`     // valid for all kinds
}

type PartKind int8

type PartsFn = func(context.Context, any) ([]*Part, error)

type PathMetadata struct {
	// Error contains error information if the path failed.
	Error string `json:"error,omitempty"`
	// Latency is the execution time for this path in milliseconds.
	Latency float64 `json:"latency,omitempty"`
	// Path is the identifier for this execution path.
	Path string `json:"path,omitempty"`
	// Status indicates the outcome of this path.
	Status string `json:"status,omitempty"`
}

type Prompt interface {
	// Name returns the name of the prompt.
	Name() string
	// Execute executes the prompt with the given options and returns a [ModelResponse].
	//
	// # Options
	//
	// Input:
	//
	//   - [WithInput]: Supply the prompt's input, overriding the default from [WithInputType]
	//
	// Conversation:
	//
	//   - [WithMessages]: Supply the conversation this execution continues
	//   - [WithMessagesFn]: As above, computed from the input
	//
	// A prompt that declares a conversation of its own decides where these go,
	// with {{history}} or [HistoryFromContext]. One that declares none uses
	// them directly, between the system message and the user prompt.
	//
	// Overrides, each replacing what the prompt was defined with:
	//
	//   - [WithModel], [WithModelName]: Call a different model
	//   - [WithConfig]: Replace the generation config
	//   - [WithDocs], [WithTextDocs]: Replace the context documents, skipping any [WithDocsFn]
	//   - [WithTools], [WithToolChoice], [WithMaxTurns], [WithReturnToolRequests]: Change tool behavior
	//   - [WithMiddleware], [WithUse]: Add middleware for this execution
	//   - [WithStreaming]: Receive streamed chunks
	Execute(ctx context.Context, opts ...PromptExecuteOption) (*ModelResponse, error)
	// ExecuteStream executes the prompt with streaming and returns an iterator.
	// It accepts the same options as Execute.
	ExecuteStream(ctx context.Context, opts ...PromptExecuteOption) iter.Seq2[*ModelStreamValue, error]
	// Render renders the prompt with the given input and returns a [GenerateActionOptions] to be used with [GenerateWithRequest].
	Render(ctx context.Context, input any) (*GenerateActionOptions, error)
}

type PromptExecuteOption interface {
	// contains filtered or unexported methods
}

type PromptFn = func(context.Context, any) (string, error)

type PromptOption interface {
	// contains filtered or unexported methods
}

type PromptingOption interface {
	PromptOption
	GenerateOption
	// contains filtered or unexported methods
}

type RankedDocumentData struct {
	// Content holds the document's parts (text and media).
	Content []*Part `json:"content,omitempty"`
	// Metadata contains the reranking score and other arbitrary key-value data.
	Metadata *RankedDocumentMetadata `json:"metadata,omitempty"`
}

type RankedDocumentMetadata struct {
	// Score is the relevance score assigned by the reranker.
	Score float64 `json:"score,omitempty"`
}

type RerankerRequest struct {
	// Documents is the array of documents to rerank.
	Documents []*Document `json:"documents,omitempty"`
	// Options contains reranker-specific configuration parameters.
	Options any `json:"options,omitempty"`
	// Query is the document to use for reranking.
	Query *Document `json:"query,omitempty"`
}

type RerankerResponse struct {
	// Documents is the array of reranked documents with scores.
	Documents []*RankedDocumentData `json:"documents,omitempty"`
}

type Resource interface {
	// Name returns the name of the resource.
	Name() string
	// Matches reports whether this resource matches the given URI.
	Matches(uri string) bool
	// ExtractVariables extracts variables from a URI using this resource's template.
	ExtractVariables(uri string) (map[string]string, error)
	// Execute runs the resource with the given input.
	Execute(ctx context.Context, input *ResourceInput) (*ResourceOutput, error)
	// Register registers the resource with the given registry.
	Register(r api.Registry)
}

type ResourceFunc = func(context.Context, *ResourceInput) (*ResourceOutput, error)

type ResourceInput struct {
	URI       string            `json:"uri"`       // The resource URI
	Variables map[string]string `json:"variables"` // Extracted variables from URI template matching
}

type ResourceOptions struct {
	// URI is the resource's static URI. Mutually exclusive with Template.
	URI string
	// Template is a URI template the resource matches. Mutually exclusive with URI.
	Template string
	// Description is the resource's human-readable description.
	Description string
	// Metadata is arbitrary key-value data attached to the action descriptor.
	Metadata map[string]any
}

type ResourceOutput struct {
	Content []*Part `json:"content"` // The content parts returned by the resource
}

type ResourcePart struct {
	// Uri is the URI of the external resource.
	Uri string `json:"uri,omitempty"`
}

type RespondOptions struct {
	// Metadata is additional metadata to include in the response.
	Metadata map[string]any
}

type RespondWithOption[Out any] interface {
	// contains filtered or unexported methods
}

type RestartOptions struct {
	// ReplaceInput allows replacing the existing input arguments to the tool with different ones,
	// for example if the user revised an action before confirming. When input is replaced,
	// the existing tool request will be amended in the message history.
	ReplaceInput any
	// ResumedMetadata is the metadata you want to provide to the tool to aide in reprocessing.
	// Defaults to true if none is supplied.
	ResumedMetadata any
}

type RestartWithOption[In any] interface {
	// contains filtered or unexported methods
}

type Retriever interface {
	// Name returns the name of the retriever.
	Name() string
	// Retrieve retrieves the documents.
	Retrieve(ctx context.Context, req *RetrieverRequest) (*RetrieverResponse, error)
	// Register registers the retriever with the given registry.
	Register(r api.Registry)
}

type RetrieverAction struct {
	// contains filtered or unexported fields
}

type RetrieverActionFunc[Config any] = func(context.Context, *RetrieverRequest, Config) (*RetrieverResponse, error)

type RetrieverArg interface {
	Name() string
}

type RetrieverFunc = func(context.Context, *RetrieverRequest) (*RetrieverResponse, error)

type RetrieverOption interface {
	// contains filtered or unexported methods
}

type RetrieverOptions struct {
	// ConfigSchema is the JSON schema for the retriever's config.
	ConfigSchema map[string]any `json:"configSchema,omitempty"`
	// Label is a user-friendly name for the retriever.
	Label string `json:"label,omitempty"`
	// Supports defines the capabilities of the retriever, such as media support.
	Supports *RetrieverSupports `json:"supports,omitempty"`
	// Metadata is arbitrary key-value data attached to the action descriptor.
	Metadata map[string]any `json:"-"`
}

type RetrieverRef struct {
	// contains filtered or unexported fields
}

type RetrieverRequest struct {
	// Options contains retriever-specific configuration parameters.
	Options any `json:"options,omitempty"`
	// Query is the document to use for retrieval.
	Query *Document `json:"query,omitempty"`
}

type RetrieverResponse struct {
	// Documents is the array of retrieved documents.
	Documents []*Document `json:"documents,omitempty"`
}

type RetrieverSupports struct {
	// Media indicates whether the retriever supports media content.
	Media bool `json:"media,omitempty"`
}

type Role string

type Score struct {
	Id      string         `json:"id,omitempty"`
	Score   any            `json:"score,omitempty"`
	Status  string         `json:"status,omitempty" jsonschema:"enum=UNKNOWN,enum=FAIL,enum=PASS"`
	Error   string         `json:"error,omitempty"`
	Details map[string]any `json:"details,omitempty"`
}

type ScoreDetails struct {
	// Reasoning explains the rationale behind the score.
	Reasoning string `json:"reasoning,omitempty"`
}

type ScoreStatus int

type StartModelOpFunc = func(ctx context.Context, req *ModelRequest) (*ModelOperation, error)

type StreamValue[Out, Stream any] struct {
	Done     bool
	Chunk    Stream         // valid if Done is false
	Output   Out            // valid if Done is true
	Response *ModelResponse // valid if Done is true
}

type StreamingFormatHandler interface {
	// ParseOutput parses the final output and returns parsed output.
	ParseOutput(message *Message) (any, error)
	// ParseChunk processes a streaming chunk and returns parsed output.
	// The handler maintains its own internal state. When the chunk's index changes, the state is reset for the new turn.
	// Returns parsed output, or nil if nothing can be parsed yet.
	ParseChunk(chunk *ModelResponseChunk) (any, error)
}

type Tool interface {
	// Name returns the name of the tool.
	Name() string
	// Definition returns the definition for this tool to be passed to models.
	Definition() *ToolDefinition
	// RunRaw runs this tool using the provided raw input and returns just the output.
	RunRaw(ctx context.Context, input any) (any, error)
	// RunRawMultipart runs this tool and returns the full [MultipartToolResponse].
	RunRawMultipart(ctx context.Context, input any) (*MultipartToolResponse, error)
	// Respond constructs a [Part] with a [ToolResponse] for a given interrupted tool request.
	Respond(toolReq *Part, outputData any, opts *RespondOptions) *Part
	// Restart constructs a [Part] with a new [ToolRequest] to re-trigger a tool,
	// potentially with new input and metadata.
	Restart(toolReq *Part, opts *RestartOptions) *Part
	// Register registers the tool with the given registry.
	Register(r api.Registry)
}

type ToolAction[In, Out any] struct {
	// contains filtered or unexported fields
}