gohumanloop 0.0.3__tar.gz → 0.0.5__tar.gz

{gohumanloop-0.0.3 → gohumanloop-0.0.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gohumanloop
-Version: 0.0.3
+Version: 0.0.5
 Summary: Perfecting AI workflows with human intelligence
 Author-email: gohumanloop authors <baird0917@163.com>
 Project-URL: repository, https://github.com/ptonlix/gohumanloop

{gohumanloop-0.0.3 → gohumanloop-0.0.5}/gohumanloop/__init__.py

@@ -12,12 +12,18 @@ from gohumanloop.manager.ghl_manager import GoHumanLoopManager
 
 from gohumanloop.providers.ghl_provider import GoHumanLoopProvider
 from gohumanloop.providers.api_provider import APIProvider
-from gohumanloop.providers.email_provider import EmailProvider
 from gohumanloop.providers.base import BaseProvider
 from gohumanloop.providers.terminal_provider import TerminalProvider
 
 from gohumanloop.utils import run_async_safely, get_secret_from_env
 
+# Conditionally import EmailProvider
+try:
+    from gohumanloop.providers.email_provider import EmailProvider
+    _has_email = True
+except ImportError:
+    _has_email = False
+
 # Dynamically get version number
 try:
     from importlib.metadata import version, PackageNotFoundError
@@ -53,7 +59,6 @@ __all__ = [
     "BaseProvider",
     "APIProvider",
     "GoHumanLoopProvider",
-    "EmailProvider",
     "TerminalProvider",
     
     # Utility Functions
@@ -62,4 +67,7 @@ __all__ = [
     
     # Version Information
     "__version__",
-]
+]
+
+if _has_email:
+    __all__.append("EmailProvider")

{gohumanloop-0.0.3 → gohumanloop-0.0.5}/gohumanloop/adapters/langgraph_adapter.py

@@ -5,12 +5,15 @@ import uuid
 import time
 from inspect import iscoroutinefunction
 from contextlib import asynccontextmanager, contextmanager
+import logging
 
 from gohumanloop.utils import run_async_safely
 from gohumanloop.core.interface import (
     HumanLoopManager, HumanLoopResult, HumanLoopStatus, HumanLoopType, HumanLoopCallback, HumanLoopProvider
 )
 
+logger = logging.getLogger(__name__)
+
 # Define TypeVars for input and output types
 T = TypeVar("T")
 R = TypeVar('R')
@@ -633,7 +636,7 @@ class LangGraphHumanLoopCallback(HumanLoopCallback):
         if self.async_on_timeout:
             await self.async_on_timeout(self.state, provider)
 
-    async def async_humanloop_on_error(
+    async def async_on_humanloop_error(
         self,
         provider: HumanLoopProvider,
         error: Exception
@@ -658,9 +661,7 @@ def default_langgraph_callback_factory(state: Any) -> LangGraphHumanLoopCallback
     Returns:
         Configured LangGraphHumanLoopCallback instance
     """
-    import logging
-    
-    logger = logging.getLogger("gohumanloop.langgraph")
+
     
     async def async_on_update(state, provider: HumanLoopProvider, result: HumanLoopResult):
         """Log human interaction update events"""
@@ -713,6 +714,8 @@ default_adapter = LangGraphAdapter(manager, default_timeout=60)
 
 default_conversation_id = str(uuid.uuid4())
 
+_SKIP_NEXT_HUMANLOOP = False
+
 def interrupt(value: Any, lg_humanloop: LangGraphAdapter = default_adapter) -> Any:
     """
     Wraps LangGraph's interrupt functionality to pause graph execution and wait for human input
@@ -726,23 +729,34 @@ def interrupt(value: Any, lg_humanloop: LangGraphAdapter = default_adapter) -> A
     Returns:
         Input value provided by human user
     """
+
+    global _SKIP_NEXT_HUMANLOOP
+
     if not _SUPPORTS_INTERRUPT:
         raise RuntimeError(
             "LangGraph version too low, interrupt not supported. Please upgrade to version 0.2.57 or higher."
             "You can use: pip install --upgrade langgraph>=0.2.57"
         )
     
-    # Get current event loop or create new one
-    lg_humanloop.manager.request_humanloop(
-        task_id="lg_interrupt",
-        conversation_id=default_conversation_id,
-        loop_type=HumanLoopType.INFORMATION,
-        context={
-            "message": f"{value}",
-            "question": "The execution has been interrupted. Please review the above information and provide your input to continue.",
-        },
-        blocking=False,
-    )
+    if not _SKIP_NEXT_HUMANLOOP:
+        # Get current event loop or create new one
+        try:
+            lg_humanloop.manager.request_humanloop(
+                task_id="lg_interrupt",
+                conversation_id=default_conversation_id,
+                loop_type=HumanLoopType.INFORMATION,
+                context={
+                    "message": f"{value}",
+                    "question": "The execution has been interrupted. Please review the above information and provide your input to continue.",
+                },
+                blocking=False,
+            )
+        except Exception as e:
+            logger.exception(f"Error in interrupt: {e}")
+    else:
+        # Reset flag to allow normal human intervention trigger next time
+        _SKIP_NEXT_HUMANLOOP = False
+
 
     # Return LangGraph's interrupt
     return _lg_interrupt(value)
@@ -758,6 +772,9 @@ def create_resume_command(lg_humanloop: LangGraphAdapter = default_adapter) -> A
     Returns:
         Command object that can be used with graph.stream method
     """
+
+    global _SKIP_NEXT_HUMANLOOP
+
     if not _SUPPORTS_INTERRUPT:
         raise RuntimeError(
             "LangGraph version too low, Command feature not supported. Please upgrade to 0.2.57 or higher."
@@ -769,15 +786,13 @@ def create_resume_command(lg_humanloop: LangGraphAdapter = default_adapter) -> A
         poll_interval = 1.0  # Polling interval (seconds)
         while True:
             result = lg_humanloop.manager.check_conversation_status(default_conversation_id)
-            print(result)
             # If status is final state (not PENDING), return result
             if result.status != HumanLoopStatus.PENDING:
                 return result.response
             # Wait before polling again
             time.sleep(poll_interval)
-    
-    # Wait for async result synchronously
-    # loop = asyncio.get_event_loop() # In synchronous environment
+
+    _SKIP_NEXT_HUMANLOOP = True
 
     response = poll_for_result()
     return _lg_Command(resume=response)
@@ -794,6 +809,8 @@ async def acreate_resume_command(lg_humanloop: LangGraphAdapter = default_adapte
     Returns:
         Command object that can be used with graph.astream method
     """
+    global _SKIP_NEXT_HUMANLOOP
+
     if not _SUPPORTS_INTERRUPT:
         raise RuntimeError(
             "LangGraph version too low, Command feature not supported. Please upgrade to 0.2.57 or higher."
@@ -811,6 +828,8 @@ async def acreate_resume_command(lg_humanloop: LangGraphAdapter = default_adapte
             # Wait before polling again
             await asyncio.sleep(poll_interval)
     
+    _SKIP_NEXT_HUMANLOOP = True
+
     # Wait for async result directly
     response = await poll_for_result()
     return _lg_Command(resume=response)

{gohumanloop-0.0.3 → gohumanloop-0.0.5}/gohumanloop/core/manager.py

@@ -1,6 +1,7 @@
 from typing import Dict, Any, Optional, List, Union, Set
 import asyncio
 import time
+from gohumanloop.utils import run_async_safely
 
 from gohumanloop.core.interface import (
     HumanLoopManager, HumanLoopProvider, HumanLoopCallback,
@@ -150,15 +151,8 @@ class DefaultHumanLoopManager(HumanLoopManager):
         blocking: bool = False,
     ) -> Union[str, HumanLoopResult]:
         """请求人机循环（同步版本）"""
-        loop = asyncio.get_event_loop()
-        if loop.is_running():
-            # 如果事件循环已经在运行，创建一个新的事件循环
-            new_loop = asyncio.new_event_loop()
-            asyncio.set_event_loop(new_loop)
-            loop = new_loop
-            
-        try:
-            return loop.run_until_complete(
+
+        return run_async_safely(
                 self.async_request_humanloop(
                     task_id=task_id,
                     conversation_id=conversation_id,
@@ -171,9 +165,7 @@ class DefaultHumanLoopManager(HumanLoopManager):
                     blocking=blocking
                 )
             )
-        finally:
-            if loop != asyncio.get_event_loop():
-                loop.close()
+
 
     async def async_continue_humanloop(
         self,
@@ -267,15 +259,8 @@ class DefaultHumanLoopManager(HumanLoopManager):
         blocking: bool = False,
     ) -> Union[str, HumanLoopResult]:
         """继续人机循环（同步版本）"""
-        loop = asyncio.get_event_loop()
-        if loop.is_running():
-            # 如果事件循环已经在运行，创建一个新的事件循环
-            new_loop = asyncio.new_event_loop()
-            asyncio.set_event_loop(new_loop)
-            loop = new_loop
-            
-        try:
-            return loop.run_until_complete(
+
+        return run_async_safely(
                 self.async_continue_humanloop(
                     conversation_id=conversation_id,
                     context=context,
@@ -286,9 +271,6 @@ class DefaultHumanLoopManager(HumanLoopManager):
                     blocking=blocking
                 )
             )
-        finally:
-            if loop != asyncio.get_event_loop():
-                loop.close()
 
     async def async_check_request_status(
         self,
@@ -334,24 +316,14 @@ class DefaultHumanLoopManager(HumanLoopManager):
         provider_id: Optional[str] = None
     ) -> HumanLoopResult:
         """检查请求状态（同步版本）"""
-        loop = asyncio.get_event_loop()
-        if loop.is_running():
-            # 如果事件循环已经在运行，创建一个新的事件循环
-            new_loop = asyncio.new_event_loop()
-            asyncio.set_event_loop(new_loop)
-            loop = new_loop
-            
-        try:
-            return loop.run_until_complete(
+
+        return run_async_safely(
                 self.async_check_request_status(
                     conversation_id=conversation_id,
                     request_id=request_id,
                     provider_id=provider_id
                 )
             )
-        finally:
-            if loop != asyncio.get_event_loop():
-                loop.close()
 
 
     async def async_check_conversation_status(
@@ -394,23 +366,13 @@ class DefaultHumanLoopManager(HumanLoopManager):
         provider_id: Optional[str] = None
     ) -> HumanLoopResult:
         """检查对话状态（同步版本）"""
-        loop = asyncio.get_event_loop()
-        if loop.is_running():
-            # 如果事件循环已经在运行，创建一个新的事件循环
-            new_loop = asyncio.new_event_loop()
-            asyncio.set_event_loop(new_loop)
-            loop = new_loop
-            
-        try:
-            return loop.run_until_complete(
+
+        return run_async_safely(
                 self.async_check_conversation_status(
                     conversation_id=conversation_id,
                     provider_id=provider_id
                 )
             )
-        finally:
-            if loop != asyncio.get_event_loop():
-                loop.close()
 
     async def async_cancel_request(
         self,
@@ -456,25 +418,14 @@ class DefaultHumanLoopManager(HumanLoopManager):
         provider_id: Optional[str] = None
     ) -> bool:
         """取消特定请求（同步版本）"""
-        loop = asyncio.get_event_loop()
-        if loop.is_running():
-            # 如果事件循环已经在运行，创建一个新的事件循环
-            new_loop = asyncio.new_event_loop()
-            asyncio.set_event_loop(new_loop)
-            loop = new_loop
-            
-        try:
-            return loop.run_until_complete(
+
+        return run_async_safely(
                 self.async_cancel_request(
                     conversation_id=conversation_id,
                     request_id=request_id,
                     provider_id=provider_id
                 )
             )
-        finally:
-            if loop != asyncio.get_event_loop():
-                loop.close()
-
 
     async def async_cancel_conversation(
         self,
@@ -547,25 +498,14 @@ class DefaultHumanLoopManager(HumanLoopManager):
         provider_id: Optional[str] = None
     ) -> bool:
         """取消整个对话（同步版本）"""
-        loop = asyncio.get_event_loop()
-        if loop.is_running():
-            # 如果事件循环已经在运行，创建一个新的事件循环
-            new_loop = asyncio.new_event_loop()
-            asyncio.set_event_loop(new_loop)
-            loop = new_loop
-            
-        try:
-            return loop.run_until_complete(
+                
+        return run_async_safely(
                 self.async_cancel_conversation(
                     conversation_id=conversation_id,
                     provider_id=provider_id
                 )
             )
-        finally:
-            if loop != asyncio.get_event_loop():
-                loop.close()
 
-                
     async def async_get_provider(
         self,
         provider_id: Optional[str] = None
@@ -582,20 +522,10 @@ class DefaultHumanLoopManager(HumanLoopManager):
         provider_id: Optional[str] = None
     ) -> HumanLoopProvider:
         """获取指定的提供者实例（同步版本）"""
-        loop = asyncio.get_event_loop()
-        if loop.is_running():
-            # 如果事件循环已经在运行，创建一个新的事件循环
-            new_loop = asyncio.new_event_loop()
-            asyncio.set_event_loop(new_loop)
-            loop = new_loop
-            
-        try:
-            return loop.run_until_complete(
+
+        return run_async_safely(
                 self.async_get_provider(provider_id=provider_id)
             )
-        finally:
-            if loop != asyncio.get_event_loop():
-                loop.close()
 
     async def async_list_providers(self) -> Dict[str, HumanLoopProvider]:
         """列出所有注册的提供者"""
@@ -604,18 +534,11 @@ class DefaultHumanLoopManager(HumanLoopManager):
 
     def list_providers(self) -> Dict[str, HumanLoopProvider]:
         """列出所有注册的提供者（同步版本）"""
-        loop = asyncio.get_event_loop()
-        if loop.is_running():
-            # 如果事件循环已经在运行，创建一个新的事件循环
-            new_loop = asyncio.new_event_loop()
-            asyncio.set_event_loop(new_loop)
-            loop = new_loop
-            
-        try:
-            return loop.run_until_complete(self.async_list_providers())
-        finally:
-            if loop != asyncio.get_event_loop():
-                loop.close()
+        
+        return run_async_safely(
+                self.async_list_providers()
+            )
+
 
 
     async def async_set_default_provider(
@@ -635,21 +558,11 @@ class DefaultHumanLoopManager(HumanLoopManager):
         provider_id: str
     ) -> bool:
         """设置默认提供者（同步版本）"""
-        loop = asyncio.get_event_loop()
-        if loop.is_running():
-            # 如果事件循环已经在运行，创建一个新的事件循环
-            new_loop = asyncio.new_event_loop()
-            asyncio.set_event_loop(new_loop)
-            loop = new_loop
-            
-        try:
-            return loop.run_until_complete(
+
+
+        return run_async_safely(
                 self.async_set_default_provider(provider_id=provider_id)
             )
-        finally:
-            if loop != asyncio.get_event_loop():
-                loop.close()
-
 
     async def _async_create_timeout_task(
         self, 

{gohumanloop-0.0.3 → gohumanloop-0.0.5}/gohumanloop/manager/ghl_manager.py

@@ -434,7 +434,7 @@ class GoHumanLoopManager(DefaultHumanLoopManager):
         Returns:
             HumanLoopResult: 请求状态结果
         """
-        # 如果没有指定provider_id，从存储的映射中获取
+        # check_request_status
         if provider_id is None:
             provider_id = self._conversation_provider.get(conversation_id)
             
@@ -442,7 +442,7 @@ class GoHumanLoopManager(DefaultHumanLoopManager):
             raise ValueError(f"Provider '{provider_id}' not found")
             
         provider = self.providers[provider_id]
-        return await provider.check_request_status(conversation_id, request_id)
+        return await provider.async_check_request_status(conversation_id, request_id)
 
     async def async_check_request_status(
         self,

{gohumanloop-0.0.3 → gohumanloop-0.0.5}/gohumanloop/providers/api_provider.py

@@ -4,7 +4,7 @@ from typing import Dict, Any, Optional
 
 import aiohttp
 from pydantic import SecretStr
-
+from concurrent.futures import ThreadPoolExecutor
 from gohumanloop.core.interface import (
     HumanLoopResult, HumanLoopStatus, HumanLoopType
 )
@@ -56,6 +56,18 @@ class APIProvider(BaseProvider):
         
         # Store the currently running polling tasks.
         self._poll_tasks = {}
+         # Create thread pool for background service execution
+        self._executor = ThreadPoolExecutor(max_workers=10)
+
+
+    def __del__(self):
+        """析构函数，确保线程池被正确关闭"""
+        self._executor.shutdown(wait=False)
+
+        # 取消所有邮件检查任务
+        for task_key, future in list(self._poll_tasks.items()):
+            future.cancel()
+        self._poll_tasks.clear()
         
     def __str__(self) -> str:
         """Returns a string description of this instance"""
@@ -230,10 +242,9 @@ class APIProvider(BaseProvider):
                 )
                 
             # Create polling task
-            poll_task = asyncio.create_task(
-                self._async_poll_request_status(conversation_id, request_id, platform)
+            self._poll_tasks[(conversation_id, request_id)] = self._executor.submit(
+            self._run_async_poll_request_status, conversation_id, request_id, platform
             )
-            self._poll_tasks[(conversation_id, request_id)] = poll_task
             
             # Create timeout task if timeout is set
             if timeout:
@@ -258,6 +269,22 @@ class APIProvider(BaseProvider):
                 status=HumanLoopStatus.ERROR,
                 error=str(e)
             )
+
+    def _run_async_poll_request_status(self, conversation_id: str, request_id: str, platform: str):
+        """Run asynchronous API 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._async_poll_request_status(conversation_id, request_id, platform))
+        finally:
+            loop.close()
+            # Remove from task dictionary
+            if (conversation_id, request_id) in self._poll_tasks:
+                del self._poll_tasks[(conversation_id, request_id)]
+
     async def async_check_request_status(
         self,
         conversation_id: str,
@@ -516,11 +543,10 @@ class APIProvider(BaseProvider):
                     error=error_msg
                 )
                 
-            # Create polling task
-            poll_task = asyncio.create_task(
-                self._async_poll_request_status(conversation_id, request_id, platform)
+             # Create polling task
+            self._poll_tasks[(conversation_id, request_id)] = self._executor.submit(
+            self._run_async_poll_request_status, conversation_id, request_id, platform
             )
-            self._poll_tasks[(conversation_id, request_id)] = poll_task
             
             # Create timeout task if timeout is set
             if timeout:

{gohumanloop-0.0.3 → gohumanloop-0.0.5}/gohumanloop/providers/base.py

@@ -7,6 +7,7 @@ import uuid
 from datetime import datetime
 from collections import defaultdict
 from gohumanloop.utils.threadsafedict import ThreadSafeDict
+from gohumanloop.utils import run_async_safely
 
 from gohumanloop.core.interface import (
     HumanLoopProvider, HumanLoopResult, HumanLoopStatus, HumanLoopType
@@ -157,15 +158,7 @@ class BaseProvider(HumanLoopProvider, ABC):
             HumanLoopResult: Result object containing request ID and initial status
         """
 
-        loop = asyncio.get_event_loop()
-        if loop.is_running():
-            # 如果事件循环已经在运行，创建一个新的事件循环
-            new_loop = asyncio.new_event_loop()
-            asyncio.set_event_loop(new_loop)
-            loop = new_loop
-            
-        try:
-            return loop.run_until_complete(
+        return run_async_safely(
                 self.async_request_humanloop(
                     task_id=task_id,
                     conversation_id=conversation_id,
@@ -173,10 +166,8 @@ class BaseProvider(HumanLoopProvider, ABC):
                     context=context,
                     metadata=metadata,
                     timeout=timeout
-                    ))
-        finally:
-            if loop != asyncio.get_event_loop():
-                loop.close()
+                )
+            )
 
 
     async def async_check_request_status(
@@ -220,24 +211,13 @@ class BaseProvider(HumanLoopProvider, ABC):
         Returns:
             HumanLoopResult: Result containing the status of the latest request in the conversation
         """
-        
-        loop = asyncio.get_event_loop()
-        if loop.is_running():
-            # 如果事件循环已经在运行，创建一个新的事件循环
-            new_loop = asyncio.new_event_loop()
-            asyncio.set_event_loop(new_loop)
-            loop = new_loop
-            
-        try:
-            return loop.run_until_complete(
+
+        return run_async_safely(
                 self.async_check_request_status(
                     conversation_id=conversation_id,
                     request_id=request_id
-                ))
-        finally:
-            if loop != asyncio.get_event_loop():
-                loop.close()
-
+                )
+            )
 
     async def async_check_conversation_status(
         self,
@@ -286,23 +266,12 @@ class BaseProvider(HumanLoopProvider, ABC):
         Returns:
             HumanLoopResult: Result containing the status of the latest request in the conversation
         """
-
-        loop = asyncio.get_event_loop()
-        if loop.is_running():
-            # 如果事件循环已经在运行，创建一个新的事件循环
-            new_loop = asyncio.new_event_loop()
-            asyncio.set_event_loop(new_loop)
-            loop = new_loop
-            
-        try:
-            return loop.run_until_complete(
-               self.async_check_conversation_status(
-                    conversation_id=conversation_id
-                ))
-        finally:
-            if loop != asyncio.get_event_loop():
-                loop.close()
     
+        return run_async_safely(
+                self.async_check_conversation_status(
+                    conversation_id=conversation_id
+                )
+            )
 
     async def async_cancel_request(
         self,
@@ -345,22 +314,13 @@ class BaseProvider(HumanLoopProvider, ABC):
         Returns:
             bool: Whether cancellation was successful, True indicates success, False indicates failure
         """
-        loop = asyncio.get_event_loop()
-        if loop.is_running():
-            # 如果事件循环已经在运行，创建一个新的事件循环
-            new_loop = asyncio.new_event_loop()
-            asyncio.set_event_loop(new_loop)
-            loop = new_loop
-            
-        try:
-            return loop.run_until_complete(
-               self.async_cancel_request(
+
+        return run_async_safely(
+                self.async_cancel_request(
                     conversation_id=conversation_id,
                     request_id=request_id
-                ))
-        finally:
-            if loop != asyncio.get_event_loop():
-                loop.close()
+                )
+            )
 
     async def async_cancel_conversation(
         self,
@@ -410,22 +370,11 @@ class BaseProvider(HumanLoopProvider, ABC):
             bool: Whether the cancellation was successful
         """
         
-        loop = asyncio.get_event_loop()
-        if loop.is_running():
-            # 如果事件循环已经在运行，创建一个新的事件循环
-            new_loop = asyncio.new_event_loop()
-            asyncio.set_event_loop(new_loop)
-            loop = new_loop
-            
-        try:
-            return loop.run_until_complete(
-               self.async_cancel_conversation(
+        return run_async_safely(
+                self.async_cancel_conversation(
                     conversation_id=conversation_id
-                ))
-        finally:
-            if loop != asyncio.get_event_loop():
-                loop.close()
-
+                )
+            )
 
     async def async_continue_humanloop(
         self,
@@ -479,24 +428,14 @@ class BaseProvider(HumanLoopProvider, ABC):
             HumanLoopResult: Result object containing request ID and status
         """
 
-        loop = asyncio.get_event_loop()
-        if loop.is_running():
-            # 如果事件循环已经在运行，创建一个新的事件循环
-            new_loop = asyncio.new_event_loop()
-            asyncio.set_event_loop(new_loop)
-            loop = new_loop
-            
-        try:
-            return loop.run_until_complete(
-               self.async_continue_humanloop(
+        return run_async_safely(
+                self.async_continue_humanloop(
                     conversation_id=conversation_id,
                     context=context,
                     metadata=metadata,
                     timeout=timeout
-                    ))
-        finally:
-            if loop != asyncio.get_event_loop():
-                loop.close()
+                    )
+            )
 
     def async_get_conversation_history(self, conversation_id: str) -> List[Dict[str, Any]]:
         """Get complete history for the specified conversation
@@ -533,18 +472,10 @@ class BaseProvider(HumanLoopProvider, ABC):
             List[Dict[str, Any]]: List of conversation history records, each containing request ID,
                                  status, context, response and other information
         """
-        loop = asyncio.get_event_loop()
-        if loop.is_running():
-            new_loop = asyncio.new_event_loop()
-            asyncio.set_event_loop(new_loop)
-            loop = new_loop
-            
-        try:
-            return loop.run_until_complete(self.async_get_conversation_history(conversation_id))
-        finally:
-            if loop != asyncio.get_event_loop():
-                loop.close()
 
+        return run_async_safely(
+                self.async_get_conversation_history(conversation_id=conversation_id)
+            )
 
     async def _async_create_timeout_task(
         self, 

{gohumanloop-0.0.3 → gohumanloop-0.0.5}/gohumanloop/providers/email_provider.py

@@ -12,6 +12,7 @@ import logging
 from typing import Dict, Any, Optional, List, Tuple
 from datetime import datetime
 from pydantic import SecretStr
+from concurrent.futures import ThreadPoolExecutor
 
 from gohumanloop.core.interface import ( HumanLoopResult, HumanLoopStatus, HumanLoopType
 )
@@ -79,6 +80,19 @@ class EmailProvider(BaseProvider):
 
         self._init_language_templates()
 
+        # Create thread pool for background service execution
+        self._executor = ThreadPoolExecutor(max_workers=10)
+
+
+    def __del__(self):
+        """析构函数，确保线程池被正确关闭"""
+        self._executor.shutdown(wait=False)
+
+        # 取消所有邮件检查任务
+        for task_key, future in list(self._mail_check_tasks.items()):
+            future.cancel()
+        self._mail_check_tasks.clear()
+
     def _init_language_templates(self):
         """初始化不同语言的模板和关键词"""
         if self.language == "zh":
@@ -700,10 +714,11 @@ class EmailProvider(BaseProvider):
         self._subject_to_request[subject] = (conversation_id, request_id)
         
         # 创建邮件检查任务
-        check_task = asyncio.create_task(
-            self._async_check_emails(conversation_id, request_id, recipient_email, subject)
+        # 使用线程池执行邮件检查任务，而不是使用asyncio.create_task
+        self._mail_check_tasks[(conversation_id, request_id)] = self._executor.submit(
+            self._run_email_check_task, conversation_id, request_id, recipient_email, subject
         )
-        self._mail_check_tasks[(conversation_id, request_id)] = check_task
+        
         
         # 如果设置了超时，创建超时任务
         if timeout:
@@ -715,7 +730,37 @@ class EmailProvider(BaseProvider):
             loop_type=loop_type,
             status=HumanLoopStatus.PENDING
         )
+
+    def _run_email_check_task(self, conversation_id: str, request_id: str, recipient_email: str, subject: str):
+        """Run email check task in thread
+        
+        Args:
+            conversation_id: Conversation ID
+            request_id: Request ID
+            recipient_email: Recipient email address
+            subject: Email subject
+        """
+        # Create new event loop
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
         
+        try:
+            # Run email check in new event loop
+            loop.run_until_complete(
+                self._async_check_emails(conversation_id, request_id, recipient_email, subject)
+            )
+        except Exception as e:
+            logger.error(f"Email check task error: {str(e)}", exc_info=True)
+            # Update request status to error
+            self._update_request_status_error(conversation_id, request_id, f"Email check task error: {str(e)}")
+        finally:
+            # Close event loop
+            loop.close()
+            # Remove from task dictionary
+            if (conversation_id, request_id) in self._mail_check_tasks:
+                del self._mail_check_tasks[(conversation_id, request_id)]
+
+    
     async def async_check_request_status(
         self,
         conversation_id: str,
@@ -876,13 +921,12 @@ class EmailProvider(BaseProvider):
             
         # 存储主题与请求的映射关系
         self._subject_to_request[subject] = (conversation_id, request_id)
-        
-        # 创建邮件检查任务
-        check_task = asyncio.create_task(
-            self._async_check_emails(conversation_id, request_id, recipient_email, subject)
-        )
-        self._mail_check_tasks[(conversation_id, request_id)] = check_task
 
+        # 使用线程池执行邮件检查任务，而不是使用asyncio.create_task
+        self._mail_check_tasks[(conversation_id, request_id)] = self._executor.submit(
+            self._run_email_check_task, conversation_id, request_id, recipient_email, subject
+        )
+        
         # 如果设置了超时，创建超时任务
         if timeout:
             await self._async_create_timeout_task(conversation_id, request_id, timeout)

{gohumanloop-0.0.3 → gohumanloop-0.0.5}/gohumanloop/providers/terminal_provider.py

@@ -1,8 +1,6 @@
 import asyncio
-from email import message
-import sys
-import json
-from typing import Dict, Any, Optional, List
+from concurrent.futures import ThreadPoolExecutor
+from typing import Dict, Any, Optional
 from datetime import datetime
 
 from gohumanloop.core.interface import (HumanLoopResult, HumanLoopStatus, HumanLoopType)
@@ -22,7 +20,21 @@ class TerminalProvider(BaseProvider):
             name: Provider name
             config: Configuration options, may include:
         """
-        super().__init__(name, config) 
+        super().__init__(name, config)
+
+        # Store running terminal input tasks
+        self._terminal_input_tasks = {}
+        # Create thread pool for background service execution
+        self._executor = ThreadPoolExecutor(max_workers=10)
+
+    def __del__(self):
+        """Destructor to ensure thread pool is properly closed"""
+        self._executor.shutdown(wait=False)
+
+        for task_key, future in list(self._terminal_input_tasks.items()):
+            future.cancel()
+        self._terminal_input_tasks.clear()
+
     def __str__(self) -> str:
         base_str = super().__str__()
         terminal_info = f"- Terminal Provider: Terminal-based human-in-the-loop implementation\n"
@@ -72,15 +84,31 @@ class TerminalProvider(BaseProvider):
             status=HumanLoopStatus.PENDING
         )
         
-        # Start async task to process user input
-        asyncio.create_task(self._process_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
-        
+
+
+    def _run_async_terminal_interaction(self, conversation_id: str, request_id: str):
+        """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))
+        finally:
+            loop.close()
+            # Remove from task dictionary
+            if (conversation_id, request_id) in self._terminal_input_tasks:
+                del self._terminal_input_tasks[(conversation_id, request_id)]
+
     async def async_check_request_status(
         self,
         conversation_id: str,
@@ -175,7 +203,7 @@ class TerminalProvider(BaseProvider):
         )
         
         # Start async task to process user input
-        asyncio.create_task(self._process_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:
@@ -299,3 +327,48 @@ class TerminalProvider(BaseProvider):
         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:
+        """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
+        """
+        request_key = (conversation_id, request_id)
+        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:
+        """Cancel the entire conversation
+        
+        Args:
+            conversation_id: Conversation identifier
+            
+        Returns:
+            bool: Whether cancellation was successful
+        """
+        # 取消所有相关的邮件检查任务
+        for request_id in self._get_conversation_requests(conversation_id):
+            request_key = (conversation_id, request_id)
+            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)

{gohumanloop-0.0.3 → gohumanloop-0.0.5}/gohumanloop/utils/utils.py

@@ -3,6 +3,9 @@ import os
 from typing import Optional, Union
 from pydantic import SecretStr
 import warnings
+import logging
+
+logger = logging.getLogger(__name__)
 
 def run_async_safely(coro):
     """
@@ -25,12 +28,12 @@ def run_async_safely(coro):
     # Handle synchronous environment
     try:
         loop = asyncio.get_event_loop()
-        print("Using existing event loop.")
+        logger.info("Using existing event loop.")
     except RuntimeError:
         loop = asyncio.new_event_loop()
         asyncio.set_event_loop(loop)
         own_loop = True
-        print("Created new event loop.")
+        logger.info("Created new event loop.")
     else:
         own_loop = False
     

{gohumanloop-0.0.3 → gohumanloop-0.0.5}/gohumanloop.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gohumanloop
-Version: 0.0.3
+Version: 0.0.5
 Summary: Perfecting AI workflows with human intelligence
 Author-email: gohumanloop authors <baird0917@163.com>
 Project-URL: repository, https://github.com/ptonlix/gohumanloop

{gohumanloop-0.0.3 → gohumanloop-0.0.5}/pyproject.toml

@@ -3,7 +3,7 @@ authors = [
     {name = "gohumanloop authors", email = "baird0917@163.com"},
 ]
 name = "gohumanloop"
-version = "0.0.3"
+version = "0.0.5"
 description = "Perfecting AI workflows with human intelligence"
 readme = "README.md"
 requires-python = ">=3.10"