process-gpt-agent-sdk 0.3.17__tar.gz → 0.3.19__tar.gz

{process_gpt_agent_sdk-0.3.17 → process_gpt_agent_sdk-0.3.19}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: process-gpt-agent-sdk
-Version: 0.3.17
+Version: 0.3.19
 Summary: Supabase 기반 이벤트/작업 폴링으로 A2A AgentExecutor를 실행하는 SDK
 License: MIT
 Project-URL: Homepage, https://github.com/your-org/process-gpt-agent-sdk

{process_gpt_agent_sdk-0.3.17 → process_gpt_agent_sdk-0.3.19}/process_gpt_agent_sdk.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: process-gpt-agent-sdk
-Version: 0.3.17
+Version: 0.3.19
 Summary: Supabase 기반 이벤트/작업 폴링으로 A2A AgentExecutor를 실행하는 SDK
 License: MIT
 Project-URL: Homepage, https://github.com/your-org/process-gpt-agent-sdk

process_gpt_agent_sdk-0.3.19/processgpt_agent_sdk/__init__.py

@@ -0,0 +1,43 @@
+from .processgpt_agent_framework import (
+    ProcessGPTAgentServer,
+    ProcessGPTRequestContext,
+    ProcessGPTEventQueue,
+    ContextPreparationError,
+)
+from .database import (
+    initialize_db,
+    get_consumer_id,
+    polling_pending_todos,
+    record_event,
+    record_events_bulk,
+    save_task_result,
+    update_task_error,
+    fetch_form_def,
+    fetch_users_grouped,
+    fetch_email_users_by_proc_inst_id,
+    fetch_tenant_mcp,
+)
+from .utils import (
+    summarize_error_to_user,
+    summarize_feedback,
+)
+
+__all__ = [
+    "ProcessGPTAgentServer",
+    "ProcessGPTRequestContext",
+    "ProcessGPTEventQueue",
+    "ContextPreparationError",
+    "initialize_db",
+    "get_consumer_id",
+    "polling_pending_todos",
+    "record_event",
+    "record_events_bulk",
+    "save_task_result",
+    "update_task_error",
+    "fetch_form_def",
+    "fetch_users_grouped",
+    "fetch_email_users_by_proc_inst_id",
+    "fetch_tenant_mcp",
+    "summarize_error_to_user",
+    "summarize_feedback",
+]

{process_gpt_agent_sdk-0.3.17 → process_gpt_agent_sdk-0.3.19}/processgpt_agent_sdk/database.py

@@ -130,51 +130,27 @@ async def polling_pending_todos(agent_orch: str, consumer: str) -> Optional[Dict
         ).execute()
 
         rows = resp.data or []
-        return rows[0] if rows else None
+        if not rows:
+            return None
+        
+        row = rows[0]
+        # 빈 값들을 NULL로 변환
+        if row.get("feedback") in ([], {}):
+            row["feedback"] = None
+        if row.get("output") in ([], {}):
+            row["output"] = None
+        if row.get("draft") in ([], {}):
+            row["draft"] = None
+            
+        return row
 
     return await _async_retry(_call, name="polling_pending_todos", fallback=lambda: None)
 
-# ------------------------------ Context Bundle ------------------------------
-async def fetch_context_bundle(
-    proc_inst_id: str,
-    tenant_id: str,
-    tool_val: str,
-    user_ids: str,
-) -> Tuple[str, Optional[Dict[str, Any]], Tuple[Optional[str], List[Dict[str, Any]], Optional[str]], List[Dict[str, Any]]]:
-    def _call():
-        client = get_db_client()
-        resp = client.rpc(
-            "fetch_context_bundle",
-            {
-                "p_proc_inst_id": proc_inst_id or "",
-                "p_tenant_id": tenant_id or "",
-                "p_tool": tool_val or "",
-                "p_user_ids": user_ids or "",
-            },
-        ).execute()
-        rows = resp.data or []
-        row = rows[0] if rows else {}
-        notify = (row.get("notify_emails") or "").strip()
-        mcp = row.get("tenant_mcp") or None
-        form_id = row.get("form_id")
-        form_fields = row.get("form_fields") or [{"key": form_id, "type": "default", "text": ""}]
-        form_html = row.get("form_html")
-        agents = row.get("agents") or []
-        return notify, mcp, (form_id, form_fields, form_html), agents
-
-    try:
-        return await _async_retry(_call, name="fetch_context_bundle", fallback=lambda: ("", None, (None, [], None), []))
-    except Exception as e:
-        logger.error("fetch_context_bundle fatal: %s", str(e), exc_info=e)
-        return ("", None, (None, [], None), [])
 
 # ------------------------------ Events & Results ------------------------------
 async def record_events_bulk(payloads: List[Dict[str, Any]]) -> None:
