llm

type AzureConfig ¶

type AzureConfig struct {
	Endpoint   string
	Deployment string
	APIVersion string
}

AzureConfig holds the Azure OpenAI-specific endpoint coordinates, required only when provider == "azure_openai".

type Client ¶

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

Client is a hand-written net/http client for an OpenAI-compatible chat/completions endpoint. It supports three providers — openai, ollama and azure_openai — that differ only in endpoint URL and auth header; the request and response JSON shape is identical across all three, so there is a single wire format. Requests are retried with exponential backoff + jitter on retryable failures (429/5xx/network), bounded by maxRetries; fatal failures (400/401/403/404) fail immediately.

func NewClient(cfg ClientConfig) (*Client, error)

func (c *Client) Complete(ctx context.Context, req Request) (Response, error)

func (c *Client) Stream(ctx context.Context, req Request, w io.Writer) (Response, error)

type ClientConfig ¶

type ClientConfig struct {
	Provider   string
	BaseURL    string
	APIKey     string
	Timeout    time.Duration
	MaxRetries int
	Azure      AzureConfig
}

ClientConfig configures a Client. It mirrors the config.LLMConfig fields the network path needs, without importing internal/config (avoids a cycle and keeps llm reusable).

type Estimate ¶

type Estimate struct {
	Model        string
	InputTokens  int
	OutputTokens int // the configured max_tokens ceiling
	Pricing      Pricing
	CostUSD      float64
}

Estimate is the result of a cost estimation for one review request.

func EstimateCost(promptText string, maxOutputTokens int, pricing Pricing) Estimate

func (e Estimate) String() string

type Offline ¶

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

Offline is a deterministic, network-free Provider used when no API key is configured. Given the same commits and diff it always produces the same Markdown review — no time-based randomness, no external calls — so tests stay stable.

It is a genuinely useful fallback (not a "no key" stub): it summarizes commit subjects, lists changed files grouped by status, and reports rough size stats. It always carries a structured risk score (low|medium|high) computed by the shared deterministic heuristic (§7.3) — there is no model to ask.

func NewOffline(commits []gitlog.Commit, diff string) *Offline

func (o *Offline) Complete(ctx context.Context, _ Request) (Response, error)

type Pricing ¶

type Pricing struct {
	InputPer1M  float64
	OutputPer1M float64
}

Pricing is the per-1M-token price of a model, in USD.

func LookupPricing(model string) (Pricing, bool)

type Provider ¶

type Provider interface {
	Complete(ctx context.Context, req Request) (Response, error)
}

Provider produces a completion for a Request. Implemented by both the network Client and the deterministic Offline provider.

type Request ¶

type Request struct {
	// System is the system prompt (role=system); may be empty.
	System string
	// User is the user prompt (role=user).
	User string
	// Model, MaxTokens and Temperature come from config; the offline provider
	// ignores them.
	Model       string
	MaxTokens   int
	Temperature float64

	// Commits and Diff are pass-through context (not sent over the wire) so the
	// risk heuristic (§7.3) can be computed inside the provider without
	// re-deriving structure from the prompt text: the offline provider always
	// uses them, and the network Client uses them as a fallback when the
	// model's risk block is missing or invalid.
	Commits []gitlog.Commit
	Diff    string
}

Request is a provider-agnostic completion request.

type Response ¶

type Response struct {
	// Content is the assistant message text (Markdown for review), with any
	// trailing risk block already stripped (§7.2).
	Content string
	// Risk is always populated: the model supplies it, or the heuristic
	// fallback does (§7.2, §7.3). Consumers never need to handle an empty risk.
	Risk Risk
}

Response is a provider-agnostic completion response.

type Risk ¶

type Risk struct {
	Level     string
	Summary   string
	Heuristic bool
}

Risk is the structured risk score attached to a review (§7). Level is one of "low", "medium", "high"; Summary is a one-sentence explanation. Heuristic is true when the score was computed by the deterministic fallback (offline mode, or the model omitted a valid risk block) rather than parsed from the model's own fenced risk block.

func HeuristicRisk(commits []gitlog.Commit, diff string) Risk

func ParseRisk(content string) (stripped string, risk Risk, ok bool)

type StatusError ¶

type StatusError struct {
	StatusCode int
	Retryable  bool
	Provider   string
	Message    string
}

StatusError is a typed HTTP error carrying the status code and whether the request is worth retrying. It is used with errors.As so retry classification never relies on string matching.

func (e *StatusError) Error() string

type Streamer ¶ added in v0.3.0

type Streamer interface {
	Stream(ctx context.Context, req Request, w io.Writer) (Response, error)
}

Streamer is an optional interface for providers that support token-by-token SSE streaming. Client implements it; Offline does not.