whatap-python 2.1.0__py3-none-any.whl → 2.1.1__py3-none-any.whl

whatap/build.py

@@ -1,4 +1,4 @@
 app = 'Python'
 name = 'whatap-python'
-version = '2.1.0'
-release_date = '20260610'
+version = '2.1.1'
+release_date = '20260622'

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

@@ -3,68 +3,84 @@ from anthropic import APIError
 
 from whatap.llm.providers.interceptor import (
     before_call, handle_error, after_call, finalize_non_streaming, _ensure_end,
-    capture_client,
+    capture_client, extract_response, _safe, _clear_httpc_pending,
 )
-from whatap.llm.providers.stream_accumulator import sync_stream, async_stream
+from whatap.llm.providers.stream_accumulator import wrap_sync_stream, wrap_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"))
+    """Anthropic Messages 동기 호출을 인터셉트한다. 계측 실패는 사용자 호출로 전파되지 않는다."""
+    pack = active_key = None
+    try:
+        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)
+    except Exception:
+        if pack is not None and active_key is not None:
+            _safe(_ensure_end, pack, active_key)
+        return fn(*args, **kwargs)
 
-    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)
+            _safe(handle_error, pack, err, active_key, APIError)
             raise
         finally:
-            if ctx:
-                ctx._llm_httpc_pending = False
+            _safe(_clear_httpc_pending, ctx)
 
-        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)
+        try:
+            after_call(pack, ctx)
+            if stream:
+                result, _stream_returned = wrap_sync_stream(response, AnthropicStream(pack, active_key, features))
+                return result
+            extract_response(response, finalize, pack, features)
+            finalize_non_streaming(pack, active_key)
+        except Exception:
+            pass
         return response
     finally:
         if not _stream_returned:
-            _ensure_end(pack, active_key)
+            _safe(_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"))
+    """Anthropic Messages 비동기 호출을 인터셉트한다. 계측 실패는 사용자 호출로 전파되지 않는다."""
+    pack = active_key = None
+    try:
+        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)
+    except Exception:
+        if pack is not None and active_key is not None:
+            _safe(_ensure_end, pack, active_key)
+        return await fn(*args, **kwargs)
 
-    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)
+            _safe(handle_error, pack, err, active_key, APIError)
             raise
         finally:
-            if ctx:
-                ctx._llm_httpc_pending = False
+            _safe(_clear_httpc_pending, ctx)
 
-        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)
+        try:
+            after_call(pack, ctx)
+            if stream:
+                result, _stream_returned = wrap_async_stream(response, AnthropicStream(pack, active_key, features))
+                return result
+            extract_response(response, finalize, pack, features)
+            finalize_non_streaming(pack, active_key)
+        except Exception:
+            pass
         return response
     finally:
         if not _stream_returned:
-            _ensure_end(pack, active_key)
+            _safe(_ensure_end, pack, active_key)

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

@@ -84,6 +84,7 @@ class AnthropicStream(StreamAccumulator):
             self.block_type = getattr(block, 'type', None)
             self.block_name = getattr(block, 'name', None)
             if self.block_type == 'tool_use':
+                self.on_first_token()
                 tag = (LlmFeature.COMPUTER_USE
                        if self.block_name and 'computer' in self.block_name
                        else LlmFeature.TOOL_USE)
@@ -92,7 +93,10 @@ class AnthropicStream(StreamAccumulator):
         elif t == 'content_block_delta':
             delta = getattr(event, 'delta', None)
             if self.block_type == 'thinking':
-                self.reasoning += getattr(delta, 'thinking', '') or ''
+                thinking = getattr(delta, 'thinking', '') or ''
+                if thinking:
+                    self.on_first_token()
+                    self.reasoning += thinking
             elif self.block_type == 'text':
                 text = getattr(delta, 'text', '') or ''
                 if text:

whatap/llm/providers/interceptor.py

