process-gpt-agent-sdk 0.1.2__py3-none-any.whl

processgpt_agent_sdk/server.py

@@ -0,0 +1,216 @@
+import asyncio
+from typing import Any, Dict
+
+from a2a.server.agent_execution import AgentExecutor, RequestContext
+from a2a.server.events import EventQueue, Event
+
+from .core.database import (
+	initialize_db,
+	get_consumer_id,
+	polling_pending_todos,
+	fetch_done_data,
+	fetch_agent_data,
+	fetch_form_types,
+	fetch_task_status,
+	fetch_tenant_mcp_config,
+)
+
+from .utils.logger import handle_error as _emit_error, log as _emit_log
+from .utils.summarizer import summarize_async
+from .utils.event_handler import route_event
+
+
+class ProcessGPTAgentServer:
+	"""ProcessGPT 핵심 서버
+
+	- 단일 실행기 모델: 실행기는 하나이며, 작업별 분기는 실행기 내부 로직에 위임합니다.
+	- 폴링은 타입 필터 없이(빈 값) 가져온 뒤, 작업 레코드의 정보로 처리합니다.
+	"""
+
+	def __init__(self, executor: AgentExecutor, polling_interval: int = 5, agent_orch: str = ""):
+		self.polling_interval = polling_interval
+		self.is_running = False
+		self._executor: AgentExecutor = executor
+		self.cancel_check_interval: float = 0.5
+		self.agent_orch: str = agent_orch or ""
+		initialize_db()
+
+	async def run(self) -> None:
+		self.is_running = True
+		_emit_log("ProcessGPT 서버 시작")
+		
+		while self.is_running:
+			try:
+				todo = await polling_pending_todos(self.agent_orch, get_consumer_id())
+				if not todo:
+					await asyncio.sleep(self.polling_interval)
+					continue
+
+				todo_id = todo["id"]
+				_emit_log(f"[JOB START] todo_id={todo_id}")
+
+				prepared_data = await self._prepare_service_data(todo)
+				_emit_log(f"[RUN] 서비스 데이터 준비 완료 [todo_id={todo_id} agent={prepared_data.get('agent_orch','')}]")
+
+				await self._execute_with_cancel_watch(todo, prepared_data)
+				_emit_log(f"[RUN] 서비스 실행 완료 [todo_id={todo_id} agent={prepared_data.get('agent_orch','')}]")
+				
+			except Exception as e:
+				_emit_error("폴링 루프 오류", e)
+				await asyncio.sleep(self.polling_interval)
+
+	def stop(self) -> None:
+		self.is_running = False
+		_emit_log("ProcessGPT 서버 중지")
+
+	async def _prepare_service_data(self, todo: Dict[str, Any]) -> Dict[str, Any]:
+		done_outputs = await fetch_done_data(todo.get("proc_inst_id"))
+		_emit_log(f"[PREP] done_outputs → {done_outputs}")
+		feedbacks = todo.get("feedback")
+
+		agent_list = await fetch_agent_data(str(todo.get("user_id", "")))
+		_emit_log(f"[PREP] agent_list → {agent_list}")
+
+		mcp_config = await fetch_tenant_mcp_config(str(todo.get("tenant_id", "")))
+		_emit_log(f"[PREP] mcp_config(툴) → {mcp_config}")
+
+		form_id, form_types = await fetch_form_types(
+			str(todo.get("tool", "")),
+			str(todo.get("tenant_id", ""))
+		)
+		_emit_log(f"[PREP] form → id={form_id} types={form_types}")
+
+		output_summary, feedback_summary = await summarize_async(
+			done_outputs or [], feedbacks or "", todo.get("description", "")
+		)
+		_emit_log(f"[PREP] summary → output={output_summary} feedback={feedback_summary}")
+
+		prepared: Dict[str, Any] = {
+			"todo_id": str(todo.get("id")),
+			"proc_inst_id": todo.get("proc_inst_id"),
+			"agent_list": agent_list or [],
+			"mcp_config": mcp_config,
+			"form_id": form_id,
+			"form_types": form_types or [],
+			"activity_name": str(todo.get("activity_name", "")),
+			"message": str(todo.get("description", "")),
+			"agent_orch": str(todo.get("agent_orch", "")),
+			"done_outputs": done_outputs or [],
+			"output_summary": output_summary or "",
+			"feedback_summary": feedback_summary or "",
+		}
+
+		return prepared
+
+	async def _execute_with_cancel_watch(self, todo: Dict[str, Any], prepared_data: Dict[str, Any]) -> None:
+		executor = self._executor
+
+		context = ProcessGPTRequestContext(prepared_data)
+		event_queue = ProcessGPTEventQueue(todo)
+
+		_emit_log(f"[EXEC START] todo_id={todo.get('id')} agent={prepared_data.get('agent_orch','')}")
+		execute_task = asyncio.create_task(executor.execute(context, event_queue))
+		cancel_watch_task = asyncio.create_task(self._watch_cancellation(todo, executor, context, event_queue, execute_task))
+		
+		try:
+			done, pending = await asyncio.wait(
+				[cancel_watch_task, execute_task], 
+				return_when=asyncio.FIRST_COMPLETED
+			)
+			for task in pending:
+				task.cancel()
+				
+		except Exception as e:
+			_emit_error("서비스 실행 오류", e)
+			cancel_watch_task.cancel()
+			execute_task.cancel()
+		finally:
+			try:
+				await event_queue.close()
+			except Exception as e:
+				_emit_error("이벤트 큐 종료 실패", e)
+			_emit_log(f"[EXEC END] todo_id={todo.get('id')} agent={prepared_data.get('agent_orch','')}")
+
+	async def _watch_cancellation(self, todo: Dict[str, Any], executor: AgentExecutor, context: RequestContext, event_queue: EventQueue, execute_task: asyncio.Task) -> None:
+		todo_id = str(todo.get("id"))
+		
+		while True:
+			await asyncio.sleep(self.cancel_check_interval)
+			
+			status = await fetch_task_status(todo_id)
+			normalized = (status or "").strip().lower()
+			if normalized in ("cancelled", "fb_requested"):
+				_emit_log(f"작업 취소 감지: {todo_id}, 상태: {status}")
+				
+				try:
+					await executor.cancel(context, event_queue)
+				except Exception as e:
+					_emit_error("취소 처리 실패", e)
+				finally:
+					try:
+						execute_task.cancel()
+					except Exception as e:
+						_emit_error("실행 태스크 즉시 취소 실패", e)
+					try:
+						await event_queue.close()
+					except Exception as e:
+						_emit_error("취소 후 이벤트 큐 종료 실패", e)
+				break
+
+
+class ProcessGPTRequestContext(RequestContext):
+	def __init__(self, prepared_data: Dict[str, Any]):
+		self._prepared_data = prepared_data
+		self._message = prepared_data.get("message", "")
+		self._current_task = None
+
+	def get_user_input(self) -> str:
+		return self._message
+
+	@property
+	def message(self) -> str:
+		return self._message
+
+	@property
+	def current_task(self):
+		return getattr(self, "_current_task", None)
+
+	def get_context_data(self) -> Dict[str, Any]:
+		return self._prepared_data
+
+
+class ProcessGPTEventQueue(EventQueue):
+	def __init__(self, todo: Dict[str, Any]):
+		self.todo = todo
+		super().__init__()
+
+	def enqueue_event(self, event: Event):
+		try:
+			try:
+				super().enqueue_event(event)
+			except Exception as e:
+				_emit_error("이벤트 큐 삽입 실패", e)
+
+			self._create_bg_task(route_event(self.todo, event), "route_event")
+		except Exception as e:
+			_emit_error("이벤트 저장 실패", e)
+		
+	def task_done(self) -> None:
+		try:
+			_emit_log(f"태스크 완료: {self.todo['id']}")
+		except Exception as e:
+			_emit_error("태스크 완료 처리 실패", e)
+
+	async def close(self) -> None:
+		pass
+
+	def _create_bg_task(self, coro: Any, label: str) -> None:
+		try:
+			task = asyncio.create_task(coro)
+			def _cb(t: asyncio.Task):
+				exc = t.exception()
+				if exc:
+					_emit_error(f"백그라운드 태스크 오류({label})", exc)
+			task.add_done_callback(_cb)
+		except Exception as e:
+			_emit_error(f"백그라운드 태스크 생성 실패({label})", e)

