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

whatap/build.py

@@ -1,4 +1,4 @@
 app = 'Python'
 name = 'whatap-python'
-version = '2.2.2'
-release_date = '20261019'
+version = '2.3.0'
+release_date = '20261112'

whatap/conf/configuration.py

@@ -433,6 +433,8 @@ Configuration = {
     #   않는다 — 줄을 지우면 재기동 전까지 마지막 값이 그대로 남아 계속 차단된다.
     "llm_blocked_users": "",
 
+    # >>> LLM-EVAL: 평가(Evaluation) 설정 키 — 평가 기능을 떼면 이 블록째 지운다
+    # (whatap/llm/evaluators/REMOVAL.md).
     # ── LLM Evaluation ──
     # 평가 파이프라인 마스터 토글. false면 enqueue/worker가 동작하지 않음.
     "llm_eval_enabled": False,
@@ -490,26 +492,44 @@ Configuration = {
 
     # ── conf 기반 default judge (앱 코드 0) ──
     # llm-as-judge 평가자(combined_judge 등)는 평가용 LLM 호출에 자체 자격증명이 필요하다.
-    # judge 해석 순서: ① evaluator(judge_fn=) → ② set_default_judge_fn() → ③ 계측이
-    # 캡처한 사용자 client 인스턴스 재사용 → ④ ctx.provider 매칭 후 환경변수 키.
-    # 요청 스코프(요청마다 client 생성·종료) 앱이나 OAuth 전용 환경에서는 ③(평가는 요청이
-    # 끝난 뒤 비동기로 도는데 그 시점엔 client 가 이미 닫힘)·④(환경변수 키 없음)가 모두
-    # 막혀, 앱에서 set_default_judge_fn 을 직접 호출해야만 했다. 아래 키를 채우면
-    # 부트스트랩이 그 값으로 default judge 를 자동 등록해 — 앱 코드 수정 없이 conf 만으로 —
-    # 평가가 돈다. 코드로 set_default_judge_fn 을 이미 호출했으면 그쪽이 우선(conf 미적용).
+    # judge 해석 순서: ① evaluator(judge_fn=) → ② set_default_judge_fn() / 아래 conf →
+    # ③ 계측이 사용자 호출에서 떠 둔 엔드포인트·자격증명 스냅샷 → ④ ctx.provider 매칭 후
+    # 환경변수 키. 보통 ③ 이 자동으로 풀린다(앱과 같은 엔드포인트·자격증명·모델). OAuth 라
+    # 평문 키가 없거나 다른 모델·엔드포인트로 평가하려면 아래 키를 채운다 — 부트스트랩이 그
+    # 값으로 default judge 를 자동 등록해 앱 코드 수정 없이 conf 만으로 평가가 돈다.
+    # 코드로 set_default_judge_fn 을 이미 호출했으면 그쪽이 우선(conf 미적용).
     #
-    #   llm_eval_judge_provider    : "openai" | "anthropic". 미지정 시 base_url 이 있으면
-    #                                openai(호환)로 간주, 없으면 자동 등록 안 함(③/④ 유지).
+    # Bedrock: Bedrock 을 부르는 앱(boto3·aioboto3·AnthropicBedrock·LiteLLM)은 ③ 으로
+    # judge 도 Bedrock Runtime(Converse)으로 간다 — 앱과 같은 리전·엔드포인트·자격증명·모델.
+    # 다른 앱(OpenAI 등)도 judge 만 Bedrock 으로 보내려면 provider=bedrock + model(+region).
+    #
+    #   llm_eval_judge_provider    : "openai" | "anthropic" | "bedrock". 미지정 시 base_url 이
+    #                                있으면 openai(호환)로 간주, 없으면 자동 등록 안 함(③/④ 유지).
     #   llm_eval_judge_model       : judge 모델. 미지정 시 provider 별 default
-    #                                (openai=gpt-4o-mini, anthropic=claude-3-5-haiku-latest).
+    #                                (openai=gpt-4o-mini, anthropic=claude-haiku-5-5).
+    #                                provider 나 base_url 과 함께 넣어야 적용된다 — 모델만
+    #                                넣으면 무시하고 LLM056 경고(③ 은 계속 앱 모델로 평가).
+    #                                bedrock 은 **필수** — modelId 또는 추론 프로파일 ID
+    #                                (예: us.anthropic.claude-haiku-4-5-20251001-v1:0). 계정·리전마다
+    #                                열린 모델이 달라 기본값을 두지 않는다.
     #   llm_eval_judge_api_key_env : judge 키가 담긴 환경변수 이름(권장 — 키를 설정 파일에
     #                                직접 두지 않음). 예: "WHATAP_LLM_EVAL_JUDGE_API_KEY".
     #   llm_eval_judge_api_key     : (대안) judge API 키 직접 지정. _env 가 있으면 그쪽 우선.
-    #                                로컬 vLLM 등 키가 불필요하면 "EMPTY".
+    #                                로컬 vLLM 등 키가 불필요하면 "EMPTY". bedrock 엔 쓰지 않는다
+    #                                (AWS 자격증명으로 서명 — env / 프로파일 / IAM 역할).
     #   llm_eval_judge_base_url    : (선택) OpenAI 호환 엔드포인트 / 프록시 / 내부 게이트웨이.
+    #                                bedrock 이면 Bedrock Runtime endpoint_url(VPC 엔드포인트 등).
+    #   llm_eval_judge_region      : (bedrock) AWS 리전. 미지정 시 AWS 기본 해석
+    #                                (AWS_DEFAULT_REGION / ~/.aws/config — botocore 는
+    #                                AWS_REGION 을 읽지 않는다).
+    #   llm_eval_judge_aws_profile : (bedrock) ~/.aws 프로파일 이름. 미지정 시 AWS 기본 자격증명
+    #                                체인(env → 공유 자격증명 파일 → IAM 역할).
     "llm_eval_judge_provider": "",
     "llm_eval_judge_model": "",
     "llm_eval_judge_api_key_env": "",
     "llm_eval_judge_api_key": "",
     "llm_eval_judge_base_url": "",
+    "llm_eval_judge_region": "",
+    "llm_eval_judge_aws_profile": "",
+    # <<< LLM-EVAL
 }

whatap/counter/tasks/llm_evaluator_task.py

@@ -22,8 +22,9 @@
 
 평가는 fire-and-forget. LlmStepStatus 송출과 완전 독립 — 사용자 트랜잭션 영향 0.
 모든 예외는 swallow 후 [LLM] 로그로만 기록.
+
+코어(계측·송출)는 이 모듈을 직접 부르지 않는다 — ``whatap.llm.evaluators.hooks`` 를 거친다.
 """
-import contextvars
 import queue
 import threading
 import time
@@ -32,6 +33,9 @@ from whatap import logging
 from whatap.conf.configure import Configure as conf
 
 from whatap.llm.evaluators.base import EvaluatorContext, EvaluatorResult
+from whatap.llm.evaluators.hooks import (
+    conf_truthy as _conf_truthy, enter_judge_call, exit_judge_call, is_judge_call,
+)
 from whatap.llm.evaluators.registry import EvaluatorRegistry
 from whatap.llm.evaluators.sampler import EvaluatorSampler
 from whatap.llm.log_sink_packs.llm_step_eval_status import LlmStepEvalStatus
@@ -40,23 +44,6 @@ from whatap.llm.log_sink_packs.llm_step_eval_status import LlmStepEvalStatus
 _DEFAULT_BUFFER_LIMIT = 1000
 _DEFAULT_WORKERS = 4
 
-
-def _conf_truthy(name, default=False):
-    """Configure attr 을 bool 로 안전 변환.
-
-    Configure.setProperty 가 config file 에서 읽은 문자열 'true'/'false' 를 그대로
-    setattr 해서 string 으로 저장 → 'false' 도 truthy 로 평가되는 reload 버그 우회.
-    """
-    try:
-        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)
-
 _scope_ignored_warned = [False]
 
 
@@ -98,44 +85,6 @@ _LABEL_TO_FIELD = {
     'combined_judge': 'eval_combined_judge',
 }
 
-# 평가 워커 안인지 판별하는 플래그 — 두 저장소 동시 사용:
-#   - thread-local : sync 워커 스레드 자체에서 발생한 LLM 호출 인지용
-#   - ContextVar   : async judge 가 ``run_coroutine_threadsafe`` 로 user loop 에 dispatch
-#                    된 task 의 context 에서도 인지되도록 propagate
-# 무한 재귀 방지 (judge 호출이 다시 평가 큐에 안 들어가도록) + intercept 가 judge 호출도
-# 정상 추적 (단, 재귀 가드 덕분에 다시 평가 enqueue 되지 않음) 의 두 가지 목적.
-_eval_worker_local = threading.local()
-_eval_worker_cv = contextvars.ContextVar('whatap_eval_worker', default=False)
-
-
-def _is_in_evaluator_worker():
-    """평가 워커 안인지 — thread-local 또는 ContextVar 기준."""
-    if getattr(_eval_worker_local, 'in_eval', False):
-        return True
-    cv_val = _eval_worker_cv.get()
-    if isinstance(cv_val, dict):
-        return bool(cv_val.get('in_eval'))
-    return bool(cv_val)
-
-
-def _get_eval_worker_state():
-    """현재 eval worker state 반환. 없으면 None.
-
-    구조: {'in_eval', 'parent_txid', 'parent_step_id', 'parent_index'}.
-    CV 우선, fallback TL.
-    """
-    cv_val = _eval_worker_cv.get()
-    if isinstance(cv_val, dict) and cv_val.get('in_eval'):
-        return cv_val
-    if getattr(_eval_worker_local, 'in_eval', False):
-        return {
-            'in_eval': True,
-            'parent_txid': getattr(_eval_worker_local, 'parent_txid', None),
-            'parent_step_id': getattr(_eval_worker_local, 'parent_step_id', None),
-            'parent_index': getattr(_eval_worker_local, 'parent_index', None),
-        }
-    return None
-
 
 # EvalStat 인스턴스 캐시.
 _eval_stat_cache = [None]
@@ -190,10 +139,12 @@ class LlmEvaluatorTask(object):
         if not _conf_truthy('llm_eval_enabled'):
             _warn_scope_ignored_once()
             return
-        if _is_in_evaluator_worker():
+        if is_judge_call():
             return  # judge 평가자의 자기 호출이 다시 평가 큐에 들어가는 무한 재귀 차단
         if pack is None:
             return
+        if _is_embedding_call(pack):
+            return  # 평가할 텍스트 응답이 없다 — judge 가 임베딩 모델로 불려 실패만 쌓인다
 
         # conf.llm_eval_evaluators 기반 빌트인 자동 register (1회 — 안에서 fast-path).
         # is_empty() 검사 전에 호출해야 첫 enqueue 가 skip 안 됨.
@@ -262,27 +213,37 @@ class LlmEvaluatorTask(object):
                 continue
             try:
                 merged, scope_designated = self._merge_evaluators(scope_evs)
-                ctx_txid = pack.txid
-                # 샘플링 통과한 평가자만 모아서 한 워커 task 로 묶음 — 한 LLM 호출당
-                # LlmStepEvalStatus pack 1개만 송출되도록.
-                #
-                # 스코프로 지정된 평가자는 샘플링 면제 (항상 실행). 구간을 지정한 것
-                # 자체가 "이 구간은 다 본다" 는 선언이고, 거기에 sample_rate 를 또
-                # 곱하면 "데코레이터 붙였는데 10% 만 평가" 가 된다.
-                active = []
-                for evaluator in merged:
-                    if not evaluator.LABEL:
-                        continue
-                    if not scope_designated \
-                            and not self._sampler.should_run(evaluator, ctx_txid):
-                        continue
-                    active.append(evaluator)
+                # 고른 평가자를 한 워커 task 로 묶음 — 한 LLM 호출당 LlmStepEvalStatus
+                # pack 1개만 송출되도록.
+                active = self._select_active(merged, scope_designated, pack)
                 if active:
                     self._executor.submit(self._safe_run_pack, active, pack)
             except Exception as e:
                 logging.warning('[LLM] eval dispatch failed: %s' % e,
                                 extra={'id': 'LLM031'})
 
+    def _select_active(self, evaluators, scope_designated, pack):
+        """이 pack 에 돌릴 평가자.
+
+        - 응답 텍스트가 없는 호출(도구만 부른 단계 · 실패한 호출)은 judge 가 빈 답을 채점하게
+          되므로 judge 평가자를 건너뛴다. 규칙 기반 평가자는 그대로 돈다. 에이전트라면 최종
+          답변 단계의 입력에 앞 단계의 도구 결과가 모두 들어가므로 프롬프트 인젝션도 거기서 본다.
+        - 스코프로 지정된 평가자는 샘플링 면제 (항상 실행). 구간을 지정한 것 자체가
+          "이 구간은 다 본다" 는 선언이고, 거기에 sample_rate 를 또 곱하면 "데코레이터
+          붙였는데 10% 만 평가" 가 된다.
+        """
+        has_response = _has_response_text(pack)
+        active = []
+        for evaluator in evaluators:
+            if not evaluator.LABEL:
+                continue
+            if not has_response and getattr(evaluator, 'USES_LLM_JUDGE', False):
+                continue
+            if not scope_designated and not self._sampler.should_run(evaluator, pack.txid):
+                continue
+            active.append(evaluator)
+        return active
+
     @staticmethod
     def _merge_evaluators(scope_evs=None):
         """이번 pack 에 실행할 평가자 목록 결정.
@@ -308,27 +269,11 @@ class LlmEvaluatorTask(object):
 
         모든 예외 swallow + 재귀 방지 + 부모 step 키 propagation.
 
-        TL/CV 에 다음 stash:
-          - in_eval=True (재귀 가드)
-          - parent_txid / parent_step_id / parent_index : 원본 user step 의 키
-            ``llm_eval_track_judge_calls=true`` 일 때 judge LLM 호출 pack 의 결합 키를
-            user step 과 동일하게 override 해서 dashboard 에서 같은 transaction 으로
-            보이도록 함.
-
-        TL 은 워커 스레드 자체에서 발생한 LLM 호출 (sync judge), CV 는 dispatched coro
-        (async judge, user loop 으로 dispatch) 에서 propagate 되도록.
+        평가하는 동안 judge 호출 표시(``hooks.enter_judge_call``)를 켠다 — 재귀 가드이자,
+        ``llm_eval_track_judge_calls=true`` 일 때 judge LLM 호출 pack 의 결합 키를 user
+        step 과 같게 덮어 dashboard 에서 같은 transaction 으로 보이게 하는 좌표.
         """
-        state = {
-            'in_eval': True,
-            'parent_txid': pack.txid,
-            'parent_step_id': pack.step_id,
-            'parent_index': pack.index,
-        }
-        _eval_worker_local.in_eval = True
-        _eval_worker_local.parent_txid = pack.txid
-        _eval_worker_local.parent_step_id = pack.step_id
-        _eval_worker_local.parent_index = pack.index
-        cv_token = _eval_worker_cv.set(state)
+        token = enter_judge_call(pack)
         try:
             self._run_pack(evaluators, pack)
         except Exception as e:
@@ -336,11 +281,7 @@ class LlmEvaluatorTask(object):
                             % (len(evaluators), e),
                             extra={'id': 'LLM036'})
         finally:
-            _eval_worker_cv.reset(cv_token)
-            _eval_worker_local.in_eval = False
-            _eval_worker_local.parent_txid = None
-            _eval_worker_local.parent_step_id = None
-            _eval_worker_local.parent_index = None
+            exit_judge_call(token)
 
     def _run_pack(self, evaluators, pack):
         """한 pack 의 모든 활성 evaluator 를 순차 실행 + 점수 모아서 단일
@@ -543,5 +484,32 @@ def build_eval_context_from_pack(pack):
         event_loop=None,
         judge_base_url=getattr(pack, '_llm_judge_base_url', None),
         judge_api_key=getattr(pack, '_llm_judge_api_key', None),
-        judge_kind=getattr(pack, '_llm_judge_kind', None),
+        judge_kind=getattr(pack, '_llm_judge_kind', None) or _bedrock_kind(pack),
+        judge_aws=getattr(pack, '_llm_judge_aws', None),
     )
