Глава 12. Стоимость и латентность

package costlatency

import (
	"context"
	"strings"

	"github.com/anthropics/anthropic-sdk-go"
)

// Complexity — оценка сложности запроса, по ней выбираем модель.
type Complexity int

const (
	Simple Complexity = iota // короткий вопрос, фактический ответ
	Hard                     // рассуждение, многошаговость, анализ
)

// classify — дешёвая эвристика «на входе». В проде роль классификатора
// может играть отдельный быстрый вызов модели класса Haiku, но эвристика
// бесплатна и часто достаточна как первый фильтр.
func classify(prompt string) Complexity {
	p := strings.ToLower(prompt)
	long := len(prompt) > 600
	reasoning := strings.Contains(p, "почему") ||
		strings.Contains(p, "сравни") ||
		strings.Contains(p, "проанализируй")
	if long || reasoning {
		return Hard
	}
	return Simple
}

// pickModel — каскад cheap -> expensive: простое отдаём быстрой дешёвой
// модели, сложное эскалируем на более сильную. Слаги сверяйте с доками.
func pickModel(c Complexity) anthropic.Model {
	if c == Hard {
		return anthropic.ModelClaudeSonnet4_6
	}
	return anthropic.ModelClaudeHaiku4_5_20251001
}

// Answer выполняет запрос на модели, выбранной каскадом.
func Answer(ctx context.Context, client anthropic.Client, prompt string) (string, error) {
	model := pickModel(classify(prompt))

	resp, err := client.Messages.New(ctx, anthropic.MessageNewParams{
		Model:     model,
		MaxTokens: 1024,
		Messages: []anthropic.MessageParam{
			anthropic.NewUserMessage(anthropic.NewTextBlock(prompt)),
		},
	})
	if err != nil {
		return "", err
	}

	var sb strings.Builder
	for _, block := range resp.Content {
		if t, ok := block.AsAny().(anthropic.TextBlock); ok {
			sb.WriteString(t.Text)
		}
	}
	return sb.String(), nil
}

package costlatency

import (
	"context"
	"errors"
	"sync"

	"github.com/anthropics/anthropic-sdk-go"
)

// ErrBudgetExceeded возвращается, когда сессия исчерпала бюджет токенов.
var ErrBudgetExceeded = errors.New("token budget exceeded")

// Budget — потокобезопасный счётчик токенов на сессию.
// Считаем суммарно input + cache + output как «использованный контекст».
type Budget struct {
	mu    sync.Mutex
	limit int64
	used  int64
}

func NewBudget(limit int64) *Budget {
	return &Budget{limit: limit}
}

// Remaining — сколько токенов ещё доступно.
func (b *Budget) Remaining() int64 {
	b.mu.Lock()
	defer b.mu.Unlock()
	return b.limit - b.used
}

// record прибавляет фактический расход из Usage ответа.
func (b *Budget) record(u anthropic.Usage) {
	b.mu.Lock()
	defer b.mu.Unlock()
	// Полный объём промпта = uncached input + запись в кеш + чтение из кеша.
	b.used += u.InputTokens +
		u.CacheCreationInputTokens +
		u.CacheReadInputTokens +
		u.OutputTokens
}

// Step делает один вызов модели под контролем бюджета.
// Если бюджет уже исчерпан — отказываем заранее (деградация), не тратя деньги.
func (b *Budget) Step(
	ctx context.Context,
	client anthropic.Client,
	params anthropic.MessageNewParams,
) (*anthropic.Message, error) {
	if b.Remaining() <= 0 {
		return nil, ErrBudgetExceeded
	}

	resp, err := client.Messages.New(ctx, params)
	if err != nil {
		return nil, err
	}

	// Учитываем расход постфактум: лимит — мягкий предохранитель, а не
	// жёсткий потолок на отдельный вызов (для этого есть MaxTokens).
	b.record(resp.Usage)
	return resp, nil
}

package costlatency

import (
	"context"
	"fmt"
	"io"

	"github.com/anthropics/anthropic-sdk-go"
)

