agentscope-runtime 1.0.2__py3-none-any.whl → 1.0.3__py3-none-any.whl

agentscope_runtime/engine/deployers/utils/docker_image_utils/image_factory.py

@@ -40,6 +40,7 @@ class ImageConfig(BaseModel):
     port: int = 8000
     env_vars: Dict[str, str] = Field(default_factory=lambda: {})
     startup_command: Optional[str] = None
+    pypi_mirror: Optional[str] = None
 
     # Runtime configuration
     host: str = "0.0.0.0"  # Container-friendly default
@@ -218,6 +219,7 @@ class ImageFactory:
                 env_vars=config.env_vars,
                 startup_command=startup_command,
                 platform=config.platform,
+                pypi_mirror=config.pypi_mirror,
             )
 
             dockerfile_path = self.dockerfile_generator.create_dockerfile(
@@ -314,6 +316,7 @@ class ImageFactory:
         embed_task_processor: bool = True,
         extra_startup_args: Optional[Dict[str, Union[str, int, bool]]] = None,
         use_cache: bool = True,
+        pypi_mirror: Optional[str] = None,
         **kwargs,
     ) -> str:
         """
@@ -339,6 +342,7 @@ class ImageFactory:
             embed_task_processor: Whether to embed task processor
             extra_startup_args: Additional startup arguments
             use_cache: Enable build cache (default: True)
+            pypi_mirror: PyPI mirror URL for pip package installation
             **kwargs: Additional configuration options
 
         Returns:
@@ -373,6 +377,7 @@ class ImageFactory:
             host=host,
             embed_task_processor=embed_task_processor,
             extra_startup_args=extra_startup_args or {},
+            pypi_mirror=pypi_mirror,
             **kwargs,
         )
 

agentscope_runtime/engine/deployers/utils/net_utils.py

@@ -0,0 +1,65 @@
+# -*- coding: utf-8 -*-
+import ipaddress
+import os
+import socket
+from typing import Optional
+
+import psutil
+
+
+def get_first_non_loopback_ip() -> Optional[str]:
+    """Get the first non-loopback IP address from network interfaces.
+
+    - Selects the interface with the lowest index
+    - Only considers interfaces that are up
+    - Supports IPv4/IPv6 based on environment variable
+    - Falls back to socket.gethostbyname() if no address found
+
+    Returns:
+        str | None: The first non-loopback IP address, or None if not found
+    """
+    result = None
+    lowest_index = float("inf")
+
+    use_ipv6 = os.environ.get("USE_IPV6", "false").lower() == "true"
+    target_family = socket.AF_INET6 if use_ipv6 else socket.AF_INET
+
+    net_if_stats = psutil.net_if_stats()
+
+    for index, (interface, addrs) in enumerate(
+        psutil.net_if_addrs().items(),
+    ):
+        stats = net_if_stats.get(interface)
+        if stats is None or not stats.isup:
+            continue
+
+        if index < lowest_index or result is None:
+            lowest_index = index
+        else:
+            continue
+
+        for addr in addrs:
+            if addr.family != target_family:
+                continue
+
+            try:
+                ip_obj = ipaddress.ip_address(
+                    addr.address.split("%")[0],
+                )
+                if ip_obj.is_loopback:
+                    continue
+                result = addr.address
+            except ValueError:
+                continue
+
+    if result is not None:
+        return result
+
+    try:
+        hostname = socket.gethostname()
+        fallback_ip = socket.gethostbyname(hostname)
+        return fallback_ip
+    except socket.error:
+        pass
+
+    return None

agentscope_runtime/engine/runner.py

@@ -282,6 +282,7 @@ class Runner:
 
             stream_adapter = identity_stream_adapter
 
+        error = None
         try:
             async for event in stream_adapter(
                 source_stream=self._call_handler_streaming(
@@ -301,8 +302,6 @@ class Runner:
                 e = UnknownAgentException(original_exception=e)
             error = Error(code=e.code, message=e.message)
             logger.error(f"{error.model_dump()}: {traceback.format_exc()}")
-            yield seq_gen.yield_with_sequence(response.failed(error))
-            return
 
         # Obtain token usage
         try:
@@ -312,4 +311,7 @@ class Runner:
             # Avoid empty message
             pass
 
-        yield seq_gen.yield_with_sequence(response.completed())
+        if error:
+            yield seq_gen.yield_with_sequence(response.failed(error))
+        else:
+            yield seq_gen.yield_with_sequence(response.completed())

agentscope_runtime/engine/schemas/exception.py

@@ -578,3 +578,27 @@ class UnknownAgentException(AgentRuntimeErrorException):
             message,
             details,
         )
+
+
+class ModelQuotaExceededException(AgentRuntimeErrorException):
+    """Model quota exceeded"""
+
+    def __init__(
+        self,
+        model_name: str,
+        details: Optional[Dict[str, Any]] = None,
+    ):
+        message = f"Model quota exceeded: {model_name}"
+        super().__init__("MODEL_QUOTA_EXCEEDED", message, details)
+
+
+class ModelContextLengthExceededException(AgentRuntimeErrorException):
+    """Model context length exceeded"""
+
+    def __init__(
+        self,
+        model_name: str,
+        details: Optional[Dict[str, Any]] = None,
+    ):
+        message = f"Model context length exceeded: {model_name}"
+        super().__init__("MODEL_CONTEXT_LENGTH_EXCEEDED", message, details)

agentscope_runtime/engine/services/agent_state/redis_state_service.py

@@ -21,29 +21,68 @@ class RedisStateService(StateService):
         self,
         redis_url: str = "redis://localhost:6379/0",
         redis_client: Optional[aioredis.Redis] = None,
+        socket_timeout: Optional[float] = 5.0,
+        socket_connect_timeout: Optional[float] = 5.0,
+        max_connections: Optional[int] = 50,
+        retry_on_timeout: bool = True,
+        ttl_seconds: Optional[int] = 3600,  # 1 hour in seconds
+        health_check_interval: Optional[float] = 30.0,
+        socket_keepalive: bool = True,
     ):
+        """
+        Initialize RedisStateService.
+
+        Args:
+            redis_url: Redis connection URL
+            redis_client: Optional pre-configured Redis client
+            socket_timeout: Socket timeout in seconds (default: 5.0)
+            socket_connect_timeout: Socket connect timeout in seconds
+            (default: 5.0)
+            max_connections: Maximum number of connections in the pool
+            (default: 50)
+            retry_on_timeout: Whether to retry on timeout (default: True)
+            ttl_seconds: Time-to-live in seconds for state data. If None,
+            data never expires (default: 3600, i.e., 1 hour)
+            health_check_interval: Interval in seconds for health checks on
+            idle connections (default: 30.0).
+                Connections idle longer than this will be checked before reuse.
+                Set to 0 to disable.
+            socket_keepalive: Enable TCP keepalive to prevent
+            silent disconnections (default: True)
+        """
         self._redis_url = redis_url
         self._redis = redis_client
-        self._health = False
+        self._socket_timeout = socket_timeout
+        self._socket_connect_timeout = socket_connect_timeout
+        self._max_connections = max_connections
+        self._retry_on_timeout = retry_on_timeout
+        self._ttl_seconds = ttl_seconds
+        self._health_check_interval = health_check_interval
+        self._socket_keepalive = socket_keepalive
 
     async def start(self) -> None:
-        """Initialize the Redis connection."""
+        """Starts the Redis connection with proper timeout and connection
+        pool settings."""
         if self._redis is None:
             self._redis = aioredis.from_url(
                 self._redis_url,
                 decode_responses=True,
+                socket_timeout=self._socket_timeout,
+                socket_connect_timeout=self._socket_connect_timeout,
+                max_connections=self._max_connections,
+                retry_on_timeout=self._retry_on_timeout,
+                health_check_interval=self._health_check_interval,
+                socket_keepalive=self._socket_keepalive,
             )
-        self._health = True
 
     async def stop(self) -> None:
-        """Close the Redis connection."""
+        """Closes the Redis connection."""
         if self._redis:
-            await self._redis.close()
+            await self._redis.aclose()
             self._redis = None
-        self._health = False
 
     async def health(self) -> bool:
-        """Service health check."""
+        """Checks the health of the service."""
         if not self._redis:
             return False
         try:
@@ -81,6 +120,11 @@ class RedisStateService(StateService):
                 round_id = 1
 
         await self._redis.hset(key, round_id, json.dumps(state))
+
+        # Set TTL for the state key if configured
+        if self._ttl_seconds is not None:
+            await self._redis.expire(key, self._ttl_seconds)
+
         return round_id
 
     async def export_state(
@@ -110,4 +154,13 @@ class RedisStateService(StateService):
 
         if state_json is None:
             return None
-        return json.loads(state_json)
+
+        # Refresh TTL when accessing the state
+        if self._ttl_seconds is not None:
+            await self._redis.expire(key, self._ttl_seconds)
+
+        try:
+            return json.loads(state_json)
+        except json.JSONDecodeError:
+            # Return None for corrupted state data instead of raising exception
+            return None

agentscope_runtime/engine/services/agent_state/state_service_factory.py

@@ -43,13 +43,10 @@ class StateServiceFactory(ServiceFactory[StateService]):
 
 StateServiceFactory.register_backend(
     "in_memory",
-    lambda **kwargs: InMemoryStateService(),
+    InMemoryStateService,
 )
 
 StateServiceFactory.register_backend(
     "redis",
-    lambda **kwargs: RedisStateService(
-        redis_url=kwargs.get("redis_url", "redis://localhost:6379/0"),
-        redis_client=kwargs.get("redis_client"),
-    ),
+    RedisStateService,
 )

agentscope_runtime/engine/services/memory/redis_memory_service.py

@@ -17,23 +17,70 @@ class RedisMemoryService(MemoryService):
         self,
         redis_url: str = "redis://localhost:6379/0",
         redis_client: Optional[aioredis.Redis] = None,
+        socket_timeout: Optional[float] = 5.0,
+        socket_connect_timeout: Optional[float] = 5.0,
+        max_connections: Optional[int] = 50,
+        retry_on_timeout: bool = True,
+        ttl_seconds: Optional[int] = 3600,  # 1 hour in seconds
+        max_messages_per_session: Optional[int] = None,
+        health_check_interval: Optional[float] = 30.0,
+        socket_keepalive: bool = True,
     ):
+        """
+        Initialize RedisMemoryService.
+
+        Args:
+            redis_url: Redis connection URL
+            redis_client: Optional pre-configured Redis client
+            socket_timeout: Socket timeout in seconds (default: 5.0)
+            socket_connect_timeout: Socket connect timeout in seconds
+             (default: 5.0)
+            max_connections: Maximum number of connections in the pool
+             (default: 50)
+            retry_on_timeout: Whether to retry on timeout (default: True)
+            ttl_seconds: Time-to-live in seconds for memory data.
+            If None, data never expires (default: 3600, i.e., 1 hour)
+            max_messages_per_session: Maximum number of messages stored per
+             session_id field within a user's Redis memory hash.
+             If None, no limit (default: None)
+            health_check_interval: Interval in seconds for health checks
+             on idle connections (default: 30.0).
+                Connections idle longer than this will be checked before reuse.
+                Set to 0 to disable.
+            socket_keepalive: Enable TCP keepalive to prevent
+            silent disconnections (default: True)
+        """
         self._redis_url = redis_url
         self._redis = redis_client
         self._DEFAULT_SESSION_ID = "default"
+        self._socket_timeout = socket_timeout
+        self._socket_connect_timeout = socket_connect_timeout
+        self._max_connections = max_connections
+        self._retry_on_timeout = retry_on_timeout
+        self._ttl_seconds = ttl_seconds
+        self._max_messages_per_session = max_messages_per_session
+        self._health_check_interval = health_check_interval
+        self._socket_keepalive = socket_keepalive
 
     async def start(self) -> None:
-        """Starts the Redis connection."""
+        """Starts the Redis connection with proper timeout
+        and connection pool settings."""
         if self._redis is None:
             self._redis = aioredis.from_url(
                 self._redis_url,
                 decode_responses=True,
+                socket_timeout=self._socket_timeout,
+                socket_connect_timeout=self._socket_connect_timeout,
+                max_connections=self._max_connections,
+                retry_on_timeout=self._retry_on_timeout,
+                health_check_interval=self._health_check_interval,
+                socket_keepalive=self._socket_keepalive,
             )
 
     async def stop(self) -> None:
         """Closes the Redis connection."""
         if self._redis:
-            await self._redis.close()
+            await self._redis.aclose()
             self._redis = None
 
     async def health(self) -> bool:
@@ -73,14 +120,27 @@ class RedisMemoryService(MemoryService):
         existing_json = await self._redis.hget(key, field)
         existing_msgs = self._deserialize(existing_json)
         all_msgs = existing_msgs + messages
+
+        # Limit the number of messages per session to prevent memory issues
+        if self._max_messages_per_session is not None:
+            if len(all_msgs) > self._max_messages_per_session:
+                # Keep only the most recent messages
+                all_msgs = all_msgs[-self._max_messages_per_session :]
+
         await self._redis.hset(key, field, self._serialize(all_msgs))
 
-    async def search_memory(
+        # Set TTL for the key if configured
+        if self._ttl_seconds is not None:
+            await self._redis.expire(key, self._ttl_seconds)
+
+    async def search_memory(  # pylint: disable=too-many-branches
         self,
         user_id: str,
         messages: list,
         filters: Optional[Dict[str, Any]] = None,
     ) -> list:
+        if not self._redis:
+            raise RuntimeError("Redis connection is not available")
         key = self._user_key(user_id)
         if (
             not messages
@@ -96,29 +156,52 @@ class RedisMemoryService(MemoryService):
 
         keywords = set(query.lower().split())
 
-        all_msgs = []
-        hash_keys = await self._redis.hkeys(key)
-        for session_id in hash_keys:
-            msgs_json = await self._redis.hget(key, session_id)
-            msgs = self._deserialize(msgs_json)
-            all_msgs.extend(msgs)
-
+        # Process messages in batches to avoid loading all into memory at once
         matched_messages = []
-        for msg in all_msgs:
-            candidate_content = await self.get_query_text(msg)
-            if candidate_content:
-                msg_content_lower = candidate_content.lower()
-                if any(keyword in msg_content_lower for keyword in keywords):
-                    matched_messages.append(msg)
+        hash_keys = await self._redis.hkeys(key)
 
+        # Get top_k limit early to optimize memory usage
+        top_k = None
         if (
             filters
             and "top_k" in filters
             and isinstance(filters["top_k"], int)
         ):
-            return matched_messages[-filters["top_k"] :]
+            top_k = filters["top_k"]
 
-        return matched_messages
+        # Process each session separately to reduce memory footprint
+        for session_id in hash_keys:
+            msgs_json = await self._redis.hget(key, session_id)
+            if not msgs_json:
+                continue
+            try:
+                msgs = self._deserialize(msgs_json)
+            except Exception:
+                # Skip corrupted message data
+                continue
+
+            # Match messages in this session
+            for msg in msgs:
+                candidate_content = await self.get_query_text(msg)
+                if candidate_content:
+                    msg_content_lower = candidate_content.lower()
+                    if any(
+                        keyword in msg_content_lower for keyword in keywords
+                    ):
+                        matched_messages.append(msg)
+
+        # Apply top_k filter if specified
+        if top_k is not None:
+            result = matched_messages[-top_k:]
+        else:
+            result = matched_messages
+
+        # Refresh TTL on read to extend lifetime of actively used data,
+        # if a TTL is configured and there is existing data for this key.
+        if self._ttl_seconds is not None and hash_keys:
+            await self._redis.expire(key, self._ttl_seconds)
+
+        return result
 
     async def get_query_text(self, message: Message) -> str:
         if message:
@@ -133,20 +216,39 @@ class RedisMemoryService(MemoryService):
         user_id: str,
         filters: Optional[Dict[str, Any]] = None,
     ) -> list:
+        if not self._redis:
+            raise RuntimeError("Redis connection is not available")
         key = self._user_key(user_id)
-        all_msgs = []
-        hash_keys = await self._redis.hkeys(key)
-        for session_id in sorted(hash_keys):
-            msgs_json = await self._redis.hget(key, session_id)
-            msgs = self._deserialize(msgs_json)
-            all_msgs.extend(msgs)
-
         page_num = filters.get("page_num", 1) if filters else 1
         page_size = filters.get("page_size", 10) if filters else 10
 
         start_index = (page_num - 1) * page_size
         end_index = start_index + page_size
 
+        # Optimize: Calculate which sessions we need to load
+        # For simplicity, we still load all but could be optimized further
+        # to only load sessions that contain the requested page range
+        all_msgs = []
+        hash_keys = await self._redis.hkeys(key)
+        for session_id in sorted(hash_keys):
+            msgs_json = await self._redis.hget(key, session_id)
+            if msgs_json:
+                try:
+                    msgs = self._deserialize(msgs_json)
+                    all_msgs.extend(msgs)
+                except json.JSONDecodeError:
+                    # Skip corrupted message data
+                    continue
+
+                # Early exit optimization: if we've loaded enough messages
+                # to cover the requested page, we can stop (but this assumes
+                # we need all previous messages for proper ordering)
+                # For now, we keep loading all for correctness
+
+        # Refresh TTL on active use to keep memory alive,
+        # mirroring get_session behavior
+        if self._ttl_seconds is not None and hash_keys:
+            await self._redis.expire(key, self._ttl_seconds)
         return all_msgs[start_index:end_index]
 
     async def delete_memory(
@@ -154,6 +256,8 @@ class RedisMemoryService(MemoryService):
         user_id: str,
         session_id: Optional[str] = None,
     ) -> None:
+        if not self._redis:
+            raise RuntimeError("Redis connection is not available")
         key = self._user_key(user_id)
         if session_id:
             await self._redis.hdel(key, session_id)