gohumanloop 0.0.4__py3-none-any.whl → 0.0.6__py3-none-any.whl

gohumanloop/providers/ghl_provider.py

@@ -1,17 +1,18 @@
 import os
 from typing import Dict, Any, Optional
-from pydantic import BaseModel, Field, field_validator, SecretStr
 
 from gohumanloop.models.glh_model import GoHumanLoopConfig
 from gohumanloop.providers.api_provider import APIProvider
 from gohumanloop.utils import get_secret_from_env
 
+
 class GoHumanLoopProvider(APIProvider):
     """
     GoHumanLoop platform provider class.
     This class is a concrete implementation of the `APIProvider` class.
     The `GoHumanLoopProvider` class is responsible for interacting with the GoHumanLoop platform.
     """
+
     def __init__(
         self,
         name: str,
@@ -19,14 +20,12 @@ class GoHumanLoopProvider(APIProvider):
         poll_interval: int = 5,
         max_retries: int = 3,
         default_platform: Optional[str] = "GoHumanLoop",
-        config: Optional[Dict[str, Any]] = None
+        config: Optional[Dict[str, Any]] = None,
     ):
         """Initialize GoHumanLoop provider
-        
+
         Args:
             name: Provider name
-            api_key: GoHumanLoop API key, if not provided will be fetched from environment variables
-            api_base_url: GoHumanLoop API base URL, if not provided will use default value
             default_platform: Default platform, e.g. "wechat", "feishu" etc.
             request_timeout: API request timeout in seconds
             poll_interval: Polling interval in seconds
@@ -35,16 +34,18 @@ class GoHumanLoopProvider(APIProvider):
         """
         # Get API key from environment variables (if not provided)
         api_key = get_secret_from_env("GOHUMANLOOP_API_KEY")
-            
+
+        if api_key is None:
+            raise ValueError("GOHUMANLOOP_API_KEY environment variable is not set!")
+
         # Get API base URL from environment variables (if not provided)
