agent

type AdvancedAgentDefinition struct {
	*BaseAgentDefinition
	// contains filtered or unexported fields
}

type Agent interface {
	// Core execution
	Execute(ctx context.Context, input string) (*AgentExecution, error)

	// Configuration
	GetConfig() *AgentConfig
	UpdateConfig(config *AgentConfig)

	// State management
	GetGraph() *core.Graph
	// IsRunning returns true if the agent is currently executing
	IsRunning() bool

	// Conversation management
	GetConversation() []llm.Message
	ClearConversation()
	// SeedConversation restores prior ReAct messages (HITL mid-run resume).
	SeedConversation(messages []llm.Message)

	// History management
	GetExecutionHistory() []AgentExecution
	ClearHistory()

	// Metadata
	Name() string
}

type AgentConfig struct {
	ID              string         `json:"id" yaml:"id"`
	Name            string         `json:"name" yaml:"name"`
	Type            AgentType      `json:"type" yaml:"type"`
	Model           string         `json:"model" yaml:"model"`
	Provider        string         `json:"provider" yaml:"provider"`
	SystemPrompt    string         `json:"system_prompt" yaml:"system_prompt"`
	Temperature     float64        `json:"temperature" yaml:"temperature"`
	MaxTokens       int            `json:"max_tokens" yaml:"max_tokens"`
	MaxIterations   int            `json:"max_iterations" yaml:"max_iterations"`
	Tools           []string       `json:"tools" yaml:"tools"`
	EnableStreaming bool           `json:"enable_streaming" yaml:"enable_streaming"`
	StreamingMode   llm.StreamMode `json:"streaming_mode,omitempty" yaml:"streaming_mode,omitempty"`
	// EarlyExit cancels remaining stream tokens once a complete JSON/tool-call
	// is formed. Nil disables token-stream early-exit (multipass JSON exit still applies).
	EarlyExit    llm.EarlyExitFunc        `json:"-" yaml:"-"`
	Timeout      time.Duration            `json:"timeout" yaml:"timeout"`
	Metadata     map[string]interface{}   `json:"metadata" yaml:"metadata"`
	Middleware   []Middleware             `json:"-" yaml:"-"`
	InterruptOn  []string                 `json:"interrupt_on" yaml:"interrupt_on"`
	Checkpointer persistence.Checkpointer `json:"-" yaml:"-"`
}

type AgentDefinition interface {
	// GetConfig returns the base configuration for the agent
	GetConfig() *AgentConfig

	// Initialize sets up the agent with the provided managers
	Initialize(llmManager *llm.ProviderManager, toolRegistry *tools.ToolRegistry) error

	// CreateAgent creates and returns the configured agent instance
	CreateAgent() (Agent, error)

	// GetMetadata returns additional metadata about the agent
	GetMetadata() map[string]interface{}

	// Validate validates the agent definition
	Validate() error
}

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

type AgentExecution struct {
	ID     string      `json:"id"`
	Input  string      `json:"input"`
	Output interface{} `json:"output"`
	// StructuredOutput carries a schema-shaped result when the agent declares
	// one; Output stays a flat value for backward compatibility.
	StructuredOutput interface{}    `json:"structured_output,omitempty"`
	Success          bool           `json:"success"`
	StartTime        time.Time      `json:"timestamp"`
	EndTime          time.Time      `json:"end_time"`
	Duration         time.Duration  `json:"duration"`
	Status           string         `json:"status"` // "running", "completed", "failed", "interrupted"
	Steps            []AgentStep    `json:"steps,omitempty"`
	ToolCalls        []llm.ToolCall `json:"tool_calls"`
	// Error holds the Go error and is not serialisable: a Go error marshals to
	// an empty object, so a failed execution used to reach clients with no
	// explanation at all. ErrorMessage carries the reason over the wire.
	Error        error                  `json:"-"`
	ErrorMessage string                 `json:"error,omitempty"`
	Metadata     map[string]interface{} `json:"metadata,omitempty"`
	// ExecutionPath lists the nodes that ran, in order, and StateChanges the
	// state after each one. Studio highlights its graph view from these.
	ExecutionPath []string      `json:"execution_path"`
	StateChanges  []StateChange `json:"state_changes,omitempty"`
}

type AgentFactory func() AgentDefinition

type AgentInfo struct {
	ID       string                 `json:"id"`
	Source   AgentSource            `json:"source"`
	Config   *AgentConfig           `json:"config,omitempty"`
	Metadata map[string]interface{} `json:"metadata"`
}

