gemini

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

type ClientOptions = genai.ClientConfig

type Deps struct {
	Client *Client
}

type Generate struct {
	xmldom.Element

	// Model specifies the Gemini AI model to use for generation.
	// Common values include "gemini-1.5-flash", "gemini-1.5-pro", etc.
	Model string `xml:"model,attr"`

	ModelExpr string `xml:"modelexpr,attr"`

	// Prompt contains the prompt or template for AI generation.
	// This can be a static string or contain data model expressions.
	Prompt string `xml:"prompt,attr"`

	// Location specifies where in the data model to store the generated result.
	// This should be a valid data model location expression.
	Location string `xml:"location,attr"`

	// Stream indicates whether to use streaming generation for real-time responses.
	// When true, responses are delivered progressively as they are generated.
	Stream bool `xml:"stream,attr"`

	// OnChunk specifies the data model location for handling streaming chunks.
	// Only used when Stream is true. Each chunk is assigned to this location.
	OnChunk string `xml:"onchunk,attr"`

	// AutoSelect enables automatic model selection based on prompt complexity.
	// When true, the model attribute becomes optional and is selected automatically.
	AutoSelect bool `xml:"autoselect,attr"`

	// ComplexityHint provides a hint about task complexity for model selection.
	// Valid values: "simple", "moderate", "complex". Optional.
	ComplexityHint string `xml:"complexity,attr"`
	// contains filtered or unexported fields
}

type Model struct {
	Name                  ModelName
	GenerateRateLimiter   *RateLimiter
	TokenCountRateLimiter *RateLimiter
}

type ModelName string

type ModelSelectionResult struct {
	// PrimaryModel is the recommended model for the task
	PrimaryModel ModelName
	// FallbackModels provides alternative models if the primary fails
	FallbackModels []ModelName
	// Complexity contains the analyzed task complexity
	Complexity TaskComplexity
	// SelectionReason explains why this model was chosen
	SelectionReason string
}

type ModelSelectionStrategy struct {
	// PreferredModels maps complexity levels to preferred model names
	PreferredModels map[string]ModelName
	// FallbackChain defines the fallback order when preferred models are rate-limited
	FallbackChain []ModelName
	// MaxFallbackAttempts limits the number of fallback attempts
	MaxFallbackAttempts int
}

type RateLimitError struct {
	Model      ModelName
	RetryAfter time.Duration
	Underlying error
}

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

type RateLimiterOptions struct {
	RPM rate.Limit // Requests per minute
	RPD rate.Limit // Requests per day
	TPM rate.Limit // Tokens per minute

	// Optional bursts to override defaults. If zero or negative, defaults are used:
	//   BurstRPM: ceil(RPM)
	//   BurstRPD: ceil(RPD)
	//   BurstTPM: ceil(TPM)
	BurstRPM int
	BurstRPD int
	BurstTPM int
}

type TaskComplexity struct {
	// Level indicates the complexity level: "simple", "moderate", or "complex"
	Level string
	// Reason explains why this complexity level was chosen
	Reason string
	// Confidence indicates the confidence score (0.0 to 1.0)
	Confidence float64
}