agentscope-runtime 1.0.4a1__py3-none-any.whl → 1.0.5__py3-none-any.whl

agentscope_runtime/engine/deployers/utils/net_utils.py

@@ -1,8 +1,10 @@
 # -*- coding: utf-8 -*-
+from functools import lru_cache
 import ipaddress
 import os
 import socket
 from typing import Optional
+from urllib import parse
 
 import psutil
 
@@ -63,3 +65,38 @@ def get_first_non_loopback_ip() -> Optional[str]:
         pass
 
     return None
+
+
+@lru_cache()
+def is_tcp_reachable(
+    endpoint: str,
+    port: int = None,
+    timeout: int = 1,
+) -> bool:
+    """Check if a domain is connectable, intelligently determining the port."""
+
+    parsed_url = parse.urlparse(endpoint)
+
+    scheme = parsed_url.scheme or "http"
+    hostname = parsed_url.hostname or endpoint
+
+    if not hostname:
+        return False
+
+    if port is not None:
+        port_to_use = port
+    elif scheme == "https":
+        port_to_use = 443
+    else:
+        port_to_use = 80
+
+    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+    sock.settimeout(timeout)
+    try:
+        ip = socket.gethostbyname(hostname)
+        sock.connect((ip, port_to_use))
+        return True
+    except (socket.timeout, socket.gaierror, socket.error):
+        return False
+    finally:
+        sock.close()

agentscope_runtime/engine/deployers/utils/oss_utils.py

@@ -0,0 +1,38 @@
+# -*- coding: utf-8 -*-
+import logging
+from typing import Optional, Tuple
+from urllib import parse
+
+
+logger = logging.getLogger(__name__)
+
+
+def parse_oss_uri(oss_uri: str) -> Tuple[str, Optional[str], str]:
+    """
+    Parse the oss uri to the format of
+    ("<bucket_name>", <endpoint>, <object_key>)
+
+    Example:
+        oss://my-bucket.oss-cn-hangzhou.aliyuncs.com/my-object-key
+        -> ("my-bucket", "oss-cn-hangzhou.aliyuncs.com", "my-object-key")
+
+        oss://my-bucket/my-object-key
+        -> ("my-bucket", None, "my-object-key")
+
+    Args:
+        oss_uri: The OSS URI to parse
+
+    Returns:
+        A tuple of (bucket_name, endpoint, object_key)
+    """
+    parsed_result = parse.urlparse(oss_uri)
+    if parsed_result.scheme != "oss":
+        raise ValueError(f"require oss uri but given '{oss_uri}'")
+    hostname = parsed_result.hostname
+    if hostname and "." in hostname:
+        bucket_name, endpoint = hostname.split(".", 1)
+    else:
+        bucket_name = hostname
+        endpoint = None
+    object_key = parsed_result.path
+    return bucket_name, endpoint, object_key.lstrip("/")

agentscope_runtime/engine/deployers/utils/package.py

