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

gohumanloop/adapters/langgraph_adapter.py

@@ -633,7 +633,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
@@ -713,6 +713,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 +728,31 @@ 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
+        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,
+        )
+    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 +768,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 +782,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 +805,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 +824,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/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/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/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/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/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/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.dist-info → gohumanloop-0.0.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gohumanloop
-Version: 0.0.3
+Version: 0.0.4
 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.dist-info → gohumanloop-0.0.4.dist-info}/RECORD

@@ -1,30 +1,30 @@
 gohumanloop/__init__.py,sha256=7_AkUtiG-_iozObldORElQS9mufxjZx_WfxuX0E5Af0,1845
 gohumanloop/__main__.py,sha256=zdGKN92H9SgwZfL4xLqPkE1YaiRcHhVg_GqC-H1VurA,75
 gohumanloop/adapters/__init__.py,sha256=alRiJPahmH5vIbiw7l6o3eFvEADVTkfWYIsXy5uPGSo,391
-gohumanloop/adapters/langgraph_adapter.py,sha256=7w3ek8Yzr1r0tfJ4A5UNb_pcFRTfNVDc5gWNVq56IH0,34099
+gohumanloop/adapters/langgraph_adapter.py,sha256=eJLJ_LgU7ZHwm2zSwlFeDIZxjbr8JgfNZiskv0TDOGg,34355
 gohumanloop/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 gohumanloop/cli/main.py,sha256=54-0nwjaAeRH2WhbyO6pN-XADPQwk4_EUUvVWDWruLc,744
 gohumanloop/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 gohumanloop/core/interface.py,sha256=UjeEBKGS_JjwIsT5sBzyq6_IhUkDFrUvBXqpkxkFrAA,22696
 gohumanloop/core/manager.py,sha256=MAgT5Sx1aLRBIb1mWxp-XJkQxEoibut8-TVtze8bWXQ,33068
 gohumanloop/manager/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-gohumanloop/manager/ghl_manager.py,sha256=m7KVdjd5bpxPNm2Sxk4LySzx_Ll4OfpJygxrfFhToDA,22026
+gohumanloop/manager/ghl_manager.py,sha256=Td54EcPg1r9Q5JfzS90QjzxiAhcMBYMigaERImLjp7M,21993
 gohumanloop/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 gohumanloop/models/api_model.py,sha256=cNTXTlfI7yrTk_87Qf6ms0VtRXO2fYFJFLPTLy2dmQk,2853
 gohumanloop/models/glh_model.py,sha256=Ht93iCdLfVYz_nW-uW4bE5s0UoyKG3VEx9q-Gg8_tiY,870
 gohumanloop/providers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-gohumanloop/providers/api_provider.py,sha256=ooZQfi4Zu27U8kyTJ9rssAVzAVoyga71xT8nUjdQJmE,24517
-gohumanloop/providers/base.py,sha256=Eq2y4fqJXdDfbA4xkyHBBH7opGeOg8PAte5vAbx2lwI,24623
-gohumanloop/providers/email_provider.py,sha256=G04557UxdyBnmCx4WTXiakElELRv1fHDYTYNbvzDtqw,42562
+gohumanloop/providers/api_provider.py,sha256=MPIe_BzXkZmbY8IbLhs04zDG-u2qw0PEy28ZWZxJQAI,25604
+gohumanloop/providers/base.py,sha256=en6Px3v-tPJz_zA8-cuT69YVoOyO1Av07kpgfeZoejc,22037
+gohumanloop/providers/email_provider.py,sha256=L_HWkWopJF-8h0e6sOFTZzu2FanBLvCFuXOVZpDahP4,44342
 gohumanloop/providers/ghl_provider.py,sha256=YdxTpRzitFhTXTbhUcMhQlPUs3kwEBd4wyXEcGK8Svk,2524
-gohumanloop/providers/terminal_provider.py,sha256=HBR6fLftaDRydueI5wxKtVOrgYF5RcPxzIhmLPrNVzo,11720
+gohumanloop/providers/terminal_provider.py,sha256=L0whpmmMEzI3shV3nOFl4MrEAXEeL06OrUT0GOVzvl0,14663
 gohumanloop/utils/__init__.py,sha256=idlE5ZNCELVNF9WIiyhtyzG9HJuQQCOlKeTr2aHJ2-Q,56
 gohumanloop/utils/context_formatter.py,sha256=v4vdgKNJCHjnTtIMq83AkyXwltL14vx-D4KahwcZhIQ,2171
 gohumanloop/utils/threadsafedict.py,sha256=0-Pmre2-lqHkUPal9wSaqh3fLaEtbo-OnJ3Wbi_knWE,9601
-gohumanloop/utils/utils.py,sha256=iwfIAYuuKSyuEpOUv4ftf7zRDqSvJ6ALgqceHaZNeO4,2102
-gohumanloop-0.0.3.dist-info/licenses/LICENSE,sha256=-U5tuCcSpndQwSKWtZbFbazb-_AtZcZL2kQgHbSLg-M,1064
-gohumanloop-0.0.3.dist-info/METADATA,sha256=e7exfCd8QVCiMbcAjFwgnAbqoziS1WMUnYh7GL7eZPc,1557
-gohumanloop-0.0.3.dist-info/WHEEL,sha256=Nw36Djuh_5VDukK0H78QzOX-_FQEo6V37m3nkm96gtU,91
-gohumanloop-0.0.3.dist-info/entry_points.txt,sha256=wM6jqRRD8bQXkvIduRVCuAJIlbyWg_F5EDXo5OZ_PwY,88
-gohumanloop-0.0.3.dist-info/top_level.txt,sha256=LvOXBqS6Mspmcuqp81uz0Vjx_m_YI0w06DOPCiI1BfY,12
-gohumanloop-0.0.3.dist-info/RECORD,,
+gohumanloop/utils/utils.py,sha256=3f53fHdWLPve-WTn9mGiz3SB0CE7l39caC5Dz0hm85U,2167
+gohumanloop-0.0.4.dist-info/licenses/LICENSE,sha256=-U5tuCcSpndQwSKWtZbFbazb-_AtZcZL2kQgHbSLg-M,1064
+gohumanloop-0.0.4.dist-info/METADATA,sha256=mM0-czwhVde-9FdxCAsEgeuXhGxW6f3OxeaTc9sIjNA,1557
+gohumanloop-0.0.4.dist-info/WHEEL,sha256=Nw36Djuh_5VDukK0H78QzOX-_FQEo6V37m3nkm96gtU,91
+gohumanloop-0.0.4.dist-info/entry_points.txt,sha256=wM6jqRRD8bQXkvIduRVCuAJIlbyWg_F5EDXo5OZ_PwY,88
+gohumanloop-0.0.4.dist-info/top_level.txt,sha256=LvOXBqS6Mspmcuqp81uz0Vjx_m_YI0w06DOPCiI1BfY,12
+gohumanloop-0.0.4.dist-info/RECORD,,