proxy

type APIError struct {
	Code           any         `json:"code,omitempty"`
	Message        string      `json:"message"`
	Param          *string     `json:"param,omitempty"`
	Type           string      `json:"type"`
	HTTPStatus     string      `json:"-"`
	HTTPStatusCode int         `json:"-"`
	InnerError     *InnerError `json:"innererror,omitempty"`
}

type AnthropicCacheControl struct {
	Type string `json:"type"` // "ephemeral"
}

type AnthropicContentBlock struct {
	Type string `json:"type"` // "text" | "tool_use" | "tool_result"

	// text
	Text string `json:"text,omitempty"`

	// tool_use (assistant asking to call a tool)
	ID    string          `json:"id,omitempty"`
	Name  string          `json:"name,omitempty"`
	Input json.RawMessage `json:"input,omitempty"`

	// tool_result (user returning a tool's output)
	ToolUseID string          `json:"tool_use_id,omitempty"`
	Content   json.RawMessage `json:"content,omitempty"` // string | []AnthropicContentBlock
	IsError   bool            `json:"is_error,omitempty"`

	// prompt caching marker
	CacheControl *AnthropicCacheControl `json:"cache_control,omitempty"`
}

type AnthropicMessage struct {
	Role    string          `json:"role"` // "user" | "assistant"
	Content json.RawMessage `json:"content"`
}

type AnthropicMessageExtractor struct{}

type AnthropicMessageReconstructor struct{}

type AnthropicMessagesRequest struct {
	Model         string               `json:"model"`
	Messages      []AnthropicMessage   `json:"messages"`
	System        json.RawMessage      `json:"system,omitempty"` // string | []AnthropicContentBlock
	MaxTokens     int                  `json:"max_tokens"`
	Temperature   *float64             `json:"temperature,omitempty"`
	TopP          *float64             `json:"top_p,omitempty"`
	StopSequences []string             `json:"stop_sequences,omitempty"`
	Tools         []AnthropicTool      `json:"tools,omitempty"`
	ToolChoice    *AnthropicToolChoice `json:"tool_choice,omitempty"`
	Stream        bool                 `json:"stream,omitempty"`
}

type AnthropicMessagesResponse struct {
	ID           string                   `json:"id"`
	Type         string                   `json:"type"` // "message"
	Role         string                   `json:"role"` // "assistant"
	Model        string                   `json:"model"`
	Content      []AnthropicResponseBlock `json:"content"`
	StopReason   string                   `json:"stop_reason,omitempty"`
	StopSequence *string                  `json:"stop_sequence"`
	Usage        AnthropicUsage           `json:"usage"`
}

type AnthropicModelListEntry struct {
	Type        string `json:"type"` // "model"
	ID          string `json:"id"`
	DisplayName string `json:"display_name"`
}

type AnthropicModelListResponse struct {
	Data    []AnthropicModelListEntry `json:"data"`
	HasMore bool                      `json:"has_more"`
}

type AnthropicResponseBlock struct {
	Type  string          `json:"type"`
	Text  string          `json:"text,omitempty"`
	ID    string          `json:"id,omitempty"`
	Name  string          `json:"name,omitempty"`
	Input json.RawMessage `json:"input,omitempty"`
}

type AnthropicTool struct {
	Name         string                 `json:"name"`
	Description  string                 `json:"description,omitempty"`
	InputSchema  map[string]any         `json:"input_schema,omitempty"`
	CacheControl *AnthropicCacheControl `json:"cache_control,omitempty"`
}

type AnthropicToolChoice struct {
	Type string `json:"type"` // "auto" | "any" | "tool"
	Name string `json:"name,omitempty"`
}

type AnthropicUsage struct {
	InputTokens              int `json:"input_tokens"`
	OutputTokens             int `json:"output_tokens"`
	CacheCreationInputTokens int `json:"cache_creation_input_tokens,omitempty"`
	CacheReadInputTokens     int `json:"cache_read_input_tokens,omitempty"`
}

type AudioConfig struct {
	Voice  string `json:"voice"`
	Format string `json:"format"`
}

