aiproxy

type AuditRecord struct {
	Time     time.Time
	UserID   int
	User     string
	RemoteID string
	Upstream string
	Kind     Kind
	Method   string
	Path     string // client path, no query string
	Model    string
	Tools    []string
	Status   int
	Outcome  Outcome
	Reason   string // why a request was refused
	Duration time.Duration
	Usage    Usage
	Error    string
}

type AuditSink interface {
	Record(AuditRecord)
}

type Config struct {
	// Prefix the handler is mounted under, e.g. "/ai". Empty when mounted with http.StripPrefix.
	Prefix string
	// MaxBodyBytes caps JSON request bodies that are inspected. Default 10 MB.
	MaxBodyBytes int64
	// StripHeaders are removed from client requests in addition to the defaults
	// (Authorization, Cookie, Proxy-Authorization, X-Api-Key).
	StripHeaders []string
	// Audit receives one record per request. Default: LogAuditSink. Use NopAuditSink to disable.
	Audit AuditSink
}

type Definition struct {
	Kind     Kind
	Upstream Upstream
	// Allowed holds AllowedModels (OpenAI) or AllowedTools (MCP).
	Allowed []string
}

type HookContext struct {
	Context     context.Context
	Request     *http.Request // BeforeProxy may modify headers/query; the key is injected later
	UserContext *security.UserContext

	Upstream string
	Kind     Kind
	Model    string   // OpenAI: requested model
	Tools    []string // MCP: tools named by tools/call

	// AfterProxy only
	StatusCode int
	Duration   time.Duration
	Usage      Usage // OpenAI only; needs stream_options.include_usage for streams
	Error      error

	// BeforeProxy only
	Abort        bool
	AbortMessage string
	AbortCode    int // default 403
}

type HookFunc func(*HookContext) error

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

type HookType string

type Kind string

type LogAuditSink struct{}

type MCPUpstream struct {
	Upstream
	// AllowedTools restricts tools/call to these tool names. Empty means any.
	AllowedTools []string
}

type NopAuditSink struct{}

type OpenAIUpstream struct {
	Upstream
	// AllowedModels restricts the "model" a request may use. Empty means any.
	// When set, write requests must be JSON bodies carrying an allowed model.
	AllowedModels []string
}

type Outcome string

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

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

type RateLimit struct {
	PerSecond float64 // sustained requests per second
	Burst     int     // bucket size; defaults to ceil(PerSecond), min 1
}

type Upstream struct {
	// Name is the route segment clients use: {prefix}/{Name}/...
	Name string
	// BaseURL of the upstream. OpenAI: include the version path (https://api.openai.com/v1).
	// MCP: the full streamable HTTP endpoint (http://localhost:3000/mcp).
	BaseURL string
	// APIKey is sent to the upstream. Never exposed to clients or logs.
	APIKey string
	// AuthHeader carries the key. Default "Authorization". Applies to OpenAI and MCP upstreams.
	AuthHeader string
	// AuthFormat renders the header value; %s is the key (e.g. "Bearer %s", "Token %s", "%s").
	// Default: "Bearer %s" for the Authorization header, "%s" (raw key) for any other header.
	AuthFormat string
	// Headers are extra static headers sent to the upstream (applied before the key header).
	// Per-request values can be set in a BeforeProxy hook.
	Headers map[string]string
	// AllowedRoles: caller needs at least one. Empty means any authenticated user.
	AllowedRoles []string
	// RateLimit per user for this upstream. Nil means unlimited.
	RateLimit *RateLimit
	// Timeout waiting for the upstream response headers. Default 120s. Streams are not cut off.
	Timeout time.Duration
}

type UpstreamStore interface {
	List(ctx context.Context) ([]Definition, error)
}

type Usage struct {
	PromptTokens     int64
	CompletionTokens int64
	TotalTokens      int64
}