type AgentMetrics struct {
	RequestCount   int64         `json:"request_count"`
	ErrorCount     int64         `json:"error_count"`
	AverageLatency time.Duration `json:"average_latency"`
	LastRequest    time.Time     `json:"last_request"`
	TotalLatency   time.Duration `json:"total_latency"`
}

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

type AgentSource string

type AgentState struct {
	ID           string                 `json:"id"`
	Status       string                 `json:"status"` // "starting", "running", "stopping", "stopped", "error"
	StartedAt    time.Time              `json:"started_at"`
	UpdatedAt    time.Time              `json:"updated_at"`
	RequestCount int64                  `json:"request_count"`
	ErrorCount   int64                  `json:"error_count"`
	LastRequest  time.Time              `json:"last_request"`
	LastError    string                 `json:"last_error"`
	HealthStatus string                 `json:"health_status"`
	Metadata     map[string]interface{} `json:"metadata"`
}

type AgentStep struct {
	NodeID    string                 `json:"node_id"`
	Timestamp time.Time              `json:"timestamp"`
	Input     map[string]interface{} `json:"input,omitempty"`
	Output    map[string]interface{} `json:"output,omitempty"`
	Error     error                  `json:"-"`
}

type AgentType string

type AlertRule struct {
	Name        string            `json:"name" yaml:"name"`
	Description string            `json:"description" yaml:"description"`
	Metric      string            `json:"metric" yaml:"metric"`
	Condition   string            `json:"condition" yaml:"condition"`
	Threshold   float64           `json:"threshold" yaml:"threshold"`
	Duration    time.Duration     `json:"duration" yaml:"duration"`
	Labels      map[string]string `json:"labels" yaml:"labels"`
	Annotations map[string]string `json:"annotations" yaml:"annotations"`
}

type AlertingConfig struct {
	Enabled  bool            `json:"enabled" yaml:"enabled"`
	Webhooks []WebhookConfig `json:"webhooks" yaml:"webhooks"`
	Email    *EmailConfig    `json:"email" yaml:"email"`
	Slack    *SlackConfig    `json:"slack" yaml:"slack"`
	Rules    []AlertRule     `json:"rules" yaml:"rules"`
}

type AuthConfig struct {
	Type     string                 `json:"type" yaml:"type"` // "jwt", "oauth", "basic", "apikey"
	Config   map[string]interface{} `json:"config" yaml:"config"`
	Enabled  bool                   `json:"enabled" yaml:"enabled"`
	Required bool                   `json:"required" yaml:"required"`
}

type AuthzConfig struct {
	Type    string                 `json:"type" yaml:"type"` // "rbac", "acl", "policy"
	Config  map[string]interface{} `json:"config" yaml:"config"`
	Enabled bool                   `json:"enabled" yaml:"enabled"`
}

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

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

type BaseMiddleware struct{}

type CORSConfig struct {
	Enabled          bool     `json:"enabled" yaml:"enabled"`
	AllowedOrigins   []string `json:"allowed_origins" yaml:"allowed_origins"`
	AllowedMethods   []string `json:"allowed_methods" yaml:"allowed_methods"`
	AllowedHeaders   []string `json:"allowed_headers" yaml:"allowed_headers"`
	ExposedHeaders   []string `json:"exposed_headers" yaml:"exposed_headers"`
	AllowCredentials bool     `json:"allow_credentials" yaml:"allow_credentials"`
	MaxAge           int      `json:"max_age" yaml:"max_age"`
}

type CacheConfig struct {
	Type       string        `json:"type" yaml:"type"`
	Host       string        `json:"host" yaml:"host"`
	Port       int           `json:"port" yaml:"port"`
	Password   string        `json:"password" yaml:"password"`
	Database   int           `json:"database" yaml:"database"`
	TTL        time.Duration `json:"ttl" yaml:"ttl"`
	MaxRetries int           `json:"max_retries" yaml:"max_retries"`
}

type Command struct {
	// Update contains state changes to apply
	Update map[string]interface{}
	// Resume contains instructions to resume from an interrupt
	Resume *ResumeCommand
	// Goto specifies a specific node to navigate to
	Goto string
}