type AuthHooks struct {
	// PreAuth runs BEFORE credential extraction and validation.
	// Only called for non-OAuth requests (LLM proxy requests).
	// Has NO access to authenticated user/app data.
	// Return true to block the request.
	PreAuth func(w http.ResponseWriter, r *http.Request) bool

	// CustomAuth lets auth plugins authenticate a request in place of app
	// keys. It is called with the endpoint the request addresses (an LLM,
	// datasource, tool, router or plugin endpoint) and the credential the
	// request presented, for every request that is not a Studio OAuth access
	// token.
	//
	// An endpoint with auth plugins attached is authenticated by them alone:
	// the hook answers AuthAccepted or AuthRejected, and app keys are not
	// tried. An endpoint without any gets AuthNotHandled, and app keys apply
	// as usual. An error means the plugins could not be asked (none could be
	// loaded, say); the request is refused with a 503.
	CustomAuth func(r *http.Request, target AuthTarget, credential, credType string) (AuthResult, error)

	// PostAuth runs AFTER successful authentication (standard or custom).
	// Only called for non-OAuth requests (LLM proxy requests).
	// Receives the authenticated app ID.
	// Return true to block the request.
	PostAuth func(w http.ResponseWriter, r *http.Request, appID uint) bool
}

type AuthIdentity = authidentity.Identity

type AuthOutcome int

type AuthResult struct {
	Outcome AuthOutcome
	AppID   uint
	// Subject is who the call is for, when the credential says (the auth
	// response's user id: a delegated token's sub, say). For audit only.
	Subject string
	// Claims the plugin returned alongside, for audit and post-auth plugins.
	Claims     map[string]string
	PluginID   uint
	PluginName string
	// Reason is why the plugins refused, for the log. It is not sent to the
	// caller.
	Reason string
}

type AuthTarget struct {
	Kind string // AuthTarget*
	ID   uint
	Slug string
}

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

type CORSResponseHook struct{}

type ChatCompletionChoice struct {
	Index        int                   `json:"index"`
	Message      ChatCompletionMessage `json:"message"`
	FinishReason string                `json:"finish_reason"`
}

type ChatCompletionChunk struct {
	ID      string                      `json:"id"`
	Object  string                      `json:"object"` // "chat.completion.chunk"
	Created int64                       `json:"created"`
	Model   string                      `json:"model"`
	Choices []ChatCompletionChunkChoice `json:"choices"`
	Usage   *CompletionUsage            `json:"usage,omitempty"` // Only in final chunk
}

type ChatCompletionChunkChoice struct {
	Index        int                 `json:"index"`
	Delta        ChatCompletionDelta `json:"delta"`
	FinishReason *string             `json:"finish_reason"` // null until final chunk
}

type ChatCompletionDelta struct {
	Role      string                        `json:"role,omitempty"`    // Only in first chunk
	Content   string                        `json:"content,omitempty"` // Streaming text content
	ToolCalls []ChatCompletionToolCallDelta `json:"tool_calls,omitempty"`
}

type ChatCompletionErrorDetail struct {
	Message string `json:"message"`
	Type    string `json:"type"`
}

type ChatCompletionFunctionDelta struct {
	Name      string `json:"name,omitempty"`
	Arguments string `json:"arguments,omitempty"`
}

type ChatCompletionMessage struct {
	Role      string                   `json:"role"`
	Content   string                   `json:"content"`
	Name      string                   `json:"name,omitempty"`
	ToolCalls []map[string]interface{} `json:"tool_calls,omitempty"`
}