-        api_base_url = os.environ.get("GOHUMANLOOP_API_BASE_URL", "https://www.gohumanloop.com")
-        
-        # Validate configuration using pydantic model
-        ghl_config = GoHumanLoopConfig(
-            api_key=api_key,
-            api_base_url=api_base_url
+        api_base_url = os.environ.get(
+            "GOHUMANLOOP_API_BASE_URL", "https://www.gohumanloop.com"
         )
-        
+
+        # Validate configuration using pydantic model
+        ghl_config = GoHumanLoopConfig(api_key=api_key, api_base_url=api_base_url)
+
         super().__init__(
             name=name,
             api_base_url=ghl_config.api_base_url,
@@ -53,12 +54,13 @@ class GoHumanLoopProvider(APIProvider):
             request_timeout=request_timeout,
             poll_interval=poll_interval,
             max_retries=max_retries,
-            config=config
+            config=config,
         )
-    
+
     def __str__(self) -> str:
         """Returns a string description of this instance"""
         base_str = super().__str__()
-        ghl_info = f"- GoHumanLoop Provider: Connected to GoHumanLoop Official Platform\n"
+        ghl_info = (
+            "- GoHumanLoop Provider: Connected to GoHumanLoop Official Platform\n"
+        )
         return f"{ghl_info}{base_str}"
-    

gohumanloop/providers/terminal_provider.py

@@ -1,21 +1,22 @@
 import asyncio
-from concurrent.futures import ThreadPoolExecutor
-from typing import Dict, Any, Optional
+from concurrent.futures import ThreadPoolExecutor, Future
+from typing import Dict, Any, Optional, Tuple
 from datetime import datetime
 
-from gohumanloop.core.interface import (HumanLoopResult, HumanLoopStatus, HumanLoopType)
+from gohumanloop.core.interface import HumanLoopResult, HumanLoopStatus, HumanLoopType
 from gohumanloop.providers.base import BaseProvider
 
+
 class TerminalProvider(BaseProvider):
     """Terminal-based human-in-the-loop provider implementation
-    
+
     This provider interacts with users through command line interface, suitable for testing and simple scenarios.
     Users can respond to requests via terminal input, supporting approval, information collection and conversation type interactions.
     """
-    
+
     def __init__(self, name: str, config: Optional[Dict[str, Any]] = None):
         """Initialize terminal provider
-        
+
         Args:
             name: Provider name
             config: Configuration options, may include:
@@ -23,11 +24,11 @@ class TerminalProvider(BaseProvider):
         super().__init__(name, config)
 
         # Store running terminal input tasks
-        self._terminal_input_tasks = {}
+        self._terminal_input_tasks: Dict[Tuple[str, str], Future] = {}
         # Create thread pool for background service execution
         self._executor = ThreadPoolExecutor(max_workers=10)
 
-    def __del__(self):
+    def __del__(self) -> None:
         """Destructor to ensure thread pool is properly closed"""
         self._executor.shutdown(wait=False)
 
@@ -37,9 +38,11 @@ class TerminalProvider(BaseProvider):
 
     def __str__(self) -> str:
         base_str = super().__str__()
-        terminal_info = f"- Terminal Provider: Terminal-based human-in-the-loop implementation\n"
+        terminal_info = (
+            "- Terminal Provider: Terminal-based human-in-the-loop implementation\n"
+        )
         return f"{terminal_info}{base_str}"
-    
+
     async def async_request_humanloop(
         self,
         task_id: str,
@@ -47,10 +50,10 @@ class TerminalProvider(BaseProvider):
         loop_type: HumanLoopType,
         context: Dict[str, Any],
         metadata: Optional[Dict[str, Any]] = None,
-        timeout: Optional[int] = None
+        timeout: Optional[int] = None,
     ) -> HumanLoopResult:
         """Request human-in-the-loop interaction through terminal
-        
+
         Args:
             task_id: Task identifier
             conversation_id: Conversation ID for multi-turn dialogs
@@ -58,13 +61,13 @@ class TerminalProvider(BaseProvider):
             context: Context information provided to human
             metadata: Additional metadata
             timeout: Request timeout in seconds
-            
+
         Returns:
             HumanLoopResult: Result object containing request ID and initial status
         """
         # Generate request ID
         request_id = self._generate_request_id()
-        
+
         # Store request information
         self._store_request(
             conversation_id=conversation_id,
@@ -73,36 +76,42 @@ class TerminalProvider(BaseProvider):
             loop_type=loop_type,
             context=context,
             metadata=metadata or {},
-            timeout=timeout
+            timeout=timeout,
         )
-        
+
         # Create initial result object
         result = HumanLoopResult(
             conversation_id=conversation_id,
             request_id=request_id,
             loop_type=loop_type,
-            status=HumanLoopStatus.PENDING
+            status=HumanLoopStatus.PENDING,
         )
-        
 
-        self._terminal_input_tasks[(conversation_id, request_id)] = self._executor.submit(self._run_async_terminal_interaction, conversation_id, request_id)
+        self._terminal_input_tasks[
+            (conversation_id, request_id)
+        ] = self._executor.submit(
+            self._run_async_terminal_interaction, conversation_id, request_id
+        )
 
         # Create timeout task if timeout is specified
         if timeout:
             await self._async_create_timeout_task(conversation_id, request_id, timeout)
-        
-        return result
 
+        return result
 
-    def _run_async_terminal_interaction(self, conversation_id: str, request_id: str):
+    def _run_async_terminal_interaction(
+        self, conversation_id: str, request_id: str
+    ) -> None:
         """Run asynchronous terminal interaction in a separate thread"""
         # Create new event loop
         loop = asyncio.new_event_loop()
         asyncio.set_event_loop(loop)
-        
+
         try:
             # Run interaction processing in the new event loop
-            loop.run_until_complete(self._process_terminal_interaction(conversation_id, request_id))
+            loop.run_until_complete(
+                self._process_terminal_interaction(conversation_id, request_id)
+            )
         finally:
             loop.close()
             # Remove from task dictionary
@@ -110,16 +119,14 @@ class TerminalProvider(BaseProvider):
                 del self._terminal_input_tasks[(conversation_id, request_id)]
 
     async def async_check_request_status(
-        self,
-        conversation_id: str,
-        request_id: str
+        self, conversation_id: str, request_id: str
     ) -> HumanLoopResult:
         """Check request status
-        
+
         Args:
             conversation_id: Conversation identifier
             request_id: Request identifier
-            
+
         Returns:
             HumanLoopResult: Result object containing current status
         """
@@ -130,9 +137,9 @@ class TerminalProvider(BaseProvider):
                 request_id=request_id,
                 loop_type=HumanLoopType.CONVERSATION,
                 status=HumanLoopStatus.ERROR,
-                error=f"Request '{request_id}' not found in conversation '{conversation_id}'"
+                error=f"Request '{request_id}' not found in conversation '{conversation_id}'",
             )
-        
+
         # Build result object
         result = HumanLoopResult(
             conversation_id=conversation_id,
@@ -143,11 +150,11 @@ class TerminalProvider(BaseProvider):
             feedback=request_info.get("feedback", {}),
             responded_by=request_info.get("responded_by", None),
             responded_at=request_info.get("responded_at", None),
-            error=request_info.get("error", None)
+            error=request_info.get("error", None),
         )
-        
+
         return result
-        
+
     async def async_continue_humanloop(
         self,
         conversation_id: str,
@@ -156,13 +163,13 @@ class TerminalProvider(BaseProvider):
         timeout: Optional[int] = None,
     ) -> HumanLoopResult:
         """Continue human-in-the-loop interaction for multi-turn conversations
-        
+
         Args:
             conversation_id: Conversation identifier
             context: Context information provided to human
             metadata: Additional metadata
             timeout: Request timeout in seconds
-            
+
         Returns:
             HumanLoopResult: Result object containing request ID and status
         """
@@ -174,15 +181,15 @@ class TerminalProvider(BaseProvider):
                 request_id="",
                 loop_type=HumanLoopType.CONVERSATION,
                 status=HumanLoopStatus.ERROR,
-                error=f"Conversation '{conversation_id}' not found"
+                error=f"Conversation '{conversation_id}' not found",
             )
-        
+
         # Generate new request ID
         request_id = self._generate_request_id()
-        
+
         # Get task ID
         task_id = conversation_info.get("task_id", "unknown_task")
-        
+
         # Store request information
         self._store_request(
             conversation_id=conversation_id,
@@ -191,30 +198,36 @@ class TerminalProvider(BaseProvider):
             loop_type=HumanLoopType.CONVERSATION,  # Default to conversation type for continued dialog
             context=context,
             metadata=metadata or {},
-            timeout=timeout
+            timeout=timeout,
         )
-        
+
         # Create initial result object
         result = HumanLoopResult(
             conversation_id=conversation_id,
             request_id=request_id,
             loop_type=HumanLoopType.CONVERSATION,
-            status=HumanLoopStatus.PENDING
+            status=HumanLoopStatus.PENDING,
         )
-        
+
         # Start async task to process user input
-        self._terminal_input_tasks[(conversation_id, request_id)] = self._executor.submit(self._run_async_terminal_interaction, conversation_id, request_id)
-        
+        self._terminal_input_tasks[
+            (conversation_id, request_id)
+        ] = self._executor.submit(
+            self._run_async_terminal_interaction, conversation_id, request_id
+        )
+
         # Create timeout task if timeout is specified
         if timeout:
             await self._async_create_timeout_task(conversation_id, request_id, timeout)
-        
+
         return result
-    
-    async def _process_terminal_interaction(self, conversation_id: str, request_id: str):
+
+    async def _process_terminal_interaction(
+        self, conversation_id: str, request_id: str
+    ) -> None:
         request_info = self._get_request(conversation_id, request_id)
         if not request_info:
-            return 
+            return
 
         prompt = self.build_prompt(
             task_id=request_info["task_id"],
@@ -223,33 +236,40 @@ class TerminalProvider(BaseProvider):
             loop_type=request_info["loop_type"],
             created_at=request_info.get("created_at", ""),
             context=request_info["context"],
-            metadata=request_info.get("metadata")
+            metadata=request_info.get("metadata"),
         )
 
         loop_type = request_info["loop_type"]
-        
+
         # Display prompt message
         print(prompt)
-        
+
         # Handle different interaction types based on loop type
         if loop_type == HumanLoopType.APPROVAL:
-            await self._async_handle_approval_interaction(conversation_id, request_id, request_info)
+            await self._async_handle_approval_interaction(
+                conversation_id, request_id, request_info
+            )
         elif loop_type == HumanLoopType.INFORMATION:
-            await self._async_handle_information_interaction(conversation_id, request_id, request_info)
+            await self._async_handle_information_interaction(
+                conversation_id, request_id, request_info
+            )
         else:  # HumanLoopType.CONVERSATION
-            await self._async_handle_conversation_interaction(conversation_id, request_id, request_info)
+            await self._async_handle_conversation_interaction(
+                conversation_id, request_id, request_info
+            )
 
-            
-    async def _async_handle_approval_interaction(self, conversation_id: str, request_id: str, request_info: Dict[str, Any]):
+    async def _async_handle_approval_interaction(
+        self, conversation_id: str, request_id: str, request_info: Dict[str, Any]
+    ) -> None:
         """Handle approval type interaction
-        
+
         Args:
             conversation_id: Conversation ID
             request_id: Request ID
             request_info: Request information
         """
         print("\nPlease enter your decision (approve/reject):")
-        
+
         # Execute blocking input() call in thread pool using run_in_executor
         loop = asyncio.get_event_loop()
         response = await loop.run_in_executor(None, input)
@@ -266,53 +286,59 @@ class TerminalProvider(BaseProvider):
         else:
             print("\nInvalid input, please enter 'approve' or 'reject'")
             # Recursively handle approval interaction
-            await self._async_handle_approval_interaction(conversation_id, request_id, request_info)
+            await self._async_handle_approval_interaction(
+                conversation_id, request_id, request_info
+            )
             return
-        
+
         # Update request information
         request_info["status"] = status
         request_info["response"] = response_data
         request_info["responded_by"] = "terminal_user"
         request_info["responded_at"] = datetime.now().isoformat()
-        
+
         print(f"\nYour decision has been recorded: {status.value}")
-    
-    async def _async_handle_information_interaction(self, conversation_id: str, request_id: str, request_info: Dict[str, Any]):
+
+    async def _async_handle_information_interaction(
+        self, conversation_id: str, request_id: str, request_info: Dict[str, Any]
+    ) -> None:
         """Handle information collection type interaction
-        
+
         Args:
             conversation_id: Conversation ID
             request_id: Request ID
             request_info: Request information
         """
         print("\nPlease provide the required information:")
-        
+
         # Execute blocking input() call in thread pool using run_in_executor
         loop = asyncio.get_event_loop()
         response = await loop.run_in_executor(None, input)
-        
+
         # Update request information
         request_info["status"] = HumanLoopStatus.COMPLETED
         request_info["response"] = response
         request_info["responded_by"] = "terminal_user"
         request_info["responded_at"] = datetime.now().isoformat()
-        
+
         print("\nYour information has been recorded")
-    
-    async def _async_handle_conversation_interaction(self, conversation_id: str, request_id: str, request_info: Dict[str, Any]):
+
+    async def _async_handle_conversation_interaction(
+        self, conversation_id: str, request_id: str, request_info: Dict[str, Any]
+    ) -> None:
         """Handle conversation type interaction
-        
+
         Args:
             conversation_id: Conversation ID
             request_id: Request ID
             request_info: Request information
         """
         print("\nPlease enter your response (type 'exit' to end conversation):")
-        
+
         # Execute blocking input() call in thread pool using run_in_executor
         loop = asyncio.get_event_loop()
         response = await loop.run_in_executor(None, input)
-        
+
         # Process response
         if response.strip().lower() in ["exit", "quit", "结束", "退出"]:
             status = HumanLoopStatus.COMPLETED
@@ -325,20 +351,16 @@ class TerminalProvider(BaseProvider):
         request_info["response"] = response
         request_info["responded_by"] = "terminal_user"
         request_info["responded_at"] = datetime.now().isoformat()
-        
+
         print("\nYour response has been recorded")
 
-    async def async_cancel_request(
-        self,
-        conversation_id: str,
-        request_id: str
-    ) -> bool:
+    async def async_cancel_request(self, conversation_id: str, request_id: str) -> bool:
         """Cancel human-in-the-loop request
-        
+
         Args:
             conversation_id: Conversation identifier for multi-turn dialogues
             request_id: Request identifier for specific interaction request
-            
+
         Return:
             bool: Whether cancellation was successful, True indicates successful cancellation,
                  False indicates cancellation failed
@@ -347,19 +369,16 @@ class TerminalProvider(BaseProvider):
         if request_key in self._terminal_input_tasks:
             self._terminal_input_tasks[request_key].cancel()
             del self._terminal_input_tasks[request_key]
-            
+
         # 调用父类方法取消请求
         return await super().async_cancel_request(conversation_id, request_id)
-        
-    async def async_cancel_conversation(
-        self,
-        conversation_id: str
-    ) -> bool:
+
+    async def async_cancel_conversation(self, conversation_id: str) -> bool:
         """Cancel the entire conversation
-        
+
         Args:
             conversation_id: Conversation identifier
-            
+
         Returns:
             bool: Whether cancellation was successful
         """
@@ -369,6 +388,6 @@ class TerminalProvider(BaseProvider):
             if request_key in self._terminal_input_tasks:
                 self._terminal_input_tasks[request_key].cancel()
                 del self._terminal_input_tasks[request_key]
-                
+
         # 调用父类方法取消对话
-        return await super().async_cancel_conversation(conversation_id)
+        return await super().async_cancel_conversation(conversation_id)

gohumanloop/utils/__init__.py

@@ -1 +1,7 @@
-from .utils import run_async_safely, get_secret_from_env
+from .utils import run_async_safely, get_secret_from_env
+
+
+__all__ = [
+    "run_async_safely",
+    "get_secret_from_env",
+]

gohumanloop/utils/context_formatter.py

@@ -1,40 +1,45 @@
-from typing import Dict, Any, List, Optional, Union
+from typing import Dict, Any
 import json
 
+
 class ContextFormatter:
     """上下文格式化工具"""
-    
+
     @staticmethod
     def format_for_human(context: Dict[str, Any]) -> str:
         """将上下文格式化为人类可读的文本"""
         result = []
-        
+
         # 添加标题（如果有）
         if "title" in context:
             result.append(f"# {context['title']}\n")
-            
+
         # 添加描述（如果有）
         if "description" in context:
             result.append(f"{context['description']}\n")
-            
+
         # 添加任务信息
         if "task" in context:
             result.append(f"## 任务\n{context['task']}\n")
-            
+
         # 添加代理信息
         if "agent" in context:
             result.append(f"## 代理\n{context['agent']}\n")
-            
+
         # 添加操作信息
         if "action" in context:
             result.append(f"## 请求的操作\n{context['action']}\n")
-            
+
         # 添加原因
         if "reason" in context:
             result.append(f"## 原因\n{context['reason']}\n")
-            
+
         # 添加其他键值对
-        other_keys = [k for k in context.keys() if k not in ["title", "description", "task", "agent", "action", "reason"]]
+        other_keys = [
+            k
+            for k in context.keys()
+            if k not in ["title", "description", "task", "agent", "action", "reason"]
+        ]
         if other_keys:
             result.append("## 附加信息\n")
             for key in other_keys:
@@ -42,18 +47,18 @@ class ContextFormatter:
                 if isinstance(value, (dict, list)):
                     value = json.dumps(value, ensure_ascii=False, indent=2)
                 result.append(f"### {key}\n```\n{value}\n```\n")
-                
+
         return "\n".join(result)
-        
+
     @staticmethod
     def format_for_api(context: Dict[str, Any]) -> Dict[str, Any]:
         """将上下文格式化为API友好的格式"""
         # 复制上下文以避免修改原始数据
         formatted = context.copy()
-        
+
         # 确保所有值都是可序列化的
         for key, value in formatted.items():
             if not isinstance(value, (str, int, float, bool, list, dict, type(None))):
                 formatted[key] = str(value)
-                
-        return formatted
+
+        return formatted