gohumanloop 0.0.9__tar.gz → 0.0.11__tar.gz

{gohumanloop-0.0.9 → gohumanloop-0.0.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gohumanloop
-Version: 0.0.9
+Version: 0.0.11
 Summary: Perfecting AI workflows with human intelligence
 Author-email: gohumanloop authors <baird0917@163.com>
 Project-URL: repository, https://github.com/ptonlix/gohumanloop
@@ -255,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.9 → gohumanloop-0.0.11}/README.md

@@ -230,7 +230,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.9 → gohumanloop-0.0.11}/gohumanloop/adapters/base_adapter.py

@@ -19,7 +19,7 @@ from inspect import iscoroutinefunction
 from contextlib import asynccontextmanager, contextmanager
 import logging
 
-from gohumanloop.utils import run_async_safely
+from gohumanloop.utils import run_async_safely, generate_function_summary
 from gohumanloop.core.interface import (
     HumanLoopRequest,
     HumanLoopResult,
@@ -241,6 +241,12 @@ class HumanloopAdapter:
 
         @wraps(fn)
         async def async_wrapper(*args: Any, **kwargs: Any) -> R:
+            # Check if ret_key exists in function parameters
+            if ret_key not in fn.__code__.co_varnames:
+                raise ValueError(
+                    f"Function {fn.__name__} must have parameter named {ret_key}"
+                )
+
             # Determine if callback is instance or factory function
             cb = None
             if callable(callback) and not isinstance(callback, HumanLoopCallback):
@@ -255,7 +261,8 @@ class HumanloopAdapter:
                 conversation_id=conversation_id,
                 loop_type=HumanLoopType.APPROVAL,
                 context={
-                    "message": {
+                    "message": generate_function_summary(fn, args, kwargs),
+                    "function": {
                         "function_name": fn.__name__,
                         "function_signature": str(fn.__code__.co_varnames),
                         "arguments": str(args),
@@ -289,7 +296,9 @@ class HumanloopAdapter:
                     "error": result.error,
                 }
 
-            kwargs[ret_key] = approval_info
+                # Inject approval info into kwargs
+                kwargs[ret_key] = approval_info
+
             # Check approval result
             if isinstance(result, HumanLoopResult):
                 # Handle based on approval status
@@ -426,6 +435,12 @@ class HumanloopAdapter:
 
         @wraps(fn)
         async def async_wrapper(*args: Any, **kwargs: Any) -> R:
+            # Check if ret_key exists in function parameters
+            if ret_key not in fn.__code__.co_varnames:
+                raise ValueError(
+                    f"Function {fn.__name__} must have parameter named {ret_key}"
+                )
+
             # Determine if callback is instance or factory function
             cb = None
             state = args[0] if args else None
@@ -434,11 +449,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}"
@@ -510,8 +531,8 @@ class HumanloopAdapter:
                     "responded_at": result.responded_at,
                     "error": result.error,
                 }
-
-            kwargs[ret_key] = conversation_info
+                # Inject conversation info into kwargs
+                kwargs[ret_key] = conversation_info
 
             if isinstance(result, HumanLoopResult):
                 if iscoroutinefunction(fn):
@@ -625,6 +646,12 @@ class HumanloopAdapter:
 
         @wraps(fn)
         async def async_wrapper(*args: Any, **kwargs: Any) -> R:
+            # Check if ret_key exists in function parameters
+            if ret_key not in fn.__code__.co_varnames:
+                raise ValueError(
+                    f"Function {fn.__name__} must have parameter named {ret_key}"
+                )
+
             # Determine if callback is an instance or factory function
             # callback: can be HumanLoopCallback instance or factory function
             # - If factory function: accepts state parameter and returns HumanLoopCallback instance
@@ -659,12 +686,11 @@ class HumanloopAdapter:
                 provider_id=provider_id,
                 blocking=True,
             )
-
-            # 初始化审批结果对象为None
+            # Initialize response info object as None
             resp_info = None
 
             if isinstance(result, HumanLoopResult):
-                # 如果结果是HumanLoopResult类型，则构建完整的审批信息
+                # If result is HumanLoopResult type, build complete response info
                 resp_info = {
                     "conversation_id": result.conversation_id,
                     "request_id": result.request_id,
@@ -676,12 +702,12 @@ class HumanloopAdapter:
                     "responded_at": result.responded_at,
                     "error": result.error,
                 }