processgpt_agent_sdk/tools/knowledge_tools.py

@@ -0,0 +1,206 @@
+import os
+from typing import Optional, List, Type
+from pydantic import BaseModel, Field, PrivateAttr, field_validator
+from crewai.tools import BaseTool
+from dotenv import load_dotenv
+from mem0 import Memory
+import requests
+from ..utils.logger import log, handle_error
+
+# ============================================================================
+# 설정 및 초기화
+# ============================================================================
+
+load_dotenv()
+
+DB_USER = os.getenv("DB_USER")
+DB_PASSWORD = os.getenv("DB_PASSWORD")
+DB_HOST = os.getenv("DB_HOST")
+DB_PORT = os.getenv("DB_PORT")
+DB_NAME = os.getenv("DB_NAME")
+
+CONNECTION_STRING = None
+if all([DB_USER, DB_PASSWORD, DB_HOST, DB_PORT, DB_NAME]):
+	CONNECTION_STRING = f"postgresql://{DB_USER}:{DB_PASSWORD}@{DB_HOST}:{DB_PORT}/{DB_NAME}"
+else:
+	log("mem0 연결 문자열이 설정되지 않았습니다(DB_* env). 기능은 제한될 수 있습니다.")
+
+# ============================================================================
+# 스키마 정의
+# ============================================================================
+
+class KnowledgeQuerySchema(BaseModel):
+	query: str = Field(..., description="검색할 지식 쿼리")
+	
+	@field_validator('query', mode='before')
+	@classmethod
+	def validate_query(cls, v):
+		import json
+		if isinstance(v, dict):
+			for k in ("description", "query", "q", "text", "message"):
+				if k in v and v[k]:
+					return str(v[k])
+			return "" if not v else json.dumps(v, ensure_ascii=False)
+		return v if isinstance(v, str) else str(v)
+
+# ============================================================================
+# 지식 검색 도구
+# ============================================================================
+
+class Mem0Tool(BaseTool):
+	"""Supabase 기반 mem0 지식 검색 도구 - 에이전트별"""
+	name: str = "mem0"
+	description: str = (
+		"🧠 에이전트별 개인 지식 저장소 검색 도구\n\n"
+		"🚨 필수 검색 순서: 작업 전 반드시 피드백부터 검색!\n\n"
+		"저장된 정보:\n"
+		"🔴 과거 동일한 작업에 대한 피드백 및 교훈 (최우선 검색 대상)\n"
+		"🔴 과거 실패 사례 및 개선 방안\n"
+		"• 객관적 정보 (사람명, 수치, 날짜, 사물 등)\n"
+		"검색 목적:\n"
+		"- 작업지시사항을 올바르게 수행하기 위해 필요한 정보(매개변수, 제약, 의존성)와\n"
+		"  안전 수행을 위한 피드백/주의사항을 찾기 위함\n"
+		"- 과거 실패 경험을 통한 실수 방지\n"
+		"- 정확한 객관적 정보 조회\n\n"
+		"사용 지침:\n"
+		"- 현재 작업 맥락(사용자 요청, 시스템/도구 출력, 최근 단계)을 근거로 자연어의 완전한 문장으로 질의하세요.\n"
+		"- 핵심 키워드 + 엔터티(고객명, 테이블명, 날짜 등) + 제약(환경/범위)을 조합하세요.\n"
+		"- 동의어/영문 용어를 섞어 2~3개의 표현으로 재질의하여 누락을 줄이세요.\n"
+		"- 필요한 경우 좁은 쿼리 → 넓은 쿼리 순서로 반복 검색하세요. (필요 시 기간/버전 범위 명시)\n"
+		"- 동일 정보를 다른 표현으로 재질의하며, 최신/가장 관련 결과를 우선 검토하세요.\n\n"
+		"⚡ 핵심: 어떤 작업이든 시작 전에, 해당 작업을 안전하게 수행하기 위한 피드백/주의사항과\n"
+		"  필수 매개변수를 먼저 질의하여 확보하세요!"
+	)
+	args_schema: Type[KnowledgeQuerySchema] = KnowledgeQuerySchema
+	_tenant_id: Optional[str] = PrivateAttr()
+	_user_id: Optional[str] = PrivateAttr()
+	_namespace: Optional[str] = PrivateAttr()
+	_memory: Optional[Memory] = PrivateAttr(default=None)
+
+	def __init__(self, tenant_id: str = None, user_id: str = None, **kwargs):
+		super().__init__(**kwargs)
+		self._tenant_id = tenant_id
+		self._user_id = user_id
+		self._namespace = user_id
+		self._memory = self._initialize_memory()
+		log(f"Mem0Tool 초기화: user_id={self._user_id}, namespace={self._namespace}")
+
+	def _initialize_memory(self) -> Optional[Memory]:
+		"""Memory 인스턴스 초기화 - 에이전트별"""
+		if not CONNECTION_STRING:
+			return None
+		config = {
+			"vector_store": {
+				"provider": "supabase",
+				"config": {
+					"connection_string": CONNECTION_STRING,
+					"collection_name": "memories",
+					"index_method": "hnsw",
+					"index_measure": "cosine_distance"
+				}
+			}
+		}
+		return Memory.from_config(config_dict=config)
+
+	def _run(self, query: str) -> str:
+		"""지식 검색 및 결과 반환 - 에이전트별 메모리에서"""
+		if not query:
+			return "검색할 쿼리를 입력해주세요."
+		if not self._user_id:
+			return "개인지식 검색 비활성화: user_id 없음"
+		if not self._memory:
+			return "mem0 비활성화: DB 연결 정보(DB_*)가 설정되지 않았습니다."
+		
+		try:
+			log(f"에이전트별 검색 시작: user_id={self._user_id}, query='{query}'")
+			results = self._memory.search(query, user_id=self._user_id)
+			hits = results.get("results", [])
+			
+			THRESHOLD = 0.5
+			MIN_RESULTS = 5
+			hits_sorted = sorted(hits, key=lambda x: x.get("score", 0), reverse=True)
+			filtered_hits = [h for h in hits_sorted if h.get("score", 0) >= THRESHOLD]
+			if len(filtered_hits) < MIN_RESULTS:
+				filtered_hits = hits_sorted[:MIN_RESULTS]
+			hits = filtered_hits
+
+			log(f"에이전트별 검색 결과: {len(hits)}개 항목 발견")
+			
+			if not hits:
+				return f"'{query}'에 대한 개인 지식이 없습니다."
+			
+			return self._format_results(hits)
+			
+		except Exception as e:
+			handle_error("지식검색오류", e, raise_error=False)
+			return f"지식검색오류: {e}"
+
+	def _format_results(self, hits: List[dict]) -> str:
+		"""검색 결과 포맷팅"""
+		items = []
+		for idx, hit in enumerate(hits, start=1):
+			memory_text = hit.get("memory", "")
+			score = hit.get("score", 0)
+			items.append(f"개인지식 {idx} (관련도: {score:.2f})\n{memory_text}")
+		
+		return "\n\n".join(items)
+
+# ============================================================================
+# 사내 문서 검색 (memento) 도구
+# ============================================================================
+
+class MementoQuerySchema(BaseModel):
+	query: str = Field(..., description="검색 키워드 또는 질문")
+
+class MementoTool(BaseTool):
+	"""사내 문서 검색을 수행하는 도구"""
+	name: str = "memento"
+	description: str = (
+		"🔒 보안 민감한 사내 문서 검색 도구\n\n"
+		"저장된 정보:\n"
+		"• 보안 민감한 사내 기밀 문서\n"
+		"• 대용량 사내 문서 및 정책 자료\n"
+		"• 객관적이고 정확한 회사 내부 지식\n"
+		"• 업무 프로세스, 규정, 기술 문서\n\n"
+		"검색 목적:\n"
+		"- 작업지시사항을 올바르게 수행하기 위한 회사 정책/규정/프로세스/매뉴얼 확보\n"
+		"- 최신 버전의 표준과 가이드라인 확인\n\n"
+		"사용 지침:\n"
+		"- 현재 작업/요청과 직접 연결된 문맥을 담아 자연어의 완전한 문장으로 질의하세요.\n"
+		"- 문서 제목/버전/담당조직/기간/환경(프로덕션·스테이징·모듈 등) 조건을 명확히 포함하세요.\n"
+		"- 약어·정식명칭, 한·영 용어를 함께 사용해 2~3회 재질의하며 누락을 줄이세요.\n"
+		"- 처음엔 좁게, 필요 시 점진적으로 범위를 넓혀 검색하세요.\n\n"
+		"⚠️ 보안 민감 정보 포함 - 적절한 권한과 용도로만 사용"
+	)
+	args_schema: Type[MementoQuerySchema] = MementoQuerySchema
+	_tenant_id: str = PrivateAttr()
+
+	def __init__(self, tenant_id: str = "localhost", **kwargs):
+		super().__init__(**kwargs)
+		self._tenant_id = tenant_id
+		log(f"MementoTool 초기화: tenant_id={self._tenant_id}")
+
+	def _run(self, query: str) -> str:
+		try:
+			log(f"Memento 문서 검색 시작: tenant_id='{self._tenant_id}', query='{query}'")
+			response = requests.post(
+				"http://memento.process-gpt.io/retrieve",
+				json={"query": query, "options": {"tenant_id": self._tenant_id}}
+			)
+			if response.status_code != 200:
+				return f"API 오류: {response.status_code}"
+			data = response.json()
+			if not data.get("response"):
+				return f"테넌트 '{self._tenant_id}'에서 '{query}' 검색 결과가 없습니다."
+			results = []
+			docs = data.get("response", [])
+			log(f"Memento 검색 결과 개수: {len(docs)}")
+			for doc in docs:
+				fname = doc.get('metadata', {}).get('file_name', 'unknown')
+				idx = doc.get('metadata', {}).get('chunk_index', 'unknown')
+				content = doc.get('page_content', '')
+				results.append(f"📄 파일: {fname} (청크 #{idx})\n내용: {content}\n---")
+			return f"테넌트 '{self._tenant_id}'에서 '{query}' 검색 결과:\n\n" + "\n".join(results)
+		except Exception as e:
+			handle_error("문서검색오류", e, raise_error=False)
+			return f"문서검색오류: {e}"

