protocol

type APIStyle string

type AnthropicBetaMessagesRequest struct {
	Stream bool `json:"stream"`
	anthropic.BetaMessageNewParams
}

type AnthropicMessagesRequest struct {
	Stream bool `json:"stream"`
	anthropic.MessageNewParams
}

type BetaRound struct {
	Messages       []anthropic.BetaMessageParam
	IsCurrentRound bool
	Stats          *RoundStats // Optional metadata about the round structure
}

type Client interface {
	// APIStyle returns the type of provider this client implements
	APIStyle() APIStyle

	// Close closes any resources held by the client
	Close() error
}

type ErrorDetail struct {
	Message string `json:"message"`
	Type    string `json:"type"`
	Code    string `json:"code,omitempty"`
}

type ErrorResponse struct {
	Error ErrorDetail `json:"error"`
}

type Grouper struct{}

type HandleContext struct {
	// Gin context
	GinContext *gin.Context

	// Model info
	ResponseModel string

	// Hooks for stream processing (chainable - multiple hooks can be added)
	OnStreamEventHooks    []func(event interface{}) error
	OnStreamCompleteHooks []func()
	OnStreamErrorHooks    []func(err error)

	// Stream configuration flags
	DisableStreamUsage bool // Don't include usage in streaming chunks
}

type OpenAIChatCompletionRequest struct {
	openai.ChatCompletionNewParams
	Stream bool `json:"stream"`
}

type OpenAIConfig struct {
	// HasThinking indicates whether the request contains thinking content
	// This can be used by providers like DeepSeek to handle reasoning_content
	HasThinking bool

	// ReasoningEffort specifies the reasoning effort level for OpenAI-compatible APIs
	// Valid values: "none", "minimal", "low", "medium", "high", "xhigh"
	// Defaults to "low" when HasThinking is true
	ReasoningEffort shared.ReasoningEffort
}

type Response = responses.Response

type ResponseCreateRequest struct {
	// Stream indicates whether to stream the response
	// This is not part of ResponseNewParams as streaming is controlled
	// by using NewStreaming() method on the SDK client
	Stream bool `json:"stream"`

	// Embed the native SDK type for all other fields
	responses.ResponseNewParams
}

type ResponseInputItemUnionParam = responses.ResponseInputItemUnionParam

type ResponseNewParams = responses.ResponseNewParams

type ResponseNewParamsInputUnion = responses.ResponseNewParamsInputUnion

type RoundStats struct {
	UserMessageCount int  // Number of pure user messages in this round (should be 1)
	AssistantCount   int  // Number of assistant messages
	ToolResultCount  int  // Number of tool result messages
	TotalMessages    int  // Total messages in the round
	HasThinking      bool // Whether any assistant message contains thinking blocks
}

type TokenUsage struct {
	// InputTokens is the number of input/prompt tokens consumed (excluding cache)
	InputTokens int `json:"input_tokens"`

	// OutputTokens is the number of output/completion tokens consumed
	OutputTokens int `json:"output_tokens"`

	// CacheInputTokens is the number of cache-related tokens consumed
	// (includes both cache creation and cache read operations)
	CacheInputTokens int `json:"cache_input_tokens,omitempty"`

	// SystemTokens represents tokens consumed by system-level operations
	// such as prompt templates, system instructions, or framework overhead
	SystemTokens int `json:"system_tokens,omitempty"`
}

type Transformer interface {
	// HandleV1 handles compacting for Anthropic v1 requests.
	HandleV1(req *anthropic.MessageNewParams) error

	// HandleV1Beta handles compacting for Anthropic v1beta requests.
	HandleV1Beta(req *anthropic.BetaMessageNewParams) error
}

type V1Round struct {
	Messages       []anthropic.MessageParam
	IsCurrentRound bool
	Stats          *RoundStats // Optional metadata about the round structure
}