type ChatCompletionRequest struct {
	Messages            []Message       `json:"messages"`
	Model               string          `json:"model"`
	Store               *bool           `json:"store,omitempty"`
	Metadata            map[string]any  `json:"metadata,omitempty"`
	FrequencyPenalty    *float64        `json:"frequency_penalty,omitempty"`
	LogitBias           map[string]int  `json:"logit_bias,omitempty"`
	LogProbs            *bool           `json:"logprobs,omitempty"`
	TopLogProbs         *int            `json:"top_logprobs,omitempty"`
	MaxCompletionTokens *int            `json:"max_completion_tokens,omitempty"`
	MaxTokens           *int            `json:"max_tokens,omitempty"`
	ReasoningEffort     *string         `json:"reasoning_effort,omitempty"`
	N                   *int            `json:"n,omitempty"`
	Modalities          []string        `json:"modalities,omitempty"`
	Audio               *AudioConfig    `json:"audio,omitempty"`
	PresencePenalty     *float64        `json:"presence_penalty,omitempty"`
	ResponseFormat      *ResponseFormat `json:"response_format,omitempty"`
	Seed                *int            `json:"seed,omitempty"`
	ServiceTier         *string         `json:"service_tier,omitempty"`
	Stop                any             `json:"stop,omitempty"`
	Stream              *bool           `json:"stream,omitempty"`
	StreamOptions       *StreamOptions  `json:"stream_options,omitempty"`
	Temperature         *float64        `json:"temperature,omitempty"`
	TopP                *float64        `json:"top_p,omitempty"`
	Tools               []Tool          `json:"tools,omitempty"`
	ToolChoice          any             `json:"tool_choice,omitempty"`
	ParallelToolCalls   *bool           `json:"parallel_tool_calls,omitempty"`
	User                *string         `json:"user,omitempty"`
}

type ChatCompletionResponse struct {
	ID      string                 `json:"id"`
	Object  string                 `json:"object"`
	Created int64                  `json:"created"`
	Model   string                 `json:"model"`
	Choices []ChatCompletionChoice `json:"choices"`
	Usage   CompletionUsage        `json:"usage"`
}

type ChatCompletionStreamError struct {
	Error ChatCompletionErrorDetail `json:"error"`
}

type ChatCompletionToolCallDelta struct {
	Index    int                          `json:"index"`
	ID       string                       `json:"id,omitempty"`
	Type     string                       `json:"type,omitempty"`
	Function *ChatCompletionFunctionDelta `json:"function,omitempty"`
}

type CompletionChoice struct {
	Text         string    `json:"text"`
	Index        int       `json:"index"`
	LogProbs     *LogProbs `json:"logprobs"`
	FinishReason string    `json:"finish_reason"`
}

type CompletionResponse struct {
	ID      string             `json:"id"`
	Object  string             `json:"object"`
	Created int64              `json:"created"`
	Model   string             `json:"model"`
	Choices []CompletionChoice `json:"choices"`
	Usage   CompletionUsage    `json:"usage"`
}

type CompletionUsage struct {
	PromptTokens     int `json:"prompt_tokens"`
	CompletionTokens int `json:"completion_tokens"`
	TotalTokens      int `json:"total_tokens"`
}

type Config struct {
	Port int

	// TLSEnabled reports that the listener this proxy is served from terminates
	// TLS. The /ai/ and unified-router handlers re-enter the gateway with a
	// loopback HTTP call to /llm/call/{slug} on Port (see getInternalLLMBaseURL);
	// that hop must speak HTTPS when the listener does, otherwise the server
	// rejects it with "client sent an HTTP request to an HTTPS server" and every
	// OpenAI-compatible request fails. The loopback connects to 127.0.0.1 and the
	// serving certificate is issued for the public hostname, so it does not
	// verify the certificate: it is talking to its own process.
	TLSEnabled bool

	// LLMTimeout is the timeout for upstream LLM HTTP requests (both streaming and REST).
	// Defaults to 5 minutes if zero, suitable for long-running agentic workloads.
	LLMTimeout time.Duration

	// Server timeouts for the standalone proxy HTTP server (used by proxy.Start()).
	// These are not used when the proxy is mounted into another server.
	// Zero values use defaults: ReadTimeout=5m, WriteTimeout=10m, IdleTimeout=5m.
	ServerReadTimeout  time.Duration
	ServerWriteTimeout time.Duration
	ServerIdleTimeout  time.Duration

	// DebugHTTPProxy logs every request the standalone proxy server
	// receives. DEBUG_HTTP_PROXY=true also turns it on.
	DebugHTTPProxy bool

	// Datasource endpoint limits (zero values use defaults)
	DatasourceMaxBodyBytes  int64 // Max request body size in bytes (default: 1MB)
	DatasourceMaxResults    int   // Max documents returned per query (default: 100)
	DatasourceMaxEmbedTexts int   // Max texts per embedding request (default: 100)

	// UnifiedRouterBasePath is where the OpenRouter-style single-endpoint ingress
	// is mounted: "{base}/chat/completions", "{base}/completions" and "{base}/models".
	// Empty uses DefaultUnifiedRouterBasePath ("/v1").
	//
	// This exists because the proxy is embedded in host gateways (e.g. Tyk's API
	// Gateway) that already own "/v1" or mount the proxy under their own prefix.
	// The value is normalized by NormalizeUnifiedRouterBasePath; the base path of
	// the internal per-route shims (/ai/{slug}/v1/...) is unaffected by it.
	UnifiedRouterBasePath string

	// DisableUnifiedRouter removes the unified ingress entirely: no base-path
	// interception and no {base}/models route, so those paths fall through to the
	// normal authenticated router (404). Per-route endpoints (/ai/, /llm/,
	// /anthropic/) are unaffected. Hosts that expose their own single endpoint,
	// or that must not have the proxy claim a shared path prefix, set this.
	DisableUnifiedRouter bool

	// ServerTiming adds a Server-Timing header and trailer to LLM responses that
	// split each request into gateway time and upstream time (see
	// server_timing.go). Off by default; meant for benchmarking and diagnosis.
	ServerTiming bool
}

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

