gohumanloop 0.0.6__tar.gz → 0.0.7__tar.gz

{gohumanloop-0.0.6/gohumanloop.egg-info → gohumanloop-0.0.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gohumanloop
-Version: 0.0.6
+Version: 0.0.7
 Summary: Perfecting AI workflows with human intelligence
 Author-email: gohumanloop authors <baird0917@163.com>
 Project-URL: repository, https://github.com/ptonlix/gohumanloop
@@ -19,6 +19,8 @@ Requires-Dist: langgraph>=0.3.30; extra == "langgraph"
 Provides-Extra: apiservices
 Requires-Dist: fastapi>=0.115.12; extra == "apiservices"
 Requires-Dist: uvicorn>=0.34.2; extra == "apiservices"
+Provides-Extra: agentops
+Requires-Dist: agentops>=0.4.12; extra == "agentops"
 Dynamic: license-file
 
 <div align="center">
@@ -61,17 +63,15 @@ To get started, check out the following example or jump straight into one of the
 
 - 🦜⛓️ [LangGraph](./examples/langgraph/)
 
-### Example
+### Installation
 
 **GoHumanLoop** currently supports `Python`.
 
-- Installation
-
 ```shell
 pip install gohumanloop
 ```
 
-- Example
+### Example
 
 The following example enhances [the official LangGraph example](https://langchain-ai.github.io/langgraph/tutorials/get-started/4-human-in-the-loop/#5-resume-execution) with `human-in-the-loop` functionality.
 
@@ -95,7 +95,9 @@ from langgraph.prebuilt import ToolNode, tools_condition
 
 from gohumanloop.adapters.langgraph_adapter import interrupt, create_resume_command
 
+# Please replace with your Deepseek API Key from https://platform.deepseek.com/usage
 os.environ["DEEPSEEK_API_KEY"] = "sk-xxx"
+# Please replace with your Tavily API Key from https://app.tavily.com/home
 os.environ["TAVILY_API_KEY"] = "tvly-xxx"
 
 llm = init_chat_model("deepseek:deepseek-chat")
@@ -169,6 +171,43 @@ for event in events:
 
 ```
 
+- Deployment & Test
+
+Run the above code with the following steps:
+
+```shell
+# 1.Initialize environment
+uv init gohumanloop-example
+cd gohumanloop-example
+uv venv .venv --python=3.10
+
+# 2.Copy the above code to main.py
+
+# 3.Deploy and test
+uv pip install langchain
+uv pip install langchain_tavily
+uv pip install langgraph
+uv pip install langchain-deepseek
+uv pip install gohumanloop
+
+python main.py
+
+```
+
+- Interaction Demo
+
+![终端展示](http://cdn.oyster-iot.cloud/202505232244870.png)
+
+Perform `human-in-the-loop` interaction by entering:
+
+> We, the experts are here to help! We'd recommend you check out LangGraph to build your agent.It's much more reliable and extensible than simple autonomous agents.
+
+![输出结果](http://cdn.oyster-iot.cloud/202505232248390.png)
+
+🚀🚀🚀 Completed successfully ~
+
+➡️ Check out more examples in the [Examples Directory](./examples/) and we look foward to your contributions!
+
 ## 🎵 Why GoHumanloop?
 
 ### Human-in-the-loop

gohumanloop-0.0.6/PKG-INFO → gohumanloop-0.0.7/README.md

@@ -1,26 +1,3 @@
-Metadata-Version: 2.4
-Name: gohumanloop
-Version: 0.0.6
-Summary: Perfecting AI workflows with human intelligence
-Author-email: gohumanloop authors <baird0917@163.com>
-Project-URL: repository, https://github.com/ptonlix/gohumanloop
-Requires-Python: >=3.10
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: aiohttp>=3.11.16
-Requires-Dist: click>=8.1.8
-Requires-Dist: dotenv>=0.9.9
-Requires-Dist: pydantic>=2.11.3
-Requires-Dist: tomli>=2.2.1
-Provides-Extra: email
-Requires-Dist: imapclient>=3.0.1; extra == "email"
-Provides-Extra: langgraph
-Requires-Dist: langgraph>=0.3.30; extra == "langgraph"
-Provides-Extra: apiservices
-Requires-Dist: fastapi>=0.115.12; extra == "apiservices"
-Requires-Dist: uvicorn>=0.34.2; extra == "apiservices"
-Dynamic: license-file
-
 <div align="center">
 
 ![Wordmark Logo of HumanLayer](./docs/images/wordmark.png)
@@ -61,17 +38,15 @@ To get started, check out the following example or jump straight into one of the
 
 - 🦜⛓️ [LangGraph](./examples/langgraph/)
 
-### Example
+### Installation
 
 **GoHumanLoop** currently supports `Python`.
 
-- Installation
-
 ```shell
 pip install gohumanloop
 ```
 
-- Example
+### Example
 
 The following example enhances [the official LangGraph example](https://langchain-ai.github.io/langgraph/tutorials/get-started/4-human-in-the-loop/#5-resume-execution) with `human-in-the-loop` functionality.
 
@@ -95,7 +70,9 @@ from langgraph.prebuilt import ToolNode, tools_condition
 
 from gohumanloop.adapters.langgraph_adapter import interrupt, create_resume_command
 
+# Please replace with your Deepseek API Key from https://platform.deepseek.com/usage
 os.environ["DEEPSEEK_API_KEY"] = "sk-xxx"
+# Please replace with your Tavily API Key from https://app.tavily.com/home
 os.environ["TAVILY_API_KEY"] = "tvly-xxx"
 
 llm = init_chat_model("deepseek:deepseek-chat")
@@ -169,6 +146,43 @@ for event in events:
 
 ```
 
+- Deployment & Test
+
+Run the above code with the following steps:
+
+```shell
+# 1.Initialize environment
+uv init gohumanloop-example
+cd gohumanloop-example
+uv venv .venv --python=3.10
+
+# 2.Copy the above code to main.py
+
+# 3.Deploy and test
+uv pip install langchain
+uv pip install langchain_tavily
+uv pip install langgraph
+uv pip install langchain-deepseek
+uv pip install gohumanloop
+
+python main.py
+
+```
+
+- Interaction Demo
+
+![终端展示](http://cdn.oyster-iot.cloud/202505232244870.png)
+
+Perform `human-in-the-loop` interaction by entering:
+
+> We, the experts are here to help! We'd recommend you check out LangGraph to build your agent.It's much more reliable and extensible than simple autonomous agents.
+
+![输出结果](http://cdn.oyster-iot.cloud/202505232248390.png)
+
+🚀🚀🚀 Completed successfully ~
+
+➡️ Check out more examples in the [Examples Directory](./examples/) and we look foward to your contributions!
+
 ## 🎵 Why GoHumanloop?
 
 ### Human-in-the-loop

{gohumanloop-0.0.6 → gohumanloop-0.0.7}/gohumanloop/adapters/__init__.py

@@ -1,5 +1,5 @@
 from .langgraph_adapter import (
-    LangGraphAdapter,
+    HumanloopAdapter,
     LangGraphHumanLoopCallback,
     default_langgraph_callback_factory,
     interrupt,
@@ -8,7 +8,7 @@ from .langgraph_adapter import (
 )
 
 __all__ = [
-    "LangGraphAdapter",
+    "HumanloopAdapter",
     "LangGraphHumanLoopCallback",
     "default_langgraph_callback_factory",
     "interrupt",

gohumanloop-0.0.6/gohumanloop/adapters/langgraph_adapter.py → gohumanloop-0.0.7/gohumanloop/adapters/base_adapter.py

@@ -1,10 +1,10 @@
 from typing import (
     cast,
     Dict,
+    List,
     Any,
     Optional,
     Callable,
-    Awaitable,
     TypeVar,
     Union,
     Type,
@@ -14,24 +14,21 @@ from typing import (
 )
 from types import TracebackType
 from functools import wraps
-import asyncio
 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,
+    HumanLoopRequest,
     HumanLoopResult,
     HumanLoopStatus,
     HumanLoopType,
     HumanLoopCallback,
     HumanLoopProvider,
+    HumanLoopManager,
 )
-from gohumanloop.core.manager import DefaultHumanLoopManager
-from gohumanloop.providers.terminal_provider import TerminalProvider
 
 logger = logging.getLogger(__name__)
 
@@ -40,37 +37,6 @@ T = TypeVar("T")
 R = TypeVar("R", bound=Union[Any, None])
 
 
-# Check LangGraph version
-def _check_langgraph_version() -> bool:
-    """Check LangGraph version to determine if interrupt feature is supported"""
-    try:
-        import importlib.metadata
-
-        version = importlib.metadata.version("langgraph")
-        version_parts = version.split(".")
-        major, minor, patch = (
-            int(version_parts[0]),
-            int(version_parts[1]),
-            int(version_parts[2]),
-        )
-
-        # Interrupt support starts from version 0.2.57
-        return major > 0 or (major == 0 and (minor > 2 or (minor == 2 and patch >= 57)))
-    except (importlib.metadata.PackageNotFoundError, ValueError, IndexError):
-        # If version cannot be determined, assume no support
-        return False
-
-
-# Import corresponding features based on version
-_SUPPORTS_INTERRUPT = _check_langgraph_version()
-if _SUPPORTS_INTERRUPT:
-    try:
-        from langgraph.types import interrupt as _lg_interrupt
-        from langgraph.types import Command as _lg_Command
-    except ImportError:
-        _SUPPORTS_INTERRUPT = False
-
-
 class HumanLoopWrapper:
     def __init__(
         self,
@@ -85,8 +51,8 @@ class HumanLoopWrapper:
         return self.decorator(fn)
 
 
-class LangGraphAdapter:
-    """LangGraph adapter for simplifying human-in-the-loop integration
+class HumanloopAdapter:
+    """Humanloop adapter for simplifying human-in-the-loop integration
 
     Provides decorators for three scenarios:
     - require_approval: Requires human approval
@@ -100,7 +66,7 @@ class LangGraphAdapter:
         self.manager = manager
         self.default_timeout = default_timeout
 
-    async def __aenter__(self) -> "LangGraphAdapter":
+    async def __aenter__(self) -> "HumanloopAdapter":
         """Implements async context manager protocol, automatically manages manager lifecycle"""
 
         manager = cast(Any, self.manager)
@@ -122,7 +88,7 @@ class LangGraphAdapter:
 
         return None
 
-    def __enter__(self) -> "LangGraphAdapter":
+    def __enter__(self) -> "HumanloopAdapter":
         """Implements sync context manager protocol, automatically manages manager lifecycle"""
 
         manager = cast(Any, self.manager)
@@ -145,7 +111,7 @@ class LangGraphAdapter:
         return None
 
     @asynccontextmanager
-    async def asession(self) -> AsyncIterator["LangGraphAdapter"]:
+    async def asession(self) -> AsyncIterator["HumanloopAdapter"]:
         """Provides async context manager for managing session lifecycle
 
         Example:
@@ -162,7 +128,7 @@ class LangGraphAdapter:
                 await manager.__aexit__(None, None, None)
 
     @contextmanager
-    def session(self) -> Iterator["LangGraphAdapter"]:
+    def session(self) -> Iterator["HumanloopAdapter"]:
         """Provides a synchronous context manager for managing session lifecycle
 
         Example:
@@ -735,243 +701,138 @@ class LangGraphAdapter:
         return sync_wrapper
 
 
-class LangGraphHumanLoopCallback(HumanLoopCallback):
-    """LangGraph-specific human loop callback, compatible with TypedDict or Pydantic BaseModel State"""
-
-    def __init__(
-        self,
-        state: Any,
-        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,
-    ) -> None:
-        self.state = state
-        self.async_on_update = async_on_update
-        self.async_on_timeout = async_on_timeout
-        self.async_on_error = async_on_error
-
-    async def async_on_humanloop_update(
-        self, provider: HumanLoopProvider, result: HumanLoopResult
-    ) -> None:
-        if self.async_on_update:
-            await self.async_on_update(self.state, provider, result)
-
-    async def async_on_humanloop_timeout(
-        self,
-        provider: HumanLoopProvider,
-    ) -> None:
-        if self.async_on_timeout:
-            await self.async_on_timeout(self.state, provider)
-
-    async def async_on_humanloop_error(
-        self, provider: HumanLoopProvider, error: Exception
-    ) -> None:
-        if self.async_on_error:
-            await self.async_on_error(self.state, provider, error)
-
-
-def default_langgraph_callback_factory(state: Any) -> LangGraphHumanLoopCallback:
-    """Default human-loop callback factory for LangGraph framework
-
-    This callback focuses on:
-    1. Logging human interaction events
-    2. Providing debug information
-    3. Collecting performance metrics
-
-    Note: This callback does not modify state to maintain clear state management
-
-    Args:
-        state: LangGraph state object, only used for log correlation
-
-    Returns:
-        Configured LangGraphHumanLoopCallback instance
-    """
-
-    async def async_on_update(
-        state: Any, provider: HumanLoopProvider, result: HumanLoopResult
-    ) -> None:
-        """Log human interaction update events"""
-        logger.info(f"Provider ID: {provider.name}")
-        logger.info(
-            f"Human interaction update "
-            f"status={result.status}, "
-            f"response={result.response}, "
-            f"responded_by={result.responded_by}, "
-            f"responded_at={result.responded_at}, "
-            f"feedback={result.feedback}"
-        )
-
-    async def async_on_timeout(state: Any, provider: HumanLoopProvider) -> None:
-        """Log human interaction timeout events"""
-
-        logger.info(f"Provider ID: {provider.name}")
-        from datetime import datetime
-
-        current_time = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-        logger.warning(f"Human interaction timeout - Time: {current_time}")
-
-        # Alert logic can be added here, such as sending notifications
-
-    async def async_on_error(
-        state: Any, provider: HumanLoopProvider, error: Exception
-    ) -> None:
-        """Log human interaction error events"""
-
-        logger.info(f"Provider ID: {provider.name}")
-        from datetime import datetime
-
-        current_time = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-        logger.error(f"Human interaction error - Time: {current_time} Error: {error}")
-
-    return LangGraphHumanLoopCallback(
-        state=state,
-        async_on_update=async_on_update,
-        async_on_timeout=async_on_timeout,
-        async_on_error=async_on_error,
-    )
-
-
-# Create HumanLoopManager instance
-manager = DefaultHumanLoopManager(
-    initial_providers=TerminalProvider(name="LGDefaultProvider")
-)
-
-# Create LangGraphAdapter instance
-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
-
-    Raises RuntimeError if LangGraph version doesn't support interrupt
-
-    Args:
-        value: Any JSON-serializable value that will be shown to human user
-        lg_humanloop: LangGraphAdapter instance, defaults to global instance
+class AgentOpsHumanLoopCallback(HumanLoopCallback):
+    """AgentOps-specific human loop callback, compatible with TypedDict or Pydantic BaseModel State
 
-    Returns:
-        Input value provided by human user
+    This implementation integrates with AgentOps for monitoring and tracking human-in-the-loop interactions.
+    It records events, tracks metrics, and provides observability for human-agent interactions.
     """
 
-    global _SKIP_NEXT_HUMANLOOP
+    import importlib.util
 
-    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"
-        )
-
-    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}")
+    if importlib.util.find_spec("agentops") is not None:
+        from agentops.sdk import session, agent, operation, task  # type: ignore
     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:
-    """
-    Create a Command object to resume interrupted graph execution
-
-    Will raise RuntimeError if LangGraph version doesn't support Command
-
-    Args:
-        lg_humanloop: LangGraphAdapter instance, defaults to global instance
-
-    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."
-            "You can use: pip install --upgrade langgraph>=0.2.57"
+        logger.debug(
+            "AgentOps package not installed. AgentOps features disabled. Please pip install agentops"
         )
 
-    # Define async polling function
-    def poll_for_result() -> Optional[Dict[str, Any]]:
-        poll_interval = 1.0  # Polling interval (seconds)
-        while True:
-            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
-            time.sleep(poll_interval)
-
-    _SKIP_NEXT_HUMANLOOP = True
-
-    response = poll_for_result()
-    return _lg_Command(resume=response)
+    def __init__(self, session_tags: Optional[List[str]] = None) -> None:
+        """Initialize the AgentOps human loop callback.
 
+        Args:
+            session_tags: Optional tags for AgentOps session tracking
+        """
+        self.session_tags = session_tags or ["gohumanloop"]
 
-async def acreate_resume_command(
-    lg_humanloop: LangGraphAdapter = default_adapter
-) -> Any:
-    """
-    Create an async version of Command object to resume interrupted graph execution
+        try:
+            import agentops  # type: ignore
 
-    Will raise RuntimeError if LangGraph version doesn't support Command
+            agentops.init(tags=self.session_tags)
+        except Exception as e:
+            logger.warning(f"Failed to initialize AgentOps: {str(e)}")
 
-    Args:
-        lg_humanloop: LangGraphAdapter instance, defaults to global instance
+    @operation
+    async def async_on_humanloop_request(
+        self, provider: HumanLoopProvider, request: HumanLoopRequest
+    ) -> Any:
+        """Handle human loop start events."""
+        try:
+            # Create event data
+            event_data = {
+                "event_type": "gohumanloop_request",
+                "provider": provider.name,
+                "task_id": request.task_id,
+                "conversation_id": request.conversation_id,
+                "request_id": request.request_id,
+                "loop_type": request.loop_type.value,
+                "context": request.context,
+                "metadata": request.metadata,
+                "timeout": request.timeout,
+                "created_at": request.created_at,
+            }
+            return event_data
+        except (ImportError, Exception) as e:
+            logger.warning(f"Failed to record AgentOps event: {str(e)}")
+
+    @operation
+    async def async_on_humanloop_update(
+        self, provider: HumanLoopProvider, result: HumanLoopResult
+    ) -> Any:
+        """Handle human loop update events.
 
-    Returns:
-        Command object that can be used with graph.astream method
-    """
-    global _SKIP_NEXT_HUMANLOOP
+        Args:
+            provider: The human loop provider instance
+            result: The human loop result containing status and response
+        """
+        try:
+            # Create event data
+            event_data = {
+                "event_type": "gohumanloop_update",
+                "provider": provider.name,
+                "conversation_id": result.conversation_id,
+                "request_id": result.request_id,
+                "loop_type": result.loop_type.value,
+                "status": result.status.value,
+                "response": result.response,
+                "feedback": result.feedback,
+                "responded_by": result.responded_by,
+                "responded_at": result.responded_at,
+                "error": result.error,
+            }
+
+            return event_data
+        except Exception as e:
+            logger.warning(f"Failed to record AgentOps event: {str(e)}")
 
-    if not _SUPPORTS_INTERRUPT:
-        raise RuntimeError(
-            "LangGraph version too low, Command feature not supported. Please upgrade to 0.2.57 or higher."
-            "You can use: pip install --upgrade langgraph>=0.2.57"
-        )
+    @operation
+    async def async_on_humanloop_timeout(
+        self, provider: HumanLoopProvider, result: HumanLoopResult
+    ) -> Any:
+        """Handle human loop timeout events.
 
-    # Define async polling function
-    async def poll_for_result() -> Optional[Dict[str, Any]]:
-        poll_interval = 1.0  # Polling interval (seconds)
-        while True:
-            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)
+        Args:
+            provider: The human loop provider instance
+        """
+        try:
+            # Create error event
+            error_data = {
+                "event_type": "gohumanloop_timeout",
+                "provider": provider.name,
+                "conversation_id": result.conversation_id,
+                "request_id": result.request_id,
+                "loop_type": result.loop_type.value,
+                "status": result.status.value,
+                "response": result.response,
+                "feedback": result.feedback,
+                "responded_by": result.responded_by,
+                "responded_at": result.responded_at,
+                "error": result.error,
+            }
+
+            return error_data
+        except Exception as e:
+            logger.warning(f"Failed to record AgentOps timeout event: {str(e)}")
 
-    _SKIP_NEXT_HUMANLOOP = True
+    @operation
+    async def async_on_humanloop_error(
+        self, provider: HumanLoopProvider, error: Exception
+    ) -> Any:
+        """Handle human loop error events.
 
-    # Wait for async result directly
-    response = await poll_for_result()
-    return _lg_Command(resume=response)
+        Args:
+            provider: The human loop provider instance
+            error: The exception that occurred
+        """
+        try:
+            # Create error event
+            error_data = {
+                "event_type": "gohumanloop_error",
+                "provider": provider.name,
+                "error": str(error),
+            }
+
+            # Record the error event
+            return error_data
+        except Exception as e:
+            logger.warning(f"Failed to record AgentOps error event: {str(e)}")