-    """
-    이벤트 다건 저장:
-    - 성공: 'record_events_bulk ok'
-    - 실패(최종): '❌ record_events_bulk failed' (개수 포함)
-    """
+    """이벤트 다건 저장 함수"""
+
     if not payloads:
         return
 
@@ -196,12 +172,8 @@ async def record_events_bulk(payloads: List[Dict[str, Any]]) -> None:
         logger.info("record_events_bulk ok: count=%d", len(safe_list))
 
 async def record_event(payload: Dict[str, Any]) -> None:
-    """
-    단건 이벤트 저장.
-    - 성공: 'record_event ok'
-    - 실패(최종): '❌ record_event failed'
-    - 실패해도 워크플로우는 계속(요청사항)
-    """
+    """단건 이벤트 저장 함수"""
+
     if not payload:
         return
 
@@ -219,6 +191,8 @@ async def record_event(payload: Dict[str, Any]) -> None:
         logger.info("record_event ok: event_type=%s", payload.get("event_type"))
 
 async def save_task_result(todo_id: str, result: Any, final: bool = False) -> None:
+    """결과 저장 함수"""
+
     if not todo_id:
         logger.error("save_task_result invalid todo_id: %s", str(todo_id))
         return
@@ -245,6 +219,8 @@ async def save_task_result(todo_id: str, result: Any, final: bool = False) -> No
 
 # ------------------------------ Failure Status ------------------------------
 async def update_task_error(todo_id: str) -> None:
+    """작업 실패 상태 업데이트 함수"""
+
     if not todo_id:
         return
 
@@ -257,3 +233,151 @@ async def update_task_error(todo_id: str) -> None:
         logger.error("❌ update_task_error failed todo_id=%s", todo_id)
     else:
         logger.info("update_task_error ok todo_id=%s", todo_id)
+
+# ============================== Prepare Context ==============================
+
+from typing import Any, Dict, List, Optional, Tuple
+
+async def fetch_form_def(tool_val: str, tenant_id: str) -> Tuple[str, List[Dict[str, Any]], Optional[str]]:
+    """폼 정의 조회 함수"""
+    form_id = (tool_val or "").replace("formHandler:", "", 1)
+
+    def _call():
+        client = get_db_client()
+        resp = (
+            client.table("form_def")
+            .select("fields_json, html")
+            .eq("id", form_id)
+            .eq("tenant_id", tenant_id or "")
+            .execute()
+        )
+        data = (resp.data or [])
+        if not data:
+            return None
+
+        row = data[0]
+        return {
+            "fields": row.get("fields_json"),
+            "html": row.get("html"),
+        }
+
+    try:
+        res = await _async_retry(_call, name="fetch_form_def")
+    except Exception as e:
+        logger.error("fetch_form_def fatal: %s", str(e), exc_info=e)
+        res = None
+
+    if not res or not res.get("fields"):
+        # 기본(자유형식) 폼
+        return (
+            form_id or "freeform",
+            [{"key": "freeform", "type": "textarea", "text": "자유형식 입력", "placeholder": "원하는 내용을 자유롭게 입력해주세요."}],
+            None,
+        )
+    return (form_id or "freeform", res["fields"], res.get("html"))
+
+
+async def fetch_users_grouped(user_ids: List[str]) -> Tuple[List[Dict[str, Any]], List[Dict[str, Any]]]:
+    """해당 todo에서 사용자 목록과 에이전트 목록 조회하는는 함수"""
+    ids = [u for u in (user_ids or []) if u]
+    if not ids:
+        return ([], [])
+
+    def _call():
+        client = get_db_client()
+        resp = (
+            client.table("users")
+            .select("*")
+            .in_("id", ids)
+            .execute()
+        )
+        rows = resp.data or []
+        return rows
+
+    try:
+        rows = await _async_retry(_call, name="fetch_users_grouped", fallback=lambda: [])
+    except Exception as e:
+        logger.error("fetch_users_grouped fatal: %s", str(e), exc_info=e)
+        rows = []
+
+    agents, users = [], []
+    for r in rows:
+        if r.get("is_agent") is True:
+            agents.append(r)
+        else:
+            users.append(r)
+    return (agents, users)
+
+async def fetch_email_users_by_proc_inst_id(proc_inst_id: str) -> str:
+    """proc_inst_id로 이메일 수집(사람만): todolist → users(in) 한 번에"""
+    if not proc_inst_id:
+        return ""
+
+    def _call():
+        client = get_db_client()
+        # 3-1) 해당 인스턴스의 user_id 수집(중복 제거)
+        tl = (
+            client.table("todolist")
+            .select("user_id")
+            .eq("proc_inst_id", proc_inst_id)
+            .execute()
+        )
+        ids_set = set()
+        for row in (tl.data or []):
+            uid_csv = (row.get("user_id") or "").strip()
+            if not uid_csv:
+                continue
+            # user_id는 문자열 CSV라고 전제
+            for uid in uid_csv.split(","):
+                u = uid.strip()
+                if u:
+                    ids_set.add(u)
+        if not ids_set:
+            return []
+
+        # 3-2) 한 번의 IN 조회로 사람만 이메일 추출
+        ur = (
+            client.table("users")
+            .select("id, email, is_agent")
+            .in_("id", list(ids_set))
+            .eq("is_agent", False)
+            .execute()
+        )
+        emails = []
+        for u in (ur.data or []):
+            email = (u.get("email") or "").strip()
+            if email:
+                emails.append(email)
+        # 중복 제거 및 정렬(보기 좋게)
+        return sorted(set(emails))
+
+    try:
+        emails = await _async_retry(_call, name="fetch_email_users_by_proc_inst_id", fallback=lambda: [])
+    except Exception as e:
+        logger.error("fetch_email_users_by_proc_inst_id fatal: %s", str(e), exc_info=e)
+        emails = []
+
+    return ",".join(emails) if emails else ""
+
+async def fetch_tenant_mcp(tenant_id: str) -> Optional[Dict[str, Any]]:
+    """mcp 설정 조회 함수"""
+    if not tenant_id:
+        return None
+
+    def _call():
+        client = get_db_client()
+        return (
+            client.table("tenants")
+            .select("mcp")
+            .eq("id", tenant_id)
+            .single()
+            .execute()
+        )
+
+    try:
+        resp = await _async_retry(_call, name="fetch_tenant_mcp", fallback=lambda: None)
+    except Exception as e:
+        logger.error("fetch_tenant_mcp fatal: %s", str(e), exc_info=e)
+        return None
+
+    return resp.data.get("mcp") if resp and getattr(resp, "data", None) else None

