whatap-python 2.1.0__py3-none-any.whl

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

@@ -0,0 +1,127 @@
+"""OpenAI Chat Completions 응답에서 토큰 사용량 및 완성 텍스트를 추출하는 모듈."""
+import json
+
+from whatap.llm.features import LlmFeature
+from whatap.llm.providers.stream_accumulator import StreamAccumulator
+
+
+def extract_usage(usage):
+    """usage 객체에서 토큰 사용량 상세 정보를 딕셔너리로 추출한다."""
+    input_t = getattr(usage, "prompt_tokens", 0) or 0
+    output_t = getattr(usage, "completion_tokens", 0) or 0
+    prompt_d = getattr(usage, "prompt_tokens_details", None)
+    comp_d = getattr(usage, "completion_tokens_details", None)
+    return {
+        "input_tokens": input_t,
+        "output_tokens": output_t,
+        "total_tokens_count": input_t + output_t,
+        "cached_tokens": getattr(prompt_d, "cached_tokens", 0) or 0,
+        "audio_input_tokens": getattr(prompt_d, "audio_tokens", 0) or 0,
+        "reasoning_tokens": getattr(comp_d, "reasoning_tokens", 0) or 0,
+        "audio_output_tokens": getattr(comp_d, "audio_tokens", 0) or 0,
+        "accepted_prediction_tokens": getattr(comp_d, "accepted_prediction_tokens", 0) or 0,
+        "rejected_prediction_tokens": getattr(comp_d, "rejected_prediction_tokens", 0) or 0,
+    }
+
+
+def finalize(response, pack, features):
+    """비스트리밍 Chat 응답에서 완성 텍스트, 토큰, 도구 호출 정보를 팩에 기록한다."""
+    texts, reasonings = [], []
+    for choice in response.choices:
+        if not pack.finish_reason:
+            pack.finish_reason = getattr(choice, 'finish_reason', None)
+        texts.append(choice.message.content or "")
+        reasonings.append(
+            getattr(choice.message, "reasoning_content", "") or
+            getattr(choice.message, "reasoning", "") or "")
+        tc = getattr(choice.message, "tool_calls", None)
+        if tc and LlmFeature.TOOL_USE not in features:
+            features.append(LlmFeature.TOOL_USE)
+            try:
+                pack.tool_calls_text = json.dumps([t.model_dump() for t in tc], ensure_ascii=False)
+            except Exception:
+                pack.tool_calls_text = str(tc)
+
+    reasoning = "".join(reasonings)
+    if reasoning and LlmFeature.REASONING not in features:
+        features.append(LlmFeature.REASONING)
+
+    pack.features = ",".join(features)
+    pack.set_tokens(extract_usage(getattr(response, "usage", None)))
+    pack.completion_text = "".join(texts)
+    if reasoning:
+        pack.reasoning_text = reasoning
+
+
+class ChatStream(StreamAccumulator):
+    """OpenAI Chat 스트리밍 응답 청크를 누적하는 어큐뮬레이터."""
+
+    def __init__(self, pack, active_key):
+        super().__init__(pack, active_key)
+        self.text = ""
+        self.reasoning = ""
+        self.usage = {}
+        self.tool_chunks = {}
+        self.has_tool = False
+        self.finish_reason = None
+
+    def on_chunk(self, chunk):
+        usage = getattr(chunk, "usage", None)
+        if usage:
+            self.usage = extract_usage(usage)
+
+        choices = getattr(chunk, 'choices', None)
+        if not choices:
+            return
+
+        finish_reason = getattr(choices[0], 'finish_reason', None)
+        if finish_reason:
+            self.finish_reason = finish_reason
+
+        delta = choices[0].delta
+
+        content = getattr(delta, "content", None) or ""
+        if content:
+            self.on_first_token()
+            self.text += content
+
+        reasoning = (
+            getattr(delta, "reasoning_content", None) or
+            getattr(delta, "reasoning", None) or "")
+        if reasoning:
+            self.reasoning += reasoning
+
+        if getattr(delta, "tool_calls", None):
+            self.has_tool = True
+            for tc in delta.tool_calls:
+                idx = tc.index
+                if idx not in self.tool_chunks:
+                    self.tool_chunks[idx] = {"id": "", "function": "", "arguments": ""}
+                if tc.id:
+                    self.tool_chunks[idx]["id"] = tc.id
+                fn = getattr(tc, "function", None)
+                if fn:
+                    if fn.name:
+                        self.tool_chunks[idx]["function"] = fn.name
+                    if fn.arguments:
+                        self.tool_chunks[idx]["arguments"] += fn.arguments
+
+    def _apply(self):
+        pack = self.pack
+        pack.finish_reason = self.finish_reason
+        if self.has_tool:
+            parts = [f for f in pack.features.split(",") if f]
+            if LlmFeature.TOOL_USE not in parts:
+                parts.append(LlmFeature.TOOL_USE)
+            pack.features = ",".join(parts)
+        if self.reasoning:
+            parts = [f for f in pack.features.split(",") if f]
+            if LlmFeature.REASONING not in parts:
+                parts.append(LlmFeature.REASONING)
+            pack.features = ",".join(parts)
+        if self.tool_chunks:
+            pack.tool_calls_text = json.dumps(list(self.tool_chunks.values()), ensure_ascii=False)
+        pack.set_tokens(self.usage)
+        pack.completion_text = self.text
+        if self.reasoning:
+            pack.reasoning_text = self.reasoning

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