processgpt_agent_sdk/tools/safe_tool_loader.py

@@ -0,0 +1,191 @@
+import os
+import subprocess
+import time
+from typing import List, Dict, Optional
+import anyio
+from mcp.client.stdio import StdioServerParameters
+from crewai_tools import MCPServerAdapter
+from .knowledge_tools import Mem0Tool, MementoTool
+from ..utils.logger import log, handle_error
+
+
+class SafeToolLoader:
+	"""도구 로더 클래스"""
+	adapters = []  # MCPServerAdapter 인스턴스 등록
+	
+	ANYIO_PATCHED: bool = False
+
+	def __init__(self, tenant_id: Optional[str] = None, user_id: Optional[str] = None, agent_name: Optional[str] = None, mcp_config: Optional[Dict] = None):
+		self.tenant_id = tenant_id
+		self.user_id = user_id
+		self.agent_name = agent_name
+		# 외부에서 전달된 MCP 설정 사용 (DB 접근 금지)
+		self._mcp_servers = (mcp_config or {}).get('mcpServers', {})
+		self.local_tools = ["mem0", "memento", "human_asked"]
+		log(f"SafeToolLoader 초기화 완료 (tenant_id: {tenant_id}, user_id: {user_id})")
+
+	def warmup_server(self, server_key: str):
+		"""npx 기반 서버의 패키지를 미리 캐시에 저장해 실제 실행을 빠르게."""
+		cfg = self._get_mcp_config(server_key)
+		if not cfg or cfg.get("command") != "npx":
+			return
+			
+		npx = self._find_npx_command()
+		if not npx:
+			return
+			
+		args = cfg.get("args", [])
+		if not (args and args[0] == "-y"):
+			return
+			
+		pkg = args[1]
+		
+		try:
+			subprocess.run([npx, "-y", pkg, "--help"], capture_output=True, timeout=10, shell=True)
+			return
+		except subprocess.TimeoutExpired:
+			pass
+		except Exception:
+			pass
+			
+		try:
+			subprocess.run([npx, "-y", pkg, "--help"], capture_output=True, timeout=60, shell=True)
+		except Exception:
+			pass
+
+	def _find_npx_command(self) -> str:
+		"""npx 명령어 경로 찾기"""
+		try:
+			import shutil
+			npx_path = shutil.which("npx") or shutil.which("npx.cmd")
+			if npx_path:
+				return npx_path
+		except Exception:
+			pass
+		return "npx"
+
+	def create_tools_from_names(self, tool_names: List[str]) -> List:
+		"""tool_names 리스트에서 실제 Tool 객체들 생성"""
+		if isinstance(tool_names, str):
+			tool_names = [tool_names]
+		log(f"도구 생성 요청: {tool_names}")
+		
+		tools = []
+		
+		tools.extend(self._load_mem0())
+		tools.extend(self._load_memento())
+		tools.extend(self._load_human_asked())
+		
+		for name in tool_names:
+			key = name.strip().lower()
+			if key in self.local_tools:
+				continue
+			else:
+				self.warmup_server(key)
+				tools.extend(self._load_mcp_tool(key))
+		
+		log(f"총 {len(tools)}개 도구 생성 완료")
+		return tools
+
+	def _load_mem0(self) -> List:
+		"""mem0 도구 로드 - 에이전트별 메모리"""
+		try:
+			if not self.user_id:
+				log("mem0 도구 로드 생략: user_id 없음")
+				return []
+			return [Mem0Tool(tenant_id=self.tenant_id, user_id=self.user_id)]
+		except Exception as e:
+			handle_error("툴mem0오류", e, raise_error=False)
+			return []
+
+	def _load_memento(self) -> List:
+		"""memento 도구 로드"""
+		try:
+			return [MementoTool(tenant_id=self.tenant_id)]
+		except Exception as e:
+			handle_error("툴memento오류", e, raise_error=False)
+			return []
+
+	def _load_human_asked(self) -> List:
+		"""human_asked 도구 로드 (선택사항: 사용 시 외부에서 주입)"""
+		try:
+			# 필요한 경우 외부에서 HumanQueryTool을 이 패키지에 추가하여 import하고 리턴하도록 변경 가능
+			return []
+		except Exception as e:
+			handle_error("툴human오류", e, raise_error=False)
+			return []
+
+	def _load_mcp_tool(self, tool_name: str) -> List:
+		"""MCP 도구 로드 (timeout & retry 지원)"""
+		self._apply_anyio_patch()
+		
+		server_cfg = self._get_mcp_config(tool_name)
+		if not server_cfg:
+			return []
+		
+		env_vars = os.environ.copy()
+		env_vars.update(server_cfg.get("env", {}))
+		timeout = server_cfg.get("timeout", 40)
+
+		max_retries = 2
+		retry_delay = 5
+
+		for attempt in range(1, max_retries + 1):
+			try:
+				cmd = server_cfg["command"]
+				if cmd == "npx":
+					cmd = self._find_npx_command() or cmd
+				
+				params = StdioServerParameters(
+					command=cmd,
+					args=server_cfg.get("args", []),
+					env=env_vars,
+					timeout=timeout
+				)
+				
+				adapter = MCPServerAdapter(params)
+				SafeToolLoader.adapters.append(adapter)
+				log(f"{tool_name} MCP 로드 성공 (툴 {len(adapter.tools)}개): {[tool.name for tool in adapter.tools]}")
+				return adapter.tools
+
+			except Exception as e:
+				if attempt < max_retries:
+					time.sleep(retry_delay)
+				else:
+					handle_error(f"툴{tool_name}오류", e, raise_error=False)
+					return []
+
+	def _apply_anyio_patch(self):
+		"""anyio stderr 패치 적용"""
+		if SafeToolLoader.ANYIO_PATCHED:
+			return
+		from anyio._core._subprocesses import open_process as _orig
+
+		async def patched_open_process(*args, **kwargs):
+			stderr = kwargs.get('stderr')
+			if not (hasattr(stderr, 'fileno') and stderr.fileno()):
+				kwargs['stderr'] = subprocess.PIPE
+			return await _orig(*args, **kwargs)
+
+		anyio.open_process = patched_open_process
+		anyio._core._subprocesses.open_process = patched_open_process
+		SafeToolLoader.ANYIO_PATCHED = True
+
+	def _get_mcp_config(self, tool_name: str) -> dict:
+		"""전달받은 mcp_config에서 툴별 설정을 조회."""
+		try:
+			return self._mcp_servers.get(tool_name, {}) if self._mcp_servers else {}
+		except Exception as e:
+			handle_error("툴설정오류", e, raise_error=False)
+			return {}
+
+	@classmethod
+	def shutdown_all_adapters(cls):
+		"""모든 MCPServerAdapter 연결 종료"""
+		for adapter in cls.adapters:
+			try:
+				adapter.stop()
+			except Exception as e:
+				handle_error("툴종료오류", e, raise_error=True)
+		log("모든 MCPServerAdapter 연결 종료 완료")
+		cls.adapters.clear()