+                # Inject approval info into kwargs
+                kwargs[ret_key] = resp_info
 
-            kwargs[ret_key] = resp_info
-
-            # 检查结果是否有效
+            # Check if result is valid
             if isinstance(result, HumanLoopResult):
-                # 返回获取信息结果，由用户去判断是否使用
+                # Return the information result, let user decide whether to use it
                 if iscoroutinefunction(fn):
                     ret = await fn(*args, **kwargs)
                 else:
@@ -695,7 +721,7 @@ class HumanloopAdapter:
             ret = run_async_safely(async_wrapper(*args, **kwargs))
             return cast(R, ret)
 
-        # 根据被装饰函数类型返回对应的wrapper
+        # Return corresponding wrapper based on decorated function type
         if iscoroutinefunction(fn):
             return async_wrapper
         return sync_wrapper

{gohumanloop-0.0.9 → gohumanloop-0.0.11}/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-0.0.9 → gohumanloop-0.0.11}/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-0.0.9 → gohumanloop-0.0.11}/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-0.0.9 → gohumanloop-0.0.11}/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-0.0.9 → gohumanloop-0.0.11}/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-0.0.11/gohumanloop/utils/__init__.py

@@ -0,0 +1,5 @@
+from .utils import run_async_safely, get_secret_from_env
+from .context_formatter import generate_function_summary
+
+
+__all__ = ["run_async_safely", "get_secret_from_env", "generate_function_summary"]

gohumanloop-0.0.11/gohumanloop/utils/context_formatter.py

@@ -0,0 +1,136 @@
+import inspect
+from typing import Callable, Any, Dict, Union, cast
+
+
+def _param_detail_zh(p: inspect.Parameter) -> str:
+    return (
+        f"    {p.name}: "
+        + (f"类型[{p.annotation}] " if p.annotation != p.empty else "")
+        + (f"(默认值={p.default})" if p.default != p.empty else "")
+    )
+
+
+def _param_detail_en(p: inspect.Parameter) -> str:
+    return (
+        f"    {p.name}: "
+        + (f"Type[{p.annotation}] " if p.annotation != p.empty else "")
+        + (f"(default={p.default})" if p.default != p.empty else "")
+    )
+
+
+def generate_function_summary(
+    fn: Callable,
+    *args: Any,
+    language: str = "zh",
+    **kwargs: Any,
+) -> str:
+    """生成支持中英文切换的函数说明模板
+
+    Args:
+        fn: 目标函数
+        *args: 位置参数示例
+        **kwargs: 关键字参数示例
+        language: 输出语言 ('zh'/'en')
+
+    Returns:
+        纯文本格式的函数说明
+    """
+
+    # 定义翻译类型
+
+    # 语言配置
+    translations: Dict[
+        str, Dict[str, Union[str, Callable[[inspect.Parameter], str]]]
+    ] = {
+        "zh": {
+            "title": "函数说明",
+            "name": "函数名称",
+            "module": "所属模块",
+            "description": "功能描述",
+            "params": "参数列表",
+            "param_detail": _param_detail_zh,
+            "return": "返回值类型",
+            "current_input": "当前输入",
+            "positional_args": "位置参数",
+            "keyword_args": "关键字参数",
+            "usage": "调用方式",
+            "approval": "审批状态",
+            "no_doc": "无文档说明",
+        },
+        "en": {
+            "title": "Function Documentation",
+            "name": "Function Name",
+            "module": "Module",
+            "description": "Description",
+            "params": "Parameters",
+            "param_detail": _param_detail_en,
+            "return": "Return Type",
+            "current_input": "Current Input",
+            "positional_args": "Positional Args",
+            "keyword_args": "Keyword Args",
+            "usage": "Usage",
+            "approval": "Approval Status",
+            "no_doc": "No documentation",
+        },
+    }
+
+    lang = translations.get(language, translations["zh"])
+
+    # 明确告诉类型检查器这是一个可调用对象
+    param_detail_func = cast(Callable[[inspect.Parameter], str], lang["param_detail"])
+
+    # 获取函数信息
+    func_name = fn.__name__
+    module_obj = inspect.getmodule(fn)
+    module = module_obj.__name__ if module_obj is not None else str(lang["no_doc"])
+    doc = (fn.__doc__ or str(lang["no_doc"])).strip()
+    sig = inspect.signature(fn)
+
+    # 构建模板
+    template = (
+        f"""
+- {lang['title']}: {func_name}
+- {lang['name']}: {func_name}
+- {lang['module']}: {module}
+
+- {lang['description']}:
+{doc}
+
+- {lang['params']}:
+"""
+        + "\n".join(param_detail_func(p) for p in sig.parameters.values())
+        + f"""
+
+- {lang['return']}: {sig.return_annotation if sig.return_annotation != sig.empty else lang['no_doc']}
+
+- {lang['current_input']}:
+{lang['positional_args']}: {args}
+{lang['keyword_args']}: {kwargs}
+
+- {lang['usage']}: {func_name}(*{args}, **{kwargs})
+
+"""
+    )
+    return template.strip()
+
+
+if __name__ == "__main__":
+    # 示例函数
+    def calculate(a: int, b: float = 1.0) -> float:
+        """计算两个数的乘积/Calculate the product of two numbers"""
+        return a * b
+
+    # 中文输出
+    print("==== 中文版 ====")
+    print(generate_function_summary(calculate, 3, b=2.5))
+
+    # 英文输出
+    print("\n==== English Version ====")
+    print(
+        generate_function_summary(
+            calculate,
+            3,
+            language="en",
+            b=2.5,
+        )
+    )

