from __future__ import annotations

import sys

import time

from abc import ABC, abstractmethod

import anthropic

import httpx

from felderize.config import Config

_RATE_LIMIT_RETRIES = 5

class PromptTooLargeError(Exception):

"""The request exceeded the model's context window.

Raised instead of the raw ``anthropic.BadRequestError`` so callers can turn a

too-large program into a clear "shorten the input" message rather than an

opaque API error. Retrying does not help, so this is never retried.

"""

def _is_context_length_error(error: anthropic.BadRequestError) -> bool:

"""Tell a context-window overflow apart from other 400 errors.

Anthropic reports an oversized request with a message such as

``prompt is too long: N tokens > M maximum``. Match that phrasing (and a few

near-synonyms) so genuine bad requests still surface unchanged.

"""

message = str(error).lower()

if (

"too long" in message

or "context window" in message

or "context length" in message

):

return True

return "maximum" in message and "token" in message

# Transient failures worth retrying: dropped/again-refused connections, timeouts,

# and 5xx. The raw httpx errors are included because a streamed response can drop

# mid-body (RemoteProtocolError) without the SDK wrapping it.

_TRANSIENT_ERRORS = (

anthropic.APIConnectionError,

anthropic.APITimeoutError,

anthropic.InternalServerError,

httpx.RemoteProtocolError,

httpx.ReadError,

httpx.ConnectError,

)

class LLMClient(ABC):

"""Abstract interface for LLM translation backends."""

@abstractmethod

def translate(self, system_prompt: str, user_prompt: str) -> str:

"""Send a translation request and return the raw response text."""

class AnthropicClient(LLMClient):

"""LLM client backed by the Anthropic API."""

def __init__(self, config: Config, verbose: bool = False):

self.client = anthropic.Anthropic(

api_key=config.api_key, base_url=config.base_url

)

self.model = config.model

self.max_tokens = config.max_tokens

self.verbose = verbose

def translate(self, system_prompt: str, user_prompt: str) -> str:

"""Send a prompt to the Anthropic API and return the response text.

Retries up to _RATE_LIMIT_RETRIES times on rate limit errors, with

linearly increasing back-off.

"""

for attempt in range(_RATE_LIMIT_RETRIES):

try:

with self.client.messages.stream(

model=self.model,

max_tokens=self.max_tokens,

system=[

{

"type": "text",

"text": system_prompt,

"cache_control": {"type": "ephemeral"},

}

],

messages=[{"role": "user", "content": user_prompt}],

) as stream:

response = stream.get_final_message()

u = response.usage

if self.verbose:

print(

f" llm: input={u.input_tokens} "

f"cache_read={getattr(u, 'cache_read_input_tokens', 0)} "

f"cache_write={getattr(u, 'cache_creation_input_tokens', 0)} "

f"output={u.output_tokens}",

file=sys.stderr,

)

return response.content[0].text

except anthropic.BadRequestError as e:

if _is_context_length_error(e):

raise PromptTooLargeError(str(e)) from e

raise

except anthropic.RateLimitError:

if attempt == _RATE_LIMIT_RETRIES - 1:

raise

wait = 60 * (attempt + 1)

print(f"Rate limited — waiting {wait}s before retry...", flush=True)

time.sleep(wait)

except _TRANSIENT_ERRORS as e:

if attempt == _RATE_LIMIT_RETRIES - 1:

raise

wait = 5 * (attempt + 1)

print(

f"Transient API error ({type(e).__name__}) — retrying in {wait}s...",

file=sys.stderr,

flush=True,

)

time.sleep(wait)

raise AssertionError("unreachable")

def create_client(config: Config, verbose: bool = False) -> LLMClient:

"""Instantiate the appropriate LLM client for the given config."""

return AnthropicClient(config, verbose=verbose)