type ContentFilterResults struct {
	Hate     Hate     `json:"hate,omitempty"`
	SelfHarm SelfHarm `json:"self_harm,omitempty"`
	Sexual   Sexual   `json:"sexual,omitempty"`
	Violence Violence `json:"violence,omitempty"`
}

type CreateCompletionRequest struct {
	Model            string      `json:"model"`
	Prompt           string      `json:"prompt,omitempty"`
	MaxTokens        *int        `json:"max_tokens,omitempty"`
	Temperature      *float64    `json:"temperature,omitempty"`
	TopP             *float64    `json:"top_p,omitempty"`
	N                *int        `json:"n,omitempty"`
	Stream           *bool       `json:"stream,omitempty"`
	LogProbs         *int        `json:"logprobs,omitempty"`
	Echo             *bool       `json:"echo,omitempty"`
	Stop             interface{} `json:"stop,omitempty"`
	PresencePenalty  *float64    `json:"presence_penalty,omitempty"`
	FrequencyPenalty *float64    `json:"frequency_penalty,omitempty"`
	User             string      `json:"user,omitempty"`
}

type CredentialExtractor func(r *http.Request) (string, error)

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

type DatasourceDocument struct {
	PageContent string         `json:"PageContent"`
	Metadata    map[string]any `json:"Metadata"`
	Score       float32        `json:"Score"`
}

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

type EmbeddingRequest struct {
	Texts []string `json:"texts"`
}

type EmbeddingResponse struct {
	Vectors [][]float32 `json:"vectors"`
}

type EndpointMap struct {
	LLMs        map[string]string
	Datasources map[string]string
}

type ErrorResponse struct {
	Status  int    `json:"status"`
	Message string `json:"message"`
	Error   string `json:"error,omitempty"`
}

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

type FunctionConfig struct {
	Description string         `json:"description,omitempty"`
	Name        string         `json:"name"`
	Parameters  map[string]any `json:"parameters,omitempty"`
	Strict      *bool          `json:"strict,omitempty"`
}

type GoogleAIMessageExtractor struct{}

type GoogleAIMessageReconstructor struct{}

type Hate struct {
	Filtered bool   `json:"filtered"`
	Severity string `json:"severity,omitempty"`
}

type HeadersRequest struct {
	Headers map[string]string `json:"headers"`
	Context *PluginContext    `json:"context"`
}

type HeadersResponse struct {
	Modified bool              `json:"modified"`
	Headers  map[string]string `json:"headers"`
}

type InnerError struct {
	Code                 string               `json:"code,omitempty"`
	ContentFilterResults ContentFilterResults `json:"content_filter_result,omitempty"`
}

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

