whatap-python 2.2.2__py3-none-any.whl → 2.3.0__py3-none-any.whl

whatap/llm/evaluators/builtins/judge_factories.py

@@ -1,8 +1,8 @@
-"""provider 별 judge_fn 팩토리 (OpenAI / Anthropic).
+"""provider 별 judge_fn 팩토리 (OpenAI / Anthropic / Bedrock).
 
 M-4: ``llm_judge.py`` 에서 분리 — evaluator 레이어에서 유일하게 구체 LLM SDK 를 아는 곳.
-SDK(``openai`` / ``anthropic``) import 는 judge_fn 이 **처음 호출될 때** lazy 로 일어난다
-(모듈 로드 시점 아님) — 그 SDK 가 설치 안 된 환경에서도 이 모듈 import 는 안전하다.
+SDK(``openai`` / ``anthropic`` / ``botocore``) import 는 judge_fn 이 **처음 호출될 때** lazy
+로 일어난다 (모듈 로드 시점 아님) — 그 SDK 가 설치 안 된 환경에서도 이 모듈 import 는 안전하다.
 
 judge 는 항상 **자기 소유의 client** 로 동작한다 — 사용자 요청 client 를 빌리지 않으므로
 요청 수명/event loop 상태와 무관하다. (요청 스코프 client 는 평가가 비동기로 도는 시점에
@@ -10,11 +10,29 @@ judge 는 항상 **자기 소유의 client** 로 동작한다 — 사용자 요
 
 하위호환: ``make_openai_judge`` / ``make_anthropic_judge`` 는 ``llm_judge`` 가 re-export
 하므로 기존 import 경로(``from ...llm_judge import make_openai_judge``)가 그대로 동작한다.
+
+최신 모델은 judge 가 보내던 옵션 일부를 거절한다(temperature · 출력 한도). judge 는 거절당한
+옵션을 한 번 빼거나 바꿔 다시 보내고, 그 뒤로는 처음부터 그 모양으로 보낸다.
+
+출력 한도는 빼면 안 되는 곳에만 보낸다. OpenAI 는 선택 항목이라 보내지 않는다(모델 기본값).
+Anthropic 은 API 가 요구한다. Bedrock 은 요청마다 이 한도만큼 계정 할당량(TPM)을 먼저 잡는데,
+빼면 모델 최대치를 잡아 앱 호출이 throttle 될 수 있다. 입력은 자르지 않는다.
 """
+import re
+
+# Anthropic · Bedrock judge 출력 한도. Claude 5 계열은 thinking 을 기본으로 켜고 thinking 토큰도
+# 이 한도에 들어가 2048 이면 판정이 잘린다. 서비스 중인 Claude 모델이 모두 받는 값이고(최소 64K),
+# 비스트리밍 요청이 SDK 의 긴 요청 검사에 걸리지 않는 선이다.
+_JUDGE_MAX_TOKENS = 16000
+# 출력 한도가 그보다 작은 Bedrock 모델(Llama · Titan · Nova 등)이 거절하면 낮출 값 — 예전 기본값.
+_SMALL_MAX_TOKENS = 2048
+# Bedrock 이 출력 한도 초과를 알리는 메시지의 칸 이름(maxTokens · max_tokens · max_new_tokens ·
+# max_gen_len · "maximum tokens").
+_MAX_TOKENS_REJECTION = re.compile(r'max(?:imum)?[ _]?(?:new_)?tokens?|max_gen_len')
 
 
 def make_openai_judge(client=None, model='gpt-4o-mini', api_key=None, base_url=None,
-                      temperature=0.0, max_tokens=2048, timeout=None):
+                      temperature=0.0, max_tokens=None, timeout=None):
     """OpenAI 호환 API 를 사용하는 judge_fn 을 생성한다.
 
     judge 는 **자기 소유의 client** 로 동작한다 — ``client`` 를 주면 그대로, 안 주면 첫
@@ -24,10 +42,18 @@ def make_openai_judge(client=None, model='gpt-4o-mini', api_key=None, base_url=N
     :param client: 기존 ``openai.OpenAI`` 인스턴스 (선택).
     :param model:  평가용 모델.
     :param base_url: OpenAI 호환 엔드포인트 (client 미지정 시).
+    :param temperature: 판정을 일정하게 하려는 샘플링 온도(기본 0.0). 기본값만 받는 reasoning
+        모델(o 시리즈 · gpt-5 등)이면 한 번 거절당한 뒤로는 빼고 보낸다. ``None`` 이면 처음부터
+        보내지 않는다.
+    :param max_tokens: 출력 한도. 기본 ``None`` 은 보내지 않고 모델 기본값에 맡긴다 — 한도가 작은
+        자체 호스팅 모델도, ``max_tokens`` 를 받지 않는 reasoning 모델도 거절할 일이 없다. 값을
+        주면 ``max_tokens`` 로 보내고, reasoning 모델이 거절하면 같은 값을
+        ``max_completion_tokens`` 로 보낸다.
     :param timeout: judge 1회 호출 최대 대기 초. client 를 새로 만들 때만 적용
                     (None 이면 SDK 기본). worker 무한 블록 방지.
     """
     _client_ref = [client]
+    state = {'no_temperature': temperature is None, 'completion_tokens': False}
 
     def judge_fn(system, user):
         c = _client_ref[0]
@@ -42,28 +68,75 @@ def make_openai_judge(client=None, model='gpt-4o-mini', api_key=None, base_url=N
                 client_kwargs['timeout'] = timeout
             c = openai.OpenAI(**client_kwargs)
             _client_ref[0] = c
-        resp = c.chat.completions.create(
-            model=model,
-            messages=[
-                {'role': 'system', 'content': system},
-                {'role': 'user', 'content': user},
-            ],
-            temperature=temperature,
-            max_tokens=max_tokens,
-        )
-        return resp.choices[0].message.content or ''
+        while True:
+            request = _chat_request(model, system, user, max_tokens, temperature, state)
+            try:
+                resp = c.chat.completions.create(**request)
+            except Exception as e:
+                # 모델이 거절한 옵션을 바꿔 다시 — 옵션마다 한 번뿐이라 루프는 끝난다.
+                rejected = _openai_rejected_option(e, request)
+                if rejected is None:
+                    raise
+                state[rejected] = True
+                continue
+            return resp.choices[0].message.content or ''
     return judge_fn
 
 
-def make_anthropic_judge(client=None, model='claude-3-5-haiku-latest', api_key=None,
-                         max_tokens=2048, temperature=0.0, timeout=None):
+def _chat_request(model, system, user, max_tokens, temperature, state):
+    """Chat Completions 요청 — 앞서 거절당한 옵션은 빼거나 reasoning 모델 모양으로 바꾼다."""
+    request = {
+        'model': model,
+        'messages': [
+            {'role': 'system', 'content': system},
+            {'role': 'user', 'content': user},
+        ],
+    }
+    if max_tokens is not None:
+        # reasoning 모델은 같은 한도를 max_completion_tokens 로 받는다.
+        key = 'max_completion_tokens' if state['completion_tokens'] else 'max_tokens'
+        request[key] = max_tokens
+    if not state['no_temperature']:
+        request['temperature'] = temperature
+    return request
+
+
+def _openai_rejected_option(err, request):
+    """reasoning 모델의 거절 → 다음부터 바꿀 ``state`` 키. 그런 거절이 아니면 None.
+
+    openai ``BadRequestError``(400) 의 ``param`` 과 메시지가 거절한 칸을 짚는다. 이번 요청에 넣은
+    옵션만 짚으므로 같은 옵션을 두 번 바꾸며 돌지 않는다.
+    """
+    if getattr(err, 'status_code', None) != 400:
+        return None
+    message = ('%s %s' % (getattr(err, 'param', None) or '', err)).lower()
+    if 'temperature' in message and 'temperature' in request:
+        return 'no_temperature'
+    if 'max_completion_tokens' in message and 'max_tokens' in request:
+        return 'completion_tokens'
+    return None
+
+
+def make_anthropic_judge(client=None, model='claude-haiku-5-5', api_key=None,
+                         max_tokens=_JUDGE_MAX_TOKENS, temperature=0.0, timeout=None):
     """Anthropic 을 사용하는 judge_fn 을 생성한다.
 
     judge 는 **자기 소유의 client** 로 동작한다 — ``client`` 미지정 시 첫 호출에
     ``anthropic.Anthropic(...)`` 를 만들어(env ``ANTHROPIC_API_KEY`` 또는 ``api_key``)
     재사용. ``timeout`` 은 client 를 새로 만들 때만 적용 (worker 무한 블록 방지).
+
+    ``temperature`` 는 SDK 인자가 아니라 ``extra_body`` 로 싣는다 — anthropic SDK 1.x 는
+    ``messages.create()`` 의 sampling 인자를 없앴다(넘기면 TypeError). 받지 않는 모델(Opus 4.7
+    이후는 값과 무관하게, Sonnet 5·5.5 · Haiku 5.5 는 기본값이 아니면)이나 모든 모델이 거절하는
+    API 버전 2026-10-21(SDK 2.x 기본)이면 한 번 거절당한 뒤로는 빼고 보낸다. ``None`` 이면
+    처음부터 보내지 않는다.
+
+    ``max_tokens`` 는 Messages API 가 요구해서 뺄 수 없다. 넉넉히 두는 건 Claude 5 계열이
+    thinking 을 기본으로 켜고 thinking 토큰도 이 한도에 들어가서다 — 작으면 판정이 잘린다.
+    서비스 중인 모델은 모두 이 값을 받고, OTPM 할당량은 실제 출력만 세므로 크게 둬도 손해가 없다.
     """
     _client_ref = [client]
+    state = {'no_temperature': temperature is None}
 
     def judge_fn(system, user):
         c = _client_ref[0]
@@ -76,15 +149,175 @@ def make_anthropic_judge(client=None, model='claude-3-5-haiku-latest', api_key=N
                 client_kwargs['timeout'] = timeout
             c = anthropic.Anthropic(**client_kwargs)
             _client_ref[0] = c
-        resp = c.messages.create(
-            model=model,
-            system=system,
-            messages=[{'role': 'user', 'content': user}],
-            max_tokens=max_tokens,
-            temperature=temperature,
-        )
-        for block in resp.content:
-            if getattr(block, 'type', None) == 'text':
-                return block.text or ''
-        return ''
+        request = {
+            'model': model,
+            'system': system,
+            'messages': [{'role': 'user', 'content': user}],
+            'max_tokens': max_tokens,
+        }
+        if not state['no_temperature']:
+            try:
+                return _anthropic_text(c.messages.create(
+                    extra_body={'temperature': temperature}, **request))
+            except Exception as e:
+                if not _rejects_temperature(e):
+                    raise
+                state['no_temperature'] = True
+        return _anthropic_text(c.messages.create(**request))
     return judge_fn
+
+
+def _rejects_temperature(err):
+    """temperature 를 받지 않는 모델·API 버전의 거절인가 — anthropic ``BadRequestError``(400)."""
+    return getattr(err, 'status_code', None) == 400 and 'temperature' in str(err).lower()
+
+
+def _anthropic_text(resp):
+    """첫 text 블록 — thinking 블록 등은 건너뛴다."""
+    for block in resp.content:
+        if getattr(block, 'type', None) == 'text':
+            return block.text or ''
+    return ''
+
+
+def make_bedrock_judge(client=None, model=None, region_name=None, endpoint_url=None,
+                       profile_name=None, credentials=None,
+                       max_tokens=_JUDGE_MAX_TOKENS, temperature=0.0, timeout=None):
+    """AWS Bedrock Runtime 의 Converse API 를 사용하는 judge_fn 을 생성한다.
+
+    Converse 는 모델과 무관한 공통 스키마라 Claude·Nova·Llama·Mistral 등 Bedrock 텍스트
+    모델을 한 경로로 부른다. ``model`` 은 modelId · 추론 프로파일 ID(``us.anthropic...``)
+    · ARN 모두 된다. **기본 모델이 없다** — 계정·리전마다 열린 모델(모델 액세스·추론
+    프로파일)이 달라 '작은 기본 모델'을 가정할 수 없다.
+
+    judge 는 **자기 소유의 client** 로 동작한다 — ``client``(boto3 ``bedrock-runtime``)를
+    주면 그대로, 안 주면 첫 호출에 botocore 로 만든다(boto3 불필요).
+
+    :param region_name: AWS 리전. 없으면 AWS 기본 해석(AWS_DEFAULT_REGION, ~/.aws/config …
+        — botocore 는 AWS_REGION 을 읽지 않는다).
+    :param endpoint_url: Bedrock Runtime 엔드포인트(VPC 엔드포인트 등). 없으면 리전 기본값.
+    :param profile_name: ~/.aws 프로파일 이름. ``credentials`` 가 있으면 그쪽이 우선.
+    :param credentials: botocore 자격증명 객체(``boto3.Session().get_credentials()`` 등).
+        호출마다 현재 값을 꺼내므로 갱신형(assume-role·IMDS·SSO)도 만료되지 않고, 값이
+        바뀌면 client 를 새로 만든다. 없으면 AWS 기본 자격증명 체인.
+    :param timeout: 연결·읽기 타임아웃(초). client 를 새로 만들 때만 적용
+                    (None 이면 botocore 기본). worker 무한 블록 방지.
+    :param max_tokens: 출력 한도(기본 16000) — Claude 5 계열은 thinking 토큰도 여기에 들어간다.
+        한도가 이보다 작은 모델(Llama · Titan · Nova 등)이 거절하면 한 번 뒤로는 2048 로 보낸다.
+        빼지 않는 건 Bedrock 이 요청마다 이 값만큼 계정 할당량(TPM)을 먼저 잡아서다 — 빼면 모델
+        최대치(Claude 는 64K~128K)를 잡아 같은 모델을 쓰는 앱 호출이 throttle 될 수 있다.
+    :param temperature: 판정을 일정하게 하려는 샘플링 온도(기본 0.0). 받지 않는 모델(Claude
+        Opus 4.7 이후는 값과 무관하게, Sonnet 5·5.5 · Haiku 5.5 는 기본값이 아니면 거절)이면
+        한 번 거절당한 뒤로는 빼고 보낸다. ``None`` 이면 처음부터 보내지 않는다.
+
+    system 블록을 받지 않는 모델(Titan Text·Mistral Instruct 등)이면 한 번 거절당한 뒤로는
+    system 을 user 앞에 붙여 보낸다.
+    """
+    if not model:
+        raise ValueError('make_bedrock_judge: model is required '
+                         '(Bedrock modelId, inference profile ID or ARN)')
+    state = {'client': client, 'identity': None, 'no_system': False,
+             'no_temperature': temperature is None, 'small_max_tokens': False}
+
+    def _client():
+        if client is not None:
+            return client
+        frozen = credentials.get_frozen_credentials() if credentials is not None else None
+        identity = None
+        if frozen is not None:
+            identity = (frozen.access_key, frozen.secret_key, frozen.token)
+        if state['client'] is None or identity != state['identity']:
+            state['client'] = _new_bedrock_client(region_name, endpoint_url, profile_name,
+                                                  frozen, timeout)
+            state['identity'] = identity
+        return state['client']
+
+    def judge_fn(system, user):
+        c = _client()
+        while True:
+            request = _converse_request(model, system, user, max_tokens, temperature, state)
+            try:
+                return _converse_text(c.converse(**request))
+            except Exception as e:
+                # 모델이 거절한 옵션을 빼고 다시 — 옵션마다 한 번뿐이라 루프는 끝난다.
+                rejected = _rejected_option(e, request)
+                if rejected is None:
+                    raise
+                state[rejected] = True
+    return judge_fn
+
+
+def _new_bedrock_client(region_name, endpoint_url, profile_name, frozen, timeout):
+    """judge 전용 ``bedrock-runtime`` client — botocore 만으로 만든다(boto3 불필요)."""
+    import botocore.session
+    from botocore.config import Config
+
+    session = botocore.session.Session(profile=profile_name or None)
+    # 재시도는 openai/anthropic SDK 기본(max_retries=2)과 맞춘다 — botocore 기본(4회)에
+    # 타임아웃이 곱해지면 워커 하나가 분 단위로 묶인다.
+    config = {'retries': {'max_attempts': 2}}
+    if timeout:
+        config['connect_timeout'] = timeout
+        config['read_timeout'] = timeout
+    kwargs = {'config': Config(**config)}
+    if region_name:
+        kwargs['region_name'] = region_name
+    if endpoint_url:
+        kwargs['endpoint_url'] = endpoint_url
+    if frozen is not None:
+        kwargs['aws_access_key_id'] = frozen.access_key
+        kwargs['aws_secret_access_key'] = frozen.secret_key
+        kwargs['aws_session_token'] = frozen.token
+    return session.create_client('bedrock-runtime', **kwargs)
+
+
+def _converse_request(model, system, user, max_tokens, temperature, state):
+    """Converse 요청 — 앞서 거절당한 옵션(``state`` 의 no_system / no_temperature /
+    small_max_tokens)은 빼거나 낮춘다."""
+    if state['small_max_tokens']:
+        max_tokens = min(max_tokens, _SMALL_MAX_TOKENS)
+    config = {'maxTokens': max_tokens}
+    if not state['no_temperature']:
+        config['temperature'] = temperature
+    request = {'modelId': model, 'inferenceConfig': config}
+    if system and not state['no_system']:
+        request['system'] = [{'text': system}]
+        text = user
+    else:
+        text = '%s\n\n%s' % (system, user) if system else user
+    request['messages'] = _bedrock_user_message(text)
+    return request
+
+
+def _bedrock_user_message(text):
+    return [{'role': 'user', 'content': [{'text': text}]}]
+
+
+def _rejected_option(err, request):
+    """모델이 거절한 요청 옵션 → 다음부터 뺄 ``state`` 키. 그런 거절이 아니면 None.
+
+    botocore ``ClientError``(ValidationException) 메시지가 거절한 칸을 이름으로 짚는다. 이번
+    요청에 넣은 옵션만 짚으므로 같은 옵션을 두 번 빼며 돌지 않는다.
+    """
+    try:
+        error = err.response.get('Error') or {}
+    except Exception:
+        return None
+    if error.get('Code') != 'ValidationException':
+        return None
+    message = str(error.get('Message') or '').lower()
+    config = request['inferenceConfig']
+    if 'temperature' in message and 'temperature' in config:
+        return 'no_temperature'
+    if _MAX_TOKENS_REJECTION.search(message) and config['maxTokens'] > _SMALL_MAX_TOKENS:
+        return 'small_max_tokens'
+    if 'system' in message and 'system' in request:
+        return 'no_system'
+    return None
+
+
+def _converse_text(resp):
+    """Converse 응답의 텍스트 블록을 이어 붙인다(reasoningContent 등 다른 블록은 건너뛴다)."""
+    message = ((resp or {}).get('output') or {}).get('message') or {}
+    return ''.join(block.get('text') or '' for block in message.get('content') or []
+                   if isinstance(block, dict))

whatap/llm/evaluators/builtins/llm_judge.py

@@ -2,7 +2,7 @@
 
 LLM judge 평가자는 자체적으로 다른 LLM 을 호출해 평가를 수행한다.
 - 비용이 비싸므로 보통 샘플링과 함께 사용한다 (whatap.conf 의 llm_eval_sample_rate).
-- 워커 스레드의 재귀 가드 (LlmEvaluatorTask._safe_run_one 의 thread-local) 가
+- 워커의 재귀 가드 (``hooks.enter_judge_call`` 의 judge 호출 표시) 가
   judge 의 LLM 호출이 다시 평가 큐에 들어가는 것을 자동 차단한다.
 
 사용:
@@ -14,20 +14,34 @@ LLM judge 평가자는 자체적으로 다른 LLM 을 호출해 평가를 수행
 
 M-4 분리: 이 파일은 이제 베이스 클래스 + default judge 레지스트리 + 에러/타임아웃 헬퍼만
 담는다. 아래 두 관심사는 별도 모듈로 분리했고, 하위호환을 위해 여기서 re-export 한다:
-- provider 별 judge_fn 팩토리     → ``judge_factories`` (make_openai_judge/make_anthropic_judge)
+- provider 별 judge_fn 팩토리     → ``judge_factories``
+                                   (make_openai_judge/make_anthropic_judge/make_bedrock_judge)
 - judge 응답 JSON 추출/복구 유틸  → ``_json_repair`` (parse_json_response 등)
 """
+import re
+
 from whatap import logging
 from whatap.llm.evaluators.base import BaseEvaluator, EvaluatorResult
 
 # ── 하위호환 re-export (기존 import 경로 유지: from ...llm_judge import make_openai_judge 등) ──
 from whatap.llm.evaluators.builtins.judge_factories import (  # noqa: F401
-    make_openai_judge, make_anthropic_judge,
+    make_openai_judge, make_anthropic_judge, make_bedrock_judge,
 )
 from whatap.llm.evaluators.builtins._json_repair import (  # noqa: F401
     parse_json_response, _salvage_truncated_object, _JSON_BLOCK,
 )
 
+# Bedrock Runtime 호스트 → 리전. 리전 기본·FIPS·VPC 엔드포인트 모두:
+#   bedrock-runtime.ap-northeast-1.amazonaws.com
+#   bedrock-runtime-fips.us-gov-west-1.amazonaws.com
+#   vpce-0abc123.bedrock-runtime.us-east-1.vpce.amazonaws.com
+_BEDROCK_HOST = re.compile(
+    r'bedrock-runtime(?:-fips)?\.([a-z]{2}(?:-[a-z]+)+-\d+)\.(?:vpce\.)?amazonaws\.com')
+
+# 자동 해석한 Bedrock judge 캐시 상한 — 키에 자격증명 객체가 들어가서, 요청마다
+# boto3.Session 을 새로 만드는 앱이면 끝없이 늘 수 있다.
+_BEDROCK_CACHE_MAX = 32
+
 
 # 전역 default judge. set_default_judge_fn() 또는 conf.llm_eval_judge_* 부트스트랩이 등록.
 # judge 해석 순서 ②(우선순위 2) 자리 — ① evaluator judge_fn 다음, ③ 자격증명 스냅샷 앞.
@@ -107,7 +121,9 @@ class LLMJudgeBase(BaseEvaluator):
     2) 전역 default — ``set_default_judge_fn()`` 또는 ``conf.llm_eval_judge_*`` override.
     3) 계측이 캡처한 **앱 client 자격증명 스냅샷(base_url/api_key)** 으로 자기 client 생성
        — 앱과 같은 엔드포인트/키로 평가(설정 0). **기본 zero-config 경로.**
