auto

type AdvancedClassifierInterface interface {
	// ClassifyWithTranscript predicts if a tool use should be allowed, using conversation context.
	// The messages parameter provides transcript context for better classification.
	// Returns ClassifierResult with detailed stage information.
	ClassifyWithTranscript(ctx context.Context, toolName string, toolInput map[string]any, messages []types.Message, toolUseID string) (*ClassifierResult, error)
}

type AdvancedConfig struct {
	// TwoStageClassifier is the model name for the second-stage thinking classifier.
	// If empty, two-stage classification is disabled.
	TwoStageClassifier string

	// MaxTranscriptChars is the maximum characters to include in the transcript.
	MaxTranscriptChars int

	// UseCacheControl enables cache control headers for classifier calls.
	UseCacheControl bool

	// EnableThinking enables the thinking/reasoning token output.
	EnableThinking bool
}

type AutoModeOutcome struct {
	Outcome    string         `json:"outcome"`     // Outcome type (success/error/parse_failure)
	Model      string         `json:"model"`       // Model used for classification
	DurationMs int64          `json:"duration_ms"` // Time taken for classification
	Metadata   map[string]any `json:"metadata"`    // Additional outcome metadata
}

type CacheControl struct {
	Type string // Cache type (typically "ephemeral")
	TTL  string // Cache TTL (e.g., "ephemeral-1-hour")
}

type Classification struct {
	Allowed    bool    // Whether the tool use is predicted to be safe
	Confidence float64 // Confidence level (0-1) for the prediction
	Reason     string  // Human-readable explanation for the classification
}

type Classifier interface {
	// Classify predicts if a tool use should be allowed.
	// Returns the classification result with allowed flag, confidence, and reason.
	Classify(ctx context.Context, toolName string, input map[string]any) (Classification, error)
}

type ClassifierAPI interface {
	Classify(ctx context.Context, req *ClassifierAPIRequest) (*ClassifierAPIResponse, error)
}

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

type ClassifierAPIRequest struct {
	Model         string
	MaxTokens     int
	System        string
	Temperature   float64
	Messages      []types.Message
	StopSequences []string
	Thinking      bool
}

type ClassifierAPIResponse struct {
	Text       string
	Usage      *ClassifierUsage
	MessageID  string
	RequestID  string
	StopReason string
}

type ClassifierContext struct {
	ToolName                     string
	ToolInput                    map[string]any
	Mode                         types.PermissionMode
	SessionID                    types.SessionID
	TurnID                       types.TurnID
	ToolUseID                    string
	Messages                     []types.Message
	ShouldAvoidPermissionPrompts bool // Whether to avoid permission prompts (headless mode)
	Additional                   map[string]any
	DenialTracking               *types.DenialTrackingState
}

type ClassifierResult struct {
	ShouldBlock       bool             `json:"should_block"`                  // Whether action should be blocked
	Reason            string           `json:"reason"`                        // Human-readable reason
	Thinking          string           `json:"thinking,omitempty"`            // Chain-of-thought reasoning
	Model             string           `json:"model"`                         // Model used for classification
	Usage             *ClassifierUsage `json:"usage,omitempty"`               // Token usage statistics
	DurationMs        int64            `json:"duration_ms"`                   // Total classification time
	Stage             string           `json:"stage,omitempty"`               // Which stage produced result (fast/thinking)
	Unavailable       bool             `json:"unavailable,omitempty"`         // Classifier API was unavailable
	TranscriptTooLong bool             `json:"transcript_too_long,omitempty"` // Transcript exceeded context limit
	PromptLengths     PromptLengths    `json:"prompt_lengths,omitempty"`      // Prompt component lengths
	Stage1Usage       *ClassifierUsage `json:"stage1_usage,omitempty"`        // Stage 1 usage (for two-stage)
	Stage1DurationMs  int64            `json:"stage1_duration_ms,omitempty"`  // Stage 1 timing
	Stage2Usage       *ClassifierUsage `json:"stage2_usage,omitempty"`        // Stage 2 usage (for two-stage)
	Stage2DurationMs  int64            `json:"stage2_duration_ms,omitempty"`  // Stage 2 timing
}

type ClassifierUsage struct {
	InputTokens              int `json:"input_tokens"`                // Tokens in request
	OutputTokens             int `json:"output_tokens"`               // Tokens in response
	CacheReadInputTokens     int `json:"cache_read_input_tokens"`     // Tokens from cache read
	CacheCreationInputTokens int `json:"cache_creation_input_tokens"` // Tokens for cache creation
}

type Config struct {
	FailClosed bool // When true, classifier errors result in deny (fail-closed)
}

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

type DenialLimitConfig struct {
	MaxConsecutiveDenials int // Maximum consecutive denials before fallback
	MaxTotalDenials       int // Maximum total denials before fallback
	WindowMinutes         int // Time window for tracking (currently unused)
}

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

type FeatureFlags struct {
	TwoStageClassifier     bool         // Enable two-stage classifier
	TwoStageClassifierMode TwoStageMode // Which stages to run (both/fast/thinking)
	TranscriptJSONL        bool         // Use JSONL format for transcript
	CacheControl           bool         // Enable cache control headers
	ThinkingEnabled        bool         // Enable thinking/reasoning
	MaxTranscriptChars     int          // Maximum transcript character length
}

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

type ModeConfig struct {
	FailClosed bool // When true, classifier errors result in deny (fail-closed)
}

type PromptLengths struct {
	SystemPrompt int `json:"system_prompt"` // System prompt length
	ToolCalls    int `json:"tool_calls"`    // Tool calls/transcript length
	UserPrompts  int `json:"user_prompts"`  // User messages length
}

type SeshatMdProvider func() string

type TemplateConfig struct {
	UseExternalTemplate  bool     // Use external vs internal template
	UseAnthropicTemplate bool     // Use Anthropic internal template
	AllowRules           []string // User-defined allow rules
	DenyRules            []string // User-defined deny rules
	EnvironmentRules     []string // Environment-specific rules
}

type Tool interface {
	Name() string                                      // Tool name (e.g., "Read", "Edit")
	Aliases() []string                                 // Alternative names for the tool
	ToAutoClassifierInput(input map[string]any) string // Encode input for classifier
}

type ToolRegistry map[string]Tool

type TranscriptBlock struct {
	Type  string `json:"type"`            // "text" or "tool_use"
	Text  string `json:"text,omitempty"`  // For text blocks
	Name  string `json:"name,omitempty"`  // For tool_use blocks (tool name)
	Input any    `json:"input,omitempty"` // For tool_use blocks (tool input)
}

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

type TranscriptEntry struct {
	Role    string            `json:"role"`    // "user" or "assistant"
	Content []TranscriptBlock `json:"content"` // Content blocks in this entry
}

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

type TwoStageConfig struct {
	Model              string
	TwoStageMode       TwoStageMode
	MaxTranscriptChars int
	UseCacheControl    bool
	EnableThinking     bool
}

type TwoStageMode string

type XMLParser struct{}