@@ -6,6 +6,7 @@ API 호출 전후 처리 흐름:
 """
 import time
 
+from whatap import logging
 from whatap.counter.tasks.llm_log_sink_task import dispatch_llm_pack
 
 
@@ -93,6 +94,25 @@ def _active_stat():
     return LlmStatTask.get_stat('ActiveStat')
 
 
+def _safe(fn, *args, **kwargs):
+    """계측 보조 단계를 안전하게 실행한다 — 예외를 흡수(디버그 로깅)해 사용자 호출을 보호.
+
+    계측은 어떤 경우에도 사용자 애플리케이션을 깨면 안 된다. 인터셉트 라이프사이클의
+    모든 보조 호출(before/after/handle_error/_ensure_end 등)을 이걸로 감싼다.
+    """
+    try:
+        return fn(*args, **kwargs)
+    except Exception as e:
+        logging.debug('[LLM] instrumentation step skipped: %s' % e, extra={'id': 'LLM008'})
+        return None
+
+
+def _clear_httpc_pending(ctx):
+    """fn() 직후 httpc pending 플래그 해제(있을 때만)."""
+    if ctx is not None:
+        ctx._llm_httpc_pending = False
+
+
 def before_call(pack, active_key):
     """API 호출 전: active 카운터 증가 + 시작 시간 기록 + 순차 인덱스 할당."""
     pack._active_ended = False
@@ -174,9 +194,39 @@ def finalize_non_streaming(pack, active_key):
         _ensure_end(pack, active_key)
 
 
+def extract_response(response, finalize_fn, pack, *finalize_args):
+    """비스트리밍 응답을 계측한다. 어떤 예외도 사용자 호출로 전파시키지 않는다.
+
+    계측은 사용자 애플리케이션을 절대 깨면 안 된다. finalize_fn 은 응답 구조
+    (``.choices`` / ``.content`` / ``.output`` 등) 를 단정하므로, 예상 밖 응답
+    (예: litellm/langchain 이 ``with_raw_response`` 로 받는 ``LegacyAPIResponse``)
+    이 와도 여기서 흡수하고 계측만 생략한다.
+
+    또한 응답이 ``parse()`` 를 가진 raw 래퍼면 parse() 로 실제 응답을 꺼내 계측한다.
+    parse() 결과는 캐시되어 호출측(litellm 등)의 후속 parse() 와 공유된다.
+    """
+    try:
+        target = response
+        parse = getattr(response, "parse", None)
+        if callable(parse):
+            try:
+                target = parse()
+            except Exception:
+                target = response
+        finalize_fn(target, pack, *finalize_args)
+    except Exception as e:
+        logging.debug('[LLM] response extract skipped: %s' % e, extra={'id': 'LLM005'})
+
+
 def _dispatch(pack):
-    """로그싱크팩 전송 + 메트릭 stat 업데이트 통합 호출."""
-    dispatch_llm_pack(pack)
-    inst = _stat_task()
-    if inst:
-        inst.notify(pack)
+    """로그싱크팩 전송 + 메트릭 stat 업데이트 통합 호출. 송출 실패는 사용자에게 전파 안 함."""
+    try:
+        dispatch_llm_pack(pack)
+    except Exception as e:
+        logging.debug('[LLM] dispatch failed: %s' % e, extra={'id': 'LLM006'})
+    try:
+        inst = _stat_task()
+        if inst:
+            inst.notify(pack)
+    except Exception as e:
+        logging.debug('[LLM] stat notify failed: %s' % e, extra={'id': 'LLM007'})

whatap/llm/providers/openai/chat/chat.py

@@ -3,80 +3,101 @@ from openai import OpenAIError
 
 from whatap.llm.providers.interceptor import (
     before_call, handle_error, after_call, finalize_non_streaming, _ensure_end,
-    capture_client,
+    capture_client, extract_response, _safe, _clear_httpc_pending,
 )
-from whatap.llm.providers.stream_accumulator import sync_stream, async_stream
+from whatap.llm.providers.stream_accumulator import wrap_sync_stream, wrap_async_stream
 from whatap.llm.providers.openai.chat.chat_context import build_context
 from whatap.llm.providers.openai.chat.chat_extractor import finalize, ChatStream
 
 
 def intercept_create(fn, *args, **kwargs):
-    """OpenAI Chat Completions 동기 호출을 인터셉트하여 모니터링 데이터를 수집한다."""
-    pack, ctx, features, stream = build_context(kwargs)
-    capture_client(pack, ctx, args)
-    active_key = (pack.model, pack.operation_type, getattr(pack, "prompt_version", "v1"))
+    """OpenAI Chat Completions 동기 호출을 인터셉트하여 모니터링 데이터를 수집한다.
 
-    if stream:
-        opts = dict(kwargs.get("stream_options") or {})
-        if not opts.get("include_usage"):
-            opts["include_usage"] = True
-            kwargs["stream_options"] = opts
+    계측 어느 단계가 실패해도 사용자 호출은 보호된다 — 계측 예외는 전파하지 않고
+    사용자 fn 의 예외만 전파한다.
+    """
+    pack = active_key = None
+    try:
+        pack, ctx, features, stream = build_context(kwargs)
+        capture_client(pack, ctx, args)
+        active_key = (pack.model, pack.operation_type, getattr(pack, "prompt_version", "v1"))
+        if stream:
+            opts = dict(kwargs.get("stream_options") or {})
+            if not opts.get("include_usage"):
+                opts["include_usage"] = True
+                kwargs["stream_options"] = opts
+        before_call(pack, active_key)
+    except Exception:
+        if pack is not None and active_key is not None:
+            _safe(_ensure_end, pack, active_key)
+        return fn(*args, **kwargs)
 
-    before_call(pack, active_key)
     _stream_returned = False
     try:
         try:
             response = fn(*args, **kwargs)
         except Exception as err:
-            handle_error(pack, err, active_key, OpenAIError)
+            _safe(handle_error, pack, err, active_key, OpenAIError)
             raise
         finally:
-            if ctx:
-                ctx._llm_httpc_pending = False
+            _safe(_clear_httpc_pending, ctx)
 
-        after_call(pack, ctx)
-        if stream:
-            _stream_returned = True
-            return sync_stream(response, ChatStream(pack, active_key))
-        finalize(response, pack, features)
-        finalize_non_streaming(pack, active_key)
+        try:
+            after_call(pack, ctx)
+            if stream:
+                result, _stream_returned = wrap_sync_stream(response, ChatStream(pack, active_key))
+                return result
+            extract_response(response, finalize, pack, features)
+            finalize_non_streaming(pack, active_key)
+        except Exception:
+            pass
         return response
     finally:
         if not _stream_returned:
-            _ensure_end(pack, active_key)
+            _safe(_ensure_end, pack, active_key)
 
 
 async def intercept_create_async(fn, *args, **kwargs):
-    """OpenAI Chat Completions 비동기 호출을 인터셉트하여 모니터링 데이터를 수집한다."""
-    pack, ctx, features, stream = build_context(kwargs)
-    capture_client(pack, ctx, args)
-    active_key = (pack.model, pack.operation_type, getattr(pack, "prompt_version", "v1"))
+    """OpenAI Chat Completions 비동기 호출을 인터셉트하여 모니터링 데이터를 수집한다.
 
