LLM API

// Минимальный чат: история на клиенте, каждый ход — полный список сообщений.
package chat;

import com.anthropic.client.AnthropicClient;
import com.anthropic.client.okhttp.AnthropicOkHttpClient;
import com.anthropic.models.messages.Message;
import com.anthropic.models.messages.MessageCreateParams;
import com.anthropic.models.messages.MessageParam;
import com.anthropic.models.messages.StopReason;
import com.anthropic.models.messages.TextBlock;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;

public final class Session {
    private final AnthropicClient client = AnthropicOkHttpClient.fromEnv(); // ключ из ANTHROPIC_API_KEY
    private final String system;
    private final List<MessageParam> history = new ArrayList<>(); // в проде — в БД, по session_id

    public Session(String system) {
        this.system = system;
    }

    public String ask(String userText) {
        history.add(MessageParam.builder().role(MessageParam.Role.USER).content(userText).build());
        Message resp;
        try {
            resp = client.messages().create(MessageCreateParams.builder()
                    .model("claude-opus-5")
                    .maxTokens(16000)
                    .system(system)
                    .messages(history)
                    .build());
        } catch (RuntimeException e) {
            history.removeLast(); // не оставляем «висящий» user-ход
            throw e;
        }
        history.add(resp.toParam()); // ответ целиком, со всеми блоками

        String text = resp.content().stream()
                .flatMap(b -> b.text().stream())
                .map(TextBlock::text)
                .collect(Collectors.joining());
        if (resp.stopReason().map(StopReason.MAX_TOKENS::equals).orElse(false)) {
            throw new IllegalStateException("ответ обрезан по max_tokens: " + text.length() + " символов");
        }
        return text;
    }
}

// Минимальный чат: история на клиенте, каждый ход — полный список сообщений.
package chat

