inferencecost

type AllocationMethod string

type AllocationQuerier interface {
	// ComputeAllocation returns an AllocationSet for the given time window.
	ComputeAllocation(start, end time.Time) (*opencost.AllocationSet, error)
}

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

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

type Config struct {
	// PrometheusURL is the Prometheus server endpoint for vLLM metric queries.
	PrometheusURL string

	// CollectionInterval is how often metrics are collected.
	// Configurable via INFERENCE_COLLECTION_INTERVAL environment variable.
	// Default is 2 minutes to match the core metrics emitter query window.
	CollectionInterval time.Duration

	// Enabled controls whether the inference cost collector runs.
	Enabled bool

	// ModelLabel is the Kubernetes pod label whose value equals the vLLM
	// model_name metric label. Used to aggregate allocation costs by model.
	ModelLabel string

	// SharedInfraLabel and SharedInfraLabelValue identify shared inference
	// infrastructure pods (EPP, gateway) that lack ModelLabel.
	SharedInfraLabel      string
	SharedInfraLabelValue string

	// AllocationMode controls the input/output split method.
	// "compute_time" uses vLLM timing metrics (preferred).
	// "multiplier" uses a fixed ratio (fallback).
	AllocationMode string

	// OutputTokenCostMultiplier is the output/input cost ratio used when
	// AllocationMode is "multiplier".
	OutputTokenCostMultiplier float64
}

type CostBasis string

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

type InferenceCost struct {
	Properties InferenceCostProperties

	// Window is the time range over which these costs were collected.
	// Used to normalize total costs to hourly rates for Prometheus metrics.
	Window struct {
		Start time.Time
		End   time.Time
	}

	// Costs from OpenCost allocation layer.
	// AllocationTotalCost = max(request,usage)×price + idle share + shared infra share.
	AllocationTotalCost float64
	// UsageTotalCost = actual_usage×price only; does not reconcile to bill.
	UsageTotalCost float64

	// Token counts from vLLM Prometheus metrics.
	PromptTokens     float64
	GenerationTokens float64
	TotalTokens      float64

	// Processing times from vLLM Prometheus metrics (seconds in collection window).
	InputProcessingTime  float64
	OutputProcessingTime float64

	// KV cache data from vLLM Prometheus metrics.
	// CachedTokens is the number of prompt tokens served from the KV cache,
	// sourced directly from vllm:prefix_cache_hits_total (token-level counter).
	// Zero when the metric is unavailable.
	CachedTokens float64
	// PrefixCachingEnabled reflects the enable_prefix_caching label from
	// vllm:cache_config_info. False when the metric is absent.
	PrefixCachingEnabled bool
	// CacheConfigKnown is true when vllm:cache_config_info was successfully
	// joined for this model. When false, PrefixCachingEnabled is meaningless.
	CacheConfigKnown bool

	// EffectiveInputTokens is PromptTokens - CachedTokens when cache correction
	// is enabled, otherwise equals PromptTokens.
	EffectiveInputTokens float64

	// CacheSavingsFraction is CachedTokens / PromptTokens, clamped to [0, 1].
	// Represents the fraction of prompt tokens served from the KV cache. Zero
	// when PromptTokens is zero or prefix caching is disabled. The raw ratio can
	// exceed 1 in high-reuse workloads; see apitypes.go for the full explanation.
	CacheSavingsFraction float64

	// InputCost and OutputCost are the dollar amounts attributed to input and
	// output processing respectively.
	InputCost  map[CostBasis]float64
	OutputCost map[CostBasis]float64

	// AllocationMethod records which input/output split path was used.
	AllocationMethod AllocationMethod

	// Derived cost-per-million-token metrics, keyed by CostBasis.
	// Blended (input+output together), using TotalTokens as denominator.
	CostPerMillionTokens map[CostBasis]float64
	// Per-million input tokens, using PromptTokens as denominator.
	InputCostPerMillionTokens map[CostBasis]float64
	// Per-million output tokens, using GenerationTokens as denominator.
	OutputCostPerMillionTokens map[CostBasis]float64

	Timestamp time.Time
}