+
+
+def _has_response_text(pack):
+    """judge 가 채점할 응답 텍스트가 있는가 — 도구만 부른 단계 · 실패한 호출에는 없다."""
+    return bool(str(getattr(pack, 'completion_text', '') or '').strip())
+
+
+def _is_embedding_call(pack):
+    """평가할 응답이 없는 임베딩 호출인가.
+
+    OpenAI 는 operation_type 이 embedding 이다. Bedrock InvokeModel 은 모델과 무관하게 chat 으로
+    분류되므로 모델 ID 로 가른다(amazon.titan-embed-* · cohere.embed-* · amazon.nova-*-embeddings-*
+    등). 텍스트 응답이 있으면 임베딩으로 보지 않는다.
+    """
+    if str(getattr(pack, 'operation_type', '') or '').lower() == 'embedding':
+        return True
+    model = str(getattr(pack, 'model', '') or '').lower()
+    return 'embed' in model and not str(getattr(pack, 'completion_text', '') or '').strip()
+
+
+def _bedrock_kind(pack):
+    """스냅샷이 없는 Bedrock 호출(LiteLLM·직접 HTTP — 떠 둘 client 가 없다)도 Bedrock judge 로.
+
+    계측이 못박은 provider 키로 가른다. 리전·엔드포인트는 judge 가 호스트에서 읽는다.
+    """
+    return 'bedrock' if getattr(pack, '_provider_key', None) == 'bedrock' else None

