whatap-python 2.0.0rc1__tar.gz → 2.0.2__tar.gz

{whatap_python-2.0.0rc1 → whatap_python-2.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: whatap-python
-Version: 2.0.0rc1
+Version: 2.0.2
 Summary: Monitoring and Profiling Service
 Home-page: https://www.whatap.io
 Author: whatap
@@ -22,12 +22,16 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Requires-Python: >=3.7
 Requires-Dist: psutil>=5.0.0; platform_system == "Windows"
+Provides-Extra: llm
+Requires-Dist: datasketches>=5.2.0; extra == "llm"
+Requires-Dist: genai-prices; extra == "llm"
 Dynamic: author
 Dynamic: author-email
 Dynamic: classifier
 Dynamic: description
 Dynamic: home-page
 Dynamic: license
+Dynamic: provides-extra
 Dynamic: requires-dist
 Dynamic: requires-python
 Dynamic: summary

{whatap_python-2.0.0rc1 → whatap_python-2.0.2}/setup.py

@@ -35,6 +35,12 @@ setup(name=build.name,
       install_requires=[
           'psutil>=5.0.0; platform_system=="Windows"',  # Required for Windows compatibility (memory/process monitoring)
       ],
+      extras_require={
+          'llm': [
+              'datasketches>=5.2.0',
+              'genai-prices',
+          ],
+      },
       classifiers=[
           'Development Status :: 4 - Beta',
           'Intended Audience :: Developers',

{whatap_python-2.0.0rc1 → whatap_python-2.0.2}/whatap/__init__.py

@@ -59,7 +59,7 @@ def preview_whatap_conf(option_name:str):
     - standalone_enabled (False)
     - counter_thread_enabled (False)
     """
-    value = 'false'
+    value = None
     try:
         with open(whatap_config) as f:
             for raw in f:
@@ -71,15 +71,22 @@ def preview_whatap_conf(option_name:str):
                     if len(parts) == 2:
                         value = parts[1].strip()
                     break
-        return value
 
     except FileNotFoundError:
-        return value
+        pass
 
     except Exception as e:
         print(f'WHATAP: config parse error ({e!r})')
+
+    if value is not None:
         return value
 
+    env_value = os.environ.get(option_name)
+    if env_value is not None:
+        return env_value
+
+    return 'false'
+
 
 
 ignore_whatap_stdout = preview_whatap_conf("ignore_whatap_stdout")
@@ -298,15 +305,15 @@ def hooks(home):
     try:
         for key, value_list in DEFINITION.items():
             for value in value_list:
-                if len(value) == 3 and not value[2]:
+                if len(value) >= 3 and isinstance(value[2], str):
+                    module_path = value[2]
+                elif len(value) == 3 and not value[2]:
                     continue
-                
+                else:
+                    module_path = '{0}.{1}.{2}.{3}'.format(
+                        'whatap', 'trace', 'mod', key)
                 IMPORT_HOOKS[value[0]] = {'def': value[1],
-                                          'module': '{0}.{1}.{2}.{3}'.format(
-                                              'whatap',
-                                              'trace',
-                                              'mod',
-                                              key)}
+                                          'module': module_path}
     except Exception as e:
         logging.debug(e, extra={'id': 'MODULE ERROR'})
     finally:
@@ -418,15 +425,6 @@ def go(batch=False, opts={}, llm=False):
     if llm:
         home = 'WHATAP_HOME'
         file_name = AGENT_NAME + '.pid.llm'
-        # LLM Go Agent용 별도 UDP 포트
-        from whatap.conf.configure import Configure as conf
-        llm_port = int(getattr(conf, 'llm_net_udp_port', 0))
-        if not llm_port:
-            llm_port = int(conf.net_udp_port) + 100
-        conf.llm_net_udp_port = llm_port
-        newenv['WHATAP_NET_UDP_PORT'] = str(llm_port)
-        # whatap.conf에 기록하여 Go Agent가 읽을 수 있도록 함
-        update_config(home, 'llm_net_udp_port', str(llm_port))
     elif not batch:
         home = 'WHATAP_HOME'
         file_name = AGENT_NAME + '.pid'
@@ -537,12 +535,47 @@ def go(batch=False, opts={}, llm=False):
         label = 'LLM golang module' if llm else 'golang module'
 
         if sys.platform == 'win32':
-            DETACHED_PROCESS = 0x00000008
+            # SESSIONNAME 환경변수는 NSSM이 부모 세션에서 상속받아 부정확함
+            # ProcessIdToSessionId로 실제 프로세스 세션 ID 확인
+            try:
+                import ctypes
+                _sid = ctypes.c_ulong(0)
+                ctypes.windll.kernel32.ProcessIdToSessionId(
+                    ctypes.windll.kernel32.GetCurrentProcessId(),
+                    ctypes.byref(_sid)
+                )
+                is_session0 = (_sid.value == 0)
+            except Exception:
+                is_session0 = not os.environ.get('SESSIONNAME')
+
             cmd_args.append('foreground')
-            process = subprocess.Popen(cmd_args,
-                                       cwd=home_path, env=newenv,
-                                       creationflags=DETACHED_PROCESS,
-                                       stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+
+            if is_session0:
+                # Session 0에서만 WHATAP_FOREGROUND=1 추가 주입.
+                # IsAnInteractiveSession()이 false로 떨어지는 경로에서
+                # foreground CLI 인자를 보강하는 안전망.
+                newenv['WHATAP_FOREGROUND'] = '1'
+
+                # Session 0에서는 PIPE를 읽지 않으면 버퍼 고갈로 Go 프로세스가 블로킹됨
+                # 로그 파일로 리디렉션
+                # CREATE_NO_WINDOW: Session 0 서비스 컨텍스트에 적합한 플래그
+                CREATE_NO_WINDOW = 0x08000000
+                log_dir = os.path.join(home_path, 'logs')
+                go_log_path = os.path.join(log_dir, AGENT_NAME + '.log')
+                try:
+                    go_out = open(go_log_path, 'ab')
+                except Exception:
+                    go_out = subprocess.DEVNULL
+                process = subprocess.Popen(cmd_args,
+                                           cwd=home_path, env=newenv,
+                                           creationflags=CREATE_NO_WINDOW,
+                                           stdout=go_out, stderr=go_out)
+            else:
+                DETACHED_PROCESS = 0x00000008
+                process = subprocess.Popen(cmd_args,
+                                           cwd=home_path, env=newenv,
+                                           creationflags=DETACHED_PROCESS,
+                                           stdout=subprocess.PIPE, stderr=subprocess.PIPE)
         else:
             process = subprocess.Popen(cmd_args,
                                        cwd=home_path, env=newenv,
@@ -551,8 +584,11 @@ def go(batch=False, opts={}, llm=False):
 
         time.sleep(0.5)
         if process.poll() is not None:
-            stdouts, errs = process.communicate()
-            whatap_print("executed {} ".format(label), str(stdouts,"utf8"), str(errs, "utf8"))
+            if sys.platform == 'win32' and is_session0:
+                whatap_print("executed {} (exit code: {}, log: {})".format(label, process.returncode, go_log_path))
+            else:
+                stdouts, errs = process.communicate()
+                whatap_print("executed {} ".format(label), str(stdouts,"utf8"), str(errs, "utf8"))
         else:
             write_file(home, file_name, str(process.pid))
             whatap_print("executed {} in background (PID: {})".format(label, process.pid))
@@ -690,8 +726,10 @@ except ImportError:
 if sys.platform == 'win32':
     import tempfile
     default_lock_file = os.path.join(tempfile.gettempdir(), 'whatap-python.lock')
+    default_llm_lock_file = os.path.join(tempfile.gettempdir(), 'whatap-python-llm.lock')
 else:
     default_lock_file = '/tmp/whatap-python.lock'
+    default_llm_lock_file = '/tmp/whatap-python-llm.lock'
 
 def openPortFile(filepath=os.environ.get('WHATAP_LOCK_FILE', default_lock_file)):
     f = None
@@ -732,12 +770,12 @@ def openPortFile(filepath=os.environ.get('WHATAP_LOCK_FILE', default_lock_file))
                 whatap_print('WHATAP: file close failed: %s' % e)
     return None
 
-def get_port_number(port=6600, home=os.environ.get('WHATAP_HOME')):
+def get_port_number(port=6600, home=os.environ.get('WHATAP_HOME'), lock_file=None):
     if not home:
         return None
 
     for i in range(100):
-        f = openPortFile()
+        f = openPortFile(filepath=lock_file) if lock_file else openPortFile()
         if not f:
             if i > 50:
                 time.sleep(0.1)
@@ -798,6 +836,24 @@ def configPort():
             return port
 
 
+def configLlmPort():
+    # force_llm_net_udp_port가 설정된 경우 lock 파일 무시하고 해당 포트 강제 사용
+    force_port_str = preview_whatap_conf("force_llm_net_udp_port")
+    if force_port_str and force_port_str not in ('false', 'False'):
+        try:
+            port = int(force_port_str)
+        except ValueError:
+            whatap_print('WHATAP: force_llm_net_udp_port value is invalid: {}'.format(force_port_str))
+            port = None
+    else:
+        llm_lock_file = os.environ.get('WHATAP_LLM_LOCK_FILE', default_llm_lock_file)
+        port = get_port_number(port=6700, home=os.environ.get('WHATAP_HOME'), lock_file=llm_lock_file)
+
+    if port:
+        update_config('WHATAP_HOME', 'llm_net_udp_port', str(port))
+        return port
+
+
 def find_whatap_conf():
     # 1. 현재 디렉토리 검색
     script_dir = os.path.dirname(os.path.abspath(__file__))

whatap_python-2.0.2/whatap/build.py

@@ -0,0 +1,4 @@
+app = 'Python'
+name = 'whatap-python'
+version = '2.0.2'
+release_date = '20260428'

{whatap_python-2.0.0rc1 → whatap_python-2.0.2}/whatap/conf/configuration.py

@@ -19,7 +19,6 @@ Configuration = {
     "trace_ignore_url_prefix": None,
     "trace_websocket_enabled": False,
 
-    "trace_llm_log_enabled": False,
     "llm_api_hosts": "",
 
     "debug": False,
@@ -222,9 +221,8 @@ Configuration = {
     "open_file_descriptor_enabled": False,
     "open_file_descriptor_interval":60,
     "counter_thread_enabled": False,
-    "llm_net_udp_port": 0,
-    "llm_token_usage_stat_enabled" : False,
-    "llm_token_usage_stat_interval" : 5,
+    "llm_net_udp_port": 6700,
+    "force_llm_net_udp_port": False,
     "llm_model_pricing": "",
     "llm_perf_sketch_enabled": True,
     "llm_perf_sketch_k": 200

{whatap_python-2.0.0rc1 → whatap_python-2.0.2}/whatap/counter/__init__.py

@@ -6,4 +6,9 @@ counter_thread_enabled = preview_whatap_conf("counter_thread_enabled")
 if counter_thread_enabled != 'false':
     mgr = CounterMgr()
     mgr.setDaemon(True)
-    mgr.start()
+    mgr.start()
+
+    from .tasks.llm_stat_task import LlmStatTask
+    llm_stat = LlmStatTask()
+    llm_stat.setDaemon(True)
+    llm_stat.start()

whatap_python-2.0.2/whatap/counter/tasks/__init__.py

@@ -0,0 +1,3 @@
+from whatap.counter.tasks.openfiledescriptor import OpenFileDescriptorTask
+
+TASK_CLASSES = [OpenFileDescriptorTask]

whatap_python-2.0.2/whatap/counter/tasks/llm_log_sink_task.py

@@ -0,0 +1,244 @@
+import queue
+import threading
+
+from whatap import DateUtil
+from whatap import logging
+from whatap.pack import logSinkPack
+from whatap.conf.configure import Configure as conf
+from whatap.trace.trace_context_manager import TraceContextManager
+
+import whatap.io as whatapio
+import whatap.net.async_sender as async_sender
+
+from whatap.llm.log_sink_packs.llm_log_sink_pack import LlmLogSinkPack
+from whatap.llm.log_sink_packs.llm_step_status import LlmStepStatus
+from whatap.llm.log_sink_packs.llm_system_message import LlmSystemMessage
+from whatap.llm.log_sink_packs.llm_input_message import LlmInputMessage
+from whatap.llm.log_sink_packs.llm_output_message import LlmOutputMessage
+from whatap.llm.log_sink_packs.llm_tool_calls import LlmToolCalls
+from whatap.llm.log_sink_packs.llm_tool_results import LlmToolResults
+from whatap.llm.log_sink_packs.llm_tx_status import LlmTxStatus
+
+_MAX_CONTENT_BYTES = 20000
+
+
+class LlmLogSinkTask(object):
+    _instance = None
+    _lock = threading.Lock()
+
+    def __init__(self):
+        self._q = queue.Queue(4096)
+        self._started = False
+
+    @classmethod
+    def get_instance(cls):
+        if cls._instance is None:
+            with cls._lock:
+                if cls._instance is None:
+                    cls._instance = cls()
+        return cls._instance
+
+    def dispatch(self, pack):
+        if not isinstance(pack, LlmStepStatus):
+            return
+
+        ctx = getattr(pack, '_trace_ctx', None) or TraceContextManager.getLocalContext()
+        pack.set_context(ctx)
+
+        if not pack.operation_type and ctx:
+            pack.operation_type = getattr(ctx, '_llm_operation_type', '') or 'unknown'
+
+        try:
+            pack.calculate_cost()
+        except Exception as e:
+            logging.warning('[LLM] calculate_cost failed: model=%s, input_tokens=%s, output_tokens=%s, cached_tokens=%s, error=%s'
+                            % (pack.model, pack.input_tokens, pack.output_tokens, pack.cached_tokens, e),
+                            extra={'id': 'LLM024'})
+
+        self._accumulate_tx_summary(ctx, pack)
+
+        if ctx and not pack.success and pack.error_type:
+            ctx._llm_last_error_type = pack.error_type
+            ctx._llm_last_error_model = pack.model or 'unknown'
+            ctx._llm_last_error_provider = pack.provider or ''
+            ctx._llm_last_error_op_type = pack.operation_type or 'unknown'
+            ctx._llm_last_error_url = pack.url or ''
+
+        self._ensure_started()
+        if self._q.full():
+            logging.warning('[LLM] send queue full, pack dropped: model=%s' % pack.model,
+                            extra={'id': 'LLM025'})
+            return
+        self._q.put(pack)
+
+    def send_tx_status(self, ctx):
+        if not ctx:
+            return
+        if not getattr(conf, 'llm_enabled', False):
+            return
+        tx = getattr(ctx, '_llm_tx_status', None)
+        if not tx or tx.call_count == 0:
+            return
+
+        try:
+            self._send_log_sink(tx)
+            # 트랜잭션 경계에서 LLM 버퍼에 남아있는 데이터 flush (큐를 거쳐 순서 보장)
+            async_sender.flush_llm_relaypack()
+        except Exception as e:
+            logging.warning('[LLM] send_llm_tx_status failed: %s' % e, extra={'id': 'LLM022'})
+
+    # ── internal ──
+
+    def _ensure_started(self):
+        if self._started:
+            return
+        with self._lock:
+            if self._started:
+                return
+            self._started = True
+            t = threading.Thread(target=self._run, daemon=True)
+            t.start()
+
+    def _run(self):
+        while True:
+            pack = self._q.get()
+            if not pack:
+                continue
+            try:
+                self._process_pack(pack)
+            except Exception as e:
+                logging.warning('[LLM] process failed: %s' % e, extra={'id': 'LLM003'})
+
+    def _process_pack(self, pack):
+        # llm_step_status
+        self._send_log_sink(pack)
+
+        # system_message
+        for text in getattr(pack, 'system_texts', None) or []:
+            self._send_log_sink(LlmSystemMessage.from_pack(pack, system_text=text))
+
+        # input_message
+        prompt_text = getattr(pack, 'prompt_text', '') or ''
+        self._send_log_sink(LlmInputMessage.from_pack(pack, prompt_text=prompt_text))
+
+        # output_message
+        completion_text = getattr(pack, 'completion_text', '') or ''
+        reasoning_text = getattr(pack, 'reasoning_text', '') or ''
+        self._send_log_sink(LlmOutputMessage.from_pack(pack,
+            completion_text=completion_text, reasoning_text=reasoning_text))
+
+        # tool
+        tool_calls_text = getattr(pack, 'tool_calls_text', '') or ''
+        if tool_calls_text:
+            self._send_log_sink(LlmToolCalls.from_pack(pack, tool_calls_text=tool_calls_text))
+
+        # tool_result
+        tool_results_text = getattr(pack, 'tool_results_text', '') or ''
+        if tool_results_text:
+            self._send_log_sink(LlmToolResults.from_pack(pack, tool_results_text=tool_results_text))
+
+    def _accumulate_tx_summary(self, ctx, pack):
+        if not ctx:
+            return
+        tx = getattr(ctx, '_llm_tx_status', None)
+        if tx is None:
+            tx = LlmTxStatus()
+            tx.txid = str(ctx.id)
+            ctx._llm_tx_status = tx
+        tx.accumulate(pack)
+
+    def _send_log_sink(self, data):
+        tags = data.tags()
+        fields = data.fields()
+        content = data.content()
+        if content:
+            self._send_chunked(tags, fields, content, data.index)
+        else:
+            self._send_pack(tags, fields, '', data.index)
+
+    def _send_pack(self, tags, fields, content, index):
+        try:
+            tags = {k: v for k, v in tags.items() if v is not None}
+            fields = {k: v for k, v in fields.items() if v is not None}
+            fields['index'] = index
+            if content:
+                encoded = content.encode('utf-8', errors='replace')
+                if len(encoded) > _MAX_CONTENT_BYTES:
+                    content = encoded[:_MAX_CONTENT_BYTES].decode('utf-8', errors='replace')
+            p = logSinkPack.getLogSinkPack(
+                t=DateUtil.now(),
+                category=LlmLogSinkPack.CATEGORY,
+                tags=tags,
+                fields={},
+                line=DateUtil.now(),
+                content=content
+            )
+            for k, v in fields.items():
+                if isinstance(v, (int, float)):
+                    p.fields.putAuto(k, v)
+                else:
+                    p.fields.putString(k, str(v))
+
+            p.pcode = conf.PCODE
+            bout = whatapio.DataOutputX()
+            bout.writePack(p, None)
+            packbytes = bout.toByteArray()
+            async_sender.send_llm_relaypack(packbytes)
+        except Exception as e:
+            logging.warning('[LLM] send_pack failed: %s' % e, extra={'id': 'LLM001'})
+
+    def _send_chunked(self, tags, fields, content, index):
+        try:
+            if not content:
+                self._send_pack(tags, fields, '', index)
+                return
+
+            tags = {k: v for k, v in tags.items() if v is not None}
+            fields = {k: v for k, v in fields.items() if v is not None}
+
+            content_bytes = content.encode('utf-8', errors='replace')
+            total_bytes = len(content_bytes)
+
+            if total_bytes <= _MAX_CONTENT_BYTES:
+                chunk_fields = dict(fields)
+                chunk_fields["chunk_index"] = 0
+                chunk_fields["chunk_total"] = 1
+                self._send_pack(tags, chunk_fields, content, index)
+                return
+
+            raw_chunks = []
+            i = 0
+            while i < total_bytes:
+                end = min(i + _MAX_CONTENT_BYTES, total_bytes)
+                if end < total_bytes:
+                    while end > i and (content_bytes[end] & 0xC0) == 0x80:
+                        end -= 1
+                raw_chunks.append(content_bytes[i:end].decode('utf-8', errors='replace'))
+                i = end
+
+            chunk_total = len(raw_chunks)
+            for idx, chunk in enumerate(raw_chunks):
+                chunk_fields = dict(fields)
+                chunk_fields["chunk_index"] = idx
+                chunk_fields["chunk_total"] = chunk_total
+                self._send_pack(tags, chunk_fields, chunk, index)
+        except Exception as e:
+            logging.warning('[LLM] send_chunked failed: %s' % e, extra={'id': 'LLM002'})
+
+
+# ── module-level API ──
+
+def dispatch_llm_pack(pack):
+    LlmLogSinkTask.get_instance().dispatch(pack)
+
+
+def send_llm_tx_status(ctx):
+    LlmLogSinkTask.get_instance().send_tx_status(ctx)
+
+
+def send_llm_pack(metadata):
+    pack = LlmStepStatus()
+    for key, val in metadata.items():
+        if hasattr(pack, key):
+            setattr(pack, key, val)
+    dispatch_llm_pack(pack)

whatap_python-2.0.2/whatap/counter/tasks/llm_stat_task.py

@@ -0,0 +1,77 @@
+import time
+import logging
+from threading import Thread
+
+from whatap.llm.stats import LLM_STAT_CLASSES
+
+
+class LlmStatTask(Thread):
+    _instance = None
+
+    def __init__(self):
+        super(LlmStatTask, self).__init__()
+        self.stats = list()
+        self._stat_map = {}
+        self.last_executed = {}
+        LlmStatTask._instance = self
+
+    def _register_stats(self):
+        for cls in LLM_STAT_CLASSES:
+            stat = cls()
+            self.stats.append(stat)
+            self._stat_map[stat.name()] = stat
+            self.last_executed[stat.name()] = 0
+
+    def run(self):
+        self._register_stats()
+
+        while True:
+            current_time = time.time()
+            time.sleep(1)
+            for stat in self.stats:
+                last_executed_time = self.last_executed[stat.name()]
+                interval = stat.interval()
+
+                if current_time - last_executed_time >= interval:
+                    try:
+                        self.last_executed[stat.name()] = current_time
+                        stat.process()
+                    except Exception as e:
+                        logging.debug(e, extra={'id': 'WA182'}, exc_info=True)
+
+    def notify(self, pack):
+        from whatap.conf.configure import Configure as conf
+        if not getattr(conf, 'llm_enabled', False):
+            return
+        for stat in self.stats:
+            try:
+                stat.update_from_pack(pack)
+            except Exception as e:
+                logging.debug(e, extra={'id': 'WA183'}, exc_info=True)
+
+        if pack.success:
+            from whatap.llm.stats.meter import Meter
+            Meter.increment()
+
+    def flush_last_error(self, ctx):
+        last_error_type = getattr(ctx, '_llm_last_error_type', None)
+        if not last_error_type:
+            return
+        from whatap.conf.configure import Configure as conf
+        if not getattr(conf, 'llm_enabled', False):
+            return
+        stat = self._stat_map.get('ErrorStat')
+        if stat:
+            stat.update_last_error(
+                getattr(ctx, '_llm_last_error_model', 'unknown'),
+                getattr(ctx, '_llm_last_error_provider', ''),
+                getattr(ctx, '_llm_last_error_op_type', 'unknown'),
+                url=getattr(ctx, '_llm_last_error_url', ''),
+                error_type=last_error_type,
+            )
+
+    @classmethod
+    def get_stat(cls, name):
+        if cls._instance is None:
+            return None
+        return cls._instance._stat_map.get(name)

whatap_python-2.0.2/whatap/llm/__init__.py

@@ -0,0 +1 @@
+from whatap.llm.log_sink_packs.llm_step_status import LlmStepStatus

whatap_python-2.0.2/whatap/llm/definitions.py

@@ -0,0 +1,43 @@
+"""LLM 패키지에서 사용하는 상수 및 매핑 데이터 정의."""
+LOG_SINK_CATEGORY = '#LlmCallLog'
+
+PROVIDER_TOKEN_FIELDS = {
+    'openai': [
+        'input_tokens', 'output_tokens', 'total_tokens_count',
+        'cached_tokens', 'reasoning_tokens',
+        'audio_input_tokens', 'audio_output_tokens',
+        'accepted_prediction_tokens', 'rejected_prediction_tokens',
+        'embedding_count', 'dimensions', 'similarity',
+    ],
+    'anthropic': [
+        'input_tokens', 'output_tokens', 'total_tokens_count',
+        'cache_creation_input_tokens', 'cache_read_input_tokens',
+    ],
+}
+
+DEFAULT_TOKEN_FIELDS = ['input_tokens', 'output_tokens', 'total_tokens_count']
+
+OPENAI_URL_OPERATION_MAP = [
+    ("/v1/chat/completions", "chat"),
+    ("/v1/responses", "response"),
+    ("/v1/completions", "completion"),
+    ("/v1/embeddings", "embedding"),
+    ("/v1/images/generations", "image_generation"),
+    ("/v1/images/edits", "image_edit"),
+    ("/v1/audio/transcriptions", "audio_transcription"),
+    ("/v1/audio/translations", "audio_translation"),
+    ("/v1/audio/speech", "audio_speech"),
+    ("/v1/moderations", "moderation"),
+    ("/v1/fine_tuning", "fine_tuning"),
+    ("/v1/files", "file"),
+    ("/v1/assistants", "assistant"),
+    ("/v1/threads", "thread"),
+    ("/v1/vector_stores", "vector_store"),
+    ("/v1/batches", "batch"),
+]
+
+ANTHROPIC_URL_OPERATION_MAP = [
+    ("/v1/messages", "chat"),
+]
+
+URL_OPERATION_MAP = OPENAI_URL_OPERATION_MAP + ANTHROPIC_URL_OPERATION_MAP

whatap_python-2.0.2/whatap/llm/log_sink_packs/__init__.py

@@ -0,0 +1,8 @@
+from whatap.llm.log_sink_packs.llm_log_sink_pack import LlmLogSinkPack
+from whatap.llm.log_sink_packs.llm_step_status import LlmStepStatus
+from whatap.llm.log_sink_packs.llm_system_message import LlmSystemMessage
+from whatap.llm.log_sink_packs.llm_input_message import LlmInputMessage
+from whatap.llm.log_sink_packs.llm_output_message import LlmOutputMessage
+from whatap.llm.log_sink_packs.llm_tool_calls import LlmToolCalls
+from whatap.llm.log_sink_packs.llm_tool_results import LlmToolResults
+from whatap.llm.log_sink_packs.llm_tx_status import LlmTxStatus

whatap_python-2.0.2/whatap/llm/log_sink_packs/llm_input_message.py

@@ -0,0 +1,16 @@
+"""LLM 입력 메시지 데이터 모델 정의."""
+from whatap.llm.log_sink_packs.llm_log_sink_pack import LlmLogSinkPack
+
+
+class LlmInputMessage(LlmLogSinkPack):
+    """사용자 입력 프롬프트 메시지를 담는 팩."""
+
+    LLM_LOG_TYPE = 'input_message'
+
+    def __init__(self):
+        super().__init__()
+        self.prompt_text = ''
+
+    def content(self):
+        """입력 프롬프트 텍스트를 반환한다."""
+        return self.prompt_text