// StreamAnswer стримит ответ в w по мере генерации (низкий TTFT для UX)
// и параллельно собирает полное сообщение через Accumulate.
func StreamAnswer(
	ctx context.Context,
	client anthropic.Client,
	w io.Writer,
	prompt string,
) (anthropic.Message, error) {
	stream := client.Messages.NewStreaming(ctx, anthropic.MessageNewParams{
		Model: anthropic.ModelClaudeOpus4_8,
		// Для длинных ответов даём простор и обязательно стримим,
		// иначе синхронный запрос рискует упереться в таймаут SDK.
		MaxTokens: 64000,
		Messages: []anthropic.MessageParam{
			anthropic.NewUserMessage(anthropic.NewTextBlock(prompt)),
		},
	})

	// В Go нет GetFinalMessage() на стриме — аккумулируем вручную.
	message := anthropic.Message{}
	for stream.Next() {
		event := stream.Current()
		message.Accumulate(event)

		// Печатаем дельты текста сразу — пользователь видит первые слова,
		// не дожидаясь конца генерации.
		if delta, ok := event.AsAny().(anthropic.ContentBlockDeltaEvent); ok {
			if td, ok := delta.Delta.AsAny().(anthropic.TextDelta); ok {
				fmt.Fprint(w, td.Text)
			}
		}
	}
	if err := stream.Err(); err != nil {
		return anthropic.Message{}, err
	}
	return message, nil
}

package costlatency

import (
	"context"
	"math"
	"sync"

	"github.com/anthropics/anthropic-sdk-go"
)

// Embedder превращает текст в вектор смысла. Реализация — любой провайдер
// эмбеддингов; здесь нас интересует только контракт.
type Embedder interface {
	Embed(ctx context.Context, text string) ([]float32, error)
}

// cacheEntry — запомненная пара «вектор запроса -> ответ».
type cacheEntry struct {
	vec    []float32
	answer string
}

// SemanticCache — кеш ответов по эмбеддинг-похожести. Живёт на стороне
// приложения и матчит ПОХОЖИЕ запросы (в отличие от prompt caching,
// который матчит ТОЧНЫЙ префикс на сервере).
type SemanticCache struct {
	mu        sync.RWMutex
	embedder  Embedder
	client    anthropic.Client
	threshold float32 // порог косинусной близости, напр. 0.95

	// Скоуп по пользователю: ответы одного пользователя НЕ должны
	// возвращаться другому. Поиск ближайшего идёт только внутри скоупа.
	byUser map[string][]cacheEntry
}

func NewSemanticCache(e Embedder, c anthropic.Client, threshold float32) *SemanticCache {
	return &SemanticCache{
		embedder:  e,
		client:    c,
		threshold: threshold,
		byUser:    make(map[string][]cacheEntry),
	}
}

// cosine — косинусная близость двух векторов одинаковой длины.
func cosine(a, b []float32) float32 {
	var dot, na, nb float32
	for i := range a {
		dot += a[i] * b[i]
		na += a[i] * a[i]
		nb += b[i] * b[i]
	}
	if na == 0 || nb == 0 {
		return 0
	}
	// Векторы эмбеддингов обычно нормированы, но делим на нормы честно.
	return dot / float32(math.Sqrt(float64(na))*math.Sqrt(float64(nb)))
}

// lookup ищет ближайший кешированный ответ ВНУТРИ скоупа пользователя.
func (sc *SemanticCache) lookup(userID string, vec []float32) (string, bool) {
	sc.mu.RLock()
	defer sc.mu.RUnlock()
	var best float32
	var answer string
	for _, e := range sc.byUser[userID] {
		if s := cosine(vec, e.vec); s > best {
			best, answer = s, e.answer
		}
	}
	if best >= sc.threshold {
		return answer, true
	}
	return "", false
}

// Answer возвращает кешированный ответ при близком попадании,
// иначе вызывает модель и запоминает результат для будущих запросов.
func (sc *SemanticCache) Answer(
	ctx context.Context,
	userID, prompt string,
) (string, bool, error) {
	vec, err := sc.embedder.Embed(ctx, prompt)
	if err != nil {
		return "", false, err
	}

	if answer, ok := sc.lookup(userID, vec); ok {
		// Попадание: ни input, ни output, ни латентность генерации не платим.
		return answer, true, nil
	}

	// Промах: вызываем модель.
	resp, err := sc.client.Messages.New(ctx, anthropic.MessageNewParams{
		Model:     anthropic.ModelClaudeHaiku4_5_20251001,
		MaxTokens: 1024,
		Messages: []anthropic.MessageParam{
			anthropic.NewUserMessage(anthropic.NewTextBlock(prompt)),
		},
	})
	if err != nil {
		return "", false, err
	}

	var answer string
	for _, block := range resp.Content {
		if t, ok := block.AsAny().(anthropic.TextBlock); ok {
			answer += t.Text
		}
	}

	// Записываем в кеш под скоупом пользователя. В проде — с TTL/инвалидацией,
	// и только для запросов, чьи ответы устойчивы во времени.
	sc.mu.Lock()
	sc.byUser[userID] = append(sc.byUser[userID], cacheEntry{vec: vec, answer: answer})
	sc.mu.Unlock()

	return answer, false, nil
}