dataapi

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

type Authenticator interface {
	Authenticate(r *http.Request) (Caller, error)
}

type Caller struct {
	// ID names the key (never the key itself); empty for an anonymous caller. It is the
	// rate-limit bucket of the caller (see CallerKeys) and what a log line may say.
	ID string
	// contains filtered or unexported fields
}

type CallerKeys struct{}

type Config struct {
	Deps Deps

	// Prefix is the route prefix; empty means DefaultPrefix ("/v1"). It must start
	// with "/" and must not end with one. services/native sets "/api" to keep its
	// legacy paths.
	Prefix string

	// Limits are the per-route budgets; nil means DefaultLimits().
	Limits *Limits

	// Keys names the limiter bucket of a request; nil means CallerKeys (the key id of
	// an authenticated caller, else the client IP).
	Keys KeyResolver

	// Auth turns an API key into a Caller (see Authenticator, StaticKeys). Nil means no
	// keys exist: every caller is anonymous and keyed tools answer 401 api_key_required.
	// It applies to the tool endpoint and, through CallerFrom, to the MCP handler.
	Auth Authenticator

	// CorpusProbeTTL is how long /health reuses a corpus reachability verdict; zero
	// means DefaultCorpusProbeTTL. Only a Retriever that implements Pinger is probed.
	CorpusProbeTTL time.Duration

	// ToolAPI selects the raw tool endpoint mode; zero is off.
	ToolAPI ToolAPIMode

	// ToolFormat selects the body of a successful tool call; zero is the JSON
	// envelope. Errors are the JSON error shape in either format.
	ToolFormat ToolFormat

	// ToolTimeout bounds one tool execution; zero means DefaultToolTimeout.
	ToolTimeout time.Duration

	// Docs serves the generated descriptions of the API: GET {prefix}/openapi.yaml and
	// {prefix}/openapi.json, and GET /llms.txt and /llms-full.txt at the root of the
	// host (so the service must own the host's root, as cmd/dataapi does; a mount
	// under a sub-path never sees those two). They describe this service's own
	// configuration: the tool endpoint only when ToolAPI is on, the MCP endpoint only
	// when MCP is set. New fails if Docs is combined with ToolFormatText, which they do
	// not describe.
	Docs bool

	// PublicURL is the origin the service is reachable at, e.g. "https://data.eve-cyno.dev"
	// (https, no path or query; New fails otherwise). When set, the generated OpenAPI
	// `servers` entry and the links of llms.txt / llms-full.txt are absolute, which clients
	// that cannot resolve relative server URLs (ChatGPT Actions) need, and the index page
	// shows it in its examples. Empty keeps everything relative.
	PublicURL string

	// MCP, when non-nil, is mounted at {prefix}/mcp for every HTTP method, behind the
	// request ID, panic recovery, API-key authentication (an invalid key is a 401 before
	// the handler runs) and the Limits.MCP limiter. Build it with mcpserver.HTTPHandler,
	// which picks the tool set per request; give it Keyed: func(r) bool { return
	// CallerFrom(r.Context()).Allows(catalog.TierKeyed) }. Pass untyped nil, never a typed
	// nil pointer wrapped in the interface.
	MCP http.Handler

	// Logger receives the access log and handler diagnostics; every line carries
	// request_id. Nil discards.
	Logger *slog.Logger
}

type Deps struct {
	// Tools is the deterministic tool layer; Tools.SDE is the one SDE every route
	// reads (item search, hull-name resolution, EFT parsing).
	Tools *tools.Deps
	// Retriever backs /fits/search and the community frequencies of /fit/suggest.
	Retriever FitSearcher
	// Stats computes /fit/stats (core/fit/gofa).
	Stats fit.StatsProvider
}

type FitSearcher interface {
	SearchFits(ctx context.Context, q rag.FitSearchQuery) (rag.FitSearchResult, error)
}

type IPKeys struct{}

type KeyResolver interface {
	Key(r *http.Request) string
}

type Limits struct {
	FitsSearch  Rate
	FitsDetail  Rate
	FitStats    Rate
	FitSuggest  Rate
	ItemsSearch Rate
	// Tool applies only in ToolAPIPublic mode.
	Tool Rate
	// MCP counts every request to the MCP endpoint (a session is a handful of requests
	// plus one per tool call).
	MCP Rate
	// Docs covers the description routes (OpenAPI, llms.txt).
	Docs Rate
}

type Pinger interface {
	Ping(ctx context.Context) error
}

type Rate struct {
	Max    int
	Window time.Duration
}

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

type Surface struct {
	// Prefix is the route prefix ("" means DefaultPrefix).
	Prefix string
	// ToolAPI is the raw tool endpoint mode.
	ToolAPI ToolAPIMode
	// MCP is true when the MCP streamable-HTTP endpoint is mounted at {prefix}/mcp.
	MCP bool
	// Auth is true when the service accepts API keys, which makes the keyed tier
	// available and documented.
	Auth bool
	// Docs is true when the description routes (openapi.yaml, openapi.json, /llms.txt,
	// /llms-full.txt) are served.
	Docs bool
	// Limits are the per-route budgets stated in the documents.
	Limits Limits
	// PublicURL, when set (validated, no trailing slash), makes the OpenAPI servers entry
	// and the llms.txt links absolute. PublicSurface leaves it empty so the committed
	// generated files stay host-independent.
	PublicURL string
}

type ToolAPIMode int

type ToolFormat int

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