-    if stream:
-        opts = dict(kwargs.get("stream_options") or {})
-        if not opts.get("include_usage"):
-            opts["include_usage"] = True
-            kwargs["stream_options"] = opts
+    계측 어느 단계가 실패해도 사용자 호출은 보호된다.
+    """
+    pack = active_key = None
+    try:
+        pack, ctx, features, stream = build_context(kwargs)
+        capture_client(pack, ctx, args)
+        active_key = (pack.model, pack.operation_type, getattr(pack, "prompt_version", "v1"))
+        if stream:
+            opts = dict(kwargs.get("stream_options") or {})
+            if not opts.get("include_usage"):
+                opts["include_usage"] = True
+                kwargs["stream_options"] = opts
+        before_call(pack, active_key)
+    except Exception:
+        if pack is not None and active_key is not None:
+            _safe(_ensure_end, pack, active_key)
+        return await fn(*args, **kwargs)
 
-    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, OpenAIError)
+            _safe(handle_error, pack, err, active_key, OpenAIError)
             raise
         finally:
-            if ctx:
-                ctx._llm_httpc_pending = False
+            _safe(_clear_httpc_pending, ctx)
 
-        after_call(pack, ctx)
-        if stream:
-            _stream_returned = True
-            return async_stream(response, ChatStream(pack, active_key))
-        finalize(response, pack, features)
-        finalize_non_streaming(pack, active_key)
+        try:
+            after_call(pack, ctx)
+            if stream:
+                result, _stream_returned = wrap_async_stream(response, ChatStream(pack, active_key))
+                return result
+            extract_response(response, finalize, pack, features)
+            finalize_non_streaming(pack, active_key)
+        except Exception:
+            pass
         return response
     finally:
         if not _stream_returned:
-            _ensure_end(pack, active_key)
+            _safe(_ensure_end, pack, active_key)

whatap/llm/providers/openai/chat/chat_extractor.py

@@ -89,9 +89,11 @@ class ChatStream(StreamAccumulator):
             getattr(delta, "reasoning_content", None) or
             getattr(delta, "reasoning", None) or "")
         if reasoning:
+            self.on_first_token()
             self.reasoning += reasoning
 
         if getattr(delta, "tool_calls", None):
+            self.on_first_token()
             self.has_tool = True
             for tc in delta.tool_calls:
                 idx = tc.index

whatap/llm/providers/openai/completions/completions.py

@@ -3,68 +3,84 @@ from openai import OpenAIError
 
 from whatap.llm.providers.interceptor import (
     before_call, handle_error, after_call, finalize_non_streaming, _ensure_end,
-    capture_client,
+    capture_client, extract_response, _safe, _clear_httpc_pending,
 )
-from whatap.llm.providers.stream_accumulator import sync_stream, async_stream
+from whatap.llm.providers.stream_accumulator import wrap_sync_stream, wrap_async_stream
 from whatap.llm.providers.openai.completions.completions_context import build_context
 from whatap.llm.providers.openai.completions.completions_extractor import finalize, CompletionsStream
 
 
 def intercept_completions(fn, *args, **kwargs):
-    """Completions API 동기 인터셉트."""
-    pack, ctx = build_context(kwargs)
-    capture_client(pack, ctx, args)
-    active_key = (pack.model, pack.operation_type, getattr(pack, "prompt_version", "v1"))
+    """Completions API 동기 인터셉트. 계측 실패는 사용자 호출로 전파되지 않는다."""
+    pack = active_key = None
+    try:
+        pack, ctx = 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)
+    except Exception:
+        if pack is not None and active_key is not None:
+            _safe(_ensure_end, pack, active_key)
+        return fn(*args, **kwargs)
 
-    before_call(pack, active_key)
     _stream_returned = False
     try:
         try:
             response = fn(*args, **kwargs)
         except Exception as err:
-            handle_error(pack, err, active_key, OpenAIError)
+            _safe(handle_error, pack, err, active_key, OpenAIError)
             raise
         finally:
-            if ctx:
-                ctx._llm_httpc_pending = False
+            _safe(_clear_httpc_pending, ctx)
 
-        after_call(pack, ctx)
-        if pack.stream:
-            _stream_returned = True
-            return sync_stream(response, CompletionsStream(pack, active_key))
-        finalize(response, pack)
-        finalize_non_streaming(pack, active_key)
+        try:
+            after_call(pack, ctx)
+            if pack.stream:
+                result, _stream_returned = wrap_sync_stream(response, CompletionsStream(pack, active_key))
+                return result
+            extract_response(response, finalize, pack)
+            finalize_non_streaming(pack, active_key)
+        except Exception:
+            pass
         return response
     finally:
         if not _stream_returned:
-            _ensure_end(pack, active_key)
+            _safe(_ensure_end, pack, active_key)
 
 
 async def intercept_completions_async(fn, *args, **kwargs):
-    """Completions API 비동기 인터셉트."""
-    pack, ctx = build_context(kwargs)
-    capture_client(pack, ctx, args)
-    active_key = (pack.model, pack.operation_type, getattr(pack, "prompt_version", "v1"))
+    """Completions API 비동기 인터셉트. 계측 실패는 사용자 호출로 전파되지 않는다."""
+    pack = active_key = None
+    try:
+        pack, ctx = 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)
+    except Exception:
+        if pack is not None and active_key is not None:
+            _safe(_ensure_end, pack, active_key)
+        return await fn(*args, **kwargs)
 
-    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, OpenAIError)
+            _safe(handle_error, pack, err, active_key, OpenAIError)
             raise
         finally:
-            if ctx:
-                ctx._llm_httpc_pending = False
+            _safe(_clear_httpc_pending, ctx)
 
-        after_call(pack, ctx)
-        if pack.stream:
-            _stream_returned = True
-            return async_stream(response, CompletionsStream(pack, active_key))
-        finalize(response, pack)
-        finalize_non_streaming(pack, active_key)
+        try:
+            after_call(pack, ctx)
+            if pack.stream:
+                result, _stream_returned = wrap_async_stream(response, CompletionsStream(pack, active_key))
+                return result
+            extract_response(response, finalize, pack)
+            finalize_non_streaming(pack, active_key)
+        except Exception:
+            pass
         return response
     finally:
         if not _stream_returned:
-            _ensure_end(pack, active_key)
+            _safe(_ensure_end, pack, active_key)

whatap/llm/providers/openai/embeddings/embeddings.py

@@ -3,57 +3,73 @@ from openai import OpenAIError
 
 from whatap.llm.providers.interceptor import (
     before_call, handle_error, after_call, finalize_non_streaming, _ensure_end,
-    capture_client,
+    capture_client, extract_response, _safe, _clear_httpc_pending,
 )
 from whatap.llm.providers.openai.embeddings.embeddings_context import build_context
 from whatap.llm.providers.openai.embeddings.embeddings_extractor import finalize
 
 
 def intercept_embeddings(fn, *args, **kwargs):
-    """OpenAI Embeddings 동기 호출을 인터셉트하여 모니터링 데이터를 수집한다."""
-    pack, ctx = build_context(kwargs)
-    capture_client(pack, ctx, args)
-    active_key = (pack.model, pack.operation_type, getattr(pack, "prompt_version", "v1"))
+    """OpenAI Embeddings 동기 호출을 인터셉트한다. 계측 실패는 사용자 호출로 전파되지 않는다."""
+    pack = active_key = None
+    try:
+        pack, ctx = 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)
+    except Exception:
+        if pack is not None and active_key is not None:
+            _safe(_ensure_end, pack, active_key)
+        return fn(*args, **kwargs)
 
-    before_call(pack, active_key)
     try:
         try:
             response = fn(*args, **kwargs)
         except Exception as err:
-            handle_error(pack, err, active_key, OpenAIError)
+            _safe(handle_error, pack, err, active_key, OpenAIError)
             raise
         finally:
-            if ctx:
-                ctx._llm_httpc_pending = False
+            _safe(_clear_httpc_pending, ctx)
 
-        after_call(pack, ctx)
-        finalize(response, pack, kwargs)
-        finalize_non_streaming(pack, active_key)
+        try:
+            after_call(pack, ctx)
+            extract_response(response, finalize, pack, kwargs)
+            finalize_non_streaming(pack, active_key)
+        except Exception:
+            pass
         return response
     finally:
-        _ensure_end(pack, active_key)
+        _safe(_ensure_end, pack, active_key)
 
 
 async def intercept_embeddings_async(fn, *args, **kwargs):
-    """OpenAI Embeddings 비동기 호출을 인터셉트하여 모니터링 데이터를 수집한다."""
-    pack, ctx = build_context(kwargs)
-    capture_client(pack, ctx, args)
-    active_key = (pack.model, pack.operation_type, getattr(pack, "prompt_version", "v1"))
+    """OpenAI Embeddings 비동기 호출을 인터셉트한다. 계측 실패는 사용자 호출로 전파되지 않는다."""
+    pack = active_key = None
+    try:
+        pack, ctx = 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)
+    except Exception:
+        if pack is not None and active_key is not None:
+            _safe(_ensure_end, pack, active_key)
+        return await fn(*args, **kwargs)
 
-    before_call(pack, active_key)
     try:
         try:
             response = await fn(*args, **kwargs)
         except Exception as err:
-            handle_error(pack, err, active_key, OpenAIError)
+            _safe(handle_error, pack, err, active_key, OpenAIError)
             raise
         finally:
-            if ctx:
-                ctx._llm_httpc_pending = False
+            _safe(_clear_httpc_pending, ctx)
 
-        after_call(pack, ctx)
-        finalize(response, pack, kwargs)
-        finalize_non_streaming(pack, active_key)
+        try:
+            after_call(pack, ctx)
+            extract_response(response, finalize, pack, kwargs)
+            finalize_non_streaming(pack, active_key)
+        except Exception:
+            pass
         return response
     finally:
-        _ensure_end(pack, active_key)
+        _safe(_ensure_end, pack, active_key)

whatap/llm/providers/openai/responses/responses.py

@@ -3,68 +3,90 @@ from openai import OpenAIError
 
 from whatap.llm.providers.interceptor import (
     before_call, handle_error, after_call, finalize_non_streaming, _ensure_end,
-    capture_client,
+    capture_client, extract_response, _safe, _clear_httpc_pending,
 )
-from whatap.llm.providers.stream_accumulator import sync_stream, async_stream
+from whatap.llm.providers.stream_accumulator import wrap_sync_stream, wrap_async_stream
 from whatap.llm.providers.openai.responses.responses_context import build_context
 from whatap.llm.providers.openai.responses.responses_extractor import finalize, ResponsesStream
 
 
 def intercept_responses_create(fn, *args, **kwargs):
-    """OpenAI Responses 동기 호출을 인터셉트하여 모니터링 데이터를 수집한다."""
-    pack, ctx, features, stream = build_context(kwargs)
-    capture_client(pack, ctx, args)
-    active_key = (pack.model, pack.operation_type, getattr(pack, "prompt_version", "v1"))
+    """OpenAI Responses 동기 호출을 인터셉트하여 모니터링 데이터를 수집한다.
+
+    계측 어느 단계가 실패해도 사용자 호출은 보호된다.
+    """
+    pack = active_key = None
+    try:
+        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)
+    except Exception:
+        if pack is not None and active_key is not None:
+            _safe(_ensure_end, pack, active_key)
+        return fn(*args, **kwargs)
 
-    before_call(pack, active_key)
     _stream_returned = False
     try:
         try:
             response = fn(*args, **kwargs)
         except Exception as err:
-            handle_error(pack, err, active_key, OpenAIError)
+            _safe(handle_error, pack, err, active_key, OpenAIError)
             raise
         finally:
-            if ctx:
-                ctx._llm_httpc_pending = False
+            _safe(_clear_httpc_pending, ctx)
 
-        after_call(pack, ctx)
-        if stream:
-            _stream_returned = True
-            return sync_stream(response, ResponsesStream(pack, active_key))
-        finalize(response, pack, features)
-        finalize_non_streaming(pack, active_key)
+        try:
+            after_call(pack, ctx)
+            if stream:
+                result, _stream_returned = wrap_sync_stream(response, ResponsesStream(pack, active_key))
+                return result
+            extract_response(response, finalize, pack, features)
+            finalize_non_streaming(pack, active_key)
+        except Exception:
+            pass
         return response
     finally:
         if not _stream_returned:
-            _ensure_end(pack, active_key)
+            _safe(_ensure_end, pack, active_key)
 
 
 async def intercept_responses_create_async(fn, *args, **kwargs):
-    """OpenAI Responses 비동기 호출을 인터셉트하여 모니터링 데이터를 수집한다."""
-    pack, ctx, features, stream = build_context(kwargs)
-    capture_client(pack, ctx, args)
-    active_key = (pack.model, pack.operation_type, getattr(pack, "prompt_version", "v1"))
+    """OpenAI Responses 비동기 호출을 인터셉트하여 모니터링 데이터를 수집한다.
+
+    계측 어느 단계가 실패해도 사용자 호출은 보호된다.
+    """
+    pack = active_key = None
+    try:
+        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)
+    except Exception:
+        if pack is not None and active_key is not None:
+            _safe(_ensure_end, pack, active_key)
+        return await fn(*args, **kwargs)
 
-    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, OpenAIError)
+            _safe(handle_error, pack, err, active_key, OpenAIError)
             raise
         finally:
-            if ctx:
-                ctx._llm_httpc_pending = False
+            _safe(_clear_httpc_pending, ctx)
 
-        after_call(pack, ctx)
-        if stream:
-            _stream_returned = True
-            return async_stream(response, ResponsesStream(pack, active_key))
-        finalize(response, pack, features)
-        finalize_non_streaming(pack, active_key)
+        try:
+            after_call(pack, ctx)
+            if stream:
+                result, _stream_returned = wrap_async_stream(response, ResponsesStream(pack, active_key))
+                return result
+            extract_response(response, finalize, pack, features)
+            finalize_non_streaming(pack, active_key)
+        except Exception:
+            pass
         return response
     finally:
         if not _stream_returned:
-            _ensure_end(pack, active_key)
+            _safe(_ensure_end, pack, active_key)

whatap/llm/providers/openai/responses/responses_extractor.py

@@ -92,15 +92,18 @@ class ResponsesStream(StreamAccumulator):
             item = getattr(event, 'item', None)
             it = getattr(item, 'type', '') if item else ''
             if it == 'function_call':
+                self.on_first_token()
                 self.output_features.add(LlmFeature.TOOL_USE)
                 call_id = getattr(item, 'call_id', '') or getattr(item, 'id', '')
                 if call_id and call_id not in self.tool_calls:
                     self.tool_calls[call_id] = {"id": call_id, "function": getattr(item, 'name', ''), "arguments": ""}
             elif 'web_search' in it:
+                self.on_first_token()
                 self.output_features.add(LlmFeature.WEBSEARCH)
         elif t == 'response.function_call_arguments.delta':
             call_id = getattr(event, 'call_id', '')
             if call_id in self.tool_calls:
+                self.on_first_token()
                 self.tool_calls[call_id]["arguments"] += getattr(event, 'delta', '') or ''
         elif t == 'response.function_call_arguments.done':
             call_id = getattr(event, 'call_id', '')

whatap/llm/providers/stream_accumulator.py

@@ -5,6 +5,7 @@ on_chunk()로 청크 데이터를 누적하고, _apply()로 pack에 반영한다
 """
 import time
 