import (
	"context"
	"fmt"
	"strings"

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

type Session struct {
	client  anthropic.Client
	system  string
	history []anthropic.MessageParam // в проде — в БД, по session_id
}

func NewSession(system string) *Session {
	return &Session{client: anthropic.NewClient(), system: system} // ключ из ANTHROPIC_API_KEY
}

func (s *Session) Ask(ctx context.Context, userText string) (string, error) {
	s.history = append(s.history, anthropic.NewUserMessage(anthropic.NewTextBlock(userText)))
	resp, err := s.client.Messages.New(ctx, anthropic.MessageNewParams{
		Model:     "claude-opus-5",
		MaxTokens: 16000,
		System:    []anthropic.TextBlockParam{{Text: s.system}},
		Messages:  s.history,
	})
	if err != nil {
		s.history = s.history[:len(s.history)-1] // не оставляем «висящий» user-ход
		return "", fmt.Errorf("messages.new: %w", err)
	}
	s.history = append(s.history, resp.ToParam()) // ответ целиком, со всеми блоками

	var b strings.Builder
	for _, block := range resp.Content {
		if t, ok := block.AsAny().(anthropic.TextBlock); ok {
			b.WriteString(t.Text)
		}
	}
	if resp.StopReason == anthropic.StopReasonMaxTokens {
		return b.String(), fmt.Errorf("ответ обрезан по max_tokens")
	}
	return b.String(), nil
}

import anthropic

client = anthropic.Anthropic()  # ANTHROPIC_API_KEY из окружения
history = []

def ask(text: str) -> str:
    history.append({"role": "user", "content": text})
    resp = client.messages.create(
        model="claude-opus-5",
        max_tokens=16000,
        system="Ты — ассистент поддержки. Отвечай кратко.",
        messages=history,
    )
    history.append({"role": "assistant", "content": resp.content})
    return "".join(b.text for b in resp.content if b.type == "text")

// streamAnswer пишет текст в out по мере генерации, возвращает собранное сообщение.
public static Message streamAnswer(AnthropicClient client, String prompt, Writer out) throws IOException {
    long start = System.nanoTime();
    long ttft = 0;

    var params = MessageCreateParams.builder()
            .model("claude-opus-5")
            .maxTokens(64000)
            .addUserMessage(prompt)
            .build();
    var acc = MessageAccumulator.create(); // собирает итоговое Message из событий стрима

    try (StreamResponse<RawMessageStreamEvent> stream = client.messages().createStreaming(params)) {
        Iterator<RawMessageStreamEvent> it = stream.stream().iterator();
        while (it.hasNext()) { // сюда же прилетают event: error и обрыв — исключением из it.next()
            RawMessageStreamEvent ev = it.next();
            acc.accumulate(ev);
            Optional<String> text = ev.contentBlockDelta()
                    .flatMap(d -> d.delta().text())
                    .map(TextDelta::text);
            if (text.isPresent()) {
                if (ttft == 0) {
                    ttft = System.nanoTime() - start;
                }
                out.write(text.get()); // IOException: клиент ушёл — выходим, try закроет стрим
                out.flush();
            }
        }
    }
    Message msg = acc.message();
    log.atInfo().setMessage("llm stream done")
            .addKeyValue("ttft_ms", ttft / 1_000_000)
            .addKeyValue("total_ms", (System.nanoTime() - start) / 1_000_000)
            .addKeyValue("stop_reason", msg.stopReason().orElse(null))
            .addKeyValue("out_tokens", msg.usage().outputTokens())
            .log();
    return msg;
}

// StreamAnswer пишет текст в w по мере генерации, возвращает собранное сообщение.
func StreamAnswer(ctx context.Context, client anthropic.Client, prompt string, w io.Writer) (anthropic.Message, error) {
	start := time.Now()
	var ttft time.Duration

	stream := client.Messages.NewStreaming(ctx, anthropic.MessageNewParams{
		Model:     "claude-opus-5",
		MaxTokens: 64000,
		Messages:  []anthropic.MessageParam{anthropic.NewUserMessage(anthropic.NewTextBlock(prompt))},
	})
	defer stream.Close()

	msg := anthropic.Message{} // у Go-стрима нет GetFinalMessage — аккумулируем сами
	for stream.Next() {
		ev := stream.Current()
		if err := msg.Accumulate(ev); err != nil {
			return msg, fmt.Errorf("accumulate: %w", err)
		}
		if d, ok := ev.AsAny().(anthropic.ContentBlockDeltaEvent); ok {
			if t, ok := d.Delta.AsAny().(anthropic.TextDelta); ok {
				if ttft == 0 {
					ttft = time.Since(start)
				}
				if _, err := io.WriteString(w, t.Text); err != nil {
					return msg, err // клиент ушёл — выходим, defer закроет стрим
				}
				if f, ok := w.(http.Flusher); ok {
					f.Flush()
				}
			}
		}
	}
	if err := stream.Err(); err != nil { // сюда же попадает event: error и обрыв
		return msg, fmt.Errorf("stream: %w", err)
	}
	slog.InfoContext(ctx, "llm stream done",
		"ttft_ms", ttft.Milliseconds(), "total_ms", time.Since(start).Milliseconds(),
		"stop_reason", msg.StopReason, "out_tokens", msg.Usage.OutputTokens)
	return msg, nil
}

import time, anthropic

client = anthropic.Anthropic()

def stream_answer(prompt: str) -> anthropic.types.Message:
    start, ttft = time.monotonic(), None
    with client.messages.stream(
        model="claude-opus-5",
        max_tokens=64000,
        messages=[{"role": "user", "content": prompt}],
    ) as stream:
        for text in stream.text_stream:
            if ttft is None:
                ttft = time.monotonic() - start
            print(text, end="", flush=True)
        msg = stream.get_final_message()
    print(f"\nTTFT={ttft:.2f}s stop={msg.stop_reason} out={msg.usage.output_tokens}")
    return msg

// Ticket.java. Jackson по умолчанию падает на неизвестных полях (FAIL_ON_UNKNOWN_PROPERTIES).
public record Ticket(String category, String priority, String summary,
                     @JsonProperty("order_id") String orderId) {

    static final Map<String, Object> SCHEMA = Map.of(
            "type", "object",
            "properties", Map.of(
                    "category", Map.of("type", "string", "enum", List.of("billing", "bug", "delivery", "other")),
                    "priority", Map.of("type", "string", "enum", List.of("p1", "p2", "p3")),
                    "summary", Map.of("type", "string"),
                    "order_id", Map.of("type", "string")),
            "required", List.of("category", "priority", "summary", "order_id"),
            "additionalProperties", false);

    private static final Pattern ORDER = Pattern.compile("^(ORD-\\d{6})?$");

    /** То, что схема выразить не может (maxLength, формат id, бизнес-правила). */
    void validate() {
        int n = summary.codePointCount(0, summary.length());
        if (n == 0 || n > 200) {
            throw new IllegalArgumentException("summary: длина %d, нужно 1..200 символов".formatted(n));
        }
        if (!ORDER.matcher(orderId).matches()) {
            throw new IllegalArgumentException("order_id \"%s\": ожидается ORD-NNNNNN или пустая строка".formatted(orderId));
        }
    }
}

// TicketExtractor.java
static Ticket extractTicket(AnthropicClient c, String text) {
    var params = MessageCreateParams.builder()
            .model("claude-sonnet-5")
            .maxTokens(1024)
            .addUserMessage("Разбери обращение клиента в тикет.\n<message>\n" + text + "\n</message>")
            // output_config через escape hatch тела запроса: работает независимо от версии SDK
            .putAdditionalBodyProperty("output_config", JsonValue.from(Map.of(
                    "format", Map.of("type", "json_schema", "schema", Ticket.SCHEMA))));
    Exception lastErr = null;
    for (int attempt = 0; attempt < 3; attempt++) {
        // сетевые ошибки и 429 ретраит слой ниже, здесь — только логика
        Message resp = c.messages().create(params.build());
        StopReason sr = resp.stopReason().orElseThrow();
        if (sr.equals(StopReason.MAX_TOKENS) || sr.equals(StopReason.REFUSAL)) {
            throw new IllegalStateException("no valid output: stop_reason=" + sr);
        }
        String raw = resp.content().stream()
                .flatMap(b -> b.text().stream())
                .map(TextBlock::text)
                .collect(Collectors.joining());
        try {
            Ticket t = JSON.readValue(raw, Ticket.class);
            t.validate();
            return t;
        } catch (JsonProcessingException | IllegalArgumentException e) {
            lastErr = e;
        }
        // Повтор с конкретной ошибкой: модель видит свой ответ и что в нём не так.
        params.addMessage(resp.toParam())
              .addUserMessage("Ответ не прошёл валидацию: " + lastErr.getMessage()
                      + ". Верни исправленный JSON целиком.");
    }
    throw new IllegalStateException("ticket invalid after retries", lastErr);
}

type Ticket struct {
	Category string `json:"category"`
	Priority string `json:"priority"`
	Summary  string `json:"summary"`
	OrderID  string `json:"order_id"`
}

var ticketSchema = map[string]any{
	"type": "object",
	"properties": map[string]any{
		"category": map[string]any{"type": "string", "enum": []string{"billing", "bug", "delivery", "other"}},
		"priority": map[string]any{"type": "string", "enum": []string{"p1", "p2", "p3"}},
		"summary":  map[string]any{"type": "string"},
		"order_id": map[string]any{"type": "string"},
	},
	"required":             []string{"category", "priority", "summary", "order_id"},
	"additionalProperties": false,
}

var orderRe = regexp.MustCompile(`^(ORD-\d{6})?$`)

// Validate — то, что схема выразить не может (maxLength, формат id, бизнес-правила).
func (t Ticket) Validate() error {
	if n := utf8.RuneCountInString(t.Summary); n == 0 || n > 200 {
		return fmt.Errorf("summary: длина %d, нужно 1..200 символов", n)
	}
	if !orderRe.MatchString(t.OrderID) {
		return fmt.Errorf("order_id %q: ожидается ORD-NNNNNN или пустая строка", t.OrderID)
	}
	return nil
}

func ExtractTicket(ctx context.Context, c anthropic.Client, text string) (Ticket, error) {
	msgs := []anthropic.MessageParam{anthropic.NewUserMessage(anthropic.NewTextBlock(
		"Разбери обращение клиента в тикет.\n<message>\n" + text + "\n</message>"))}
	var lastErr error
	for attempt := 0; attempt < 3; attempt++ {
		resp, err := c.Messages.New(ctx, anthropic.MessageNewParams{
			Model: "claude-sonnet-5", MaxTokens: 1024, Messages: msgs,
			OutputConfig: anthropic.OutputConfigParam{
				Format: anthropic.JSONOutputFormatParam{Schema: ticketSchema},
			},
		})
		if err != nil {
			return Ticket{}, err // сетевые/429 ретраит слой ниже, здесь — только логика
		}
		switch resp.StopReason {
		case anthropic.StopReasonMaxTokens, anthropic.StopReasonRefusal:
			return Ticket{}, fmt.Errorf("no valid output: stop_reason=%s", resp.StopReason)
		}
		var raw strings.Builder
		for _, b := range resp.Content {
			if t, ok := b.AsAny().(anthropic.TextBlock); ok {
				raw.WriteString(t.Text)
			}
		}
		var t Ticket
		if lastErr = json.Unmarshal([]byte(raw.String()), &t); lastErr == nil {
			if lastErr = t.Validate(); lastErr == nil {
				return t, nil
			}
		}
		// Повтор с конкретной ошибкой: модель видит свой ответ и что в нём не так.
		msgs = append(msgs, resp.ToParam(), anthropic.NewUserMessage(anthropic.NewTextBlock(
			"Ответ не прошёл валидацию: "+lastErr.Error()+". Верни исправленный JSON целиком.")))
	}
	return Ticket{}, fmt.Errorf("ticket invalid after retries: %w", lastErr)
}

from typing import Literal
from pydantic import BaseModel, Field
import anthropic

class Ticket(BaseModel):
    category: Literal["billing", "bug", "delivery", "other"]
    priority: Literal["p1", "p2", "p3"]
    summary: str = Field(max_length=200)        # SDK проверит на клиенте
    order_id: str = Field(pattern=r"^(ORD-\d{6})?$")

client = anthropic.Anthropic()

resp = client.messages.parse(
    model="claude-sonnet-5",
    max_tokens=1024,
    messages=[{"role": "user", "content": f"Разбери обращение в тикет.\n<message>\n{text}\n</message>"}],
    output_format=Ticket,
)
ticket: Ticket = resp.parsed_output  # уже провалидированный объект

@FunctionalInterface
public interface ToolFunc {
    // Реализация обязана уважать timeout: HttpRequest.timeout, JDBC queryTimeout и т.п.
    String call(JsonValue input, Duration timeout) throws Exception;
}

public static String runTools(AnthropicClient c, List<ToolUnion> tools, Map<String, ToolFunc> impl,
                              List<MessageParam> msgs) {
    var params = MessageCreateParams.builder()
            .model("claude-opus-5").maxTokens(16000).tools(tools).messages(msgs);

    for (int turn = 0; turn < 10; turn++) { // лимит итераций — защита от зацикливания
        Message resp = c.messages().create(params.build());
        params.addMessage(resp.toParam()); // ответ модели — в историю ДО tool_result

        if (!resp.stopReason().map(StopReason.TOOL_USE::equals).orElse(false)) {
            return resp.content().stream()
                    .flatMap(b -> b.text().stream())
                    .map(TextBlock::text)
                    .collect(Collectors.joining());
        }

        List<ToolUseBlock> calls = resp.content().stream().flatMap(b -> b.toolUse().stream()).toList();
        var limit = new Semaphore(4); // не больше 4 инструментов одновременно
        List<Future<ContentBlockParam>> futures;
        try (var exec = Executors.newVirtualThreadPerTaskExecutor()) { // close() ждёт все задачи
            futures = calls.stream().map(call -> exec.submit(() -> {
                limit.acquire();
                try {
                    return runOne(impl, call); // никогда не бросает: ошибка — в tool_result
                } finally {
                    limit.release();
                }
            })).toList();
        }
        // Порядок = порядок вызовов, а не порядок завершения.
        List<ContentBlockParam> results = futures.stream().map(Future::resultNow).toList();
        params.addUserMessageOfBlockParams(results); // ВСЕ результаты одним сообщением
    }
    throw new IllegalStateException("tool loop: превышен лимит итераций");
}

static ContentBlockParam runOne(Map<String, ToolFunc> impl, ToolUseBlock call) {
    ToolFunc fn = impl.get(call.name());
    if (fn == null) {
        return toolResult(call.id(), "error: неизвестный инструмент " + call.name(), true);
    }
    try {
        String out = fn.call(call._input(), Duration.ofSeconds(15));
        if (out.length() > 20_000) { // ponytail: обрезка по символам; лучше — суммаризация/пагинация в самом инструменте
            out = out.substring(0, 20_000) + "\n…[обрезано]";
        }
        return toolResult(call.id(), out, false);
    } catch (Exception e) { // ошибка инструмента — данные для модели, а не падение цикла
        return toolResult(call.id(), "error: " + e.getMessage(), true);
    }
}

static ContentBlockParam toolResult(String toolUseId, String content, boolean isError) {
    return ContentBlockParam.ofToolResult(ToolResultBlockParam.builder()
            .toolUseId(toolUseId).content(content).isError(isError).build());
}

type ToolFunc func(ctx context.Context, input json.RawMessage) (string, error)

func RunTools(ctx context.Context, c anthropic.Client, tools []anthropic.ToolUnionParam,
	impl map[string]ToolFunc, msgs []anthropic.MessageParam) (string, error) {

	for turn := 0; turn < 10; turn++ { // лимит итераций — защита от зацикливания
		resp, err := c.Messages.New(ctx, anthropic.MessageNewParams{
			Model: "claude-opus-5", MaxTokens: 16000, Tools: tools, Messages: msgs,
		})
		if err != nil {
			return "", err
		}
		msgs = append(msgs, resp.ToParam()) // ответ модели — в историю ДО tool_result

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

		var calls []anthropic.ToolUseBlock
		for _, b := range resp.Content {
			if tu, ok := b.AsAny().(anthropic.ToolUseBlock); ok {
				calls = append(calls, tu)
			}
		}
		results := make([]anthropic.ContentBlockParamUnion, len(calls)) // порядок = порядок вызовов
		g, gctx := errgroup.WithContext(ctx)
		g.SetLimit(4) // не больше 4 инструментов одновременно
		for i, call := range calls {
			g.Go(func() error {
				out, err := runOne(gctx, impl, call)
				if err != nil { // ошибка инструмента — данные для модели, а не падение цикла
					results[i] = anthropic.NewToolResultBlock(call.ID, "error: "+err.Error(), true)
					return nil
				}
				results[i] = anthropic.NewToolResultBlock(call.ID, out, false)
				return nil
			})
		}
		_ = g.Wait() // горутины всегда возвращают nil; отмену ctx поймает следующий Messages.New
		msgs = append(msgs, anthropic.NewUserMessage(results...)) // ВСЕ результаты одним сообщением
	}
	return "", errors.New("tool loop: превышен лимит итераций")
}

func runOne(ctx context.Context, impl map[string]ToolFunc, call anthropic.ToolUseBlock) (string, error) {
	fn, ok := impl[call.Name]
	if !ok {
		return "", fmt.Errorf("неизвестный инструмент %q", call.Name)
	}
	ctx, cancel := context.WithTimeout(ctx, 15*time.Second)
	defer cancel()
	out, err := fn(ctx, json.RawMessage(call.JSON.Input.Raw()))
	if len(out) > 20_000 { // ponytail: обрезка по байтам; лучше — суммаризация/пагинация в самом инструменте
		out = out[:20_000] + "\n…[обрезано]"
	}
	return out, err
}

import asyncio, json, anthropic

client = anthropic.AsyncAnthropic()

async def run_tools(tools, impl, messages):
    for _ in range(10):
        resp = await client.messages.create(
            model="claude-opus-5", max_tokens=16000, tools=tools, messages=messages)
        messages.append({"role": "assistant", "content": resp.content})
        if resp.stop_reason != "tool_use":
            return "".join(b.text for b in resp.content if b.type == "text")

        calls = [b for b in resp.content if b.type == "tool_use"]

        async def one(call):
            try:
                out = await asyncio.wait_for(impl[call.name](**call.input), timeout=15)
                return {"type": "tool_result", "tool_use_id": call.id, "content": str(out)}
            except Exception as e:  # ошибка — модели, а не наверх
                return {"type": "tool_result", "tool_use_id": call.id,
                        "content": f"error: {e}", "is_error": True}

        results = await asyncio.gather(*(one(c) for c in calls))
        messages.append({"role": "user", "content": list(results)})
    raise RuntimeError("tool loop: превышен лимит итераций")

Message resp = client.messages().create(MessageCreateParams.builder()
        .model("claude-opus-5")
        .maxTokens(4096)
        .tools(tools) // стабильный набор, отсортирован по имени
        .systemOfTextBlockParams(List.of(TextBlockParam.builder()
                .text(policyAndCatalog) // 20K токенов, не меняется
                .cacheControl(CacheControlEphemeral.builder().build()) // breakpoint #1: tools + system
                .build()))
        .messages(history) // на последнем блоке истории — breakpoint #2
        .build());
Usage u = resp.usage();
log.info("cache read={} write={} uncached={}",
        u.cacheReadInputTokens().orElse(0L), u.cacheCreationInputTokens().orElse(0L), u.inputTokens());

resp, err := client.Messages.New(ctx, anthropic.MessageNewParams{
	Model:     "claude-opus-5",
	MaxTokens: 4096,
	Tools:     tools, // стабильный набор, отсортирован по имени
	System: []anthropic.TextBlockParam{{
		Text:         policyAndCatalog, // 20K токенов, не меняется
		CacheControl: anthropic.NewCacheControlEphemeralParam(), // breakpoint #1: tools + system
	}},
	Messages: history, // на последнем блоке истории — breakpoint #2 (или top-level CacheControl)
})
if err != nil {
	return err
}
u := resp.Usage
slog.Info("cache", "read", u.CacheReadInputTokens, "write", u.CacheCreationInputTokens, "uncached", u.InputTokens)

resp = client.messages.create(
    model="claude-opus-5",
    max_tokens=4096,
    tools=tools,
    system=[{"type": "text", "text": policy_and_catalog,
             "cache_control": {"type": "ephemeral"}}],   # или {"type": "ephemeral", "ttl": "1h"}
    messages=history,
)
u = resp.usage
print(u.cache_read_input_tokens, u.cache_creation_input_tokens, u.input_tokens)

// Клиент без встроенных ретраев — политику задаём сами.
static final AnthropicClient CLIENT = AnthropicOkHttpClient.builder().fromEnv().maxRetries(0).build();

public static <T> T withRetry(int attempts, Duration budget, Callable<T> fn) throws Exception {
    Instant deadline = Instant.now().plus(budget); // общий бюджет времени на все попытки
    for (int n = 0; ; n++) {
        try {
            return fn.call();
        } catch (Exception e) {
            Optional<Duration> delay = classify(e, n);
            if (delay.isEmpty() || n + 1 >= attempts || Instant.now().plus(delay.get()).isAfter(deadline)) {
                throw e;
            }
            log.warn("llm retry attempt={} delay={}", n + 1, delay.get(), e);
            Thread.sleep(delay.get()); // в виртуальном потоке дёшево; interrupt = отмена
        }
    }
}

/** Пустой Optional — не ретраить; иначе — сколько ждать. */
static Optional<Duration> classify(Exception e, int n) {
    long backoff = Math.min(30_000, 500L << n);
    Duration delay = Duration.ofMillis(ThreadLocalRandom.current().nextLong(backoff) + 100); // full jitter

    if (e instanceof AnthropicServiceException api) {
        int s = api.statusCode();
        if (s == 408 || s == 409 || s == 429 || s >= 500) { // 529 тоже здесь
            return Optional.of(retryAfter(api).orElse(delay)); // сервер знает лучше
        }
        return Optional.empty(); // 400/401/403/404/413 — повтор не поможет
    }
    if (e instanceof AnthropicIoException || e instanceof IOException) {
        return Optional.of(delay); // сеть, обрыв стрима
    }
    return Optional.empty(); // InterruptedException и прочее — не ретраим
}

static Optional<Duration> retryAfter(AnthropicServiceException e) {
    try {
        return e.headers().values("retry-after").stream().findFirst()
                .map(v -> Duration.ofSeconds(Long.parseLong(v.trim())));
    } catch (NumberFormatException x) {
        return Optional.empty();
    }
}

// Использование:
// Message resp = withRetry(4, Duration.ofSeconds(60), () -> CLIENT.messages().create(params));

// Клиент без встроенных ретраев — политику задаём сами.
var client = anthropic.NewClient(option.WithMaxRetries(0))

func WithRetry[T any](ctx context.Context, attempts int, fn func(context.Context) (T, error)) (T, error) {
	var zero T
	for n := 0; ; n++ {
		v, err := fn(ctx)
		if err == nil {
			return v, nil
		}
		delay, retryable := classify(err, n)
		if !retryable || n+1 >= attempts {
			return zero, err
		}
		slog.WarnContext(ctx, "llm retry", "attempt", n+1, "delay", delay, "err", err)
		t := time.NewTimer(delay)
		select {
		case <-t.C:
		case <-ctx.Done():
			t.Stop()
			return zero, errors.Join(err, ctx.Err())
		}
	}
}

func classify(err error, n int) (time.Duration, bool) {
	backoff := min(30*time.Second, 500*time.Millisecond<<n)
	delay := rand.N(backoff) + 100*time.Millisecond // full jitter

	var apierr *anthropic.Error
	if errors.As(err, &apierr) {
		switch s := apierr.StatusCode; {
		case s == 408, s == 409, s == 429, s == 529, s >= 500:
			if apierr.Response != nil {
				if ra, err := strconv.Atoi(apierr.Response.Header.Get("retry-after")); err == nil {
					delay = time.Duration(ra) * time.Second // сервер знает лучше
				}
			}
			return delay, true
		default:
			return 0, false // 400/401/403/404/413 — повтор не поможет
		}
	}
	if errors.Is(err, context.Canceled) || errors.Is(err, context.DeadlineExceeded) {
		return 0, false
	}
	var ne net.Error
	if errors.As(err, &ne) || errors.Is(err, io.ErrUnexpectedEOF) {
		return delay, true // сеть, обрыв стрима
	}
	return 0, false
}

// Использование:
// resp, err := WithRetry(ctx, 4, func(ctx context.Context) (*anthropic.Message, error) {
//     return client.Messages.New(ctx, params)
// })

import anthropic

# Обычно достаточно встроенных ретраев: backoff и retry-after SDK учитывает сам.
client = anthropic.Anthropic(max_retries=4, timeout=120.0)

try:
    resp = client.messages.create(model="claude-opus-5", max_tokens=1024,
                                  messages=[{"role": "user", "content": "…"}])
except anthropic.RateLimitError as e:        # 429 после всех повторов
    log.warning("rate limited, retry-after=%s", e.response.headers.get("retry-after"))
    raise
except anthropic.APIStatusError as e:
    if e.status_code == 529 or e.type == "overloaded_error":
        resp = call_fallback_model()           # затяжная перегрузка — другая модель
    else:
        raise