type CustomAgentDefinition interface {
	AgentDefinition

	// BuildGraph allows custom graph construction
	BuildGraph() (*core.Graph, error)

	// GetCustomTools returns custom tools specific to this agent
	GetCustomTools() []tools.Tool

	// GetCustomMiddleware returns custom middleware for this agent
	GetCustomMiddleware() []func(next func(*core.BaseState) (*core.BaseState, error)) func(*core.BaseState) (*core.BaseState, error)
}

type CustomMetricConfig struct {
	Name        string `json:"name" yaml:"name"`
	Type        string `json:"type" yaml:"type"`
	Query       string `json:"query" yaml:"query"`
	TargetValue string `json:"target_value" yaml:"target_value"`
	Resource    string `json:"resource" yaml:"resource"`
}

type DNSConfig struct {
	Policy      string   `json:"policy" yaml:"policy"`
	Nameservers []string `json:"nameservers" yaml:"nameservers"`
	Searches    []string `json:"searches" yaml:"searches"`
	Options     []string `json:"options" yaml:"options"`
}

type DatabaseConfig struct {
	Type         string        `json:"type" yaml:"type"`
	Host         string        `json:"host" yaml:"host"`
	Port         int           `json:"port" yaml:"port"`
	Database     string        `json:"database" yaml:"database"`
	Username     string        `json:"username" yaml:"username"`
	Password     string        `json:"password" yaml:"password"`
	SSLMode      string        `json:"ssl_mode" yaml:"ssl_mode"`
	MaxConns     int           `json:"max_conns" yaml:"max_conns"`
	MaxIdleConns int           `json:"max_idle_conns" yaml:"max_idle_conns"`
	MaxLifetime  time.Duration `json:"max_lifetime" yaml:"max_lifetime"`
}

type Decision struct {
	// Type is one of: "approve", "edit", "reject", "response"
	Type string
	// Args contains additional arguments for edit/response types
	// For "edit": {"action": "tool_name", "args": {...}}
	// For "response": {"response": "text to return as tool result"}
	Args map[string]interface{}
}

type DeploymentConfig struct {
	Type        string                 `json:"type" yaml:"type"` // "docker", "kubernetes", "serverless"
	Environment string                 `json:"environment" yaml:"environment"`
	Replicas    int                    `json:"replicas" yaml:"replicas"`
	Resources   *ResourceConfig        `json:"resources" yaml:"resources"`
	Networking  *NetworkingConfig      `json:"networking" yaml:"networking"`
	Scaling     *ScalingConfig         `json:"scaling" yaml:"scaling"`
	HealthCheck *HealthCheckConfig     `json:"health_check" yaml:"health_check"`
	Secrets     map[string]string      `json:"secrets" yaml:"secrets"`
	ConfigMaps  map[string]string      `json:"config_maps" yaml:"config_maps"`
	Volumes     []VolumeConfig         `json:"volumes" yaml:"volumes"`
	Metadata    map[string]interface{} `json:"metadata" yaml:"metadata"`
}

type DeploymentState struct {
	Status      string                 `json:"status"`
	StartedAt   time.Time              `json:"started_at"`
	UpdatedAt   time.Time              `json:"updated_at"`
	AgentStates map[string]*AgentState `json:"agent_states"`
	ErrorCount  int                    `json:"error_count"`
	LastError   string                 `json:"last_error"`
	Metadata    map[string]interface{} `json:"metadata"`
}

type EmailConfig struct {
	SMTP     *SMTPConfig `json:"smtp" yaml:"smtp"`
	From     string      `json:"from" yaml:"from"`
	To       []string    `json:"to" yaml:"to"`
	Subject  string      `json:"subject" yaml:"subject"`
	Template string      `json:"template" yaml:"template"`
}

type EncryptionAtRestConfig struct {
	Enabled   bool   `json:"enabled" yaml:"enabled"`
	Algorithm string `json:"algorithm" yaml:"algorithm"`
	KeyID     string `json:"key_id" yaml:"key_id"`
	Provider  string `json:"provider" yaml:"provider"`
}

type EncryptionConfig struct {
	AtRest    *EncryptionAtRestConfig    `json:"at_rest" yaml:"at_rest"`
	InTransit *EncryptionInTransitConfig `json:"in_transit" yaml:"in_transit"`
}

type EncryptionInTransitConfig struct {
	Enabled  bool     `json:"enabled" yaml:"enabled"`
	MinTLS   string   `json:"min_tls" yaml:"min_tls"`
	Ciphers  []string `json:"ciphers" yaml:"ciphers"`
	CertFile string   `json:"cert_file" yaml:"cert_file"`
	KeyFile  string   `json:"key_file" yaml:"key_file"`
}

