whatap-python 2.1.0__py3-none-any.whl

whatap/llm/pricing.py

@@ -0,0 +1,236 @@
+"""LLM 모델별 가격 데이터 및 비용 계산 로직.
+
+genai-prices 패키지가 설치되어 있으면 우선 사용하고,
+없으면 하드코딩된 MODEL_PRICING으로 fallback한다.
+"""
+from whatap.conf.configure import Configure as conf
+
+try:
+    from genai_prices import Usage as _GenaiUsage, calc_price as _genai_calc_price
+    _HAS_GENAI_PRICES = True
+except ImportError:
+    _HAS_GENAI_PRICES = False
+
+# fallback: USD per 1M tokens (input, output, cached_input)
+MODEL_PRICING = {
+    # OpenAI - GPT-5
+    'gpt-5': (1.25, 10.00, 0.125),
+    'gpt-5-mini': (0.25, 2.00, 0.025),
+    'gpt-5-nano': (0.05, 0.40, 0.005),
+    'gpt-5.1': (1.25, 10.00, 0.125),
+    'gpt-5.2': (1.75, 14.00, 0.175),
+    # OpenAI - GPT-4
+    'gpt-4o': (2.50, 10.00, 1.25),
+    'gpt-4o-mini': (0.15, 0.60, 0.075),
+    'gpt-4o-audio-preview': (2.50, 10.00, None),
+    'gpt-4o-mini-audio-preview': (0.15, 0.60, None),
+    'gpt-4.1': (2.00, 8.00, 0.50),
+    'gpt-4.1-mini': (0.40, 1.60, 0.10),
+    'gpt-4.1-nano': (0.10, 0.40, 0.025),
+    'gpt-4-turbo': (10.00, 30.00, None),
+    'gpt-4': (30.00, 60.00, None),
+    'gpt-3.5-turbo': (0.50, 1.50, None),
+    # OpenAI - o
+    'o1': (15.00, 60.00, 7.50),
+    'o1-pro': (150.00, 600.00, None),
+    'o3': (2.00, 8.00, 0.50),
+    'o3-mini': (1.10, 4.40, 0.55),
+    'o3-pro': (20.00, 80.00, None),
+    'o4-mini': (1.10, 4.40, 0.275),
+    # Anthropic - Claude 4.x
+    'claude-opus-4-6': (5.00, 25.00, 0.50),
+    'claude-sonnet-4-6': (3.00, 15.00, 0.30),
+    'claude-opus-4-5-20251101': (5.00, 25.00, 0.50),
+    'claude-opus-4-1-20250805': (15.00, 75.00, 1.50),
+    'claude-sonnet-4-5-20250929': (3.00, 15.00, 0.30),
+    'claude-sonnet-4-20250514': (3.00, 15.00, 0.30),
+    'claude-opus-4-20250514': (15.00, 75.00, 1.50),
+    'claude-haiku-4-5-20251001': (1.00, 5.00, 0.10),
+    # Anthropic - Claude 3.x
+    'claude-3-5-sonnet-20241022': (3.00, 15.00, 0.30),
+    'claude-3-5-sonnet-20240620': (3.00, 15.00, 0.30),
+    'claude-3-5-haiku-20241022': (0.80, 4.00, 0.08),
+    'claude-3-opus-20240229': (15.00, 75.00, 1.50),
+    'claude-3-sonnet-20240229': (3.00, 15.00, 0.30),
+    'claude-3-haiku-20240307': (0.25, 1.25, 0.03),
+    # OpenAI - Embeddings
+    'text-embedding-3-small': (0.02, 0, None),
+    'text-embedding-3-large': (0.13, 0, None),
+    'text-embedding-ada-002': (0.10, 0, None),
+}
+
+# prefix match fallback (model ID variations)
+MODEL_PRICING_PREFIX = [
+    # OpenAI - GPT-5
+    ('gpt-5.2', (1.75, 14.00, 0.175)),
+    ('gpt-5.1', (1.25, 10.00, 0.125)),
+    ('gpt-5-nano', (0.05, 0.40, 0.005)),
+    ('gpt-5-mini', (0.25, 2.00, 0.025)),
+    ('gpt-5', (1.25, 10.00, 0.125)),
+    # OpenAI - GPT-4
+    ('gpt-4o-mini', (0.15, 0.60, 0.075)),
+    ('gpt-4o', (2.50, 10.00, 1.25)),
+    ('gpt-4.1-nano', (0.10, 0.40, 0.025)),
+    ('gpt-4.1-mini', (0.40, 1.60, 0.10)),
+    ('gpt-4.1', (2.00, 8.00, 0.50)),
+    ('gpt-4-turbo', (10.00, 30.00, None)),
+    ('gpt-4', (30.00, 60.00, None)),
+    ('gpt-3.5-turbo', (0.50, 1.50, None)),
+    # OpenAI - o
+    ('o4-mini', (1.10, 4.40, 0.275)),
+    ('o3-pro', (20.00, 80.00, None)),
+    ('o3-mini', (1.10, 4.40, 0.55)),
+    ('o3', (2.00, 8.00, 0.50)),
+    ('o1-pro', (150.00, 600.00, None)),
+    ('o1', (15.00, 60.00, 7.50)),
+    # Anthropic
+    ('claude-opus-4-6', (5.00, 25.00, 0.50)),
+    ('claude-sonnet-4-6', (3.00, 15.00, 0.30)),
+    ('claude-opus-4-5', (5.00, 25.00, 0.50)),
+    ('claude-opus-4-1', (15.00, 75.00, 1.50)),
+    ('claude-sonnet-4-5', (3.00, 15.00, 0.30)),
+    ('claude-sonnet-4', (3.00, 15.00, 0.30)),
+    ('claude-opus-4', (15.00, 75.00, 1.50)),
+    ('claude-haiku-4-5', (1.00, 5.00, 0.10)),
+    ('claude-3-5-sonnet', (3.00, 15.00, 0.30)),
+    ('claude-3-5-haiku', (0.80, 4.00, 0.08)),
+    ('claude-3-opus', (15.00, 75.00, 1.50)),
+    ('claude-3-sonnet', (3.00, 15.00, 0.30)),
+    ('claude-3-haiku', (0.25, 1.25, 0.03)),
+    # OpenAI - Embeddings
+    ('text-embedding-3-small', (0.02, 0, None)),
+    ('text-embedding-3-large', (0.13, 0, None)),
+    ('text-embedding-ada', (0.10, 0, None)),
+]
+
+_custom_pricing_cache = {}
+_custom_pricing_raw = None
+
+
+def _parse_custom_pricing():
+    global _custom_pricing_cache, _custom_pricing_raw
+    raw = getattr(conf, 'llm_model_pricing', '') or ''
+    if raw == _custom_pricing_raw:
+        return _custom_pricing_cache
+    _custom_pricing_raw = raw
+    if not raw:
+        _custom_pricing_cache = {}
+        return _custom_pricing_cache
+    pricing = {}
+    for entry in raw.split(','):
+        parts = entry.strip().split('|')
+        if len(parts) < 3:
+            continue
+        model = parts[0].strip()
+        try:
+            inp = float(parts[1].strip())
+            out = float(parts[2].strip())
+            cached = float(parts[3].strip()) if len(parts) > 3 and parts[3].strip() else None
+            pricing[model] = (inp, out, cached)
+        except (ValueError, IndexError):
+            continue
+    _custom_pricing_cache = pricing
+    return _custom_pricing_cache
+
+
+def _get_fallback_pricing(model):
+    """하드코딩 테이블에서 모델 가격 조회. exact match → prefix match."""
+    pricing = MODEL_PRICING.get(model)
+    if pricing:
+        return pricing
+    for prefix, p in MODEL_PRICING_PREFIX:
+        if model.startswith(prefix):
+            return p
+    return None
+
+
+def _detect_provider(pack):
+    """pack.provider에서 genai-prices provider_id를 추출."""
+    provider = (pack.provider or '').lower()
+    if 'openai' in provider or 'azure' in provider:
+        return 'openai'
+    if 'anthropic' in provider:
+        return 'anthropic'
+    if 'google' in provider or 'gemini' in provider:
+        return 'google'
+    if 'deepseek' in provider:
+        return 'deepseek'
+    if 'mistral' in provider:
+        return 'mistral'
+    return None
+
+
+def calculate_cost(pack):
+    """팩의 모델과 토큰 수를 기반으로 비용을 계산하여 팩에 설정한다.
+
+    genai-prices 우선 → custom config → 하드코딩 fallback 순서.
+    """
+    if not pack.model:
+        return
+
+    # 1. custom config 우선
+    custom = _parse_custom_pricing()
+    if custom:
+        pricing = custom.get(pack.model)
+        if pricing:
+            _calculate_from_tuple(pack, pricing)
+            return
+
+    # 2. genai-prices 패키지
+    if _HAS_GENAI_PRICES:
+        if _calculate_from_genai(pack):
+            return
+
+    # 3. 하드코딩 fallback
+    pricing = _get_fallback_pricing(pack.model)
+    if pricing:
+        _calculate_from_tuple(pack, pricing)
+
+
+def _calculate_from_genai(pack):
+    """genai-prices로 비용 계산. 성공 시 True, 모델 없으면 False."""
+    try:
+        usage = _GenaiUsage(
+            input_tokens=pack.input_tokens or 0,
+            output_tokens=pack.output_tokens or 0,
+            cache_read_tokens=(pack.cached_tokens or 0) + (pack.cache_read_input_tokens or 0),
+            cache_write_tokens=pack.cache_creation_input_tokens or 0,
+        )
+        provider_id = _detect_provider(pack)
+        kwargs = {'model_ref': pack.model}
+        if provider_id:
+            kwargs['provider_id'] = provider_id
+
+        result = _genai_calc_price(usage, **kwargs)
+
+        pack.input_cost = round(float(result.input_price), 6)
+        pack.output_cost = round(float(result.output_price), 6)
+        pack.cost = round(float(result.total_price), 6)
+        pack.cached_cost = 0.0
+        return True
+    except Exception:
+        return False
+
+
+def _calculate_from_tuple(pack, pricing):
+    """(input_per_1m, output_per_1m, cached_per_1m) 튜플로 비용 계산."""
+    input_price, output_price, cached_price = pricing
+
+    input_count = pack.input_tokens or 0
+    output_count = pack.output_tokens or 0
+    cached = (pack.cached_tokens or 0) + (pack.cache_read_input_tokens or 0)
+
+    if cached_price is not None and cached > 0:
+        non_cached = max(input_count - cached, 0)
+        cached_cost = (cached * cached_price) / 1_000_000
+        input_cost = (non_cached * input_price) / 1_000_000 + cached_cost
+    else:
+        input_cost = (input_count * input_price) / 1_000_000
+        cached_cost = 0.0
+
+    output_cost = (output_count * output_price) / 1_000_000
+
+    pack.input_cost = round(input_cost, 6)
+    pack.output_cost = round(output_cost, 6)
+    pack.cached_cost = round(cached_cost, 6)
+    pack.cost = round(input_cost + output_cost, 6)