+       Bedrock 호출이면 앱과 같은 리전·엔드포인트·AWS 자격증명으로 Bedrock Runtime(Converse).
     4) ctx.provider 매칭 후 **환경변수 키**(OPENAI_API_KEY/ANTHROPIC_API_KEY)로 자기 client.
+       Bedrock 호스트면 호스트의 리전 + AWS 기본 자격증명 체인.
 
     OAuth 라 평문 key 가 없거나 엔드포인트가 chat.completions 를 안 서빙하면 (2) 로 지정.
     """
@@ -124,7 +140,7 @@ class LLMJudgeBase(BaseEvaluator):
 
     # 기본 모델 (provider 별).
     _DEFAULT_OPENAI_MODEL = 'gpt-4o-mini'
-    _DEFAULT_ANTHROPIC_MODEL = 'claude-3-5-haiku-latest'
+    _DEFAULT_ANTHROPIC_MODEL = 'claude-haiku-5-5'
 
     def __init__(self, judge_fn=None, model=None):
         if judge_fn is not None and not callable(judge_fn):
@@ -150,7 +166,9 @@ class LLMJudgeBase(BaseEvaluator):
         ② set_default_judge_fn() 전역 default **또는 conf.llm_eval_judge_* override**
         ③ 계측이 캡처한 **앱 client 자격증명 스냅샷(base_url/api_key)** 으로 자기 client 생성
            — 앱과 같은 엔드포인트/키로 평가(설정 0). 인스턴스가 아니라 '값'만 재사용.
-        ④ ctx.provider 매칭(openai.com/azure/anthropic) 후 **환경변수 키로** 자기 client 생성.
+           Bedrock(``judge_kind='bedrock'``)은 API 키가 아니라 AWS 자격증명이라 따로 간다.
+        ④ ctx.provider 매칭(openai.com/azure/anthropic/bedrock-runtime) 후 **환경변수 키로**
+           (Bedrock 은 AWS 기본 자격증명 체인으로) 자기 client 생성.
            그 외 provider + 스냅샷도 없으면 None → no_judge_configured.
 
         ③ 이 기본 zero-config 경로다 — self-host/프록시도 스냅샷된 base_url 로 그대로 동작.
@@ -166,6 +184,10 @@ class LLMJudgeBase(BaseEvaluator):
 
         timeout = _judge_timeout_sec()
 
+        # ③-a Bedrock — 서명이 API 키가 아니라 AWS(SigV4)라 아래 키 스냅샷과 갈린다.
+        if getattr(ctx, 'judge_kind', None) == 'bedrock':
+            return self._resolve_bedrock_judge(ctx, timeout)
+
         # ③ 계측이 스냅샷한 앱 client 자격증명(문자열)으로 자기 durable client 생성.
         #    인스턴스가 아니라 base_url/api_key '값'만 재사용 → client 수명과 무관.
         snap_key = getattr(ctx, 'judge_api_key', None)
@@ -197,6 +219,8 @@ class LLMJudgeBase(BaseEvaluator):
             key = 'anthropic'
         elif 'openai.com' in provider or 'azure.com' in provider:
             key = 'openai'
+        elif _BEDROCK_HOST.search(provider):
+            return self._resolve_bedrock_judge(ctx, timeout)
         else:
             return None
 
@@ -214,6 +238,45 @@ class LLMJudgeBase(BaseEvaluator):
         self._auto_cache[key] = judge_fn
         return judge_fn
 
+    def _resolve_bedrock_judge(self, ctx, timeout):
+        """Bedrock Runtime judge — 앱과 같은 리전·엔드포인트·자격증명으로, 같은 모델을 Converse 로.
+
+        모델 기본값이 없다(계정·리전마다 열린 모델이 다르다). 앱이 방금 부른 모델은 열려 있음이
+        보장되므로 그걸 쓴다 — 바꾸려면 evaluator(model=) 또는 conf ``llm_eval_judge_model``.
+        스냅샷이 없으면(LiteLLM·직접 HTTP) 앱이 실제로 보낸 Bedrock 호스트에서 리전·엔드포인트를
+        읽고 자격증명은 AWS 기본 체인에 맡긴다.
+        """
+        model = self._model or getattr(ctx, 'model', None)
+        if not model:
+            return None
+        aws = getattr(ctx, 'judge_aws', None) or {}
+        host = (getattr(ctx, 'provider', '') or '').lower()
+        match = _BEDROCK_HOST.search(host)
+        region = aws.get('region') or (match.group(1) if match else None)
+        # 호스트 전체를 쓴다 — VPC 엔드포인트는 'vpce-….bedrock-runtime…' 처럼 앞이 붙는다.
+        endpoint_url = aws.get('endpoint_url') or ('https://' + host if match else None)
+        profile = aws.get('profile')
+        credentials = aws.get('credentials')
+        # 자격증명은 객체 id 로 구분한다 — 캐시된 judge_fn 이 그 객체를 붙잡고 있으므로 캐시에
+        # 있는 동안 id 가 재사용될 일은 없다.
+        cache_key = ('bedrock', model, region or '', endpoint_url or '', profile or '',
+                     id(credentials) if credentials is not None else 0)
+        judge_fn = self._auto_cache.get(cache_key)
+        if judge_fn is not None:
+            return judge_fn
+        judge_fn = make_bedrock_judge(
+            model=model, region_name=region, endpoint_url=endpoint_url,
+            profile_name=profile, credentials=credentials, timeout=timeout,
+        )
+        # 가장 오래된 것부터 버린다(dict 는 삽입 순서). 워커 동시 변경은 다음 번에 다시 맞춘다.
+        while len(self._auto_cache) >= _BEDROCK_CACHE_MAX:
+            try:
+                self._auto_cache.pop(next(iter(self._auto_cache)))
+            except (StopIteration, KeyError, RuntimeError):
+                break
+        self._auto_cache[cache_key] = judge_fn
+        return judge_fn
+
     def evaluate(self, ctx):
         judge_fn = self._resolve_judge_fn(ctx)
         if judge_fn is None:

whatap/llm/evaluators/hooks.py

@@ -0,0 +1,182 @@
+# -*- coding: utf-8 -*-
+"""평가(Evaluation) ↔ 에이전트 코어의 접점 — 코어는 평가 기능을 이 모듈로만 부른다.
+
+코어(계측·송출·트레이스) 쪽 호출 지점은 전부 ``# >>> LLM-EVAL`` ~ ``# <<< LLM-EVAL``
+블록 안에 있고, 블록은 이 모듈(또는 평가 전용 모듈)만 import 한다. 그래서 평가 기능을
+떼어낼 때 블록만 지우면 코어에 남는 참조가 없다. @see whatap/llm/evaluators/REMOVAL.md
+
+맡는 일은 셋이다.
+
+1. **judge 호출 표시** — 평가 워커가 judge LLM 을 부르는 동안 켜진다. 계측은 이걸 보고
+   judge 호출을 사용자 호출과 가른다(평가 재귀 차단, ``operation_type=whatap_evaluation``,
+   부모 스텝 좌표). thread-local 과 ContextVar 두 군데에 둔다 — 동기 judge 는 워커
+   스레드에서 LLM 을 부르고, 앱 루프로 던진 코루틴은 ContextVar 만 물려받기 때문이다.
+2. **judge 대상 스냅샷** — 사용자 호출의 client 에서 judge 가 쓸 엔드포인트·자격증명을
+   캡처 시점에 떠 둔다. client 인스턴스는 잡지 않는다(요청 스코프면 평가가 도는 시점엔
+   이미 닫혀 있다). 평가가 꺼져 있으면 아무것도 뜨지 않는다.
+3. **평가 큐 투입** — 완료된 LLM 호출 팩을 평가 파이프라인에 넘긴다.
+"""
+import contextvars
+import inspect
+import threading
+
+JUDGE_OPERATION_TYPE = 'whatap_evaluation'
+
+_worker_local = threading.local()
+_worker_cv = contextvars.ContextVar('whatap_eval_worker', default=None)
+
+
+def conf_truthy(name, default=False):
+    """Configure attr 을 bool 로 안전 변환.
+
+    Configure.setProperty 가 config file 에서 읽은 문자열 'true'/'false' 를 그대로
+    setattr 해서 string 으로 저장 → 'false' 도 truthy 로 평가되는 reload 버그 우회.
+    """
+    try:
+        from whatap.conf.configure import Configure as conf
+        val = getattr(conf, name, default)
+    except Exception:
+        return bool(default)
+    if isinstance(val, bool):
+        return val
+    if isinstance(val, str):
+        return val.strip().lower() in ('true', 'yes', '1', 'on')
+    return bool(val)
+
+
+# ── 1. judge 호출 표시 ────────────────────────────────────────────────────────
+
+def enter_judge_call(pack):
+    """평가 워커가 ``pack`` 을 평가하기 직전에 켠다. 반환값을 ``exit_judge_call`` 에 넘긴다.
+
+    부모(사용자) 스텝 좌표를 같이 실어 둔다 — ``llm_eval_track_judge_calls=true`` 면 judge
+    호출 팩이 이 좌표로 덮여 대시보드에서 사용자 호출과 같은 트랜잭션으로 보인다.
+    """
+    state = {
+        'parent_txid': pack.txid,
+        'parent_step_id': pack.step_id,
+        'parent_index': pack.index,
+    }
+    _worker_local.state = state
+    return _worker_cv.set(state)
+
+
+def exit_judge_call(token):
+    _worker_cv.reset(token)
+    _worker_local.state = None
+
+
+def judge_call_state():
+    """judge 호출 중이면 부모 스텝 좌표 dict, 아니면 None. ContextVar 우선, thread-local 폴백."""
+    state = _worker_cv.get()
+    if state is not None:
+        return state
+    return getattr(_worker_local, 'state', None)
+
+
+def is_judge_call():
+    """지금 이 호출이 평가 워커가 부른 judge 호출인가."""
+    return judge_call_state() is not None
+
+
+def mark_judge_call(pack):
+    """judge 호출이면 팩에 표시를 남긴다 — 고정 라벨 + 부모(사용자) 스텝 좌표.
+
+    메트릭은 ``operation_type=whatap_evaluation`` 으로 사용자 호출과 분리 집계되고, 로그싱크는
+    사용자 스텝과 같은 (txid, step_id, index) 로 묶인다. 반환: judge 호출이었는가.
+    """
+    state = judge_call_state()
+    if state is None:
+        return False
+    pack.operation_type = JUDGE_OPERATION_TYPE
+    pack.prompt_version = 'v1'
+    if state.get('parent_txid'):
+        pack.txid = state['parent_txid']
+    if state.get('parent_step_id'):
+        pack.step_id = state['parent_step_id']
+    if state.get('parent_index') is not None:
+        pack.index = state['parent_index']
+    return True
+
+
+# ── 2. judge 대상 스냅샷 ──────────────────────────────────────────────────────
+
+def snapshot_judge_client(pack, llm_client):
+    """openai / anthropic SDK client 에서 judge 대상을 떠 둔다 — 인스턴스 말고 '값'만.
+
+    - 일반: base_url / api_key 문자열 → judge 가 같은 엔드포인트·키로 자기 client 를 만든다.
+    - ``AnthropicBedrock`` 계열: 자격증명이 API 키가 아니라 AWS(SigV4)라 judge 도 Bedrock
+      Runtime 으로 보낸다(같은 리전·프로파일·명시 키). 예전엔 이 client 도 'anthropic' 으로
+      떠서 judge 가 api.anthropic.com 을 Bedrock 모델 ID 로 불러 평가가 늘 실패했다.
+    """
+    if not conf_truthy('llm_eval_enabled'):
+        return
+    cls = type(llm_client).__name__
+    base_url = getattr(llm_client, 'base_url', None)
+    if 'Bedrock' in cls:
+        _snapshot_anthropic_bedrock(pack, llm_client, str(base_url or ''))
+        return
+    pack._llm_judge_kind = 'anthropic' if 'Anthropic' in cls else 'openai'
+    api_key = getattr(llm_client, 'api_key', None)
+    if api_key:
+        pack._llm_judge_api_key = str(api_key)
+    if base_url:
+        pack._llm_judge_base_url = str(base_url)
+
+
+def snapshot_bedrock_client(pack, client):
+    """boto3 / aiobotocore ``bedrock-runtime`` client 에서 judge 대상을 떠 둔다.
+
+    리전·엔드포인트는 값으로, 자격증명은 **botocore 자격증명 객체**로 잡는다. client 와 달리
+    닫히는 일이 없고, 갱신형(assume-role·IMDS·SSO)은 judge 시점에 스스로 새 값을 받아 온다
+    — 값으로 복사하면 그 갱신을 잃어 만료된다. 기본 자격증명 체인에 맡기지 않는 이유는
+    신원이다: 앱이 명시 키·다른 프로파일을 쓰면 기본 체인은 다른 계정을 잡는다.
+
+    aiobotocore 자격증명은 갱신이 코루틴(앱 이벤트 루프 소속)이라 평가 워커 스레드에서 쓸 수
+    없다 — 그때는 비워 두고 judge 가 AWS 기본 자격증명 체인을 쓴다.
+    """
+    if not conf_truthy('llm_eval_enabled'):
+        return
+    meta = getattr(client, 'meta', None)
+    creds = getattr(getattr(client, '_request_signer', None), '_credentials', None)
+    if creds is not None and inspect.iscoroutinefunction(
+            getattr(creds, 'get_frozen_credentials', None)):
+        creds = None
+    _set_bedrock_target(pack, getattr(meta, 'region_name', None),
+                        getattr(meta, 'endpoint_url', None), None, creds)
+
+
+def _snapshot_anthropic_bedrock(pack, llm_client, base_url):
+    creds = None
+    access_key = getattr(llm_client, 'aws_access_key', None)
+    secret_key = getattr(llm_client, 'aws_secret_key', None)
+    if access_key and secret_key:
+        try:
+            from botocore.credentials import Credentials
+            creds = Credentials(access_key, secret_key,
+                                getattr(llm_client, 'aws_session_token', None))
+        except Exception:
+            creds = None
+    # Converse 를 서빙하지 않는 엔드포인트(bedrock-mantle 등)는 따라가지 않는다 — 리전 기본값.
+    endpoint_url = base_url if 'bedrock-runtime' in base_url else None
+    _set_bedrock_target(pack, getattr(llm_client, 'aws_region', None), endpoint_url,
+                        getattr(llm_client, 'aws_profile', None), creds)
+
+
+def _set_bedrock_target(pack, region, endpoint_url, profile, credentials):
+    pack._llm_judge_kind = 'bedrock'
+    pack._llm_judge_aws = {
+        'region': region or None,
+        'endpoint_url': (str(endpoint_url).rstrip('/') or None) if endpoint_url else None,
+        'profile': profile or None,
+        'credentials': credentials,
+    }
+
+
+# ── 3. 평가 큐 ────────────────────────────────────────────────────────────────
+
+def enqueue(pack):
+    """완료된 LLM 호출 팩을 평가 파이프라인에 넘긴다. judge 호출은 거기서 걸러진다."""
+    # cycle-break(llm↔counter): 함수 스코프 지연 import (표준 방향의 역방향).
+    from whatap.counter.tasks.llm_evaluator_task import enqueue_evaluation
+    enqueue_evaluation(pack)