whatap/counter/tasks/llm_log_sink_task.py

@@ -11,7 +11,7 @@ import whatap.io as whatapio
 import whatap.net.async_sender as async_sender
 
 # 표준 의존 방향: counter.tasks → whatap.llm. 여기서는 whatap.llm 의 **데이터 계층**
-# (log_sink_packs) 만 모듈레벨로 import 한다. providers/evaluators/stats 같은 오케스트레이션
+# (log_sink_packs) 만 모듈레벨로 import 한다. providers/stats 등 오케스트레이션
 # 계층은 이 모듈을 (함수 스코프로) 되-import 하므로, 그쪽을 여기서 모듈레벨 import 하면
 # 부트스트랩 순환이 된다 — 하지 말 것.
 from whatap.llm.log_sink_packs.llm_log_sink_pack import LlmLogSinkPack, normalize_id
@@ -29,14 +29,15 @@ _MAX_CONTENT_BYTES = 20000
 class LlmLogSinkTask(object):
     """LLM logsink pack 송출 파이프라인.
 
-    LLM 호출 결과 pack 을 받아 즉시 송출. 평가 (LLM-judge 등) 는 별도 파이프라인
-    (``LlmEvaluatorTask``) 에서 비동기로 처리되며, 평가 결과는 ``LlmStepEvalStatus``
-    pack (``llm_log_type=llm_step_eval_status``) 으로 송출된다 — 원본 LlmStepStatus 와
-    동일한 fields/tags + 평가 점수 5 필드. (txid, step_id) 결합 키로 백엔드 사후 결합.
-
-    이 단순한 모델 덕분에 hold/timeout/callback 등의 복잡도가 모두 제거됨.
+    LLM 호출 결과 pack 을 받아 즉시 송출한다. 결과를 기다리는 후처리가 없으므로
+    hold/timeout/callback 등의 복잡도가 없다.
     """
 