@@ -0,0 +1,70 @@
+"""OpenAI Completions API 인터셉트 진입점."""
+from openai import OpenAIError
+
+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.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"))
+
+    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)
+            raise
+        finally:
+            if ctx:
+                ctx._llm_httpc_pending = False
+
+        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)
+        return response
+    finally:
+        if not _stream_returned:
+            _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"))
+
+    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)
+            raise
+        finally:
+            if ctx:
+                ctx._llm_httpc_pending = False
+
+        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)
+        return response
+    finally:
+        if not _stream_returned:
+            _ensure_end(pack, active_key)

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

@@ -0,0 +1,31 @@
+"""OpenAI Completions API 요청 파싱."""
+import json
+
+from whatap.trace.trace_context_manager import TraceContextManager
+from whatap.llm.log_sink_packs.llm_step_status import LlmStepStatus
+
+
+def build_context(kwargs):
+    """Completions kwargs에서 LlmStepStatus 팩을 생성한다."""
+    model = kwargs.get("model")
+    stream = kwargs.get("stream", False)
+    prompt = kwargs.get("prompt", "")
+
+    if isinstance(prompt, list):
+        prompt_text = json.dumps(prompt, ensure_ascii=False)
+    else:
+        prompt_text = str(prompt) if prompt else ""
+
+    pack = LlmStepStatus()
+    pack.model = model
+    pack.prompt_text = prompt_text
+    pack.stream = stream
+    if kwargs.get("temperature") is not None:
+        pack.temperature = kwargs["temperature"]
+
+    ctx = TraceContextManager.getLocalContext()
+    if ctx:
+        ctx._llm_httpc_pending = True
+        ctx._llm_model = model
+
+    return pack, ctx

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

@@ -0,0 +1,61 @@
+"""OpenAI Completions API 응답 추출."""
+from whatap.llm.providers.stream_accumulator import StreamAccumulator
+
+
+def extract_usage(usage):
+    """usage 객체에서 토큰 사용량을 추출한다."""
+    if not usage:
+        return {}
+    input_t = getattr(usage, "prompt_tokens", 0) or 0
+    output_t = getattr(usage, "completion_tokens", 0) or 0
+    return {
+        "input_tokens": input_t,
+        "output_tokens": output_t,
+        "total_tokens_count": input_t + output_t,
+    }
+
+
+def finalize(response, pack):
+    """비스트리밍 Completions 응답에서 텍스트와 토큰을 팩에 기록한다."""
+    texts = []
+    for choice in response.choices:
+        if not pack.finish_reason:
+            pack.finish_reason = getattr(choice, 'finish_reason', None)
+        texts.append(getattr(choice, 'text', '') or '')
+
+    pack.set_tokens(extract_usage(getattr(response, "usage", None)))
+    pack.completion_text = "".join(texts)
+
+
+class CompletionsStream(StreamAccumulator):
+    """OpenAI Completions 스트리밍 응답 청크를 누적하는 어큐뮬레이터."""
+
+    def __init__(self, pack, active_key):
+        super().__init__(pack, active_key)
+        self.text = ""
+        self.usage = {}
+        self.finish_reason = None
+
+    def on_chunk(self, chunk):
+        usage = getattr(chunk, "usage", None)
+        if usage:
+            self.usage = extract_usage(usage)
+
+        choices = getattr(chunk, 'choices', None)
+        if not choices:
+            return
+
+        finish_reason = getattr(choices[0], 'finish_reason', None)
+        if finish_reason:
+            self.finish_reason = finish_reason
+
+        text = getattr(choices[0], 'text', '') or ''
+        if text:
+            self.on_first_token()
+            self.text += text
+
+    def _apply(self):
+        pack = self.pack
+        pack.finish_reason = self.finish_reason
+        pack.set_tokens(self.usage)
+        pack.completion_text = self.text