+from whatap import logging
 from whatap.llm.providers.interceptor import _dispatch, _ensure_end
 
 
@@ -35,7 +36,11 @@ class StreamAccumulator(object):
             self.first_token_time = time.monotonic()
 
     def finalize(self):
-        """스트림 종료 시: latency/ttft 계산 → _apply() → 전송 → active 카운터 감소."""
+        """스트림 종료 시: latency/ttft 계산 → _apply() → 전송 → active 카운터 감소.
+
+        계측 실패(_apply/dispatch 예외)가 사용자 스트림으로 전파되면 안 되므로 흡수한다.
+        active 카운터 정리(_ensure_end)는 어떤 경우에도 보장한다.
+        """
         try:
             end_time = time.monotonic()
             self.pack.latency = round((end_time - self.pack._start_time) * 1000)
@@ -44,6 +49,8 @@ class StreamAccumulator(object):
             self._apply()
             self.pack.success = True
             _dispatch(self.pack)
+        except Exception as e:
+            logging.debug('[LLM] stream finalize skipped: %s' % e, extra={'id': 'LLM011'})
         finally:
             if self.active_key:
                 _ensure_end(self.pack, self.active_key)
@@ -54,20 +61,79 @@ class StreamAccumulator(object):
 
 
 def sync_stream(response, acc):
