models

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

type AnthropicAuth struct {
	APIKey      string
	WorkspaceID string // sent as anthropic-workspace-id; empty = not sent
}

type AnthropicWorkspaces struct {
	Deps Deps // its HTTP client, Caller and AnthropicURL
}

type Call struct {
	Provider, Model string
}

type Caller struct {
	Timeout time.Duration // per attempt
	Retries int           // extra attempts after the first
	Backoff time.Duration // wait before the first retry; doubles each time
	Sleep   func(ctx context.Context, d time.Duration) error
	// contains filtered or unexported fields
}

type Candidate struct {
	RuleID     int64
	Name       string // the rule's name, shown to models and in the synthesized reason
	Intent     string // plain-English intent
	Exceptions string // rendered "unless" text, may be empty
}

type DecideRequest struct {
	Email      message.Summary // headers, signals, text <= BODY_CHARS
	Candidates []Candidate     // eligible intent rules in priority order
	Examples   []learn.Example // few-shot corrections (fallback model only)
}

type Decider interface {
	Name() string
	Decide(ctx context.Context, req DecideRequest) (Decision, Usage, error)
}

type Decision struct {
	RuleID     int64   // 0 = none of the rules
	Confidence float64 // calibrated 0..1
	Reason     string  // one sentence; synthesized when the model gives none
}

type Deps struct {
	HTTP   *http.Client // nil = http.DefaultClient
	Caller *Caller      // the global concurrency cap, timeout and retries
	Prices Prices
	// AnthropicURL is where the Claude adapters and the workspace lookup send their
	// requests; empty = the public API. Only tests point it elsewhere.
	AnthropicURL string
	// WorkspaceNeeded is asked when Anthropic refuses a Claude request because its key covers
	// a whole organisation and no workspace was named. It answers the workspace to retry the
	// request in, or "" when there is none to use. nil = the refusal stands.
	WorkspaceNeeded func(ctx context.Context, apiKey string) string
}

type Fake struct {
	NameValue string
	// DecideFunc answers Decide; nil answers "none" with confidence 1.
	DecideFunc func(req DecideRequest) (Decision, Usage, error)
	// Spread, when set, is what DecideSpread reports as the probability of each option.
	Spread map[int64]float64
	// GenerateFunc answers Generate, usually by unmarshalling canned JSON into out.
	GenerateFunc func(system, user string, schema json.RawMessage, out any) (Usage, error)
	// contains filtered or unexported fields
}

type Generator interface {
	Generate(ctx context.Context, system, user string, schema json.RawMessage, out any) (Usage, error)
}

type LabeledEmail struct {
	Email    message.Summary
	Expected int64 // 0 = none of the rules
}

type LabeledRule struct {
	ID         int64  `json:"id"`
	Name       string `json:"name"`
	Intent     string `json:"intent"`
	Exceptions string `json:"exceptions"`
}

type Labels struct {
	Rules  []LabeledRule
	Emails []LabeledEmail
}

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

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

type Price struct {
	Input      float64 `json:"input"`
	Output     float64 `json:"output"`
	CacheRead  float64 `json:"cache_read"`  // input tokens served from a prompt cache
	CacheWrite float64 `json:"cache_write"` // input tokens written to a prompt cache
}

type Prices map[string]map[string]Price

type Report struct {
	Decider   string
	Fallback  string // "" = no fallback
	Total     int
	Correct   int
	Errors    int // emails the decider could not answer; they count as wrong
	Escalated int
	CostUSD   float64
	Latencies []time.Duration // per answered email, both calls added, sorted
	Confusion map[[2]string]int
}

type Result struct {
	Decision
	Escalated   bool   // the fallback was asked
	Primary     Usage  // always set; summed over the primary's calls
	Fallback    *Usage // set when the fallback answered; summed over its calls
	FallbackErr error  // set when the fallback was asked and failed; Decision is then the primary's
	Calls       int    // model calls made, counting each retry of an unreadable answer
	// Probabilities is what the primary gave each candidate, by rule id (0 = none of
	// them), when it is a Spreader; nil otherwise. It stays the primary's when the
	// fallback answers: it is why the fallback was asked.
	Probabilities map[int64]float64
}

type Router struct {
	Primary       Decider
	Fallback      Decider // nil = never escalate
	EscalateBelow float64
	Usage         UsageStore       // nil = do not record
	Now           func() time.Time // nil = time.Now
	// Purpose, when set, is the ledger purpose of every call ("test" for the rule tester);
	// empty records the primary's calls as "decide" and the fallback's as "escalate".
	Purpose string
	// Metered says, by provider (Usage.Provider), whether calls to it go out on a key the
	// operator holds (MAILRULES_MODE=cloud, the tenant has no key of its own), so that the
	// emails they decide count against the tenant's monthly allowance. nil = none do.
	Metered func(provider string) bool
}

type Spreader interface {
	Decider
	DecideSpread(ctx context.Context, req DecideRequest) (Decision, map[int64]float64, Usage, error)
}

type StatusError struct {
	Provider  string
	Code      int
	Type      string // the provider's error type, such as "invalid_request_error"; may be empty
	Detail    string // the provider's message, scrubbed; may be empty
	RequestID string // the provider's id for the request, for its support; may be empty
}

type Usage struct {
	Provider, Model     string
	TokensIn, TokensOut int
	CostUSD             float64
	Latency             time.Duration
}

type UsageStore interface {
	AddUsage(ctx context.Context, day, provider, model, purpose string, calls, tokensIn, tokensOut int, costUSD float64) error
}

type Workspace struct {
	ID   string `json:"id"`
	Name string `json:"name"`
}

type WorkspaceAnswer struct {
	NoneNeeded bool
	Workspaces []Workspace // the Default Workspace included; never archived ones
}