type InferenceCostAPIProperties struct {
	ModelName      string `json:"modelName"`
	ModelVersion   string `json:"modelVersion,omitempty"`
	Namespace      string `json:"namespace"`
	Cluster        string `json:"cluster,omitempty"`
	Pod            string `json:"pod,omitempty"`
	Controller     string `json:"controller,omitempty"`
	ControllerKind string `json:"controllerKind,omitempty"`
	Container      string `json:"container,omitempty"`
	WorkloadType   string `json:"workloadType"` // currently always "inference"
}

type InferenceCostProperties struct {
	ModelName      string
	ModelVersion   string
	Namespace      string
	Cluster        string
	Pod            string
	Controller     string
	ControllerKind string
	Container      string
	WorkloadType   string
}

type InferenceCostResponse struct {
	Properties InferenceCostAPIProperties `json:"properties"`
	Window     opencost.Window            `json:"window"`

	// CostBasis identifies whether these costs are usage-based or
	// allocation-based. Set from the QueryRequest.
	CostBasis CostBasis `json:"costBasis"`

	// Total infrastructure cost for the window under the chosen cost basis.
	TotalCost float64 `json:"totalCost"`

	// Token counts from vLLM metrics.
	PromptTokens     float64 `json:"promptTokens"`
	GenerationTokens float64 `json:"generationTokens"`
	TotalTokens      float64 `json:"totalTokens"`

	// Blended cost per 1M delivered tokens (input + output together).
	CostPerMillionTokens float64 `json:"costPerMillionTokens"`

	// Input/output cost split. InputCost and OutputCost sum to TotalCost if the cost basis is allocation.
	InputCost  float64 `json:"inputCost"`
	OutputCost float64 `json:"outputCost"`

	// Per-million cost metrics for differentiated pricing.
	// InputCostPerMillionTokens uses PromptTokens as the denominator (all delivered
	// input tokens, including those served from KV cache).
	InputCostPerMillionTokens  float64 `json:"inputCostPerMillionTokens"`
	OutputCostPerMillionTokens float64 `json:"outputCostPerMillionTokens"`

	// CacheSavingsFraction is the fraction of prompt tokens served from the KV
	// cache (CachedTokens / PromptTokens, clamped to [0, 1]). Zero when prefix
	// caching is disabled (see allocationMethod) or when no cache hits occurred
	// in the window.
	//
	// Note: in workloads with heavy prefix reuse (e.g. benchmarks with long
	// shared system prompts), the raw ratio can exceed 1.0 because
	// vllm:prefix_cache_hits_total counts tokens retrieved from cache per
	// request — including prefixes established by earlier requests outside the
	// current window — while vllm:prompt_tokens_total only counts new input
	// tokens delivered in this window. The value is clamped to 1.0 in that case.
	CacheSavingsFraction float64 `json:"cacheSavingsFraction"`

	// AllocationMethod records which input/output cost-split path was used.
	// Informational; omitted when empty.
	AllocationMethod AllocationMethod `json:"allocationMethod,omitempty"`
	// contains filtered or unexported fields
}

type InferenceCostSet struct {
	InferenceCosts map[string]*InferenceCostResponse `json:"inferenceCosts"`
	Window         opencost.Window                   `json:"window"`
}

type InferenceCostSetRange struct {
	InferenceCostSets []*InferenceCostSet `json:"inferenceCostSets"`
	Window            opencost.Window     `json:"window"`
}

type QueryRequest struct {
	Start       time.Time
	End         time.Time
	CostBasis   CostBasis
	AggregateBy []string
	Accumulate  opencost.AccumulateOption
	Filter      []filterSpec
	Step        time.Duration
}

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

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