type ErrorHandlerFunc func(error) string

type ExtendedAgentConfig struct {
	*AgentConfig
	Path         string             `json:"path" yaml:"path"`
	Port         int                `json:"port" yaml:"port"`
	Host         string             `json:"host" yaml:"host"`
	Subdomain    string             `json:"subdomain" yaml:"subdomain"`
	Schema       *SchemaConfig      `json:"schema" yaml:"schema"`
	Middleware   []MiddlewareConfig `json:"middleware" yaml:"middleware"`
	Resources    *ResourceConfig    `json:"resources" yaml:"resources"`
	Scaling      *ScalingConfig     `json:"scaling" yaml:"scaling"`
	Environment  map[string]string  `json:"environment" yaml:"environment"`
	Secrets      map[string]string  `json:"secrets" yaml:"secrets"`
	ConfigMaps   map[string]string  `json:"config_maps" yaml:"config_maps"`
	Volumes      []VolumeConfig     `json:"volumes" yaml:"volumes"`
	Dependencies []string           `json:"dependencies" yaml:"dependencies"`
	Priority     int                `json:"priority" yaml:"priority"`
	Labels       map[string]string  `json:"labels" yaml:"labels"`
	Annotations  map[string]string  `json:"annotations" yaml:"annotations"`
	Disabled     bool               `json:"disabled" yaml:"disabled"`
}

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

type FilesystemMiddleware struct {
	BaseMiddleware
	// contains filtered or unexported fields
}

type HTTPHeader struct {
	Name  string `json:"name" yaml:"name"`
	Value string `json:"value" yaml:"value"`
}

type HealthCheckConfig struct {
	Enabled             bool                          `json:"enabled" yaml:"enabled"`
	Path                string                        `json:"path" yaml:"path"`
	Port                int                           `json:"port" yaml:"port"`
	InitialDelaySeconds int                           `json:"initial_delay_seconds" yaml:"initial_delay_seconds"`
	PeriodSeconds       int                           `json:"period_seconds" yaml:"period_seconds"`
	TimeoutSeconds      int                           `json:"timeout_seconds" yaml:"timeout_seconds"`
	SuccessThreshold    int                           `json:"success_threshold" yaml:"success_threshold"`
	FailureThreshold    int                           `json:"failure_threshold" yaml:"failure_threshold"`
	HTTPHeaders         []HTTPHeader                  `json:"http_headers" yaml:"http_headers"`
	AgentSpecific       map[string]*HealthCheckConfig `json:"agent_specific" yaml:"agent_specific"`
}

type HealthChecker struct {
	AgentID string
	Config  *HealthCheckConfig
	Logger  *logrus.Logger
	// contains filtered or unexported fields
}

type HealthCheckerSnapshot struct {
	AgentID          string    `json:"agent_id"`
	Status           string    `json:"status"`
	LastCheck        time.Time `json:"last_check"`
	ConsecutiveFails int       `json:"consecutive_fails"`
	LastError        string    `json:"last_error,omitempty"`
}

type IngressConfig struct {
	Enabled     bool              `json:"enabled" yaml:"enabled"`
	ClassName   string            `json:"class_name" yaml:"class_name"`
	Hosts       []string          `json:"hosts" yaml:"hosts"`
	Rules       []IngressRule     `json:"rules" yaml:"rules"`
	TLS         []IngressTLS      `json:"tls" yaml:"tls"`
	Annotations map[string]string `json:"annotations" yaml:"annotations"`
}

type IngressPath struct {
	Path        string `json:"path" yaml:"path"`
	PathType    string `json:"path_type" yaml:"path_type"`
	ServiceName string `json:"service_name" yaml:"service_name"`
	ServicePort int    `json:"service_port" yaml:"service_port"`
	AgentID     string `json:"agent_id" yaml:"agent_id"`
}

type IngressRule struct {
	Host    string        `json:"host" yaml:"host"`
	Paths   []IngressPath `json:"paths" yaml:"paths"`
	AgentID string        `json:"agent_id" yaml:"agent_id"`
}

type IngressTLS struct {
	Hosts      []string `json:"hosts" yaml:"hosts"`
	SecretName string   `json:"secret_name" yaml:"secret_name"`
}

