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

gohumanloop/adapters/langgraph_adapter.py

@@ -2,6 +2,7 @@ from typing import Dict, Any, Optional, Callable, Awaitable, TypeVar, Union, Lis
 from functools import wraps
 import asyncio
 import uuid
+import time
 from inspect import iscoroutinefunction
 from contextlib import asynccontextmanager, contextmanager
 
@@ -209,7 +210,7 @@ class LangGraphAdapter:
             else:
                 cb = callback
 
-            result = await self.manager.request_humanloop(
+            result = await self.manager.async_request_humanloop(
                 task_id=task_id,
                 conversation_id=conversation_id,
                 loop_type=HumanLoopType.APPROVAL,
@@ -374,12 +375,12 @@ class LangGraphAdapter:
             question_content = f"Please respond to the following information:\n{node_input}"
             
             # Check if conversation exists to determine whether to use request_humanloop or continue_humanloop
-            conversation_requests = await self.manager.check_conversation_exist(task_id, conversation_id)
+            conversation_requests = await self.manager.async_check_conversation_exist(task_id, conversation_id)
             
             result = None
             if conversation_requests:
                 # Existing conversation, use continue_humanloop
-                result = await self.manager.continue_humanloop(
+                result = await self.manager.async_continue_humanloop(
                     conversation_id=conversation_id,
                     context={
                         "message": {
@@ -400,7 +401,7 @@ class LangGraphAdapter:
                 )
             else:
                 # New conversation, use request_humanloop
-                result = await self.manager.request_humanloop(
+                result = await self.manager.async_request_humanloop(
                     task_id=task_id,
                     conversation_id=conversation_id,
                     loop_type=HumanLoopType.CONVERSATION,
@@ -543,7 +544,7 @@ class LangGraphAdapter:
             else:
                 cb = callback
                 
-            result = await self.manager.request_humanloop(
+            result = await self.manager.async_request_humanloop(
                 task_id=task_id,
                 conversation_id=conversation_id,
                 loop_type=HumanLoopType.INFORMATION,
@@ -608,37 +609,37 @@ class LangGraphHumanLoopCallback(HumanLoopCallback):
     def __init__(
         self,
         state: Any,
-        on_update: Optional[Callable[[Any, HumanLoopProvider, HumanLoopResult], Awaitable[None]]] = None,
-        on_timeout: Optional[Callable[[Any, HumanLoopProvider], Awaitable[None]]] = None,
-        on_error: Optional[Callable[[Any, HumanLoopProvider, Exception], Awaitable[None]]] = None
+        async_on_update: Optional[Callable[[Any, HumanLoopProvider, HumanLoopResult], Awaitable[None]]] = None,
+        async_on_timeout: Optional[Callable[[Any, HumanLoopProvider], Awaitable[None]]] = None,
+        async_on_error: Optional[Callable[[Any, HumanLoopProvider, Exception], Awaitable[None]]] = None,
     ):
         self.state = state
-        self.on_update = on_update
-        self.on_timeout = on_timeout
-        self.on_error = on_error
+        self.async_on_update = async_on_update
+        self.async_on_timeout = async_on_timeout
+        self.async_on_error = async_on_error
 
-    async def on_humanloop_update(
+    async def async_on_humanloop_update(
         self,
         provider: HumanLoopProvider,
         result: HumanLoopResult
     ):
-        if self.on_update:
-            await self.on_update(self.state, provider, result)
+        if self.async_on_update:
+            await self.async_on_update(self.state, provider, result)
 
-    async def on_humanloop_timeout(
+    async def async_on_humanloop_timeout(
         self,
         provider: HumanLoopProvider,
     ):
-        if self.on_timeout:
-            await self.on_timeout(self.state, provider)
+        if self.async_on_timeout:
+            await self.async_on_timeout(self.state, provider)
 
-    async def on_humanloop_error(
+    async def async_on_humanloop_error(
         self,
         provider: HumanLoopProvider,
         error: Exception
     ):
-        if self.on_error:
-            await self.on_error(self.state, provider, error)
+        if self.async_on_error:
+            await self.async_on_error(self.state, provider, error)
 
 
 def default_langgraph_callback_factory(state: Any) -> LangGraphHumanLoopCallback:
@@ -661,7 +662,7 @@ def default_langgraph_callback_factory(state: Any) -> LangGraphHumanLoopCallback
     
     logger = logging.getLogger("gohumanloop.langgraph")
     
-    async def on_update(state, provider: HumanLoopProvider, result: HumanLoopResult):
+    async def async_on_update(state, provider: HumanLoopProvider, result: HumanLoopResult):
         """Log human interaction update events"""
         logger.info(f"Provider ID: {provider.name}")
         logger.info(
@@ -673,8 +674,9 @@ def default_langgraph_callback_factory(state: Any) -> LangGraphHumanLoopCallback
             f"feedback={result.feedback}"
         )
         
+    
 
-    async def on_timeout(state, provider: HumanLoopProvider):
+    async def async_on_timeout(state, provider: HumanLoopProvider):
         """Log human interaction timeout events"""
         
         logger.info(f"Provider ID: {provider.name}")
@@ -685,7 +687,7 @@ def default_langgraph_callback_factory(state: Any) -> LangGraphHumanLoopCallback
         
         # Alert logic can be added here, such as sending notifications
 
-    async def on_error(state, provider: HumanLoopProvider, error: Exception):
+    async def async_on_error(state, provider: HumanLoopProvider, error: Exception):
         """Log human interaction error events"""
       
         logger.info(f"Provider ID: {provider.name}")
@@ -695,9 +697,9 @@ def default_langgraph_callback_factory(state: Any) -> LangGraphHumanLoopCallback
 
     return LangGraphHumanLoopCallback(
         state=state,
-        on_update=on_update,
-        on_timeout=on_timeout,
-        on_error=on_error
+        async_on_update=async_on_update,
+        async_on_timeout=async_on_timeout,
+        async_on_error=async_on_error
     )
 
 from gohumanloop.core.manager import DefaultHumanLoopManager
@@ -711,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
@@ -724,31 +728,32 @@ 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
-    try:
-        loop = asyncio.get_event_loop()
-    except RuntimeError:
-        # If no event loop exists, create a new one
-        loop = asyncio.new_event_loop()
-        asyncio.set_event_loop(loop)
-    
-    loop.create_task(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)
 def create_resume_command(lg_humanloop: LangGraphAdapter = default_adapter) -> Any:
@@ -763,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."
@@ -770,18 +778,19 @@ def create_resume_command(lg_humanloop: LangGraphAdapter = default_adapter) -> A
         )
 
     # Define async polling function
-    async def poll_for_result():
+    def poll_for_result():
         poll_interval = 1.0  # Polling interval (seconds)
         while True:
-            result = await lg_humanloop.manager.check_conversation_status(default_conversation_id)
+            result = lg_humanloop.manager.check_conversation_status(default_conversation_id)
             # If status is final state (not PENDING), return result
             if result.status != HumanLoopStatus.PENDING:
                 return result.response
             # Wait before polling again
-            await asyncio.sleep(poll_interval)
-    
-    # Wait for async result synchronously
-    response = run_async_safely(poll_for_result())
+            time.sleep(poll_interval)
+
+    _SKIP_NEXT_HUMANLOOP = True
+
+    response = poll_for_result()
     return _lg_Command(resume=response)
 
 async def acreate_resume_command(lg_humanloop: LangGraphAdapter = default_adapter) -> Any:
@@ -796,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."
@@ -806,13 +817,15 @@ async def acreate_resume_command(lg_humanloop: LangGraphAdapter = default_adapte
     async def poll_for_result():
         poll_interval = 1.0  # Polling interval (seconds)
         while True:
-            result = await lg_humanloop.manager.check_conversation_status(default_conversation_id)
+            result = await lg_humanloop.manager.async_check_conversation_status(default_conversation_id)
             # If status is final state (not PENDING), return result
             if result.status != HumanLoopStatus.PENDING:
                 return result.response
             # 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)