gohumanloop 0.0.8__py3-none-any.whl → 0.0.10__py3-none-any.whl

gohumanloop/adapters/base_adapter.py

@@ -434,11 +434,17 @@ class HumanloopAdapter:
             else:
                 cb = callback
 
-            node_input = None
-            if state:
-                # Get input information from key fields in State
+            # First try to get node_input from kwargs using state_key
+            node_input = kwargs.get(state_key)
+
+            # If not found in kwargs, try to get from first argument (state)
+            if node_input is None and state and isinstance(state, dict):
                 node_input = state.get(state_key, {})
 
+            # If still not found, use empty dict as default
+            if node_input is None:
+                node_input = {}
+
             # Compose question content
             question_content = (
                 f"Please respond to the following information:\n{node_input}"
@@ -725,7 +731,7 @@ class AgentOpsHumanLoopCallback(HumanLoopCallback):
                 self._operation = operation
                 agentops.init(tags=self.session_tags)
             else:
-                logger.debug(
+                raise ImportError(
                     "AgentOps package not installed. Features disabled. "
                     "Please install with: pip install agentops"
                 )

gohumanloop/core/manager.py

@@ -170,12 +170,6 @@ class DefaultHumanLoopManager(HumanLoopManager):
                         pass
                 self._callbacks[(conversation_id, request_id)] = callback
 
-            # 如果设置了超时，创建超时任务
-            if timeout:
-                await self._async_create_timeout_task(
-                    conversation_id, request_id, timeout, provider, callback
-                )
-
             # 如果是阻塞模式，等待结果
             if blocking:
                 return await self._async_wait_for_result(
@@ -308,12 +302,6 @@ class DefaultHumanLoopManager(HumanLoopManager):
                         pass
                 self._callbacks[(conversation_id, request_id)] = callback
 
-            # 如果设置了超时，创建超时任务
-            if timeout:
-                await self._async_create_timeout_task(
-                    conversation_id, request_id, timeout, provider, callback
-                )
-
             # 如果是阻塞模式，等待结果
             if blocking:
                 return await self._async_wait_for_result(
@@ -429,22 +417,31 @@ class DefaultHumanLoopManager(HumanLoopManager):
 
         try:
             #  检查对话指定provider_id或默认provider_id最后一次请求的状态
-            return await provider.async_check_conversation_status(conversation_id)
-        except Exception as e:
-            # 处理检查对话状态过程中的异常
-            # 尝试找到与此对话关联的最后一个请求的回调
+            result = await provider.async_check_conversation_status(conversation_id)
+
             if (
                 conversation_id in self._conversation_requests
                 and self._conversation_requests[conversation_id]
             ):
                 last_request_id = self._conversation_requests[conversation_id][-1]
                 callback = self._callbacks.get((conversation_id, last_request_id))
-                if callback:
-                    try:
-                        await callback.async_on_humanloop_error(provider, e)
-                    except Exception:
-                        # 如果错误回调也失败，只能忽略
-                        pass
+
+                if callback and result.status not in [HumanLoopStatus.PENDING]:
+                    # 如果有回调且状态不是等待或进行中，触发状态更新回调
+                    await self._async_trigger_update_callback(
+                        conversation_id, last_request_id, provider, result
+                    )
+
+            return result
+        except Exception as e:
+            # 处理检查对话状态过程中的异常
+            # 尝试找到与此对话关联的最后一个请求的回调
+            if callback:
+                try:
+                    await callback.async_on_humanloop_error(provider, e)
+                except Exception:
+                    # 如果错误回调也失败，只能忽略
+                    pass
             raise  # 重新抛出异常，让调用者知道发生了错误
 
     def check_conversation_status(
@@ -632,42 +629,6 @@ class DefaultHumanLoopManager(HumanLoopManager):
 
         return result
 
-    async def _async_create_timeout_task(
-        self,
-        conversation_id: str,
-        request_id: str,
-        timeout: int,
-        provider: HumanLoopProvider,
-        callback: Optional[HumanLoopCallback],
-    ) -> None:
-        """创建超时任务"""
-
-        async def timeout_task() -> None:
-            await asyncio.sleep(timeout)
-            # 检查当前状态
-            result = await self.async_check_request_status(
-                conversation_id, request_id, provider.name
-            )
-
-            # 只有当状态为PENDING时才触发超时回调
-            # INPROGRESS状态表示对话正在进行中，不应视为超时
-            if result.status == HumanLoopStatus.PENDING:
-                if callback:
-                    await callback.async_on_humanloop_timeout(
-                        provider=provider, result=result
-                    )
-            # 如果状态是INPROGRESS，重置超时任务
-            elif result.status == HumanLoopStatus.INPROGRESS:
-                # 对于进行中的对话，我们可以选择延长超时时间
-                # 这里我们简单地重新创建一个超时任务，使用相同的超时时间
-                if (conversation_id, request_id) in self._timeout_tasks:
-                    self._timeout_tasks[(conversation_id, request_id)].cancel()
-                new_task = asyncio.create_task(timeout_task())
-                self._timeout_tasks[(conversation_id, request_id)] = new_task
-
-        task = asyncio.create_task(timeout_task())
-        self._timeout_tasks[(conversation_id, request_id)] = task
-
     async def _async_wait_for_result(
         self,
         conversation_id: str,
@@ -704,6 +665,8 @@ class DefaultHumanLoopManager(HumanLoopManager):
         if callback:
             try:
                 await callback.async_on_humanloop_update(provider, result)
+                if result.status == HumanLoopStatus.EXPIRED:
+                    await callback.async_on_humanloop_timeout(provider, result)
                 # 如果状态是最终状态，可以考虑移除回调
                 if result.status not in [
                     HumanLoopStatus.PENDING,

gohumanloop/providers/api_provider.py

@@ -267,14 +267,9 @@ class APIProvider(BaseProvider):
                 conversation_id,
                 request_id,
                 platform,
+                timeout,
             )
 
-            # Create timeout task if timeout is set
-            if timeout:
-                await self._async_create_timeout_task(
-                    conversation_id, request_id, timeout
-                )
-
             return HumanLoopResult(
                 conversation_id=conversation_id,
                 request_id=request_id,
@@ -296,7 +291,11 @@ class APIProvider(BaseProvider):
             )
 
     def _run_async_poll_request_status(
-        self, conversation_id: str, request_id: str, platform: str
+        self,
+        conversation_id: str,
+        request_id: str,
+        platform: str,
+        timeout: Optional[int],
     ) -> None:
         """Run asynchronous API interaction in a separate thread"""
         # Create new event loop
@@ -306,7 +305,9 @@ class APIProvider(BaseProvider):
         try:
             # Run interaction processing in the new event loop
             loop.run_until_complete(
-                self._async_poll_request_status(conversation_id, request_id, platform)
+                self._async_poll_request_status_with_timeout(
+                    conversation_id, request_id, platform, timeout
+                )
             )
         finally:
             loop.close()
@@ -579,14 +580,9 @@ class APIProvider(BaseProvider):
                 conversation_id,
                 request_id,
                 platform,
+                timeout,
             )
 
-            # Create timeout task if timeout is set
-            if timeout:
-                await self._async_create_timeout_task(
-                    conversation_id, request_id, timeout
-                )
-
             return HumanLoopResult(
                 conversation_id=conversation_id,
                 request_id=request_id,
@@ -606,6 +602,47 @@ class APIProvider(BaseProvider):
                 error=str(e),
             )
 
+    async def _async_poll_request_status_with_timeout(
+        self,
+        conversation_id: str,
+        request_id: str,
+        platform: str,
+        timeout: Optional[int],
+    ) -> None:
+        """Poll request status with optional timeout
+
+        Args:
+            conversation_id: Conversation identifier
+            request_id: Request identifier
+            platform: Platform identifier
+            timeout: Optional timeout in seconds. If specified, polling will stop after timeout period
+        """
+
+        try:
+            if timeout:
+                # 使用 wait_for 设置超时
+                await asyncio.wait_for(
+                    self._async_poll_request_status(
+                        conversation_id, request_id, platform
+                    ),
+                    timeout=timeout,
+                )
+            else:
+                # 无超时限制
+                await self._async_poll_request_status(
+                    conversation_id, request_id, platform
+                )
+
+        except asyncio.TimeoutError:
+            # 超时处理
+            request_info = self._get_request(conversation_id, request_id)
+            if request_info and request_info.get("status") == HumanLoopStatus.PENDING:
+                request_info["status"] = HumanLoopStatus.EXPIRED
+                request_info["error"] = "Request timed out"
+                logger.info(
+                    f"\nRequest {request_id} has timed out after {timeout} seconds"
+                )
+
     async def _async_poll_request_status(
         self, conversation_id: str, request_id: str, platform: str
     ) -> None:

gohumanloop/providers/base.py

@@ -1,6 +1,5 @@
 from abc import ABC
 from typing import Dict, Any, Optional, List, Tuple
-import asyncio
 import json
 import uuid
 from datetime import datetime
@@ -33,8 +32,6 @@ class BaseProvider(HumanLoopProvider, ABC):
         self._conversations: Dict[str, Dict[str, Any]] = {}
         # For quick lookup of requests in conversations
         self._conversation_requests: defaultdict[str, List[str]] = defaultdict(list)
-        # Store timeout tasks
-        self._timeout_tasks: Dict[Tuple[str, str], asyncio.Task] = {}
 
         self.prompt_template = self.config.get("prompt_template", "{context}")
 
@@ -291,11 +288,6 @@ class BaseProvider(HumanLoopProvider, ABC):
             bool: Whether cancellation was successful, True indicates success, False indicates failure
         """
 
-        # Cancel timeout task
-        if (conversation_id, request_id) in self._timeout_tasks:
-            self._timeout_tasks[(conversation_id, request_id)].cancel()
-            del self._timeout_tasks[(conversation_id, request_id)]
-
         request_key = (conversation_id, request_id)
         if request_key in self._requests:
             # Update request status to cancelled
@@ -346,11 +338,6 @@ class BaseProvider(HumanLoopProvider, ABC):
                     HumanLoopStatus.INPROGRESS,
                 ]:
                     self._requests[request_key]["status"] = HumanLoopStatus.CANCELLED
-
-                    # Cancel the timeout task for this request
-                    if request_key in self._timeout_tasks:
-                        self._timeout_tasks[request_key].cancel()
-                        del self._timeout_tasks[request_key]
             else:
                 success = False
 
@@ -482,45 +469,6 @@ class BaseProvider(HumanLoopProvider, ABC):
 
         return result
 
-    async def _async_create_timeout_task(
-        self, conversation_id: str, request_id: str, timeout: int
-    ) -> None:
-        """Create timeout task
-
-        Args:
-            conversation_id: Conversation ID
-            request_id: Request ID
-            timeout: Timeout duration in seconds
-        """
-
-        async def timeout_task() -> None:
-            await asyncio.sleep(timeout)
-
-            # Check current status
-            request_info = self._get_request(conversation_id, request_id)
-            if not request_info:
-                return
-
-            current_status = request_info.get("status", HumanLoopStatus.PENDING)
-
-            # Only trigger timeout when status is PENDING
-            # INPROGRESS status means conversation is ongoing, should not be considered as timeout
-            if current_status == HumanLoopStatus.PENDING:
-                # Update request status to expired
-                request_info["status"] = HumanLoopStatus.EXPIRED
-                request_info["error"] = "Request timed out"
-            # If status is INPROGRESS, reset timeout task
-            elif current_status == HumanLoopStatus.INPROGRESS:
-                # For ongoing conversations, we can choose to extend the timeout
-                # Here we simply create a new timeout task with the same timeout duration
-                if (conversation_id, request_id) in self._timeout_tasks:
-                    self._timeout_tasks[(conversation_id, request_id)].cancel()
-                new_task = asyncio.create_task(timeout_task())
-                self._timeout_tasks[(conversation_id, request_id)] = new_task
-
-        task = asyncio.create_task(timeout_task())
-        self._timeout_tasks[(conversation_id, request_id)] = task
-
     def build_prompt(
         self,
         task_id: str,

gohumanloop/providers/email_provider.py

@@ -213,6 +213,49 @@ class EmailProvider(BaseProvider):
             logger.exception(f"Unknown error occurred while sending email: {str(e)}")
             raise
 
+    async def _async_check_emails_with_timeout(
+        self,
+        conversation_id: str,
+        request_id: str,
+        recipient_email: str,
+        subject: str,
+        timeout: Optional[int],
+    ) -> None:
+        """Check email replies with timeout functionality
+
+        Args:
+            conversation_id: Conversation ID to identify a complete dialogue session
+            request_id: Request ID to identify a specific request
+            recipient_email: Recipient's email address
+            subject: Email subject line
+            timeout: Timeout duration in seconds, no timeout if None
+        """
+
+        try:
+            if timeout:
+                # 使用 wait_for 设置超时
+                await asyncio.wait_for(
+                    self._async_check_emails(
+                        conversation_id, request_id, recipient_email, subject
+                    ),
+                    timeout=timeout,
+                )
+            else:
+                # 无超时限制
+                await self._async_check_emails(
+                    conversation_id, request_id, recipient_email, subject
+                )
+
+        except asyncio.TimeoutError:
+            # 超时处理
+            request_info = self._get_request(conversation_id, request_id)
+            if request_info and request_info.get("status") == HumanLoopStatus.PENDING:
+                request_info["status"] = HumanLoopStatus.EXPIRED
+                request_info["error"] = "Request timed out"
+                logger.info(
+                    f"\nRequest {request_id} has timed out after {timeout} seconds"
+                )
+
     async def _async_check_emails(
         self, conversation_id: str, request_id: str, recipient_email: str, subject: str
     ) -> None:
@@ -488,11 +531,6 @@ class EmailProvider(BaseProvider):
             }
         )
 
-        # 取消超时任务
-        if request_key in self._timeout_tasks:
-            self._timeout_tasks[request_key].cancel()
-            del self._timeout_tasks[request_key]
-
     def _format_email_body(
         self, body: str, loop_type: HumanLoopType, subject: str
     ) -> Tuple[str, str]:
@@ -772,12 +810,9 @@ class EmailProvider(BaseProvider):
             request_id,
             recipient_email,
             subject,
+            timeout,
         )
 
-        # 如果设置了超时，创建超时任务
-        if timeout:
-            await self._async_create_timeout_task(conversation_id, request_id, timeout)
-
         return HumanLoopResult(
             conversation_id=conversation_id,
             request_id=request_id,
@@ -786,7 +821,12 @@ class EmailProvider(BaseProvider):
         )
 
     def _run_email_check_task(
-        self, conversation_id: str, request_id: str, recipient_email: str, subject: str
+        self,
+        conversation_id: str,
+        request_id: str,
+        recipient_email: str,
+        subject: str,
+        timeout: Optional[int],
     ) -> None:
         """Run email check task in thread
 
@@ -803,8 +843,8 @@ class EmailProvider(BaseProvider):
         try:
             # Run email check in new event loop
             loop.run_until_complete(
-                self._async_check_emails(
-                    conversation_id, request_id, recipient_email, subject
+                self._async_check_emails_with_timeout(
+                    conversation_id, request_id, recipient_email, subject, timeout
                 )
             )
         except Exception as e:
@@ -987,12 +1027,9 @@ class EmailProvider(BaseProvider):
             request_id,
             recipient_email,
             subject,
+            timeout,
         )
 
-        # 如果设置了超时，创建超时任务
-        if timeout:
-            await self._async_create_timeout_task(conversation_id, request_id, timeout)
-
         return HumanLoopResult(
             conversation_id=conversation_id,
             request_id=request_id,

gohumanloop/providers/terminal_provider.py

@@ -90,17 +90,36 @@ class TerminalProvider(BaseProvider):
         self._terminal_input_tasks[
             (conversation_id, request_id)
         ] = self._executor.submit(
-            self._run_async_terminal_interaction, conversation_id, request_id
+            self._run_async_terminal_interaction, conversation_id, request_id, timeout
         )
 
-        # 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_with_timeout(
+        self, conversation_id: str, request_id: str, timeout: Optional[int]
+    ) -> None:
+        """Process terminal interaction with timeout functionality"""
+        try:
+            if timeout:
+                # Set timeout using wait_for
+                await asyncio.wait_for(
+                    self._process_terminal_interaction(conversation_id, request_id),
+                    timeout=timeout,
+                )
+            else:
+                # No timeout limit
+                await self._process_terminal_interaction(conversation_id, request_id)
+
+        except asyncio.TimeoutError:
+            # Handle timeout
+            request_info = self._get_request(conversation_id, request_id)
+            if request_info and request_info.get("status") == HumanLoopStatus.PENDING:
+                request_info["status"] = HumanLoopStatus.EXPIRED
+                request_info["error"] = "Request timed out"
+                print(f"\nRequest {request_id} has timed out after {timeout} seconds")
+
     def _run_async_terminal_interaction(
-        self, conversation_id: str, request_id: str
+        self, conversation_id: str, request_id: str, timeout: int | None
     ) -> None:
         """Run asynchronous terminal interaction in a separate thread"""
         # Create new event loop
@@ -110,7 +129,9 @@ class TerminalProvider(BaseProvider):
         try:
             # Run interaction processing in the new event loop
             loop.run_until_complete(
-                self._process_terminal_interaction(conversation_id, request_id)
+                self._process_terminal_interaction_with_timeout(
+                    conversation_id, request_id, timeout
+                )
             )
         finally:
             loop.close()
@@ -213,13 +234,9 @@ class TerminalProvider(BaseProvider):
         self._terminal_input_tasks[
             (conversation_id, request_id)
         ] = self._executor.submit(
-            self._run_async_terminal_interaction, conversation_id, request_id
+            self._run_async_terminal_interaction, conversation_id, request_id, timeout
         )
 
-        # 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(

gohumanloop/utils/utils.py

@@ -42,6 +42,7 @@ def run_async_safely(coro: Awaitable[Any]) -> Any:
     finally:
         if own_loop and not loop.is_closed():
             loop.close()
+            asyncio.set_event_loop(None)
 
 
 def get_secret_from_env(

{gohumanloop-0.0.8.dist-info → gohumanloop-0.0.10.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gohumanloop
-Version: 0.0.8
+Version: 0.0.10
 Summary: Perfecting AI workflows with human intelligence
 Author-email: gohumanloop authors <baird0917@163.com>
 Project-URL: repository, https://github.com/ptonlix/gohumanloop
@@ -33,7 +33,7 @@ Dynamic: license-file
 **GoHumanLoop**: A Python library empowering AI agents to dynamically request human input (approval/feedback/conversation) at critical stages. Core features:
 
 - `Human-in-the-loop control`: Lets AI agent systems pause and escalate decisions, enhancing safety and trust.
-- `Multi-channel integration`: Supports Terminal, Email, API, and frameworks like LangGraph/CrewAI (soon).
+- `Multi-channel integration`: Supports Terminal, Email, API, and frameworks like LangGraph/CrewAI/...(soon)
 - `Flexible workflows`: Combines automated reasoning with human oversight for reliable AI operations.
 
 Ensures responsible AI deployment by bridging autonomous agents and human judgment.
@@ -59,9 +59,10 @@ Ensures responsible AI deployment by bridging autonomous agents and human judgme
 
 ## 🎹 Getting Started
 
-To get started, check out the following example or jump straight into one of the [Examples](./examples/):
+To get started, check out the following example or jump straight into one of the [Examples Repo](https://github.com/ptonlix/gohumanloop-examples):
 
-- 🦜⛓️ [LangGraph](./examples/langgraph/)
+- 🦜⛓️ [LangGraph](https://github.com/ptonlix/gohumanloop-examples/tree/main/LangGraph)
+- 🚣‍ [CrewAI](https://github.com/ptonlix/gohumanloop-examples/tree/main/CrewAI)
 
 ### Installation
 
@@ -206,7 +207,7 @@ Perform `human-in-the-loop` interaction by entering:
 
 🚀🚀🚀 Completed successfully ~
 
-➡️ Check out more examples in the [Examples Directory](./examples/) and we look foward to your contributions!
+➡️ Check out more examples in the [Examples Repository](https://github.com/ptonlix/gohumanloop-examples) and we look foward to your contributions!
 
 ## 🎵 Why GoHumanloop?
 
@@ -254,7 +255,7 @@ Through `GoHumanloop`'s encapsulation, you can implement secure and efficient `H
 ## 📚 Key Features
 
 <div align="center">
-	<img height=360 src="http://cdn.oyster-iot.cloud/202505211030197.png"><br>
+	<img height=360 src="http://cdn.oyster-iot.cloud/202505291027894.png"><br>
     <b face="雅黑"> GoHumanLoop Architecture</b>
 </div>
 <br>

{gohumanloop-0.0.8.dist-info → gohumanloop-0.0.10.dist-info}/RECORD

@@ -1,31 +1,31 @@
 gohumanloop/__init__.py,sha256=KiY2ncM6OQvkBYcz5rsbob_GuV8hQHOARA-EsxAylEU,2134
 gohumanloop/__main__.py,sha256=zdGKN92H9SgwZfL4xLqPkE1YaiRcHhVg_GqC-H1VurA,75
 gohumanloop/adapters/__init__.py,sha256=_XqJ6eaUBLJJJyjfBQJykBZ4X9HvC3VYOVTn2KnBlqo,484
-gohumanloop/adapters/base_adapter.py,sha256=snKd2GWE5SuFxqkNwdwS8YAhQzhMs9fpeOG6hT6VRhc,32600
+gohumanloop/adapters/base_adapter.py,sha256=G1Tw7uzBrJObDdVT2kxifotkGZIptnZh5GUqCx54rSs,32884
 gohumanloop/adapters/langgraph_adapter.py,sha256=AHJv_b6g8xjeq_9X2cGiW76pSGlfgCGBUvjrZQcbR9s,11621
 gohumanloop/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 gohumanloop/cli/main.py,sha256=Txjk31MlkiX9zeHZfFEXEu0s2IBESY8sxrxBEzZKk2U,767
 gohumanloop/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 gohumanloop/core/interface.py,sha256=uzV3xG08DDItgB9TgMvskcKVDSIFTx2qv8HXjVBtJcI,21810
-gohumanloop/core/manager.py,sha256=imeDVuQlyBRyVR5-PFwxNaFQYaZaAQ69ZGtmsiUpUDg,31790
+gohumanloop/core/manager.py,sha256=A54smLOrN6IgNey6L_zyYJMEX7uB9ZQ_2JDT2im423g,30207
 gohumanloop/manager/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 gohumanloop/manager/ghl_manager.py,sha256=rmbfaS5mAb9c8RPr9Id24vO5DJT9ZC4D282dHZ26SJE,22695
 gohumanloop/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 gohumanloop/models/api_model.py,sha256=1LtSQdx2ZVMzTdPrOVGe1JE1Cn_B0CnNQDp1-LlnqLw,2950
 gohumanloop/models/glh_model.py,sha256=gix4f_57G4URkwXhCspWhU08Sf1MKu9FtUCx424Vf3A,940
 gohumanloop/providers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-gohumanloop/providers/api_provider.py,sha256=kgduU2udtBUaaMHOjDic7v3bb5kTJeedmlLRpcaOgJM,25771
-gohumanloop/providers/base.py,sha256=JHvkInxLIWkUvypR3fphRGgisSMOkutpl-fRnYSHdOw,21893
-gohumanloop/providers/email_provider.py,sha256=n4-k4m3oQ8TocT-yxGLTwUMTXfgddFiGxEKMq9W6FGA,44704
+gohumanloop/providers/api_provider.py,sha256=lp7mMbj01aIFZii_1YJDvUbv4kpPeANBB606S7E4VcI,27023
+gohumanloop/providers/base.py,sha256=rOA9xRTh-rn-64RIZpzcIhWNar8LEzYrEXS5H5r7PpM,19554
+gohumanloop/providers/email_provider.py,sha256=kQA6kG7dqpV6R1cJUeaanLmxMVk9pcIwweNZA4IC-2o,45947
 gohumanloop/providers/ghl_provider.py,sha256=NmOac2LR0d87pc91sMuYtvTYsKdp4wZrhfmSYuZL2ko,2350
-gohumanloop/providers/terminal_provider.py,sha256=6YiATcbc6TIYrmzT2BSd9U6gNnE6o8TX4HO1M5Ejxgc,14613
+gohumanloop/providers/terminal_provider.py,sha256=aBNgGpspiu7fGigN6K-gqGlyjFDFvIqKMGp58PxGyPg,15447
 gohumanloop/utils/__init__.py,sha256=l0e3lnOVrt6HwaxidNGFXORX4awCKemhJZ_t3k-5u-s,124
 gohumanloop/utils/context_formatter.py,sha256=sAWrKJpxmsHga6gsyBwFBlAsHW8bjR1hkaGhk1PoE1M,2064
 gohumanloop/utils/threadsafedict.py,sha256=9uyewnwmvS3u1fCx3SK0YWFxHMcyIwlye1Ev7WW7WHA,9588
-gohumanloop/utils/utils.py,sha256=-bti65OaVh5dlvc5BIgiTw6dqxmqdKnOQHE0V-LKjek,2107
-gohumanloop-0.0.8.dist-info/licenses/LICENSE,sha256=-U5tuCcSpndQwSKWtZbFbazb-_AtZcZL2kQgHbSLg-M,1064
-gohumanloop-0.0.8.dist-info/METADATA,sha256=FvrBF4EDkQXWzC2Jg7A43zdvPPsdpR2BN035wgTMxOo,11216
-gohumanloop-0.0.8.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-gohumanloop-0.0.8.dist-info/entry_points.txt,sha256=wM6jqRRD8bQXkvIduRVCuAJIlbyWg_F5EDXo5OZ_PwY,88
-gohumanloop-0.0.8.dist-info/top_level.txt,sha256=LvOXBqS6Mspmcuqp81uz0Vjx_m_YI0w06DOPCiI1BfY,12
-gohumanloop-0.0.8.dist-info/RECORD,,
+gohumanloop/utils/utils.py,sha256=O0zFtMFloAkWylmZE7WpmAjbDe385ZBfuUEh7NIwgGE,2148
+gohumanloop-0.0.10.dist-info/licenses/LICENSE,sha256=-U5tuCcSpndQwSKWtZbFbazb-_AtZcZL2kQgHbSLg-M,1064
+gohumanloop-0.0.10.dist-info/METADATA,sha256=kpmDmvASjoEsVlgRTtQt87g2ZpGfSeVeRuRVFShq334,11428
+gohumanloop-0.0.10.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+gohumanloop-0.0.10.dist-info/entry_points.txt,sha256=wM6jqRRD8bQXkvIduRVCuAJIlbyWg_F5EDXo5OZ_PwY,88
+gohumanloop-0.0.10.dist-info/top_level.txt,sha256=LvOXBqS6Mspmcuqp81uz0Vjx_m_YI0w06DOPCiI1BfY,12
+gohumanloop-0.0.10.dist-info/RECORD,,