+    # >>> LLM-EVAL: 평가(LLM-judge 등)는 별도 파이프라인(``LlmEvaluatorTask``)에서 비동기로 돌고,
+    # 결과는 ``LlmStepEvalStatus`` pack(``llm_log_type=llm_step_eval_status``)으로 따로 송출된다
+    # — 원본 LlmStepStatus 와 같은 fields/tags + 평가 점수. (txid, step_id) 결합 키로 백엔드 사후 결합.
+    # <<< LLM-EVAL
+
     _instance = None
     _lock = threading.Lock()
 
@@ -53,14 +54,7 @@ class LlmLogSinkTask(object):
         return cls._instance
 
     def dispatch(self, pack):
-        """LLM 호출 결과 pack 을 즉시 송출 + 평가 큐 트리거.
-
-        평가 워커 안에서 호출된 judge LLM call 인 경우 (intercept 가 fire 한 케이스):
-          - operation_type='whatap_evaluation' / prompt_version='v1' 고정
-          - parent (user) step 의 (txid, step_id, index) 그대로 propagate
-            → dashboard 에서 같은 transaction 으로 묶여 보임
-          - eval enqueue 는 재귀 가드가 자동 차단
-        """
+        """LLM 호출 결과 pack 을 즉시 송출한다."""
         if not isinstance(pack, LlmStepStatus):
             return
 