type LogProbs struct {
	Tokens        []string             `json:"tokens"`
	TokenLogProbs []float32            `json:"token_logprobs"`
	TopLogProbs   []map[string]float32 `json:"top_logprobs"`
	TextOffset    []int                `json:"text_offset"`
}

type MCPServerCache struct {
	SSEServer        *server.SSEServer
	StreamableServer *server.StreamableHTTPServer
	MCPServer        *server.MCPServer
	ToolVersion      string
	OperationHash    string
}

type Message struct {
	Role    string `json:"role"`
	Content any    `json:"content"`
}

type MessageExtractor interface {
	// ExtractMessages parses the request body and returns normalized messages
	ExtractMessages(r *http.Request, body []byte) ([]llms.MessageContent, error)

	// VendorName returns the vendor this extractor handles
	VendorName() string
}

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

type MessageReconstructor interface {
	// Reconstruct takes normalized messages and the original request body,
	// returning a new request body with modified messages
	Reconstruct(messages []map[string]interface{}, originalBody []byte) ([]byte, error)

	// VendorName returns the vendor this reconstructor handles
	VendorName() string
}

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

type MetadataQuery struct {
	Filter     map[string]string `json:"filter"`
	FilterMode string            `json:"filter_mode"`
	Limit      int               `json:"limit"`
	Offset     int               `json:"offset"`
}

type MetadataResults struct {
	Documents  []DatasourceDocument `json:"documents"`
	TotalCount int                  `json:"total_count"`
}

type ModelNameExtractor func(r *http.Request, body []byte) (string, error)

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

type OAIErrorResponse struct {
	Error *APIError `json:"error,omitempty"`
}

type OllamaMessageExtractor struct {
	OpenAIMessageExtractor
}

type OllamaMessageReconstructor struct {
	OpenAIMessageReconstructor
}

type OpenAIMessageExtractor struct{}

type OpenAIMessageReconstructor struct{}

type OpenAPICache struct {
	Document    libopenapi.Document
	Operations  []string
	ToolVersion string
	CreatedAt   time.Time
}

type PluginContext struct {
	RequestID string            `json:"request_id"`
	LLMSlug   string            `json:"llm_slug"`
	LLMID     uint              `json:"llm_id"`
	AppID     uint              `json:"app_id"`
	UserID    uint              `json:"user_id"`
	Metadata  map[string]string `json:"metadata"`
}

type PostAuthCallback func(w http.ResponseWriter, r *http.Request, appID uint) bool

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

type ResponseFormat struct {
	Type       string `json:"type"`
	JSONSchema *any   `json:"json_schema,omitempty"`
}

type ResponseHook interface {
	// OnBeforeWriteHeaders is called before response headers are written
	OnBeforeWriteHeaders(ctx context.Context, req *HeadersRequest) (*HeadersResponse, error)

	// OnBeforeWrite is called before response body is written (REST-only)
	OnBeforeWrite(ctx context.Context, req *ResponseWriteRequest) (*ResponseWriteResponse, error)

	// OnStreamComplete is called after a streaming response finishes (streaming-only)
	OnStreamComplete(ctx context.Context, req *StreamCompleteRequest) (*StreamCompleteResponse, error)

	// GetName returns the name of this response hook
	GetName() string
}

type ResponseHookManager interface {
	// ExecuteOnBeforeWriteHeaders is called before response headers are written
	ExecuteOnBeforeWriteHeaders(ctx context.Context, req *HeadersRequest) (*HeadersResponse, error)

	// ExecuteOnBeforeWrite is called before response body is written (REST-only)
	ExecuteOnBeforeWrite(ctx context.Context, req *ResponseWriteRequest) (*ResponseWriteResponse, error)

	// ExecuteOnStreamComplete is called after a streaming response finishes (streaming-only)
	ExecuteOnStreamComplete(ctx context.Context, req *StreamCompleteRequest) (*StreamCompleteResponse, error)
}

type ResponseWriteRequest struct {
	Body    []byte            `json:"body"`
	Headers map[string]string `json:"headers"`
	Context *PluginContext    `json:"context"`
}