type InterruptData struct {
	// ToolCalls are the pending tool calls awaiting approval
	ToolCalls []llm.ToolCall
	// AllowedActions maps tool names to allowed decision types
	// e.g., {"delete_file": ["approve", "reject"], "send_email": ["approve", "edit", "reject"]}
	AllowedActions map[string][]string
}

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

type LLMProviderConfig struct {
	Type       string                 `json:"type" yaml:"type"`
	APIKey     string                 `json:"api_key" yaml:"api_key"`
	Endpoint   string                 `json:"endpoint" yaml:"endpoint"`
	Model      string                 `json:"model" yaml:"model"`
	Config     map[string]interface{} `json:"config" yaml:"config"`
	Timeout    time.Duration          `json:"timeout" yaml:"timeout"`
	MaxRetries int                    `json:"max_retries" yaml:"max_retries"`
}

type LoggingConfig struct {
	Level      string            `json:"level" yaml:"level"`
	Format     string            `json:"format" yaml:"format"`
	Output     []string          `json:"output" yaml:"output"`
	Structured bool              `json:"structured" yaml:"structured"`
	Fields     map[string]string `json:"fields" yaml:"fields"`
}

type MetricsConfig struct {
	Enabled   bool   `json:"enabled" yaml:"enabled"`
	Path      string `json:"path" yaml:"path"`
	Port      int    `json:"port" yaml:"port"`
	Namespace string `json:"namespace" yaml:"namespace"`
	Subsystem string `json:"subsystem" yaml:"subsystem"`
}

type Middleware interface {
	// Name returns the name of the middleware
	Name() string
	// BeforeRun is called before the agent execution starts
	BeforeRun(ctx context.Context, agent *BaseAgent, input string) (string, error)
	// AfterRun is called after the agent execution finishes
	AfterRun(ctx context.Context, agent *BaseAgent, result *AgentExecution) (*AgentExecution, error)
}

type MiddlewareConfig struct {
	Type    string                 `json:"type" yaml:"type"`
	Config  map[string]interface{} `json:"config" yaml:"config"`
	Enabled bool                   `json:"enabled" yaml:"enabled"`
}

type MiddlewareFunc func(next http.Handler) http.Handler

type MonitoringConfig struct {
	Enabled  bool            `json:"enabled" yaml:"enabled"`
	Metrics  *MetricsConfig  `json:"metrics" yaml:"metrics"`
	Tracing  *TracingConfig  `json:"tracing" yaml:"tracing"`
	Alerting *AlertingConfig `json:"alerting" yaml:"alerting"`
}

type MultiAgentConfig struct {
	Name        string                  `json:"name" yaml:"name"`
	Version     string                  `json:"version" yaml:"version"`
	Description string                  `json:"description" yaml:"description"`
	Agents      map[string]*AgentConfig `json:"agents" yaml:"agents"`
	Routing     *RoutingConfig          `json:"routing" yaml:"routing"`
	Deployment  *DeploymentConfig       `json:"deployment" yaml:"deployment"`
	Shared      *SharedConfig           `json:"shared" yaml:"shared"`
	Metadata    map[string]interface{}  `json:"metadata" yaml:"metadata"`
}

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

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

type MultiAgentMetrics struct {
	TotalRequests  int64                    `json:"total_requests"`
	TotalErrors    int64                    `json:"total_errors"`
	AgentMetrics   map[string]*AgentMetrics `json:"agent_metrics"`
	RoutingMetrics *RoutingMetrics          `json:"routing_metrics"`
	LastUpdated    time.Time                `json:"last_updated"`
	// contains filtered or unexported fields
}

type NetworkingConfig struct {
	Type        string            `json:"type" yaml:"type"` // "ClusterIP", "NodePort", "LoadBalancer"
	Ports       []PortConfig      `json:"ports" yaml:"ports"`
	Ingress     *IngressConfig    `json:"ingress" yaml:"ingress"`
	DNS         *DNSConfig        `json:"dns" yaml:"dns"`
	TLS         *TLSConfig        `json:"tls" yaml:"tls"`
	Proxy       *ProxyConfig      `json:"proxy" yaml:"proxy"`
	Annotations map[string]string `json:"annotations" yaml:"annotations"`
}

type PortConfig struct {
	Name       string `json:"name" yaml:"name"`
	Port       int    `json:"port" yaml:"port"`
	TargetPort int    `json:"target_port" yaml:"target_port"`
	Protocol   string `json:"protocol" yaml:"protocol"`
	AgentID    string `json:"agent_id" yaml:"agent_id"`
}