{gohumanloop-0.0.9 → gohumanloop-0.0.11}/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.9 → gohumanloop-0.0.11}/gohumanloop.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gohumanloop
-Version: 0.0.9
+Version: 0.0.11
 Summary: Perfecting AI workflows with human intelligence
 Author-email: gohumanloop authors <baird0917@163.com>
 Project-URL: repository, https://github.com/ptonlix/gohumanloop
@@ -255,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.9 → gohumanloop-0.0.11}/pyproject.toml

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

gohumanloop-0.0.9/gohumanloop/utils/__init__.py

@@ -1,7 +0,0 @@
-from .utils import run_async_safely, get_secret_from_env
-
-
-__all__ = [
-    "run_async_safely",
-    "get_secret_from_env",
-]

gohumanloop-0.0.9/gohumanloop/utils/context_formatter.py

@@ -1,64 +0,0 @@
-from typing import Dict, Any
-import json
-
-
-class ContextFormatter:
-    """上下文格式化工具"""
-
-    @staticmethod
-    def format_for_human(context: Dict[str, Any]) -> str:
-        """将上下文格式化为人类可读的文本"""
-        result = []
-
-        # 添加标题（如果有）
-        if "title" in context:
-            result.append(f"# {context['title']}\n")
-
-        # 添加描述（如果有）
-        if "description" in context:
-            result.append(f"{context['description']}\n")
-
-        # 添加任务信息
-        if "task" in context:
-            result.append(f"## 任务\n{context['task']}\n")
-
-        # 添加代理信息
-        if "agent" in context:
-            result.append(f"## 代理\n{context['agent']}\n")
-
-        # 添加操作信息
-        if "action" in context:
-            result.append(f"## 请求的操作\n{context['action']}\n")
-
-        # 添加原因
-        if "reason" in context:
-            result.append(f"## 原因\n{context['reason']}\n")
-
-        # 添加其他键值对
-        other_keys = [
-            k
-            for k in context.keys()
-            if k not in ["title", "description", "task", "agent", "action", "reason"]
-        ]
-        if other_keys:
-            result.append("## 附加信息\n")
-            for key in other_keys:
-                value = context[key]
-                if isinstance(value, (dict, list)):
-                    value = json.dumps(value, ensure_ascii=False, indent=2)
-                result.append(f"### {key}\n```\n{value}\n```\n")
-
-        return "\n".join(result)
-
-    @staticmethod
-    def format_for_api(context: Dict[str, Any]) -> Dict[str, Any]:
-        """将上下文格式化为API友好的格式"""
-        # 复制上下文以避免修改原始数据
-        formatted = context.copy()
-
-        # 确保所有值都是可序列化的
-        for key, value in formatted.items():
-            if not isinstance(value, (str, int, float, bool, list, dict, type(None))):
-                formatted[key] = str(value)
-
-        return formatted