@@ -77,23 +71,15 @@ class LlmLogSinkTask(object):
                             % (pack.model, pack.input_tokens, pack.output_tokens, pack.cached_tokens, e),
                             extra={'id': 'LLM024'})
 
-        # ── judge LLM call (eval 워커 안에서 발생) — 고정 라벨 + parent step ids ──
+        # >>> LLM-EVAL: judge 호출(평가 워커 안에서 난 LLM 호출)이면 고정 라벨 + 부모(사용자) 스텝
+        # 좌표로 덮는다 — 위 set_context 가 현재 컨텍스트 좌표로 되돌렸으므로 다시 덮어야 한다.
+        # 그래야 dashboard 에서 사용자 호출과 같은 transaction 으로 묶여 보인다.
         try:
-            from whatap.counter.tasks.llm_evaluator_task import (
-                _is_in_evaluator_worker, _get_eval_worker_state,
-            )
-            if _is_in_evaluator_worker():
-                state = _get_eval_worker_state() or {}
-                pack.operation_type = 'whatap_evaluation'
-                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']
+            from whatap.llm.evaluators.hooks import mark_judge_call
+            mark_judge_call(pack)
         except Exception:
             pass
+        # <<< LLM-EVAL
 
         # tx_summary 누적
         self._accumulate_tx_summary(ctx, pack)