type PropertyDefinition struct {
	Type        string                         `json:"type" yaml:"type"`
	Description string                         `json:"description" yaml:"description"`
	Properties  map[string]*PropertyDefinition `json:"properties" yaml:"properties"`
	Items       *PropertyDefinition            `json:"items" yaml:"items"`
	Required    []string                       `json:"required" yaml:"required"`
	MinLength   int                            `json:"min_length" yaml:"min_length"`
	MaxLength   int                            `json:"max_length" yaml:"max_length"`
	Minimum     float64                        `json:"minimum" yaml:"minimum"`
	Maximum     float64                        `json:"maximum" yaml:"maximum"`
	Pattern     string                         `json:"pattern" yaml:"pattern"`
	Format      string                         `json:"format" yaml:"format"`
	Enum        []interface{}                  `json:"enum" yaml:"enum"`
	Default     interface{}                    `json:"default" yaml:"default"`
	Example     interface{}                    `json:"example" yaml:"example"`
}

type ProxyConfig struct {
	Enabled      bool              `json:"enabled" yaml:"enabled"`
	Type         string            `json:"type" yaml:"type"` // "http", "socks5"
	URL          string            `json:"url" yaml:"url"`
	Headers      map[string]string `json:"headers" yaml:"headers"`
	Timeout      time.Duration     `json:"timeout" yaml:"timeout"`
	Retries      int               `json:"retries" yaml:"retries"`
	MaxIdleConns int               `json:"max_idle_conns" yaml:"max_idle_conns"`
}

type RateLimit struct {
	Requests  int           `json:"requests" yaml:"requests"`
	Period    time.Duration `json:"period" yaml:"period"`
	Burst     int           `json:"burst" yaml:"burst"`
	SkipPaths []string      `json:"skip_paths" yaml:"skip_paths"`
}

type RateLimitConfig struct {
	Enabled    bool                  `json:"enabled" yaml:"enabled"`
	Global     *RateLimit            `json:"global" yaml:"global"`
	PerAgent   map[string]*RateLimit `json:"per_agent" yaml:"per_agent"`
	PerUser    *RateLimit            `json:"per_user" yaml:"per_user"`
	PerIP      *RateLimit            `json:"per_ip" yaml:"per_ip"`
	BurstLimit int                   `json:"burst_limit" yaml:"burst_limit"`
	WindowSize time.Duration         `json:"window_size" yaml:"window_size"`
}

type ResourceConfig struct {
	CPU      string `json:"cpu" yaml:"cpu"`
	Memory   string `json:"memory" yaml:"memory"`
	Storage  string `json:"storage" yaml:"storage"`
	GPU      string `json:"gpu" yaml:"gpu"`
	Requests *struct {
		CPU     string `json:"cpu" yaml:"cpu"`
		Memory  string `json:"memory" yaml:"memory"`
		Storage string `json:"storage" yaml:"storage"`
	} `json:"requests" yaml:"requests"`
	Limits *struct {
		CPU     string `json:"cpu" yaml:"cpu"`
		Memory  string `json:"memory" yaml:"memory"`
		Storage string `json:"storage" yaml:"storage"`
	} `json:"limits" yaml:"limits"`
}

type ResumeCommand struct {
	// Decisions contains one decision per interrupted action, in order
	Decisions []Decision
}

type RoutingCondition struct {
	Type     string `json:"type" yaml:"type"` // "header", "query", "ip", "method"
	Key      string `json:"key" yaml:"key"`
	Value    string `json:"value" yaml:"value"`
	Operator string `json:"operator" yaml:"operator"` // "equals", "contains", "regex", "prefix", "suffix"
}

type RoutingConfig struct {
	Type         string             `json:"type" yaml:"type"` // "path", "header", "query", "subdomain"
	DefaultAgent string             `json:"default_agent" yaml:"default_agent"`
	Rules        []RoutingRule      `json:"rules" yaml:"rules"`
	Middleware   []MiddlewareConfig `json:"middleware" yaml:"middleware"`
}

type RoutingMetrics struct {
	RoutingDecisions map[string]int64 `json:"routing_decisions"`
	DefaultRoutes    int64            `json:"default_routes"`
	FailedRoutes     int64            `json:"failed_routes"`
}