-    """동기 스트림 래퍼. 원본 응답을 그대로 yield하면서 청크를 누적한다."""
+    """동기 스트림 래퍼. 원본 응답을 그대로 yield하면서 청크를 누적한다.
+
+    청크 누적(on_chunk) 실패는 흡수한다 — 계측이 사용자 스트림을 깨면 안 된다.
+    """
     try:
         for chunk in response:
-            acc.on_chunk(chunk)
+            try:
+                acc.on_chunk(chunk)
+            except Exception as e:
+                logging.debug('[LLM] stream chunk skipped: %s' % e, extra={'id': 'LLM010'})
             yield chunk
     finally:
         acc.finalize()
 
 
 async def async_stream(response, acc):
-    """비동기 스트림 래퍼. 원본 응답을 그대로 yield하면서 청크를 누적한다."""
+    """비동기 스트림 래퍼. 원본 응답을 그대로 yield하면서 청크를 누적한다.
+
+    청크 누적(on_chunk) 실패는 흡수한다 — 계측이 사용자 스트림을 깨면 안 된다.
+    """
     try:
         async for chunk in response:
-            acc.on_chunk(chunk)
+            try:
+                acc.on_chunk(chunk)
+            except Exception as e:
+                logging.debug('[LLM] stream chunk skipped: %s' % e, extra={'id': 'LLM010'})
             yield chunk
     finally:
         acc.finalize()