@@ -107,16 +93,17 @@ class LlmLogSinkTask(object):
             ctx._llm_last_error_prompt_version = (
                 getattr(pack, 'prompt_version', 'v1') or 'v1')
 
-        # pack 즉시 송출 — eval 결과 기다리지 않음
+        # pack 즉시 송출
         self._enqueue_for_send(pack)
 
-        # 평가 큐 트리거 — worker 가 pack 을 복제해 LlmStepEvalStatus 로 만들어 점수 채워 송출
-        # judge 호출 인 경우 enqueue_evaluation 의 재귀 가드가 차단
+        # >>> LLM-EVAL: 평가 큐 투입 — 워커가 pack 을 복제해 점수를 채워 LlmStepEvalStatus 로 송출.
+        # 원본 송출(위)은 평가 결과를 기다리지 않는다. judge 호출 자체는 재귀 가드가 걸러낸다.
         try:
-            from whatap.counter.tasks.llm_evaluator_task import enqueue_evaluation
-            enqueue_evaluation(pack)
+            from whatap.llm.evaluators.hooks import enqueue
+            enqueue(pack)
         except Exception as e:
             logging.warning('[LLM] eval enqueue failed: %s' % e, extra={'id': 'LLM034'})
+        # <<< LLM-EVAL
 
     def _enqueue_for_send(self, pack):
         """완성된 pack 을 송출 큐에 적재. queue full 이면 drop + LLM025."""
