pipeline

type ExecutionConfig struct {
	Provider     providers.Provider
	ToolRegistry *tools.Registry
	Temperature  float32
	MaxTokens    int
	Seed         *int
	ToolPolicy   *ToolPolicy
}

type ExecutionContext struct {
	// Context for cancellation, deadlines, and request-scoped values
	Context context.Context

	// Identifiers for organization and tracking
	RunID          string // Test run or execution batch identifier
	SessionID      string // Session identifier for grouping related conversations
	ConversationID string // Conversation identifier for this specific exchange

	// State (mutable by middleware)
	SystemPrompt     string                    // Populated by PromptAssemblyMiddleware
	Variables        map[string]string         // Populated by PromptAssemblyMiddleware and ContextExtractionMiddleware
	AllowedTools     []string                  // Populated by PromptAssemblyMiddleware
	Messages         []types.Message           // Conversation history + current messages
	Tools            []types.ToolDef           // Available tool definitions
	ToolResults      []types.MessageToolResult // Executed tool results
	PendingToolCalls []types.MessageToolCall   // Tool calls awaiting external completion (human-in-the-loop)
	Prompt           string                    // Assembled prompt (after variable substitution by TemplateMiddleware)

	// Output (populated by middleware)
	Trace       ExecutionTrace // Complete trace of all LLM calls and events
	Response    *Response      // Convenience pointer to the most recent response (= Trace.LLMCalls[len-1].Response)
	RawResponse interface{}    // Convenience pointer to most recent raw response (= Trace.LLMCalls[len-1].RawResponse)

	// Error tracking (middleware can check this to see if an error occurred earlier in the chain)
	Error error // First error encountered during execution (subsequent middleware still run)

	// Metadata (for passing data between middleware)
	Metadata map[string]interface{}

	// Cost tracking (aggregate across all calls)
	CostInfo types.CostInfo

	// Streaming support
	StreamMode        bool                       // If true, use streaming execution
	StreamOutput      chan providers.StreamChunk // Output channel for streaming chunks
	StreamInterrupted bool                       // Set to true by middleware to stop streaming
	InterruptReason   string                     // Reason for interruption

	// Middleware control
	ShortCircuit bool // Set to true by middleware to intentionally skip remaining middleware
	// contains filtered or unexported fields
}

type ExecutionOptions struct {
	// RunID identifies the test run or execution batch
	RunID string

	// SessionID identifies the session for grouping related conversations
	SessionID string

	// ConversationID identifies this specific conversation exchange
	ConversationID string

	// Context for cancellation and timeouts (if nil, uses context.Background())
	Context context.Context
}

type ExecutionResult struct {
	Messages []types.Message        `json:"messages"`  // All messages including history and responses
	Response *Response              `json:"response"`  // The final response (convenience field)
	Trace    ExecutionTrace         `json:"trace"`     // Complete execution trace with all LLM calls
	CostInfo types.CostInfo         `json:"cost_info"` // Aggregate cost across all LLM calls
	Metadata map[string]interface{} `json:"metadata"`  // Metadata populated by middleware
}

type ExecutionTrace struct {
	LLMCalls    []LLMCall    `json:"llm_calls"`              // All LLM API calls made during execution
	Events      []TraceEvent `json:"events,omitempty"`       // Other trace events (tool execution, context truncation, etc.)
	StartedAt   time.Time    `json:"started_at"`             // When pipeline execution started
	CompletedAt *time.Time   `json:"completed_at,omitempty"` // When pipeline execution completed (nil if still running)
}

type LLMCall struct {
	Sequence     int                     `json:"sequence"`               // Call number in sequence (1, 2, 3...)
	MessageIndex int                     `json:"message_index"`          // Index into ExecutionResult.Messages where assistant response is stored
	Request      interface{}             `json:"request,omitempty"`      // Raw request (if debugging enabled)
	Response     *Response               `json:"response"`               // Parsed response
	RawResponse  interface{}             `json:"raw_response,omitempty"` // Raw provider response (if debugging enabled)
	StartedAt    time.Time               `json:"started_at"`             // When call started
	Duration     time.Duration           `json:"duration"`               // How long the call took
	Cost         types.CostInfo          `json:"cost"`                   // Cost information for this call
	ToolCalls    []types.MessageToolCall `json:"tool_calls,omitempty"`   // If this call triggered tool execution
	Error        *string                 `json:"error,omitempty"`        // Error message if the call failed (nil if successful)
}