whatap/llm/prompt_meta.py

@@ -0,0 +1,288 @@
+"""LLM 호출의 prompt 메타 (operation_type / prompt_version) 를 모든 logsink pack 의
+공통 태그로 자동 인라인.
+
+배경: 사용자가 LLM API 를 어떤 프롬프트 / 체인 / agent 로 호출했는지 백엔드에서 그룹/필터링
+하기 위한 라벨링. 백엔드 대시보드의 ``operation_type`` 태그를 그대로 활용 (이전엔
+'chat'/'embedding' 같은 API 종류였던 자리).
+
+사용법 (데코레이터):
+
+    from whatap.llm.prompt_meta import prompt_meta
+
+    @prompt_meta(operation_type='checkout_chain', prompt_version='v3')
+    def checkout(question):
+        return client.chat.completions.create(...)
+
+또는 컨텍스트 매니저:
+
+    from whatap.llm.prompt_meta import prompt_meta_scope
+
+    def chat(question):
+        with prompt_meta_scope(operation_type='greeting', prompt_version='v2'):
+            return client.chat.completions.create(...)
+
+데코레이터/스코프 미적용 시 기본값:
+    operation_type='default', prompt_version='v1'
+
+LangChain / LlamaIndex 등 AI 프레임워크 계측 시에도 framework 의 자연스러운 단위
+(chain 이름 / agent 이름 등) 를 ``operation_type`` 으로 자동 채워줄 수 있다.
+
+저장: 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
+import functools
+import inspect
+
+from whatap import logging
+
+
+# task 별로 격리되는 storage. asyncio.create_task / TaskGroup 으로 분기된 task 도
+# 시작 시점의 ContextVar snapshot 을 inherit. None 이 default.
+_meta_cv = contextvars.ContextVar('whatap_llm_prompt_meta_stack', default=None)
+
+DEFAULT_OPERATION_TYPE = 'default'
+DEFAULT_PROMPT_VERSION = 'v1'
+
+
+def _ensure_cv_stack():
+    cur = _meta_cv.get()
+    if cur is None:
+        cur = []
+        _meta_cv.set(cur)
+    return cur
+
+
+def _ensure_ctx_stack(ctx):
+    if not hasattr(ctx, '_llm_prompt_meta_stack'):
+        ctx._llm_prompt_meta_stack = []
+    return ctx._llm_prompt_meta_stack
+
+
+def _get_active_stacks():
+    """현재 활성 stack 들 — (trace ctx + ContextVar) 양쪽 모두 반환.
+
+    enter 시 양쪽 모두에 push, exit 시 양쪽 모두에서 pop. trace ctx 가 hot path 에서
+    빠른 lookup, ContextVar 는 task 분기 시 inherit 보강.
+    """
+    stacks = []
+    try:
+        from whatap.trace.trace_context_manager import TraceContextManager
+        ctx = TraceContextManager.getLocalContext()
+        if ctx is not None:
+            stacks.append(_ensure_ctx_stack(ctx))
+    except Exception:
+        pass
+    stacks.append(_ensure_cv_stack())
+    return stacks
+
+
+def get_prompt_meta():
+    """현재 활성 ``(operation_type, prompt_version)`` 튜플 반환.
+
+    스코프 미적용 시 ``('default', 'v1')``. 중첩 스코프이면 가장 안쪽 (stack top) 값.
+    interceptor 가 LLM 호출 시점에 호출해 pack 의 태그 set.
+
+    trace ctx stack 우선 — 같은 task chain 이면 ContextVar 와 자동 sync 되어 같은 값.
+    trace ctx 가 None 이거나 다른 ctx 인 경우 ContextVar fallback.
+    """
+    # trace ctx 우선
+    try:
+        from whatap.trace.trace_context_manager import TraceContextManager
+        ctx = TraceContextManager.getLocalContext()
+        if ctx is not None:
+            stack = getattr(ctx, '_llm_prompt_meta_stack', None)
+            if stack:
+                return stack[-1]
+    except Exception:
+        pass
+
+    cv_stack = _meta_cv.get()
+    if cv_stack:
+        return cv_stack[-1]
+
+    return DEFAULT_OPERATION_TYPE, DEFAULT_PROMPT_VERSION
+
+
+class prompt_meta_scope(object):
+    """LLM 호출에 prompt 메타데이터를 스코프 단위로 적용하는 컨텍스트 매니저.
+
+    Example:
+        with prompt_meta_scope(operation_type='greeting', prompt_version='v2'):
+            response = client.chat.completions.create(...)
+
+    중첩 안전 — 안쪽 스코프 가 stack top 으로, 안쪽 호출에만 적용. 바깥 스코프 보존.
+    """
+
+    def __init__(self, operation_type=None, prompt_version=None):
+        self._op = str(operation_type) if operation_type else DEFAULT_OPERATION_TYPE
+        self._ver = str(prompt_version) if prompt_version else DEFAULT_PROMPT_VERSION
+        self._stacks = None
+        self._pushed = False
+
+    def __enter__(self):
+        try:
+            self._stacks = _get_active_stacks()
+            for s in self._stacks:
+                s.append((self._op, self._ver))
+            self._pushed = True
+        except Exception as e:
+            logging.warning('[LLM] prompt_meta_scope enter failed: %s' % e,
+                            extra={'id': 'LLM070'})
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        if not self._pushed:
+            return False
+        try:
+            for s in self._stacks or ():
+                if s and s[-1] == (self._op, self._ver):
+                    s.pop()
+                elif s:
+                    # stack 망쳐졌으면 (외부 leak 등) 가장 가까운 같은 항목만 제거 시도
+                    for i in range(len(s) - 1, -1, -1):
+                        if s[i] == (self._op, self._ver):
+                            del s[i]
+                            break
+        except Exception as e:
+            logging.warning('[LLM] prompt_meta_scope exit failed: %s' % e,
+                            extra={'id': 'LLM071'})
+        finally:
+            self._stacks = None
+            self._pushed = False
+        return False  # 예외 propagate
+
+
+def _is_streaming_response(obj):
+    """FastAPI/Starlette StreamingResponse 호환 객체 감지."""
+    return hasattr(obj, 'body_iterator')
+
+
+def _wrap_async_iter(orig_iter, scope):
+    async def wrapped():
+        try:
+            async for chunk in orig_iter:
+                yield chunk
+        finally:
+            scope.__exit__(None, None, None)
+    return wrapped()
+
+
+def _wrap_sync_iter(orig_iter, scope):
+    def wrapped():
+        try:
+            for chunk in orig_iter:
+                yield chunk
+        finally:
+            scope.__exit__(None, None, None)
+    return wrapped()
+
+
+def _wrap_result_keep_scope(result, scope):
+    """함수 result 의 type 별로 scope 유지 wrapping.
+
+    - StreamingResponse → body_iterator wrap
+    - async generator object / sync generator object → 직접 wrap
+    - 그 외                                            → 즉시 scope 닫음
+    """
+    if _is_streaming_response(result):
+        orig = result.body_iterator
+        if inspect.isasyncgen(orig) or hasattr(orig, '__aiter__'):
+            result.body_iterator = _wrap_async_iter(orig, scope)
+        else:
+            result.body_iterator = _wrap_sync_iter(orig, scope)
+        return result
+
+    if inspect.isasyncgen(result):
+        return _wrap_async_iter(result, scope)
+
+    if inspect.isgenerator(result):
+        return _wrap_sync_iter(result, scope)
+
+    scope.__exit__(None, None, None)
+    return result
+
+
+def prompt_meta(operation_type=None, prompt_version=None):
+    """함수에 prompt 메타데이터 (operation_type / prompt_version) 를 스코프 단위로
+    묶는 데코레이터.
+
+    sync / async / generator / async generator / FastAPI StreamingResponse 모두 지원 —
+    함수 안에서 발생하는 LLM 호출의 메트릭/pack 태그에 자동 인라인.
+
+    Example:
+        @prompt_meta(operation_type='greeting', prompt_version='v1')
+        async def chat(q):
+            return await client.chat.completions.create(...)
+
+        @prompt_meta(operation_type='rag_chain', prompt_version='v3')
+        async def rag(q):
+            async def gen():
+                stream = await client.chat.completions.create(stream=True, ...)
+                async for chunk in stream:
+                    yield chunk
+            return StreamingResponse(gen(), ...)
+
+    asyncio.create_task / TaskGroup 으로 분기된 sub-task 도 ContextVar inherit 으로
+    같은 prompt_meta 가 보임.
+    """
+    op = operation_type
+    ver = prompt_version
+
+    def decorator(fn):
+        if asyncio.iscoroutinefunction(fn):
+            @functools.wraps(fn)
+            async def async_wrapper(*args, **kwargs):
+                scope = prompt_meta_scope(operation_type=op, prompt_version=ver)
+                scope.__enter__()
+                try:
+                    result = await fn(*args, **kwargs)
+                except BaseException:
+                    scope.__exit__(None, None, None)
+                    raise
+                return _wrap_result_keep_scope(result, scope)
+            return async_wrapper
+
+        if inspect.isasyncgenfunction(fn):
+            @functools.wraps(fn)
+            def async_gen_wrapper(*args, **kwargs):
+                scope = prompt_meta_scope(operation_type=op, prompt_version=ver)
+                scope.__enter__()
+                try:
+                    gen = fn(*args, **kwargs)
+                except BaseException:
+                    scope.__exit__(None, None, None)
+                    raise
+                return _wrap_async_iter(gen, scope)
+            return async_gen_wrapper
+
+        if inspect.isgeneratorfunction(fn):
+            @functools.wraps(fn)
+            def gen_wrapper(*args, **kwargs):
+                scope = prompt_meta_scope(operation_type=op, prompt_version=ver)
+                scope.__enter__()
+                try:
+                    gen = fn(*args, **kwargs)
+                except BaseException:
+                    scope.__exit__(None, None, None)
+                    raise
+                return _wrap_sync_iter(gen, scope)
+            return gen_wrapper
+
+        # 일반 sync 함수 — return 이 generator/asyncgen/StreamingResponse 일 수 있으니
+        # result 분기 적용.
+        @functools.wraps(fn)
+        def sync_wrapper(*args, **kwargs):
+            scope = prompt_meta_scope(operation_type=op, prompt_version=ver)
+            scope.__enter__()
+            try:
+                result = fn(*args, **kwargs)
+            except BaseException:
+                scope.__exit__(None, None, None)
+                raise
+            return _wrap_result_keep_scope(result, scope)
+        return sync_wrapper
+    return decorator

whatap/llm/providers/anthropic/__init__.py

@@ -0,0 +1,37 @@
+from whatap.conf.configure import Configure as conf
+from whatap.trace.trace_handler import trace_handler, async_trace_handler
+from whatap.llm.providers.anthropic.messages.messages import intercept_create, async_intercept_create
+
+
+def instrument_anthropic(module):
+
+    if not conf.llm_enabled:
+        return
+
+    def create_wrapper(fn):
+        @trace_handler(fn)
+        def trace(*args, **kwargs):
+            return intercept_create(fn, *args, **kwargs)
+        return trace
+
+    def async_create_wrapper(fn):
+        @async_trace_handler(fn)
+        async def trace(*args, **kwargs):
+            return await async_intercept_create(fn, *args, **kwargs)
+        return trace
+
+    # Sync: anthropic.resources.messages.Messages.create
+    if (hasattr(module, 'resources') and
+            hasattr(module.resources, 'messages') and
+            hasattr(module.resources.messages, 'Messages') and
+            hasattr(module.resources.messages.Messages, 'create')):
+        original_create = module.resources.messages.Messages.create
+        module.resources.messages.Messages.create = create_wrapper(original_create)
+
+    # Async: anthropic.resources.messages.AsyncMessages.create
+    if (hasattr(module, 'resources') and
+            hasattr(module.resources, 'messages') and
+            hasattr(module.resources.messages, 'AsyncMessages') and
+            hasattr(module.resources.messages.AsyncMessages, 'create')):
+        original_async_create = module.resources.messages.AsyncMessages.create
+        module.resources.messages.AsyncMessages.create = async_create_wrapper(original_async_create)

whatap/llm/providers/anthropic/messages/messages.py

@@ -0,0 +1,70 @@
+"""Anthropic Messages API 호출을 인터셉트하는 모듈."""
+from anthropic import APIError
+
+from whatap.llm.providers.interceptor import (
+    before_call, handle_error, after_call, finalize_non_streaming, _ensure_end,
+    capture_client,
+)
+from whatap.llm.providers.stream_accumulator import sync_stream, async_stream
+from whatap.llm.providers.anthropic.messages.messages_context import build_context
+from whatap.llm.providers.anthropic.messages.messages_extractor import finalize, AnthropicStream
+
+
+def intercept_create(fn, *args, **kwargs):
+    """Anthropic Messages 동기 호출을 인터셉트하여 모니터링 데이터를 수집한다."""
+    pack, ctx, features, stream = build_context(kwargs)
+    capture_client(pack, ctx, args)
+    active_key = (pack.model, pack.operation_type, getattr(pack, "prompt_version", "v1"))
+
+    before_call(pack, active_key)
+    _stream_returned = False
+    try:
+        try:
+            response = fn(*args, **kwargs)
+        except Exception as err:
+            handle_error(pack, err, active_key, APIError)
+            raise
+        finally:
+            if ctx:
+                ctx._llm_httpc_pending = False
+
+        after_call(pack, ctx)
+        if stream:
+            _stream_returned = True
+            return sync_stream(response, AnthropicStream(pack, active_key, features))
+        finalize(response, pack, features)
+        finalize_non_streaming(pack, active_key)
+        return response
+    finally:
+        if not _stream_returned:
+            _ensure_end(pack, active_key)
+
+
+async def async_intercept_create(fn, *args, **kwargs):
+    """Anthropic Messages 비동기 호출을 인터셉트하여 모니터링 데이터를 수집한다."""
+    pack, ctx, features, stream = build_context(kwargs)
+    capture_client(pack, ctx, args)
+    active_key = (pack.model, pack.operation_type, getattr(pack, "prompt_version", "v1"))
+
+    before_call(pack, active_key)
+    _stream_returned = False
+    try:
+        try:
+            response = await fn(*args, **kwargs)
+        except Exception as err:
+            handle_error(pack, err, active_key, APIError)
+            raise
+        finally:
+            if ctx:
+                ctx._llm_httpc_pending = False
+
+        after_call(pack, ctx)
+        if stream:
+            _stream_returned = True
+            return async_stream(response, AnthropicStream(pack, active_key, features))
+        finalize(response, pack, features)
+        finalize_non_streaming(pack, active_key)
+        return response
+    finally:
+        if not _stream_returned:
+            _ensure_end(pack, active_key)