@@ -362,6 +349,7 @@ def send_llm_tx_status(ctx):
     LlmLogSinkTask.get_instance().send_tx_status(ctx)
 
 
+# >>> LLM-EVAL: 평가 결과 pack 송출구 — 평가 워커와 submit_evaluation 만 부른다.
 def dispatch_llm_evaluation_pack(pack):
     """LlmStepEvalStatus pack 을 LogSink 인프라로 송출.
 
@@ -373,3 +361,4 @@ def dispatch_llm_evaluation_pack(pack):
     except Exception as e:
         logging.warning('[LLM] dispatch_llm_evaluation_pack failed: %s' % e,
                         extra={'id': 'LLM037'})
+# <<< LLM-EVAL

whatap/doctor.py

@@ -229,7 +229,7 @@ def _llm_sdk_result(found):
 
 
 def check_llm_features(conf, sdk_present):
-    """LLM 관측 on/off 와 Evaluation 상태를 요약한다(비용 경고 포함)."""
+    """LLM 관측 on/off 상태를 요약한다."""
     if conf is None or "__error__" in conf:
         return None
     llm_on = conf.get("llm_enabled", "false") == "true"
@@ -240,13 +240,18 @@ def check_llm_features(conf, sdk_present):
                                "(references/llm-observability.md)")
         return Result(OK, "LLM 관측", "off")
 
+    result = Result(OK, "LLM 관측", "on")
+    # >>> LLM-EVAL: Evaluation 상태 요약(비용 경고 포함)
     if conf.get("llm_eval_enabled", "false") == "true":
         evs = conf.get("llm_eval_evaluators", "combined_judge, pii_leak, url_scan")
-        return Result(WARN, "LLM Evaluation", "on / evaluators={0}".format(evs),
-                      hint="judge LLM 호출만큼 토큰·비용이 추가 발생. combined_judge 권장, "
-                           "필요시 llm_eval_sample_rate 로 비율 조절 (references/llm-evaluation.md)")
-    return Result(OK, "LLM 관측", "on (Evaluation off)",
-                  hint="응답 품질 평가가 필요하면 llm_eval_enabled=true (references/llm-evaluation.md)")
+        result = Result(WARN, "LLM Evaluation", "on / evaluators={0}".format(evs),
+                        hint="judge LLM 호출만큼 토큰·비용이 추가 발생. combined_judge 권장, "
+                             "필요시 llm_eval_sample_rate 로 비율 조절 (references/llm-evaluation.md)")
+    else:
+        result = Result(OK, "LLM 관측", "on (Evaluation off)",
+                        hint="응답 품질 평가가 필요하면 llm_eval_enabled=true (references/llm-evaluation.md)")
+    # <<< LLM-EVAL
+    return result
 
 
 def check_process():
@@ -279,7 +284,9 @@ _SCAN_PATTERNS = [
     ("workflow/agent", re.compile(r"@(workflow|agent|agent_name)\b|with\s+(workflow|agent|agent_name)\s*\(")),
     ("session/user", re.compile(r"set_(session|user)_id\s*\(|with\s+(session|user)\s*\(")),
     ("operation/prompt", re.compile(r"@prompt_meta\b|with\s+prompt_meta_scope\s*\(")),
+    # >>> LLM-EVAL: 고객 소스의 평가 API 사용
     ("evaluation", re.compile(r"@evaluate_with\b|evaluate_with\s*\(|with\s+evaluation_scope\s*\(")),
+    # <<< LLM-EVAL
     ("marker", re.compile(r"#\s*whatap")),
 ]
 

whatap/llm/api/prompt_meta.py

@@ -35,7 +35,6 @@ LangChain / LlamaIndex 등 AI 프레임워크 계측 시에도 framework 의 자
 저장: trace context (있으면) + ContextVar (항상). 양쪽 동시에 같은 stack 을 push/pop.
 중첩 안전 (LIFO stack). asyncio.create_task / TaskGroup 분기 시 ContextVar 가 inherit
 되어 sub-task 안에서 LLM 호출 시에도 같은 prompt_meta 가 보임.
-``whatap.llm.evaluators.scope`` 와 같은 패턴.
 """
 import asyncio
 import contextvars