whatap/llm/providers/openai/content_parser.py

@@ -0,0 +1,41 @@
+"""OpenAI 컨텐츠 블록 파싱.
+
+OpenAI API의 content 필드는 문자열 또는 블록 리스트(text, image_url 등)로 올 수 있다.
+이 모듈은 다양한 content 형태를 텍스트로 변환한다.
+"""
+
+
+def _block_to_dict(block):
+    """Pydantic 모델 등 비dict 블록을 dict로 변환."""
+    if isinstance(block, dict):
+        return block
+    if hasattr(block, 'model_dump'):
+        try:
+            return block.model_dump()
+        except Exception:
+            pass
+    if hasattr(block, '__dict__'):
+        return dict(vars(block))
+    return {"type": str(getattr(block, 'type', ''))}
+
+
+def extract_content_text(content):
+    """content를 텍스트로 변환. 이미지/오디오 블록은 [IMAGE], [AUDIO]로 치환."""
+    if isinstance(content, str):
+        return content
+    if isinstance(content, list):
+        parts = []
+        for block in content:
+            if not isinstance(block, dict):
+                block = _block_to_dict(block)
+            block_type = block.get("type", "")
+            if block_type in ("text", "input_text"):
+                parts.append(block.get("text", ""))
+            elif block_type in ("image_url", "input_image"):
+                parts.append("[IMAGE]")
+            elif block_type == "input_audio":
+                parts.append("[AUDIO]")
+            elif block_type:
+                parts.append("[{}]".format(block_type.upper()))
+        return "".join(parts)
+    return str(content) if content else ""

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

@@ -0,0 +1,59 @@
+"""OpenAI Embeddings API 호출을 인터셉트하는 모듈."""
+from openai import OpenAIError
+
+from whatap.llm.providers.interceptor import (
+    before_call, handle_error, after_call, finalize_non_streaming, _ensure_end,
+    capture_client,
+)
+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"))
+
+    before_call(pack, active_key)
+    try:
+        try:
+            response = fn(*args, **kwargs)
+        except Exception as err:
+            handle_error(pack, err, active_key, OpenAIError)
+            raise
+        finally:
+            if ctx:
+                ctx._llm_httpc_pending = False
+
+        after_call(pack, ctx)
+        finalize(response, pack, kwargs)
+        finalize_non_streaming(pack, active_key)
+        return response
+    finally:
+        _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"))
+
+    before_call(pack, active_key)
+    try:
+        try:
+            response = await fn(*args, **kwargs)
+        except Exception as err:
+            handle_error(pack, err, active_key, OpenAIError)
+            raise
+        finally:
+            if ctx:
+                ctx._llm_httpc_pending = False
+
+        after_call(pack, ctx)
+        finalize(response, pack, kwargs)
+        finalize_non_streaming(pack, active_key)
+        return response
+    finally:
+        _ensure_end(pack, active_key)

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

@@ -0,0 +1,25 @@
+"""OpenAI Embeddings API 요청에서 컨텍스트를 구성하는 모듈."""
+import json
+
+from whatap.trace.trace_context_manager import TraceContextManager
+from whatap.llm.log_sink_packs.llm_step_status import LlmStepStatus
+
+
+def build_context(kwargs):
+    """Embeddings kwargs로부터 LlmStepStatus 팩과 트레이스 컨텍스트를 구성한다."""
+    input_data = kwargs.get("input", "")
+    model = kwargs.get("model")
+
+    inputs = input_data if isinstance(input_data, list) else [input_data]
+
+    pack = LlmStepStatus()
+    pack.model = model
+    pack.prompt_text = json.dumps(inputs, ensure_ascii=False)
+    pack.stream = False
+
+    ctx = TraceContextManager.getLocalContext()
+    if ctx:
+        ctx._llm_httpc_pending = True
+        ctx._llm_model = model
+
+    return pack, ctx

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

@@ -0,0 +1,26 @@
+"""OpenAI Embeddings 응답에서 토큰 사용량과 임베딩 정보를 추출하는 모듈."""
+from whatap import logging
+
+
+def finalize(response, pack, kwargs):
+    """Embeddings 응답에서 토큰 수, 임베딩 개수, 차원 수를 팩에 기록한다."""
+    usage = getattr(response, "usage", None)
+    input_tokens = getattr(usage, "prompt_tokens", 0) or 0
+
+    embedding_count = 0
+    dimensions = 0
+    try:
+        data = getattr(response, "data", [])
+        embedding_count = len(data)
+        if data and kwargs.get("encoding_format") != "base64":
+            dimensions = len(data[0].embedding)
+    except Exception as e:
+        logging.warning('[LLM] embeddings data extraction failed: %s' % e, extra={'id': 'LLM010'})
+
+    pack.set_tokens({
+        "input_tokens": input_tokens,
+        "output_tokens": 0,
+        "total_tokens_count": getattr(usage, "total_tokens", 0) or 0,
+        "embedding_count": embedding_count,
+        "dimensions": dimensions,
+    })

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