type Middleware interface {
	Process(ctx *ExecutionContext, next func() error) error
	// StreamChunk is called for each chunk during streaming execution (if StreamMode is true).
	// Middleware can inspect, validate, or modify chunks. Return an error or call ctx.InterruptStream()
	// to stop streaming. Most middleware should return nil (no-op).
	StreamChunk(ctx *ExecutionContext, chunk *providers.StreamChunk) error
}

type MiddlewareConfig struct {
	Type   string                 `json:"type"`             // Middleware type (e.g., "template", "provider", "validator")
	Config map[string]interface{} `json:"config,omitempty"` // Type-specific configuration
}

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

type PipelineConfig struct {
	Stages     []string           `json:"stages"`               // Pipeline stages in order (e.g., ["template", "provider", "validator"])
	Middleware []MiddlewareConfig `json:"middleware,omitempty"` // Middleware configurations
}

type PipelineRuntimeConfig struct {
	// MaxConcurrentExecutions limits the number of concurrent pipeline executions.
	// Default: 100
	MaxConcurrentExecutions int

	// StreamBufferSize sets the buffer size for streaming output channels.
	// Default: 100
	StreamBufferSize int

	// ExecutionTimeout sets the maximum duration for a single pipeline execution.
	// Set to 0 to disable timeout.
	// Default: 30 seconds
	ExecutionTimeout time.Duration

	// GracefulShutdownTimeout sets the maximum time to wait for in-flight executions during shutdown.
	// Default: 10 seconds
	GracefulShutdownTimeout time.Duration
}

type ProviderMiddlewareConfig struct {
	RetryPolicy  *RetryPolicy `json:"retry_policy,omitempty"`  // Retry policy
	TimeoutMs    int          `json:"timeout_ms,omitempty"`    // Request timeout in milliseconds
	DisableTrace bool         `json:"disable_trace,omitempty"` // Disable execution tracing (default: false = tracing enabled)
}

type Response struct {
	Role          string
	Content       string
	Parts         []types.ContentPart // Multimodal content parts (text, image, audio, video)
	ToolCalls     []types.MessageToolCall
	FinalResponse string // If tools were used, this is the final response after tools
	Metadata      ResponseMetadata
}

type ResponseMetadata struct {
	Provider     string
	Model        string
	Latency      time.Duration
	TokensInput  int
	TokensOutput int
	Cost         float64
}

type RetryPolicy struct {
	MaxRetries     int    `json:"max_retries"`                // Maximum retry attempts
	Backoff        string `json:"backoff"`                    // Backoff strategy ("fixed", "exponential")
	InitialDelayMs int    `json:"initial_delay_ms,omitempty"` // Initial delay in milliseconds
}

type StateStoreConfig struct {
	Store          interface{}            // State store implementation (statestore.Store)
	ConversationID string                 // Unique conversation identifier
	UserID         string                 // User identifier (optional)
	Metadata       map[string]interface{} // Additional metadata to store (optional)
}

type TemplateMiddlewareConfig struct {
	StrictMode     bool `json:"strict_mode"`     // Fail on undefined variables
	AllowUndefined bool `json:"allow_undefined"` // Allow undefined variables (opposite of strict_mode)
}

type ToolPolicy struct {
	ToolChoice          string   `json:"tool_choice,omitempty"` // "auto", "required", "none", or specific tool name
	MaxRounds           int      `json:"max_rounds,omitempty"`
	MaxToolCallsPerTurn int      `json:"max_tool_calls_per_turn,omitempty"`
	Blocklist           []string `json:"blocklist,omitempty"`
}

type TraceEvent struct {
	Type      string      `json:"type"`              // Event type (e.g., "tool_execution", "context_truncation", "validation_failed")
	Timestamp time.Time   `json:"timestamp"`         // When the event occurred
	Data      interface{} `json:"data"`              // Event-specific data
	Message   string      `json:"message,omitempty"` // Human-readable description
}

type ValidationError struct {
	Type     string
	Details  string
	Failures []types.ValidationResult // All failed validations (for aggregation)
}

type ValidatorMiddlewareConfig struct {
	FailFast         bool `json:"fail_fast"`          // Stop on first validation error
	CollectAllErrors bool `json:"collect_all_errors"` // Collect all errors before failing
}