{process_gpt_agent_sdk-0.3.17 → process_gpt_agent_sdk-0.3.19}/processgpt_agent_sdk/processgpt_agent_framework.py

@@ -17,13 +17,16 @@ from .database import (
     initialize_db,
     polling_pending_todos,
     record_events_bulk,
-    record_event,          # 단건 이벤트 기록
+    record_event,
     save_task_result,
     update_task_error,
     get_consumer_id,
-    fetch_context_bundle,
+    fetch_form_def,
+    fetch_users_grouped,
+    fetch_email_users_by_proc_inst_id,
+    fetch_tenant_mcp,
 )
-from .utils import summarize_error_to_user
+from .utils import summarize_error_to_user, summarize_feedback
 
 load_dotenv()
 logging.basicConfig(level=logging.INFO)
@@ -93,64 +96,116 @@ class TodoListRowContext:
 class ProcessGPTRequestContext(RequestContext):
     def __init__(self, row: Dict[str, Any]):
         self.row = row
-        self._user_input = (row.get("description") or "").strip()
+        self._user_input = (row.get("query") or "").strip()
         self._message = self._user_input
         self._current_task = None
         self._task_state = row.get("draft_status") or ""
         self._extra_context: Dict[str, Any] = {}
 
     async def prepare_context(self) -> None:
-        """
-        컨텍스트 준비.
-        - 실패 시: 더 이상 진행하지 않고 ContextPreparationError를 발생시켜
-          상위 경계에서 FAILED 처리(이벤트 기록 포함)를 단일 경로로 수행.
-        """
-        logger.info("\n🔧 컨텍스트 준비 시작...")
-        
-        # 1단계: 기본 정보 추출
+        """익스큐터를 위한 컨텍스트 준비를 합니다."""
+
         effective_proc_inst_id = self.row.get("root_proc_inst_id") or self.row.get("proc_inst_id")
         tool_val = self.row.get("tool") or ""
         tenant_id = self.row.get("tenant_id") or ""
         user_ids = self.row.get("user_id") or ""
-        
-        logger.info("📋 기본 정보 추출 완료 - proc_inst_id: %s, tool: %s, tenant: %s", 
-                   effective_proc_inst_id, tool_val, tenant_id)
 
         try:
-            # 2단계: 컨텍스트 번들 조회
-            logger.info("🔍 컨텍스트 번들 조회 중...")
-            notify_emails, tenant_mcp, form_tuple, agents = await fetch_context_bundle(
-                effective_proc_inst_id, tenant_id, tool_val, user_ids
+            # 데이터베이스 조회
+            user_id_list = [u.strip() for u in (user_ids or '').split(',') if u.strip()]
+            notify_task = fetch_email_users_by_proc_inst_id(effective_proc_inst_id)
+            mcp_task = fetch_tenant_mcp(tenant_id)
+            form_task = fetch_form_def(tool_val, tenant_id)
+            users_task = fetch_users_grouped(user_id_list)
+
+            notify_emails, tenant_mcp, form_tuple, users_group = await asyncio.gather(
+                notify_task, mcp_task, form_task, users_task
             )
             form_id, form_fields, form_html = form_tuple
+            agents, users = users_group
+            
+            logger.info("\n\n🔍 [데이터베이스 조회 결과]")
+            logger.info("-" * 60)
+            
+            # Users 정보
+            if users:
+                user_info = []
+                for u in users[:5]:
+                    name = u.get("name", u.get("user_name", "Unknown"))
+                    email = u.get("email", "")
+                    user_info.append(f"{name}({email})" if email else name)
+                logger.info("• Users (%d명): %s%s", len(users), ", ".join(user_info), "..." if len(users) > 5 else "")
+            else:
+                logger.info("• Users: 없음")
+            
+            # Agents 정보
+            if agents:
+                agent_info = []
+                for a in agents[:5]:
+                    name = a.get("name", a.get("agent_name", "Unknown"))
+                    tools = a.get("tools", [])
+                    tool_names = [t.get("name", str(t)) for t in tools[:3]] if tools else []
+                    tool_str = f"[{', '.join(tool_names)}]" if tool_names else ""
+                    agent_info.append(f"{name}{tool_str}")
+                logger.info("• Agents (%d개): %s%s", len(agents), ", ".join(agent_info), "..." if len(agents) > 5 else "")
+            else:
+                logger.info("• Agents: 없음")
+            
+            # Form 정보
+            if form_fields:
+                pretty_json = json.dumps(form_fields, ensure_ascii=False, separators=(',', ':'))
+                logger.info("• Form: %s (%d개 필드) - %s", form_id, len(form_fields), pretty_json)
+            else:
+                logger.info("• Form: %s (필드 없음)", form_id)
             
-            logger.info("📦 컨텍스트 번들 조회 완료 - agents: %d개, notify_emails: %s", 
-                       len(agents) if isinstance(agents, list) else 0, 
-                       "있음" if notify_emails else "없음")
+            # Notify 정보
+            if notify_emails:
+                email_list = notify_emails.split(',') if ',' in notify_emails else [notify_emails]
+                logger.info("• Notify (%d개): %s", len(email_list), 
+                           ", ".join(email_list[:3]) + ("..." if len(email_list) > 3 else ""))
+            else:
+                logger.info("• Notify: 없음")
+            
+            # MCP 정보 - 상세 표시
+            if tenant_mcp:
+                logger.info("• %s 테넌트에 연결된 MCP 설정 정보가 존재합니다.", tenant_id)
+            else:
+                logger.info("• %s 테넌트에 연결된 MCP 설정 정보가 존재하지 않습니다.", tenant_id)
+            
+            # 피드백 처리
+            feedback_data = self.row.get("feedback")
+            content_data = self.row.get("output") or self.row.get("draft")
+            summarized_feedback = ""
+            if feedback_data:
+                logger.info("\n\n📝 [피드백 처리]")
+                logger.info("-" * 60)
+                logger.info("• %d자 → AI 요약 중...", len(feedback_data))
+                summarized_feedback = await summarize_feedback(feedback_data, content_data)
+                logger.info("• 요약 완료: %d자", len(summarized_feedback))
+            
+            # 컨텍스트 구성
+            self._extra_context = {
+                "id": self.row.get("id"),
+                "proc_inst_id": effective_proc_inst_id,
+                "root_proc_inst_id": self.row.get("root_proc_inst_id"),
+                "activity_name": self.row.get("activity_name"),
+                "agents": agents,
+                "users": users,
+                "tenant_mcp": tenant_mcp,
+                "form_fields": form_fields,
+                "form_html": form_html,
+                "form_id": form_id,
+                "notify_user_emails": notify_emails,
+                "summarized_feedback": summarized_feedback,
+            }
+            
+            logger.info("\n\n🎉 [컨텍스트 준비 완료] 모든 데이터 준비됨")
+            logger.info("-"*60)
             
         except Exception as e:
-            logger.error("❌ 컨텍스트 번들 조회 실패: %s", str(e))
-            # 사용자 친화 요약은 상위 경계에서 한 번만 기록하도록 넘김
+            logger.error("❌ [데이터 조회 실패] %s", str(e))
             raise ContextPreparationError(e)
 
-        # 3단계: 컨텍스트 구성
-        logger.info("🏗️ 컨텍스트 구성 중...")
-        self._extra_context = {
-            "id": self.row.get("id"),
-            "proc_inst_id": effective_proc_inst_id,
-            "root_proc_inst_id": self.row.get("root_proc_inst_id"),
-            "activity_name": self.row.get("activity_name"),
-            "agents": agents,
-            "tenant_mcp": tenant_mcp,
-            "form_fields": form_fields,
-            "form_html": form_html,
-            "form_id": form_id,
-            "notify_user_emails": notify_emails,
-        }
-        
-        logger.info("✅ 컨텍스트 준비 완료! (agents=%d개)", 
-                   len(agents) if isinstance(agents, list) else 0)
-
     def get_user_input(self) -> str:
         return self._user_input
 
@@ -336,11 +391,18 @@ class ProcessGPTAgentServer:
 
         while self.is_running and not self._shutdown_event.is_set():
             try:
-                logger.info("🔍 Polling for tasks (agent_orch=%s)...", self.agent_orch)
+                logger.info("\n\n" + "-"*80)
+                logger.info("🔍 [폴링 시작] 작업 대기 중... (agent_orch=%s)", self.agent_orch)
+                logger.info("-"*80)
+                
                 row = await polling_pending_todos(self.agent_orch, get_consumer_id())
 
                 if row:
-                    logger.info("✅ 새 작업: %s (proc=%s, activity=%s)", row.get("id"), row.get("proc_inst_id"), row.get("activity_name"))
+                    logger.info("\n\n" + "-"*80)
+                    logger.info("✅ [새 작업 발견] Task ID: %s", row.get("id"))
+                    logger.info("• Activity: %s | Tool: %s | Tenant: %s", 
+                               row.get("activity_name"), row.get("tool"), row.get("tenant_id"))
+                    logger.info("-"*80)
                     try:
                         self._current_todo_id = str(row.get("id"))
                         await self.process_todolist_item(row)
@@ -380,29 +442,23 @@ class ProcessGPTAgentServer:
           4) 예외 재전달(상위 루프는 죽지 않고 다음 폴링)
         """
         task_id = row.get("id")
-        logger.info("\n🎯 작업 처리 시작 - Task ID: %s", task_id)
-        logger.info("📝 작업 정보 - proc_inst_id: %s, activity: %s, tool: %s", 
-                   row.get("proc_inst_id"), row.get("activity_name"), row.get("tool"))
+        logger.info("\n🎯 [작업 처리 시작] Task ID: %s", task_id)
         
         friendly_text: Optional[str] = None
 
         try:
             # 1) 컨텍스트 준비 (실패 시 ContextPreparationError로 올라옴)
-            logger.info("🔧 컨텍스트 준비 단계 시작...")
             context = ProcessGPTRequestContext(row)
             await context.prepare_context()
-            logger.info("✅ 컨텍스트 준비 완료")
 
             # 2) 실행
-            logger.info("🤖 에이전트 실행 단계 시작...")
+            logger.info("\n\n🤖 [Agent Orchestrator 실행]")
+            logger.info("-" * 60)
             event_queue = ProcessGPTEventQueue(str(task_id), self.agent_orch, row.get("proc_inst_id"))
             await self.agent_executor.execute(context, event_queue)
-            logger.info("✅ 에이전트 실행 완료")
-
-            # 3) 정상 완료 이벤트
-            logger.info("🏁 작업 완료 처리 중...")
             event_queue.task_done()
-            logger.info("🎉 작업 완료: %s\n", task_id)
+            logger.info("\n🎉 [Agent Orchestrator 완료] Task ID: %s", task_id)
+            logger.info("-"*60)
 
         except Exception as e:
             logger.error("❌ 작업 처리 중 오류 발생: %s", str(e))

process_gpt_agent_sdk-0.3.19/processgpt_agent_sdk/utils.py

@@ -0,0 +1,190 @@
+import os
+import logging
+import traceback
+from typing import Any, Dict, Optional, List
+from typing import Iterable, Union
+from openai import AsyncOpenAI
+
+
+logger = logging.getLogger(__name__)
+
+
+# ─────────────────────────────
+# Lazy Singleton OpenAI Client
+# ─────────────────────────────
+_client: Optional["AsyncOpenAI"] = None  # type: ignore[name-defined]
+
+def _require_env(name: str, default: Optional[str] = None) -> str:
+    v = os.getenv(name, default if default is not None else "")
+    if not v:
+        raise RuntimeError(f"Missing required environment variable: {name}")
+    return v
+
+def get_client() -> "AsyncOpenAI":  # type: ignore[name-defined]
+    global _client
+    if _client is not None:
+        return _client
+    if AsyncOpenAI is None:
+        raise RuntimeError("OpenAI SDK (async) is not available")
+    base_url = os.getenv("OPENAI_BASE_URL", "https://api.openai.com/v1")
+    api_key = _require_env("OPENAI_API_KEY", "")
+    _client = AsyncOpenAI(base_url=base_url, api_key=api_key)
+    return _client
+
+# ─────────────────────────────
+# 공통 LLM 호출 유틸
+# ─────────────────────────────
+async def _llm_request(system: str, user: str, model_env: str, default_model: str) -> str:
+    model_name = os.getenv(model_env, default_model)
+    logger.info("📡 LLM 요청 전송 (모델: %s)", model_name)
+
+    client = get_client()
+    # responses API (신규)
+    resp = await client.responses.create(
+        model=model_name,
+        input=[
+            {"role": "system", "content": system},
+            {"role": "user", "content": user},
+        ],
+    )
+
+    # 다양한 SDK 출력 구조 호환
+    text: Optional[str] = None
+    try:
+        text = getattr(resp, "output_text", None)  # 최신 필드
+    except Exception:
+        text = None
+
+    if not text and hasattr(resp, "choices") and resp.choices:  # 구 구조 호환
+        choice0 = resp.choices[0]
+        text = getattr(getattr(choice0, "message", None), "content", None)
+
+    if not text:
+        raise RuntimeError("No text in LLM response")
+
+    return text.strip()
+
+# ─────────────────────────────
+# 공개 API
+# ─────────────────────────────
+async def summarize_error_to_user(exc: Exception, meta: Dict[str, Any]) -> str:
+    """
+    예외 정보를 바탕으로 사용자 친화적인 5줄 요약을 생성.
+    - 모델: gpt-4.1-nano (환경변수 ERROR_SUMMARY_MODEL로 재정의 가능)
+    - 폴백: 없음 (LLM 실패 시 예외를 상위로 전파)
+    """
+    logger.info("🔍 오류 컨텍스트 분석 시작")
+
+    err_text = f"{type(exc).__name__}: {str(exc)}"
+
+    # 가벼운 스택 문자열 (상위 3프레임)
+    try:
+        tb = "".join(traceback.TracebackException.from_exception(exc, limit=3).format())
+    except Exception:
+        tb = traceback.format_exc(limit=3)
+
+    meta_items: List[str] = []
+    for k in ("task_id", "proc_inst_id", "agent_orch", "tool"):
+        v = meta.get(k)
+        if v:
+            meta_items.append(f"{k}={v}")
+    meta_text = ", ".join(meta_items)
+
+    logger.info("📋 오류 컨텍스트 정리 완료 - %s", meta_text)
+
+    system = (
+        "당신은 엔터프라이즈 SDK의 오류 비서입니다. "
+        "사용자(비개발자도 이해 가능)를 위해, 아래 조건을 정확히 지켜 5줄로 한국어 설명을 만드세요.\n"
+        "형식: 각 줄은 1문장씩, 총 5줄.\n"
+        "포함 요소: ①무슨 문제인지(원인 추정) ②어떤 영향이 있는지 ③즉시 할 일(대처) "
+        "④재발 방지 팁 ⑤필요시 지원 요청 경로.\n"
+        "과장 금지, 간결하고 친절하게."
+    )
+    user = (
+        f"[오류요약대상]\n"
+        f"- 컨텍스트: {meta_text}\n"
+        f"- 에러: {err_text}\n"
+        f"- 스택(상위 3프레임):\n{tb}\n"
+        f"위 정보를 바탕으로 5줄 설명을 출력하세요."
+    )
+
+    try:
+        text = await _llm_request(system, user, "ERROR_SUMMARY_MODEL", "gpt-4.1-nano")
+        logger.info("✅ LLM 오류 요약 생성 완료")
+        return text
+    except Exception as e:
+        logger.warning("⚠️ LLM 오류 요약 생성 실패: %s", e, exc_info=True)
+        # 폴백 없이 상위 전파
+        raise
+
+async def summarize_feedback(feedback_data: List[dict], content_data: dict = {}) -> str:
+    """
+    피드백과 결과물을 바탕으로 통합된 피드백 요약을 생성.
+    - 모델: gpt-4.1-nano (환경변수 FEEDBACK_SUMMARY_MODEL로 재정의 가능)
+    - 폴백: 없음 (LLM 실패 시 예외를 상위로 전파)
+    """
+    logger.info(
+        "🔍 피드백 요약 처리 시작 | 피드백: %s, 결과물: %s자",
+        feedback_data, content_data)
+
+    system_prompt = _get_feedback_system_prompt()
+    user_prompt = _create_feedback_summary_prompt(feedback_data, content_data)
+
+    try:
+        text = await _llm_request(system_prompt, user_prompt, "FEEDBACK_SUMMARY_MODEL", "gpt-4.1-nano")
+        logger.info("✅ LLM 피드백 요약 생성 완료")
+        return text
+    except Exception as e:
+        logger.error("❌ LLM 피드백 요약 생성 실패: %s", e, exc_info=True)
+        # 폴백 없이 상위 전파
+        raise
+
+# ─────────────────────────────
+# 프롬프트 유틸
+# ─────────────────────────────
+def _create_feedback_summary_prompt(feedback_data: List[dict], content_data: dict = {}) -> str:
+    """피드백 정리 프롬프트 - 현재 결과물과 피드백을 함께 분석"""
+    blocks: List[str] = ["다음은 사용자의 피드백과 결과물입니다. 이를 분석하여 통합된 피드백을 작성해주세요:"]
+    if feedback_data:
+        blocks.append(f"=== 피드백 내용 ===\n{feedback_data}")
+    if content_data:
+        blocks.append(f"=== 현재 결과물/작업 내용 ===\n{content_data}")
+
+    blocks.append(
+        """**상황 분석 및 처리 방식:**
+- **현재 결과물을 보고 어떤 점이 문제인지, 개선이 필요한지 판단**
+- 피드백이 있다면 그 의도와 요구사항을 정확히 파악
+- 결과물 자체가 마음에 안들어서 다시 작업을 요청하는 경우일 수 있음
+- 작업 방식이나 접근법이 잘못되었다고 판단하는 경우일 수 있음
+- 부분적으로는 좋지만 특정 부분의 수정이나 보완이 필요한 경우일 수 있음
+- 현재 결과물에 매몰되지 말고, 실제 어떤 부분이 문제인지 파악하여 개선 방안을 제시
+
+**피드백 통합 원칙:**
+- **가장 최신 피드백을 최우선으로 반영**
+- 결과물과 피드백을 종합적으로 분석하여 핵심 문제점 파악
+- **시간 흐름을 파악하여 피드백들 간의 연결고리와 문맥을 이해**
+- 구체적이고 실행 가능한 개선사항 제시
+- **자연스럽고 통합된 하나의 완전한 피드백으로 작성**
+- 최대 1000자까지 허용하여 상세히 작성
+
+**중요한 상황별 처리:**
+- 결과물 품질에 대한 불만 → **품질 개선** 요구
+- 작업 방식에 대한 불만 → **접근법 변경** 요구
+- 이전에 저장을 했는데 잘못 저장되었다면 → **수정**이 필요
+- 이전에 조회만 했는데 저장이 필요하다면 → **저장**이 필요
+- 부분적 수정이 필요하다면 → **특정 부분 개선** 요구
+
+출력 형식: 현재 상황을 종합적으로 분석한 완전한 피드백 문장 (다음 작업자가 즉시 이해하고 실행할 수 있도록)"""
+    )
+    return "\n\n".join(blocks)
+
+def _get_feedback_system_prompt() -> str:
+    """피드백 요약용 시스템 프롬프트"""
+    return """당신은 피드백 정리 전문가입니다.
+
+핵심 원칙:
+- 최신 피드백을 최우선으로 하여 시간 흐름을 파악
+- 피드백 간 문맥과 연결고리를 파악하여 하나의 완전한 요청으로 통합
+- 자연스럽고 통합된 피드백으로 작성
+- 구체적인 요구사항과 개선사항을 누락 없이 포함
+- 다음 작업자가 즉시 이해할 수 있도록 명확하게"""

{process_gpt_agent_sdk-0.3.17 → process_gpt_agent_sdk-0.3.19}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "process-gpt-agent-sdk"
-version = "0.3.17"
+version = "0.3.19"
 description = "Supabase 기반 이벤트/작업 폴링으로 A2A AgentExecutor를 실행하는 SDK"
 readme = "README.md"
 requires-python = ">=3.9"

process_gpt_agent_sdk-0.3.17/processgpt_agent_sdk/__init__.py

@@ -1,25 +0,0 @@
-from .processgpt_agent_framework import ProcessGPTAgentServer
-from .database import (
-    initialize_db,
-    get_consumer_id,
-    polling_pending_todos,
-    record_event,
-    record_events_bulk,
-    save_task_result,
-    update_task_error,
-    fetch_context_bundle,
-)
-from .utils import summarize_error_to_user
-
-__all__ = [
-    "ProcessGPTAgentServer",
-    "initialize_db",
-    "get_consumer_id",
-    "polling_pending_todos",
-    "record_event",
-    "record_events_bulk",
-    "save_task_result",
-    "update_task_error",
-    "fetch_context_bundle",
-    "summarize_error_to_user",
-]

process_gpt_agent_sdk-0.3.17/processgpt_agent_sdk/utils.py

@@ -1,100 +0,0 @@
-import os
-import traceback
-import logging
-from typing import Any, Dict
-
-# OpenAI 호환 엔드포인트 사용 (환경변수 기반)
-# OPENAI_API_KEY, OPENAI_BASE_URL(required if not default)
-try:
-    from openai import OpenAI
-except Exception:  # 라이브러리 미설치/호환 환경 대비
-    OpenAI = None  # type: ignore
-
-logger = logging.getLogger(__name__)
-
-
-async def summarize_error_to_user(exc: Exception, meta: Dict[str, Any]) -> str:
-    """
-    예외 정보를 바탕으로 사용자 친화적인 5줄 요약을 생성.
-    - 모델: gpt-4.1-nano (요청사항 반영)
-    - 실패 시 Fallback: 간단한 수동 요약문
-    """
-    # 오류 컨텍스트 정리
-    logger.info("🔍 오류 컨텍스트 분석 중...")
-    err_text = f"{type(exc).__name__}: {str(exc)}"
-    tb = traceback.format_exc(limit=3)
-    meta_lines = [
-        f"task_id={meta.get('task_id')}",
-        f"proc_inst_id={meta.get('proc_inst_id')}",
-        f"agent_orch={meta.get('agent_orch')}",
-        f"tool={meta.get('tool')}",
-    ]
-    meta_text = ", ".join([x for x in meta_lines if x])
-    logger.info("📋 오류 컨텍스트 분석 완료 - %s", meta_text)
-
-    system = (
-        "당신은 엔터프라이즈 SDK의 오류 비서입니다. "
-        "사용자(비개발자도 이해 가능)를 위해, 아래 조건을 정확히 지켜 5줄로 한국어 설명을 만드세요.\n"
-        "형식: 각 줄은 1문장씩, 총 5줄.\n"
-        "포함 요소: ①무슨 문제인지(원인 추정) ②어떤 영향이 있는지 ③즉시 할 일(대처) "
-        "④재발 방지 팁 ⑤필요시 지원 요청 경로.\n"
-        "과장 금지, 간결하고 친절하게."
-    )
-    user = (
-        f"[오류요약대상]\n"
-        f"- 컨텍스트: {meta_text}\n"
-        f"- 에러: {err_text}\n"
-        f"- 스택(상위 3프레임):\n{tb}\n"
-        f"위 정보를 바탕으로 5줄 설명을 출력하세요."
-    )
-
-    try:
-        if OpenAI is None:
-            logger.warning("⚠️ OpenAI SDK 사용 불가 - Fallback 모드로 전환")
-            raise RuntimeError("OpenAI SDK not available")
-
-        logger.info("🤖 OpenAI 클라이언트 초기화 중...")
-        client = OpenAI(
-            base_url=os.getenv("OPENAI_BASE_URL", "https://api.openai.com/v1"),
-            api_key=os.getenv("OPENAI_API_KEY", ""),
-        )
-        
-        model_name = os.getenv("ERROR_SUMMARY_MODEL", "gpt-4.1-nano")
-        logger.info("📡 LLM 요청 전송 중... (모델: %s)", model_name)
-        
-        # responses API (신규 SDK)
-        resp = client.responses.create(
-            model=model_name,
-            input=[{"role": "system", "content": system},
-                   {"role": "user", "content": user}],
-        )
-        
-        logger.info("🔍 LLM 응답 분석 중...")
-        # 텍스트 추출(호환성 고려)
-        text = None
-        try:
-            text = resp.output_text  # type: ignore[attr-defined]
-        except Exception:
-            # 다른 필드 구조 호환
-            if hasattr(resp, "choices") and resp.choices:
-                text = getattr(resp.choices[0].message, "content", None)  # type: ignore
-        if not text:
-            raise RuntimeError("No text in LLM response")
-        
-        logger.info("✅ LLM 오류 요약 생성 완료")
-        return text.strip()
-
-    except Exception as e:
-        logger.warning("⚠️ LLM 오류 요약 생성 실패: %s - Fallback 모드로 전환", str(e))
-        # Fallback: 간단 5줄
-        logger.info("📝 Fallback 오류 요약 생성 중...")
-        
-        fallback_text = (
-            "1) 처리 중 알 수 없는 오류가 발생했어요(환경/입력 값 문제일 수 있어요).\n"
-            "2) 작업 결과가 저장되지 않았거나 일부만 반영됐을 수 있어요.\n"
-            "3) 입력 값과 네트워크 상태를 확인하고, 다시 시도해 주세요.\n"
-            "4) 같은 문제가 반복되면 로그와 설정(키/URL/권한)을 점검해 주세요.\n"
-            "5) 계속되면 관리자나 운영팀에 문의해 원인 분석을 요청해 주세요."
-        )
-        logger.info("✅ Fallback 오류 요약 생성 완료")
-        return fallback_text