processgpt_agent_sdk/utils/event_handler.py

@@ -0,0 +1,27 @@
+from __future__ import annotations
+
+from typing import Any, Dict
+
+from a2a.server.events import Event
+from .logger import handle_error as _emit_error, log as _emit_log
+from ..core.database import record_event
+
+
+def _event_to_dict(event: Event) -> Dict[str, Any]:
+	try:
+		if hasattr(event, "__dict__"):
+			return {k: v for k, v in event.__dict__.items() if not k.startswith("_")}
+		return {"event": str(event)}
+	except Exception as e:
+		_emit_error("event dict 변환 실패", e)
+		return {"event": str(event)}
+
+
+async def route_event(todo: Dict[str, Any], event: Event) -> None:
+	"""이벤트를 dict으로 변환해 events 테이블에 기록.
+
+	- 복잡한 라우팅/분기는 추후 확장. 현재는 단일 events 테이블에 기록.
+	- event_type은 None으로 두거나, 필요 시 상위에서 지정하도록 추후 확장 가능.
+	"""
+	data = _event_to_dict(event)
+	await record_event(todo, data, event_type=None)

processgpt_agent_sdk/utils/logger.py

@@ -0,0 +1,30 @@
+import logging
+import os
+import traceback
+from typing import Optional, Dict
+
+
+# Configure root logger only once (idempotent)
+if not logging.getLogger().handlers:
+	logging.basicConfig(
+		level=logging.INFO,
+		format="%(asctime)s %(levelname)s %(name)s - %(message)s",
+	)
+
+_logger = logging.getLogger("process-gpt-agent-framework")
+
+
+def log(message: str, level: int = logging.INFO) -> None:
+	spaced = os.getenv("LOG_SPACED", "1") != "0"
+	suffix = "\n" if spaced else ""
+	_logger.log(level, f"{message}{suffix}")
+
+
+def handle_error(title: str, error: Exception, *, raise_error: bool = False, extra: Optional[Dict] = None) -> None:
+	spaced = os.getenv("LOG_SPACED", "1") != "0"
+	suffix = "\n" if spaced else ""
+	context = f" | extra={extra}" if extra else ""
+	_logger.error(f"{title}: {error}{context}{suffix}")
+	_logger.error(traceback.format_exc())
+	if raise_error:
+		raise error