+
+
+def _wrap_via_parse(response, acc, wrapper, iter_attr):
+    """with_raw_response 래퍼(LegacyAPIResponse)를 호환 처리한다.
+
+    litellm 은 스트리밍 시 ``client.chat.completions.with_raw_response.create(...)`` 로
+    헤더를 뽑은 뒤 ``raw_response.parse()`` 로 실제 스트림을 꺼낸다. 이 경로의 응답은
+    스트림 이터러블이 아니라 ``parse()`` 를 가진 래퍼이므로, 그대로 ``async_stream`` 으로
+    감싸면 litellm 의 ``raw_response.parse()`` 가 'async_generator has no attribute parse'
+    로 터진다. 여기서는 ``parse()`` 가 돌려줄 실제 스트림만 계측 래퍼로 감싸도록
+    ``parse`` 를 래핑하고 원본을 그대로 돌려준다.
+
+    반환: (호출자가 돌려줄 객체, 계측 소유 여부). 감쌀 수 없으면 (response, False).
+    """
+    parse = getattr(response, "parse", None)
+    if not callable(parse):
+        return response, False
+
+    state = {}
+
+    def instrumented_parse(*args, **kwargs):
+        real = parse(*args, **kwargs)
+        if hasattr(real, iter_attr):
+            if "g" not in state:
+                state["g"] = wrapper(real, acc)
+            return state["g"]
+        return real
+
+    try:
+        response.parse = instrumented_parse
+        return response, True
+    except Exception:
+        return response, False
+
+
+def wrap_sync_stream(response, acc):
+    """동기 스트리밍 응답을 계측 래퍼로 감싼다. 반환: (돌려줄 객체, 계측 소유 여부)."""
+    if hasattr(response, "__iter__"):
+        return sync_stream(response, acc), True
+    return _wrap_via_parse(response, acc, sync_stream, "__iter__")
+
+
+def wrap_async_stream(response, acc):
+    """비동기 스트리밍 응답을 계측 래퍼로 감싼다. 반환: (돌려줄 객체, 계측 소유 여부)."""
+    if hasattr(response, "__aiter__"):
+        return async_stream(response, acc), True
+    return _wrap_via_parse(response, acc, async_stream, "__aiter__")