whatap/llm/evaluators/base.py

@@ -52,11 +52,14 @@ EvaluatorContext = namedtuple(
         # 인스턴스를 안 잡으므로 수명 무관. OAuth 등 못 읽으면 None → conf/env 로 폴백.
         'judge_base_url',     # str|None — 앱 client 의 base_url
         'judge_api_key',      # str|None — 앱 client 의 api_key
-        'judge_kind',         # 'openai'|'anthropic'|None
+        'judge_kind',         # 'openai'|'anthropic'|'bedrock'|None
+        # Bedrock 은 API 키가 아니라 AWS 자격증명으로 서명한다 — 앱 client 의 리전·엔드포인트와
+        # botocore 자격증명 객체(닫히지 않고, 갱신형은 judge 시점에 스스로 갱신)를 담는다.
+        'judge_aws',          # dict|None — {'region', 'endpoint_url', 'profile', 'credentials'}
     ],
 )
-# 후행 optional 필드 defaults: event_loop, judge_base_url, judge_api_key, judge_kind
-EvaluatorContext.__new__.__defaults__ = (None, None, None, None)
+# 후행 optional 필드 defaults: event_loop, judge_base_url, judge_api_key, judge_kind, judge_aws
+EvaluatorContext.__new__.__defaults__ = (None, None, None, None, None)
 
 
 class EvaluatorResult(object):

whatap/llm/evaluators/builtins/__init__.py

@@ -47,7 +47,9 @@ LLM judge 기반 평가자는 별도 LLM 호출(judge call)로 점수를 산출
 Judge LLM 호출 헬퍼:
 
     make_openai_judge(client=..., model='gpt-4o-mini')
-    make_anthropic_judge(client=..., model='claude-3-5-haiku-latest')
+    make_anthropic_judge(client=..., model='claude-haiku-5-5')
+    make_bedrock_judge(model='us.anthropic.claude-haiku-4-5-20251001-v1:0',
+                       region_name='us-east-1')       # Bedrock Runtime Converse (모델 필수)
 
 커스텀 judge 작성 시 ``LLMJudgeBase`` 상속하고 ``make_prompt`` / ``parse_judgment`` 만
 구현하면 된다.
@@ -56,6 +58,7 @@ from whatap.llm.evaluators.builtins.llm_judge import (
     LLMJudgeBase,
     make_openai_judge,
     make_anthropic_judge,
+    make_bedrock_judge,
     parse_json_response,
     set_default_judge_fn,
     get_default_judge_fn,
@@ -75,6 +78,7 @@ __all__ = [
     'LLMJudgeBase',
     'make_openai_judge',
     'make_anthropic_judge',
+    'make_bedrock_judge',
     'parse_json_response',
     'set_default_judge_fn',
     'get_default_judge_fn',