@@ -0,0 +1,70 @@
+"""OpenAI Responses API 호출을 인터셉트하는 모듈."""
+from openai import OpenAIError
+
+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.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"))
+
+    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)
+            raise
+        finally:
+            if ctx:
+                ctx._llm_httpc_pending = False
+
+        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)
+        return response
+    finally:
+        if not _stream_returned:
+            _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"))
+
+    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)
+            raise
+        finally:
+            if ctx:
+                ctx._llm_httpc_pending = False
+
+        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)
+        return response
+    finally:
+        if not _stream_returned:
+            _ensure_end(pack, active_key)

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

@@ -0,0 +1,88 @@
+"""OpenAI Responses API 요청에서 컨텍스트를 구성하는 모듈."""
+import json
+
+from whatap import logging
+from whatap.llm.features import LlmFeature
+from whatap.llm.log_sink_packs.llm_step_status import LlmStepStatus
+from whatap.llm.providers.openai.content_parser import extract_content_text, _block_to_dict
+from whatap.trace.trace_context_manager import TraceContextManager
+
+
+def _msg_to_dict(msg):
+    """메시지 객체를 딕셔너리로 변환한다."""
+    if isinstance(msg, dict):
+        return msg
+    if hasattr(msg, 'model_dump'):
+        try:
+            return msg.model_dump()
+        except Exception as e:
+            logging.warning('[LLM] _msg_to_dict model_dump failed: %s' % e, extra={'id': 'LLM014'})
+    if hasattr(msg, '__dict__'):
+        return dict(vars(msg))
+    return {"type": str(getattr(msg, 'type', 'unknown'))}
+
+
+def build_context(kwargs):
+    """Responses kwargs로부터 LlmStepStatus 팩과 트레이스 컨텍스트를 구성한다."""
+    input_data = kwargs.get("input", "")
+    model = kwargs.get("model")
+    stream = kwargs.get("stream", False)
+    instructions = kwargs.get("instructions")
+
+    system_parts = [instructions] if instructions else []
+    has_vision = False
+    tool_results = []
+
+    if isinstance(input_data, str):
+        prompt_text = input_data
+    elif isinstance(input_data, list):
+        prompt_msgs = []
+        for raw_msg in input_data:
+            msg = _msg_to_dict(raw_msg)
+            role = msg.get("role", "user")
+            content = msg.get("content")
+            if role == "system":
+                system_parts.append(content or "")
+            else:
+                sanitized = dict(msg)
+                if isinstance(content, list):
+                    if not has_vision:
+                        for block in content:
+                            if _block_to_dict(block).get("type") == "input_image":
+                                has_vision = True
+                                break
+                    sanitized["content"] = extract_content_text(content)
+                prompt_msgs.append(sanitized)
+                if msg.get("type") == "function_call_output":
+                    tool_results.append({"call_id": msg.get("call_id", ""), "output": msg.get("output", "")})
+        try:
+            prompt_text = json.dumps(prompt_msgs, ensure_ascii=False) if prompt_msgs else ""
+        except Exception as e:
+            logging.warning('[LLM] responses prompt serialization failed: %s' % e, extra={'id': 'LLM005'})
+            prompt_text = ""
+    else:
+        prompt_text = str(input_data)
+
+    features = []
+    if kwargs.get("reasoning"):
+        features.append(LlmFeature.REASONING)
+    if has_vision:
+        features.append(LlmFeature.VISION)
+
+    pack = LlmStepStatus()
+    pack.model = model
+    pack.prompt_text = prompt_text
+    pack.system_texts = system_parts
+    pack.stream = stream
+    pack.features = ",".join(features)
+    if kwargs.get("temperature") is not None:
+        pack.temperature = kwargs["temperature"]
+    if tool_results:
+        pack.tool_results_text = json.dumps(tool_results, ensure_ascii=False)
+
+    ctx = TraceContextManager.getLocalContext()
+    if ctx:
+        ctx._llm_httpc_pending = True
+        ctx._llm_model = model
+
+    return pack, ctx, features, stream