{whatap_python-2.1.0.dist-info → whatap_python-2.1.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: whatap-python
-Version: 2.1.0
+Version: 2.1.1
 Summary: Monitoring and Profiling Service
 Home-page: https://www.whatap.io
 Author: whatap

{whatap_python-2.1.0.dist-info → whatap_python-2.1.1.dist-info}/RECORD

@@ -2,10 +2,10 @@ whatap/LICENSE,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 whatap/README.rst,sha256=M4dohffaOQQcSlo02OgWplEr9SlffyjV3v7w9vHf1RI,967
 whatap/__init__.py,sha256=tuUaSBg5PFasSmn3wUJASnPccQnSa0xOp0xq5BEdMLQ,32665
 whatap/__main__.py,sha256=9fgK-V2eh7rZQ0OKWjpYsWRCyhOx35zRK6XUvJXWuUo,64
-whatap/build.py,sha256=tD-Ae80QyXxkhtuyJZcLcSkZp_KnG4mTkFaw-ygyAW4,82
+whatap/build.py,sha256=hKoNW8VIOOedHEmBLuaSxYWeJmPPBnrPCTza2KD885U,82
 whatap/whatap.conf,sha256=E3UACbCDQ3-3XgDJWovbAtEN6LVLa7BQuCA0NXtX3CY,457
-whatap/agent/darwin/amd64/whatap_python,sha256=kym_h4e-8h1DIrQ13nkP1wur9jn_mAgTEylZJl-dM-Y,14038408
-whatap/agent/darwin/arm64/whatap_python,sha256=ZMvRHqgpC5aiaNnKlXG_MrK0e6eM2KDbBBeXlSnE2co,13435730
+whatap/agent/darwin/amd64/whatap_python,sha256=dLdQ2aVjuinboro4S8600b4sEA73RpFIHw72lvkSvRk,20802384
+whatap/agent/darwin/arm64/whatap_python,sha256=ar2scLqop8rVxB_ITdOrSIMlyTThQ6rF1V6pf1acqag,19784050
 whatap/agent/linux/amd64/whatap_python,sha256=kt0etbV-7uxNXD3mzrAeVhM2oxwim1N0OtbpkJJB2vg,18905944
 whatap/agent/linux/arm64/whatap_python,sha256=7V7bcI9mELhE1vRPmSQcBBCoRTp2VbBXIKeq-ixTrm4,18780673
 whatap/agent/windows/whatap_python.exe,sha256=ZmZIlcLD8yecsTOlqR6SBnLVQvlbtN70Wv0bb83j8f4,30576618
@@ -58,31 +58,31 @@ whatap/llm/log_sink_packs/llm_tool_calls.py,sha256=CIYbIsjUQWBr4qetAfLNAVjIFnv-l
 whatap/llm/log_sink_packs/llm_tool_results.py,sha256=bbg71I_p6ICVsoqMyIJJ-dpvuhjaeAe7Go3JHYPuxB0,465
 whatap/llm/log_sink_packs/llm_tx_status.py,sha256=m-bSncZO7hD0sa5L7_xRxM9izY9f5k_WOr3Z6JcfEDI,3863
 whatap/llm/providers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-whatap/llm/providers/interceptor.py,sha256=SyIWMQy-oaZqTJmlLGVod_dmmKy3ClFpvZKM3u3Plls,6771
-whatap/llm/providers/stream_accumulator.py,sha256=79P29Su3-j96D2LPsHu-F843Liitr68Ol3zWID9pq6I,2500
+whatap/llm/providers/interceptor.py,sha256=e_zel79upmedpRYF8p-EEIlpDv-6SMsD_PSBxsXKfyM,8952
+whatap/llm/providers/stream_accumulator.py,sha256=9AZ0yepp0q9y-p4QiWSRSpAW3jXI2tDoQtpfXo9AnWA,5353
 whatap/llm/providers/anthropic/__init__.py,sha256=OT75EbX5Wly5TrzQbwJsPXo1_wmDZTKm13LuLPwL90w,1595
 whatap/llm/providers/anthropic/messages/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-whatap/llm/providers/anthropic/messages/messages.py,sha256=KiI7KCM7-NFWaqkarin2raYlh9Xg7YICWiy-JAs1bbQ,2587
+whatap/llm/providers/anthropic/messages/messages.py,sha256=GSSko_KjoJGpNdjP3sH0yq8K0ESmYNZTTA9qpu17PPM,3336
 whatap/llm/providers/anthropic/messages/messages_context.py,sha256=Hbl66Hgea514ygMEYUwIs5JbFQfpmpGx3IP-FHWTDoY,2736
-whatap/llm/providers/anthropic/messages/messages_extractor.py,sha256=NcpUZqq7VWteXRBgUiUNIU9h7TRj37fsdObVCQWPxPI,5438
+whatap/llm/providers/anthropic/messages/messages_extractor.py,sha256=Iy5Zrl9D7OZJzND1CxSYiSoy2WWIQP3W2htBQa-fi-0,5587
 whatap/llm/providers/openai/__init__.py,sha256=XBU4X6FLhKVS-XhXiUfjXM-TZTJP-4Z155yyBlw-6fc,6408
 whatap/llm/providers/openai/content_parser.py,sha256=0b72UMfzVDnof66-cY6ELeCbqngUXsNhfO4BxRl9UAY,1484
 whatap/llm/providers/openai/chat/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-whatap/llm/providers/openai/chat/chat.py,sha256=4Z-D0EZm6Fojz4pNdz5p1X9Ja-XjsP_2kYMHNpPMReg,2949
+whatap/llm/providers/openai/chat/chat.py,sha256=0zws4O84wXN1bHjghdU7r4icB9HMn2RS4-PFWfjPh9w,3939
 whatap/llm/providers/openai/chat/chat_context.py,sha256=5hdZq_pYXwAaJtX28LaG5sNp002HXPzMlwgL0jhYy3Q,2947
-whatap/llm/providers/openai/chat/chat_extractor.py,sha256=YH9R5HXotoB-7liXB3l9LrU29VkRtyscs7qfUi2rCdY,5067
+whatap/llm/providers/openai/chat/chat_extractor.py,sha256=ubPoi6CKGvuNgkv40eVrzvLGIRMBFWUFu7nnpLb6T0g,5135
 whatap/llm/providers/openai/completions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-whatap/llm/providers/openai/completions/completions.py,sha256=YZYBZ1JVpZW3FZxl1Zq7WahorlMD3-V_shYUBA5Vn88,2420
+whatap/llm/providers/openai/completions/completions.py,sha256=N5DO40p8VbKlr71bRg3ptRxI5rV6K7NjKUNYQA88oGM,3247
 whatap/llm/providers/openai/completions/completions_context.py,sha256=cYA2F2gjZUaLsOgbjkFQcDkE_nJIDr5UgayvxyGFixk,917
 whatap/llm/providers/openai/completions/completions_extractor.py,sha256=uCW05rou1zwQPuTifOmv-987nW_WoXZ4WKoJTmeD4TE,1934
 whatap/llm/providers/openai/embeddings/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-whatap/llm/providers/openai/embeddings/embeddings.py,sha256=GfK66PKJ7cxr5dFhTPot37041trqOjV_k-8iTfhDlZ0,2050
+whatap/llm/providers/openai/embeddings/embeddings.py,sha256=8AJ2RlJYCOdbBuEuV2QVbAWbBqlZ2QLAXJEzruOv21U,2735
 whatap/llm/providers/openai/embeddings/embeddings_context.py,sha256=Knu3q9zI5Ph5rQUeALl-ZvaXRfvvbSoaOvCTAjdKb_g,793
 whatap/llm/providers/openai/embeddings/embeddings_extractor.py,sha256=Qzjt4SHmuLfSGECr8nt6hVj8R-SkeQfqkXY_xUz_VSg,983
 whatap/llm/providers/openai/responses/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-whatap/llm/providers/openai/responses/responses.py,sha256=AkGdtD9ZLG-Gv8H4BL7xSIoSImc31bLZd-5TGS4dIUc,2585
+whatap/llm/providers/openai/responses/responses.py,sha256=GKdwOuRpjT5ePxfMwgLL32odJdJ8UWSX6vusM_JL4m8,3452
 whatap/llm/providers/openai/responses/responses_context.py,sha256=8ZzqEbG4LFi8nhHggMkx7xoL3HNV8_HVShyqD7BSnmc,3308
-whatap/llm/providers/openai/responses/responses_extractor.py,sha256=sIU6g6DcYtfECouGmffVvQbynT8ef_qI3L-d_wcXvME,5386
+whatap/llm/providers/openai/responses/responses_extractor.py,sha256=HinUvPiQplM_lRUiR694a5DJOmCA8RlPJztdvaayQ6k,5500
 whatap/llm/stats/__init__.py,sha256=uR_KiY5K_dwRyHX1u1961TY0hy94LJE0_hmueVgRfgo,1352
 whatap/llm/stats/active_stat.py,sha256=lPyfy_pBq1CM8ABXHU7bMmTXKu2CxXIAOhScfqOKC9s,2917
 whatap/llm/stats/answer_relevance_eval_stat.py,sha256=rel9_fdH5_90qQ4AZy01Qv8plorQsWmB-4A3XwJ3oFw,353
@@ -220,8 +220,8 @@ whatap/value/text_hash_value.py,sha256=WPsSWzkR17plw3sgGjhJK0heCQiy0XdDYhawvBvQl
 whatap/value/text_value.py,sha256=8CWF57POGgosr5zEnGc0BdY0pYF0Vh8EsifHaRgfEwU,1148
 whatap/value/value.py,sha256=puRYlGm7q0iX3TKOqe_e0NdgK9Zj2J1t7NzqaQ8g7bU,578
 whatap/value/value_enum.py,sha256=AoUU4HUWC1bPan8k8CRBE9ayl0rGvJJHdRCTsamkWxE,2577
-whatap_python-2.1.0.dist-info/METADATA,sha256=F5gjn7Ri6gu6Tf5nwZNyA9aMq2ontZHPiiOn95KhsvM,2244
-whatap_python-2.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
-whatap_python-2.1.0.dist-info/entry_points.txt,sha256=lAwpO3oqmPt5riREZO759dHWoM8dqv-vMpDWwDcMiJY,280
-whatap_python-2.1.0.dist-info/top_level.txt,sha256=8bRV-cNhEi4cSEIRQm5zDLRqkH1ki9YVrcfLIUVs5jg,7
-whatap_python-2.1.0.dist-info/RECORD,,
+whatap_python-2.1.1.dist-info/METADATA,sha256=0arI4JATShXzF1jtoYJ6-5xybdFQ1PqZAErvzxlu_yA,2244
+whatap_python-2.1.1.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+whatap_python-2.1.1.dist-info/entry_points.txt,sha256=lAwpO3oqmPt5riREZO759dHWoM8dqv-vMpDWwDcMiJY,280
+whatap_python-2.1.1.dist-info/top_level.txt,sha256=8bRV-cNhEi4cSEIRQm5zDLRqkH1ki9YVrcfLIUVs5jg,7
+whatap_python-2.1.1.dist-info/RECORD,,