type ResponseWriteResponse struct {
	Modified bool              `json:"modified"`
	Body     []byte            `json:"body"`
	Headers  map[string]string `json:"headers"`
}

type RouteDecision struct {
	Router RouterRef
	LLMID  uint
	Model  string
	// Pool is the Model Router pool that matched.
	Pool string
	// Route is the route that was chosen, for routers that have named routes.
	Route string
	// Reason says why this target was chosen, from a small fixed set
	// ("model_pattern", ...), for analytics and the X-Tyk-Route-Reason header.
	Reason string
	// Selection is how the target was picked among the candidates (a Model
	// Router pool's algorithm: "round_robin", "weighted"), for analytics.
	Selection string
	// SourceModel is the model the caller asked the router for; Model is what
	// the chosen LLM is asked for. Set by resolveRoute.
	SourceModel string
	// Score is the similarity that decided a Semantic Router's embedding
	// match, 0 otherwise.
	Score float64
	// ShadowRoute is, for a Semantic Router in shadow mode, the route the
	// classifier picked while the default route served the request.
	ShadowRoute string
}

type RouteRequest struct {
	Router RouterRef
	App    *models.App
	// Model is the model the caller asked for, with the router prefix
	// already stripped by the ingress.
	Model string
	// Body is the OpenAI-shaped request body as the caller sent it.
	Body []byte
	// Header is the caller's request header (session affinity and the like).
	Header http.Header
	// Allow restricts the LLMs the resolver may pick. Nil allows every LLM
	// the router can reach.
	Allow func(llmID uint) bool
}

type RouteResolver interface {
	// Lookup reports whether slug names a router.
	Lookup(slug string) (RouterRef, bool)
	// Resolve picks the LLM and model for a request. Errors are
	// ErrRouteNoMatch, ErrRouteNoCandidates or ErrRouteUnavailable, possibly
	// wrapped.
	Resolve(ctx context.Context, req RouteRequest) (*RouteDecision, error)
	// Reaches reports whether the router can send a request to the LLM.
	Reaches(ref RouterRef, llmID uint) bool
	// Models lists the model names the router advertises (GET /v1/models).
	Models(ref RouterRef) []string
}

type RouterKind string

type RouterRef struct {
	Kind RouterKind
	ID   uint
	Slug string
}

type SearchQuery struct {
	Query string `json:"query"`
	N     int    `json:"n"`
}

type SearchResults struct {
	Documents []DatasourceDocument `json:"documents"`
}

type SelfHarm struct {
	Filtered bool   `json:"filtered"`
	Severity string `json:"severity,omitempty"`
}

type Sexual struct {
	Filtered bool   `json:"filtered"`
	Severity string `json:"severity,omitempty"`
}

type StreamCompleteRequest struct {
	AccumulatedResponse []byte            `json:"accumulated_response"` // Full SSE response (all chunks concatenated)
	Headers             map[string]string `json:"headers"`              // Response headers from upstream
	StatusCode          int               `json:"status_code"`          // HTTP status code
	Context             *PluginContext    `json:"context"`              // Plugin context with request metadata
	ChunkCount          int               `json:"chunk_count"`          // Number of chunks received
	RequestBody         []byte            `json:"request_body"`         // Original request body (for cache key generation)
}

type StreamCompleteResponse struct {
	Handled      bool   `json:"handled"`       // Plugin processed the response
	Cached       bool   `json:"cached"`        // Response was cached (for metrics/logging)
	ErrorMessage string `json:"error_message"` // Error description if any
}

type StreamOptions struct {
	IncludeUsage bool `json:"include_usage"`
}

type Tool struct {
	Type     string         `json:"type"`
	Function FunctionConfig `json:"function"`
}

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

type VectorSearchQuery struct {
	Embedding           []float32 `json:"embedding"`
	N                   int       `json:"n"`
	SimilarityThreshold float64   `json:"similarity_threshold"`
}

type VertexMessageExtractor struct {
	GoogleAIMessageExtractor
}

type VertexMessageReconstructor struct {
	GoogleAIMessageReconstructor
}

type Violence struct {
	Filtered bool   `json:"filtered"`
	Severity string `json:"severity,omitempty"`
}