type RoutingRule struct {
	ID      string `json:"id" yaml:"id"`
	Pattern string `json:"pattern" yaml:"pattern"`
	// Match selects how Pattern is compared against the request path: one of
	// exact, prefix, suffix, contains or regex. Empty means exact, which is
	// what the HTTP router has always done for path routing.
	//
	// This field exists because matchesRule used to switch on Pattern itself
	// against the literal strings "prefix"/"suffix"/"exact"/"contains", so the
	// match mode could never be selected and every real pattern silently fell
	// through to prefix matching - disagreeing with the HTTP router, which
	// matched the same rule exactly.
	Match      string                 `json:"match,omitempty" yaml:"match,omitempty"`
	AgentID    string                 `json:"agent_id" yaml:"agent_id"`
	Method     string                 `json:"method" yaml:"method"`
	Priority   int                    `json:"priority" yaml:"priority"`
	Conditions []RoutingCondition     `json:"conditions" yaml:"conditions"`
	Metadata   map[string]interface{} `json:"metadata" yaml:"metadata"`
}

type SMTPConfig struct {
	Host     string `json:"host" yaml:"host"`
	Port     int    `json:"port" yaml:"port"`
	Username string `json:"username" yaml:"username"`
	Password string `json:"password" yaml:"password"`
	TLS      bool   `json:"tls" yaml:"tls"`
}

type ScalingConfig struct {
	Enabled             bool                 `json:"enabled" yaml:"enabled"`
	MinReplicas         int                  `json:"min_replicas" yaml:"min_replicas"`
	MaxReplicas         int                  `json:"max_replicas" yaml:"max_replicas"`
	TargetCPUPercent    int                  `json:"target_cpu_percent" yaml:"target_cpu_percent"`
	TargetMemoryPercent int                  `json:"target_memory_percent" yaml:"target_memory_percent"`
	ScaleUpCooldown     time.Duration        `json:"scale_up_cooldown" yaml:"scale_up_cooldown"`
	ScaleDownCooldown   time.Duration        `json:"scale_down_cooldown" yaml:"scale_down_cooldown"`
	CustomMetrics       []CustomMetricConfig `json:"custom_metrics" yaml:"custom_metrics"`
}

type SchemaConfig struct {
	Input  *SchemaDefinition `json:"input" yaml:"input"`
	Output *SchemaDefinition `json:"output" yaml:"output"`
}

type SchemaDefinition struct {
	Type       string                         `json:"type" yaml:"type"`
	Properties map[string]*PropertyDefinition `json:"properties" yaml:"properties"`
	Required   []string                       `json:"required" yaml:"required"`
	MinLength  int                            `json:"min_length" yaml:"min_length"`
	MaxLength  int                            `json:"max_length" yaml:"max_length"`
	Pattern    string                         `json:"pattern" yaml:"pattern"`
	Format     string                         `json:"format" yaml:"format"`
	Enum       []interface{}                  `json:"enum" yaml:"enum"`
	Example    interface{}                    `json:"example" yaml:"example"`
}

type SecurityConfig struct {
	Authentication *AuthConfig       `json:"authentication" yaml:"authentication"`
	Authorization  *AuthzConfig      `json:"authorization" yaml:"authorization"`
	Encryption     *EncryptionConfig `json:"encryption" yaml:"encryption"`
	RateLimit      *RateLimitConfig  `json:"rate_limit" yaml:"rate_limit"`
	CORS           *CORSConfig       `json:"cors" yaml:"cors"`
	Headers        map[string]string `json:"headers" yaml:"headers"`
}

type SharedConfig struct {
	Database     *DatabaseConfig               `json:"database" yaml:"database"`
	Cache        *CacheConfig                  `json:"cache" yaml:"cache"`
	Logging      *LoggingConfig                `json:"logging" yaml:"logging"`
	Monitoring   *MonitoringConfig             `json:"monitoring" yaml:"monitoring"`
	Security     *SecurityConfig               `json:"security" yaml:"security"`
	Environment  map[string]string             `json:"environment" yaml:"environment"`
	Secrets      map[string]string             `json:"secrets" yaml:"secrets"`
	LLMProviders map[string]*LLMProviderConfig `json:"llm_providers" yaml:"llm_providers"`
}

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

type SlackConfig struct {
	WebhookURL string `json:"webhook_url" yaml:"webhook_url"`
	Channel    string `json:"channel" yaml:"channel"`
	Username   string `json:"username" yaml:"username"`
	IconEmoji  string `json:"icon_emoji" yaml:"icon_emoji"`
}