@@ -593,60 +593,64 @@ def package(
     Package an AgentApp or Runner for deployment.
 
     This function supports two deployment patterns:
+
     1. Object-style: package(app=my_app) or package(runner=my_runner)
-    2. Entrypoint-style: package(entrypoint="app.py") or package(
-    entrypoint="project_dir/")
+    2. Entrypoint-style: package(entrypoint="app.py") or
+       package(entrypoint="project_dir/")
 
     For object-style deployment, this function will:
-    1. Extract the project directory containing the app/runner
-    2. Generate a new main.py that imports and runs the app/runner
-    3. Package the project with the generated main.py as entrypoint
+
+    1. Extract the project directory containing the app/runner.
+    2. Generate a new main.py that imports and runs the app/runner.
+    3. Package the project with the generated main.py as entrypoint.
 
     Build directory naming:
+
     - When output_dir=None (default), creates workspace directory with
-                platform-aware naming
-    - Directory format: cwd/.agentscope_runtime/builds/<platform>_
-                 <timestamp>_<code>/
-    - Explicit output_dir uses the provided path
+      platform-aware naming.
+    - Directory format: cwd/.agentscope_runtime/builds/
+      <platform>_<timestamp>_<code>/
+    - Explicit output_dir uses the provided path.
 
     Args:
-        app: AgentApp instance (for object-style deployment)
-        runner: Runner instance (for object-style deployment)
-        entrypoint: Entrypoint specification (for CLI-style deployment)
-        output_dir: Output directory (creates temp dir if None)
-        host: Default host for the service (default: "0.0.0.0")
-        port: Default port for the service (default: 8090)
-        extra_parameters: Additional runtime parameters to expose via CLI
-        requirements: Additional pip requirements
-        platform: Deployment platform (k8s, modelstudio, agentrun, local)
-        **kwargs: Additional keyword arguments (ignored)
+        app: AgentApp instance (for object-style deployment).
+        runner: Runner instance (for object-style deployment).
+        entrypoint: Entrypoint specification (for CLI-style deployment).
+        output_dir: Output directory (creates temp dir if None).
+        host: Default host for the service (default: "0.0.0.0").
+        port: Default port for the service (default: 8090).
+        extra_parameters: Additional runtime parameters to expose via CLI.
+        requirements: Additional pip requirements.
+        platform: Deployment platform (k8s, modelstudio, agentrun, local).
+        **kwargs: Additional keyword arguments (ignored).
 
     Returns:
-        Tuple of (package_path, project_info)
-        - package_path: Path to the deployment package directory
-        - project_info: ProjectInfo with project metadata
+        Tuple of (package_path, project_info).
 
-    Raises:
-        ValueError: If neither app/runner nor entrypoint is provided
-        RuntimeError: If packaging fails
+        - package_path: Path to the deployment package directory.
+        - project_info: ProjectInfo with project metadata.
 
-    Example:
-        >>> # Package with extra parameters
-        >>> extra_params = [
-        ...     RuntimeParameter(
-        ...         name="log_level",
-        ...         type="str",
-        ...         default="info",
-        ...         help="Logging level"
-        ...     ),
-        ...     RuntimeParameter(
-        ...         name="workers",
-        ...         type="int",
-        ...         default=4,
-        ...         help="Number of worker threads"
-        ...     ),
-        ... ]
-        >>> package(app=my_app, extra_parameters=extra_params, platform="k8s")
+    Raises:
+        ValueError: If neither app/runner nor entrypoint is provided.
+        RuntimeError: If packaging fails.
+
+    Example::
+
+        extra_params = [
+            RuntimeParameter(
+                name="log_level",
+                type="str",
+                default="info",
+                help="Logging level",
+            ),
+            RuntimeParameter(
+                name="workers",
+                type="int",
+                default=4,
+                help="Number of worker threads",
+            ),
+        ]
+        package(app=my_app, extra_parameters=extra_params, platform="k8s")
     """
     # Determine project info and target object
     target_obj = None

agentscope_runtime/engine/helpers/agent_api_client.py

@@ -0,0 +1,372 @@
+# -*- coding: utf-8 -*-
+"""
+Agent API Protocol Client Library.
+"""
+
+import json
+import logging
+from abc import ABC, abstractmethod
+from typing import AsyncIterator, Dict, Iterator, Optional
+
+import httpx
+
+from agentscope_runtime.engine.schemas.agent_schemas import (
+    AgentRequest,
+    AgentResponse,
+    Content,
+    DataContent,
+    Event,
+    ImageContent,
+    Message,
+    TextContent,
+)
+
+logger = logging.getLogger(__name__)
+
+
+class AgentAPIClientBase(ABC):
+    """
+    Abstract base class for Agent API Protocol clients.
+
+    All Agent API clients must implement this interface, which defines
+    the core method for streaming requests and responses according to
+    the Agent API Protocol.
+    """
+
+    @abstractmethod
+    def stream(self, request: AgentRequest) -> Iterator[Event]:
+        """
+        Send a request and stream the response events (synchronous).
+
+        Args:
+            request: AgentRequest object
+
+        Yields:
+            Event objects (Message, Content, AgentResponse, etc.)
+
+        Raises:
+            Exception: If the request fails
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    async def astream(self, request: AgentRequest) -> AsyncIterator[Event]:
+        """
+        Send a request and stream the response events (asynchronous).
+
+        Args:
+            request: AgentRequest object
+
+        Yields:
+            Event objects (Message, Content, AgentResponse, etc.)
+
+        Raises:
+            Exception: If the request fails
+        """
+        raise NotImplementedError
+        # Make this an async generator for proper type checking
+        yield  # pylint: disable=unreachable
+
+
+# ============================================================================
+# HTTP Implementation
+# ============================================================================
+
+
+def parse_sse_line_bytes(line: bytes) -> tuple[Optional[str], Optional[str]]:
+    """
+    Parse a single SSE (Server-Sent Events) line from bytes.
+
+    Args:
+        line: SSE line as bytes
+
+    Returns:
+        Tuple of (field, value) where field can be 'data', 'event',
+        'id', or 'retry'
+    """
+    line_str = line.decode("utf-8").strip()
+    return parse_sse_line(line_str)
+
+
+def parse_sse_line(line: str) -> tuple[Optional[str], Optional[str]]:
+    """
+    Parse a single SSE (Server-Sent Events) line.
+
+    Args:
+        line: SSE line string (already decoded from bytes)
+
+    Returns:
+        Tuple of (field, value) where field can be 'data', 'event',
+        'id', or 'retry'
+    """
+    line_str = line.strip()
+    if line_str.startswith("data: "):
+        return "data", line_str[6:]
+    elif line_str.startswith("event:"):
+        return "event", line_str[7:].strip()
+    elif line_str.startswith("id: "):
+        return "id", line_str[4:].strip()
+    elif line_str.startswith("retry:"):
+        return "retry", line_str[7:].strip()
+    return None, None
+
+
+def parse_event_from_json(data: Dict) -> Optional[Event]:
+    """
+    Parse an Event object from JSON data according to Agent API Protocol.
+
+    Args:
+        data: Parsed JSON response data
+
+    Returns:
+        Event object (Message, Content, or AgentResponse) if valid,
+        None otherwise
+    """
+    try:
+        obj_type = data.get("object")
+
+        if obj_type == "response":
+            return AgentResponse(**data)
+        if obj_type == "message":
+            return Message(**data)
+        if obj_type == "content":
+            content_type = data.get("type", "")
+            content_class_map = {
+                "text": TextContent,
+                "image": ImageContent,
+                "data": DataContent,
+            }
+            content_class = content_class_map.get(content_type, Content)
+            return content_class(**data)
+        # Unknown object type, return as generic event if it has
+        # required fields
+        if "object" in data:
+            return Event(**data)
+        return None
+    except Exception as e:
+        logger.warning(
+            "Failed to parse event from JSON: %s, error: %s",
+            data,
+            e,
+        )
+        return None
+
+
+class HTTPAgentAPIClient(AgentAPIClientBase):
+    """
+    HTTP/SSE implementation of Agent API Protocol client.
+
+    This client uses HTTP POST with Server-Sent Events (SSE) for streaming
+    responses from Agent API Protocol endpoints.
+
+    Attributes:
+        endpoint: API endpoint URL
+        token: Optional authorization token
+        timeout: Request timeout in seconds
+        headers: Additional custom headers
+    """
+
+    def __init__(
+        self,
+        endpoint: str,
+        token: Optional[str] = None,
+        timeout: float = 300.0,
+        headers: Optional[Dict[str, str]] = None,
+    ):
+        """
+        Initialize HTTP Agent API client.
+
+        Args:
+            endpoint: API endpoint URL
+                (e.g., "https://api.example.com/process")
+            token: Optional authorization token (Bearer token)
+            timeout: Request timeout in seconds (default: 300)
+            headers: Optional additional custom headers
+        """
+        self.endpoint = endpoint
+        self.token = token
+        self.timeout = timeout
+        self.headers = headers or {}
+
+    def _prepare_headers(self) -> Dict[str, str]:
+        """Prepare HTTP headers for the request."""
+        headers = {
+            "Content-Type": "application/json",
+            "Accept": "text/event-stream",
+            "Cache-Control": "no-cache",
+        }
+
+        # Add custom headers
+        headers.update(self.headers)
+
+        # Add authorization if token is provided
+        if self.token:
+            headers["Authorization"] = f"Bearer {self.token}"
+
+        return headers
+
+    def stream(self, request: AgentRequest) -> Iterator[Event]:
+        """
+        Send a request and stream the response events (synchronous).
+
+        Args:
+            request: AgentRequest object
+
+        Yields:
+            Event objects (Message, Content, AgentResponse, etc.)
+
+        Raises:
+            requests.exceptions.RequestException: If the HTTP request fails
+        """
+        import requests
+
+        headers = self._prepare_headers()
+        payload = request.model_dump(exclude_none=True)
+
+        try:
+            response = requests.post(
+                self.endpoint,
+                json=payload,
+                headers=headers,
+                stream=True,
+                timeout=self.timeout,
+            )
+            response.raise_for_status()
+
+            # Parse SSE stream
+            for line in response.iter_lines():
+                if not line:
+                    continue
+                field, value = parse_sse_line_bytes(line)
+                if field != "data" or not value:
+                    continue
+                try:
+                    data = json.loads(value)
+                    event = parse_event_from_json(data)
+                    if event:
+                        yield event
+                except json.JSONDecodeError:
+                    logger.debug("Failed to parse JSON: %s", value)
+
+        except requests.exceptions.RequestException as e:
+            logger.error("HTTP request failed: %s", e)
+            raise
+
+    async def astream(self, request: AgentRequest) -> AsyncIterator[Event]:
+        """
+        Send a request and stream the response events (asynchronous).
+
+        Args:
+            request: AgentRequest object
+
+        Yields:
+            Event objects (Message, Content, AgentResponse, etc.)
+
+        Raises:
+            httpx.HTTPError: If the HTTP request fails
+        """
+        headers = self._prepare_headers()
+        payload = request.model_dump(exclude_none=True)
+
+        try:
+            async with httpx.AsyncClient(timeout=self.timeout) as client:
+                async with client.stream(
+                    "POST",
+                    self.endpoint,
+                    json=payload,
+                    headers=headers,
+                ) as response:
+                    # chunks = ""
+
+                    # async for c in response.aiter_bytes():
+                    #     if c:
+                    #         chunks += c.decode("utf-8")
+                    # print(chunks)
+
+                    response.raise_for_status()
+
+                    # Parse SSE stream
+                    async for line in response.aiter_lines():
+                        if not line:
+                            continue
+                        field, value = parse_sse_line(line)
+                        if field != "data" or not value:
+                            continue
+                        try:
+                            data = json.loads(value)
+                            event = parse_event_from_json(data)
+                            if event:
+                                yield event
+                        except json.JSONDecodeError:
+                            logger.debug(
+                                "Failed to parse JSON: %s",
+                                value,
+                            )
+
+        except httpx.HTTPError as e:
+            logger.error("HTTP request failed: %s", e)
+            raise
+
+
+# ============================================================================
+# Convenience Utilities
+# ============================================================================
+
+
+def extract_text_from_event(event: Event) -> Optional[str]:
+    """
+    Extract text content from an Event.
+
+    Args:
+        event: Event object
+
+    Returns:
+        Text string if the event contains text content, None otherwise
+    """
+    if isinstance(event, TextContent):
+        return event.text
+    elif isinstance(event, Message):
+        # Extract text from completed messages
+        if event.status == "completed" and event.content:
+            texts = []
+            for content_item in event.content:
+                if isinstance(content_item, TextContent) and content_item.text:
+                    texts.append(content_item.text)
+            return "".join(texts) if texts else None
+    return None
+
+
+def create_simple_text_request(
+    query: str,
+    session_id: Optional[str] = None,
+    **kwargs,
+) -> AgentRequest:
+    """
+    Create a simple AgentRequest with a text query.
+
+    Args:
+        query: User query text
+        session_id: Optional session ID for conversation continuity
+        **kwargs: Additional parameters for AgentRequest
+
+    Returns:
+        AgentRequest object
+    """
+    message = Message(
+        role="user",
+        type="message",
+        content=[TextContent(type="text", text=query)],
+    )
+
+    request_params = {
+        "input": [message],
+        "stream": True,
+    }
+
+    if session_id:
+        request_params["session_id"] = session_id
+
+    # Merge with any additional parameters
+    request_params.update(kwargs)
+
+    return AgentRequest(**request_params)

agentscope_runtime/engine/runner.py

@@ -236,6 +236,7 @@ class Runner:
 
         query_kwargs = {
             "request": request,
+            "response": response,
         }
 
         if self.framework_type == "text":
@@ -272,6 +273,18 @@ class Runner:
             kwargs.update(
                 {"msgs": await message_to_agno_message(request.input)},
             )
+        elif self.framework_type == "ms_agent_framework":
+            from ..adapters.ms_agent_framework.stream import (
+                adapt_ms_agent_framework_message_stream,
+            )
+            from ..adapters.ms_agent_framework.message import (
+                message_to_ms_agent_framework_message,
+            )
+
+            stream_adapter = adapt_ms_agent_framework_message_stream
+            kwargs.update(
+                {"msgs": message_to_ms_agent_framework_message(request.input)},
+            )
         # TODO: support other frameworks
         else:
 

agentscope_runtime/engine/schemas/agent_schemas.py

@@ -622,15 +622,17 @@ class Message(Event):
 
         # new content
         if new_content.index is None:
+            content_index = len(self.content)
             copy = deepcopy(new_content)
             copy.delta = None
-            copy.index = None
-            copy.msg_id = None
+            copy.index = content_index
+            copy.msg_id = self.id
             self.content.append(copy)
 
-            new_content.index = len(self.content) - 1
+            new_content.index = content_index
             new_content.msg_id = self.id
             new_content.in_progress()
+
             return new_content
 
         # delta content
@@ -869,6 +871,10 @@ class BaseResponse(Event):
         self.output = self.output or []
         self.output.append(message)
 
+    def completed(self) -> Self:
+        self.completed_at = int(datetime.now().timestamp())
+        return super().completed()
+
 
 class AgentResponse(BaseResponse):
     """agent response"""

agentscope_runtime/engine/services/agent_state/__init__.py

@@ -1,6 +1,13 @@
 # -*- coding: utf-8 -*-
 from typing import TYPE_CHECKING
 from ....common.utils.lazy_loader import install_lazy_loader
+from ....common.utils.deprecation import deprecated_module
+
+deprecated_module(
+    module_name=__name__,
+    removed_in="v1.1",
+    alternative="agentscope.session",
+)
 
 if TYPE_CHECKING:
     from .state_service import StateService, InMemoryStateService

agentscope_runtime/engine/services/memory/__init__.py

@@ -1,6 +1,13 @@
 # -*- coding: utf-8 -*-
 from typing import TYPE_CHECKING
 from ....common.utils.lazy_loader import install_lazy_loader
+from ....common.utils.deprecation import deprecated_module
+
+deprecated_module(
+    module_name=__name__,
+    removed_in="v1.1",
+    alternative="agentscope.memory",
+)
 
 if TYPE_CHECKING:
     from .memory_service import MemoryService, InMemoryMemoryService