type StateChange struct {
	NodeID    string                 `json:"node_id"`
	NodeName  string                 `json:"node_name"`
	Timestamp time.Time              `json:"timestamp"`
	Before    map[string]interface{} `json:"before,omitempty"`
	After     map[string]interface{} `json:"after,omitempty"`
	Duration  time.Duration          `json:"duration"`
}

type StatusUpdate struct {
	// Type is the type of update: "progress", "tool_call", "completion", "error"
	Type string
	// Message is a human-readable status message
	Message string
	// Metadata contains additional context
	Metadata map[string]interface{}
}

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

type SubAgentMiddleware struct {
	BaseMiddleware
	// contains filtered or unexported fields
}

type SubAgentRequest struct {
	// AgentID is the identifier of the subagent to execute
	AgentID string
	// Input is the input to pass to the subagent
	Input string
	// Timeout is the maximum duration for subagent execution
	Timeout time.Duration
	// ShareState determines if global state should be shared
	ShareState bool
	// Messages seeds ReAct conversation history on resume (HITL mid-run).
	// When non-empty, the agent continues from this history instead of a cold start.
	Messages []llm.Message
	// Iteration restores the ReAct loop counter on resume.
	Iteration int
	// PendingToolCalls restores in-flight tool calls interrupted mid-act.
	PendingToolCalls []llm.ToolCall
	// Resume skips re-adding Input as a fresh user turn when Messages already end
	// with an equivalent user/assistant/tool exchange.
	Resume bool
	// TaskID is an optional caller tag (persisted in result metadata for checkpoints).
	TaskID string
}

type SubAgentResult struct {
	// AgentID is the identifier of the executed subagent
	AgentID string
	// Output is the final output from the subagent
	Output interface{}
	// State is the final state after execution
	State *core.BaseState
	// Duration is how long the execution took
	Duration time.Duration
	// Error contains any error that occurred
	Error error
	// Messages is the ReAct conversation at exit (including on cancel/interrupt).
	Messages []llm.Message
	// Iteration is the ReAct loop counter at exit.
	Iteration int
	// PendingToolCalls are tool calls awaiting observation (mid-tool-call interrupt).
	PendingToolCalls []llm.ToolCall
	// Provider / Model identify the LLM backend used (for checkpoint restore).
	Provider string
	Model    string
	// TaskID echoes the request tag when set.
	TaskID string
	// Usage aggregates token counts from LLM calls (estimated when providers omit).
	Usage llm.Usage
	// UsageEstimated is true when Usage was filled by heuristics (e.g. early_exit).
	UsageEstimated bool
}

type SummarizationMiddleware struct {
	BaseMiddleware
	// contains filtered or unexported fields
}

type TLSConfig struct {
	Enabled            bool   `json:"enabled" yaml:"enabled"`
	CertFile           string `json:"cert_file" yaml:"cert_file"`
	KeyFile            string `json:"key_file" yaml:"key_file"`
	CAFile             string `json:"ca_file" yaml:"ca_file"`
	InsecureSkipVerify bool   `json:"insecure_skip_verify" yaml:"insecure_skip_verify"`
}

type TodoListMiddleware struct {
	BaseMiddleware
}

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

type ToolRuntime struct {
	// State is the current agent state
	State *core.BaseState
	// Store provides persistent storage across sessions
	Store persistence.Store
	// ToolCallID is the unique identifier for this tool invocation
	ToolCallID string
	// ThreadID is the conversation thread identifier
	ThreadID string
}

type TracingConfig struct {
	Enabled     bool    `json:"enabled" yaml:"enabled"`
	Endpoint    string  `json:"endpoint" yaml:"endpoint"`
	ServiceName string  `json:"service_name" yaml:"service_name"`
	SampleRate  float64 `json:"sample_rate" yaml:"sample_rate"`
}

type VolumeConfig struct {
	Name      string `json:"name" yaml:"name"`
	Type      string `json:"type" yaml:"type"` // "configmap", "secret", "emptydir", "persistentvolume"
	Source    string `json:"source" yaml:"source"`
	MountPath string `json:"mount_path" yaml:"mount_path"`
	ReadOnly  bool   `json:"read_only" yaml:"read_only"`
	AgentID   string `json:"agent_id" yaml:"agent_id"`
}

type WebhookConfig struct {
	URL     string            `json:"url" yaml:"url"`
	Method  string            `json:"method" yaml:"method"`
	Headers map[string]string `json:"headers" yaml:"headers"`
	Timeout time.Duration     `json:"timeout" yaml:"timeout"`
}