agentscope-runtime 0.2.0b2__py3-none-any.whl → 1.0.0b1__py3-none-any.whl

agentscope_runtime/engine/deployers/utils/service_utils/fastapi_templates.py

@@ -13,7 +13,8 @@ class FastAPITemplateManager:
     def __init__(self):
         """Initialize template manager."""
         self.template_dir = os.path.join(
-            os.path.dirname(__file__),
+            os.path.dirname(os.path.dirname(__file__)),
+            "templates",
         )
         self.env = Environment(
             loader=FileSystemLoader(self.template_dir),
@@ -59,7 +60,6 @@ class FastAPITemplateManager:
         response_type: str = "sse",
         runner_code: str = "",
         func_code: str = "",
-        services_config: str = "",
         protocol_adapters: Optional[str] = None,
         **kwargs,
     ) -> str:
@@ -73,7 +73,6 @@ class FastAPITemplateManager:
             response_type: Response type
             runner_code: Code to setup runner
             func_code: Code to setup custom function
-            services_config: Services configuration code
             protocol_adapters: Protocol adapters code string
             **kwargs: Additional template variables
 
@@ -89,7 +88,6 @@ class FastAPITemplateManager:
             response_type=response_type,
             runner_code=runner_code,
             func_code=func_code,
-            services_config=services_config,
             protocol_adapters=protocol_adapters,
             **kwargs,
         )

agentscope_runtime/engine/deployers/utils/service_utils/process_manager.py

@@ -251,13 +251,17 @@ class ProcessManager:
         """
         import socket
 
+        # Normalize host for connection check
+        # When service binds to 0.0.0.0, we need to connect to 127.0.0.1
+        check_host = self._normalize_host_for_check(host)
+
         end_time = asyncio.get_event_loop().time() + timeout
 
         while asyncio.get_event_loop().time() < end_time:
             try:
                 with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
                     sock.settimeout(1)
-                    result = sock.connect_ex((host, port))
+                    result = sock.connect_ex((check_host, port))
                     if result == 0:
                         return True
             except Exception:
@@ -266,3 +270,21 @@ class ProcessManager:
             await asyncio.sleep(0.5)
 
         return False
+
+    @staticmethod
+    def _normalize_host_for_check(host: str) -> str:
+        """Normalize host for connection check.
+
+        When a service binds to 0.0.0.0 (all interfaces), it cannot be
+        directly connected to. We need to connect to 127.0.0.1 instead
+        to check if the service is running locally.
+
+        Args:
+            host: The host the service binds to
+
+        Returns:
+            The host to use for connection check
+        """
+        if host in ("0.0.0.0", "::"):
+            return "127.0.0.1"
+        return host

agentscope_runtime/engine/deployers/utils/templates/app_main.py.j2

@@ -0,0 +1,84 @@
+# -*- coding: utf-8 -*-
+"""
+Auto-generated main.py for AgentApp deployment.
+
+This file imports and runs the AgentApp from the original entrypoint file,
+avoiding circular deployment issues.
+"""
+
+import argparse
+import asyncio
+from agentscope_runtime.engine.deployers.utils.deployment_modes import DeploymentMode
+
+
+from {{ module_name }} import {{ object_name }}
+
+# Type whitelist for argument parser to prevent code injection
+ALLOWED_TYPES = {
+    "int": int,
+    "str": str,
+    "float": float,
+    "bool": bool,
+}
+
+
+def main():
+    """Run the AgentApp service."""
+    parser = argparse.ArgumentParser(
+        description="{{ object_name }} Service"
+    )
+    parser.add_argument(
+        "--host",
+        default="{{ host }}",
+        help="Host to bind to (default: {{ host }})"
+    )
+    parser.add_argument(
+        "--port",
+        type=int,
+        default={{ port }},
+        help="Port to bind to (default: {{ port }})"
+    )
+    parser.add_argument(
+        "--embed-task-processor",
+        action="store_true",
+        default=False,
+        help="Whether to embed task processor"
+    )
+{% if extra_parameters %}
+
+    # Additional runtime parameters
+{% for param in extra_parameters %}
+{% set cli_arg = param.cli_name or '--' + param.name.replace('_', '-') %}
+    parser.add_argument(
+        {{ cli_arg | tojson }},
+{% if param.type == "bool" %}
+        action="store_true",
+        default={{ param.default | default(False) | lower }},
+{% else %}
+        type=ALLOWED_TYPES[{{ param.type | tojson }}],
+        default={{ param.default | tojson if param.default is not none else 'None' }},
+{% endif %}
+        help={{ (param.help or param.name) | tojson }}
+    )
+{% endfor %}
+{% endif %}
+
+    args = parser.parse_args()
+
+    # Run the AgentApp with specified parameters
+    {{ object_name }}.run(
+        mode=DeploymentMode.DETACHED_PROCESS,
+        host=args.host,
+        port=args.port,
+        embed_task_processor=args.embed_task_processor,
+{% if extra_parameters %}
+        # Additional parameters
+{% for param in extra_parameters %}
+        {{ param.name }}=args.{{ param.name }},
+{% endfor %}
+{% endif %}
+    )
+
+
+if __name__ == "__main__":
+    main()

agentscope_runtime/engine/deployers/utils/templates/runner_main.py.j2

@@ -0,0 +1,95 @@
+# -*- coding: utf-8 -*-
+"""
+Auto-generated main.py for Runner deployment.
+
+This file imports the Runner from the original entrypoint file,
+wraps it in an AgentApp, and runs it as a service.
+"""
+
+import argparse
+import asyncio
+from {{ module_name }} import {{ object_name }}
+from agentscope_runtime.engine.app import AgentApp
+
+# Type whitelist for argument parser to prevent code injection
+ALLOWED_TYPES = {
+    "int": int,
+    "str": str,
+    "float": float,
+    "bool": bool,
+}
+
+
+# Wrap the runner in an AgentApp
+app = AgentApp(
+    app_name="{{ app_name }}",
+    app_description="{{ app_description }}",
+)
+
+
+@app.query(framework="agentscope")
+async def query_func(self, msgs, **kwargs):
+    """Query handler that uses the runner."""
+    result = await {{ object_name }}(msgs)
+    return result
+
+
+async def main():
+    """Run the Runner as an AgentApp service."""
+    parser = argparse.ArgumentParser(
+        description="{{ object_name }} Service (wrapped in AgentApp)"
+    )
+    parser.add_argument(
+        "--host",
+        default="{{ host }}",
+        help="Host to bind to (default: {{ host }})"
+    )
+    parser.add_argument(
+        "--port",
+        type=int,
+        default={{ port }},
+        help="Port to bind to (default: {{ port }})"
+    )
+    parser.add_argument(
+        "--embed-task-processor",
+        action="store_true",
+        default=False,
+        help="Whether to embed task processor"
+    )
+{% if extra_parameters %}
+
+    # Additional runtime parameters
+{% for param in extra_parameters %}
+{% set cli_arg = param.cli_name or '--' + param.name.replace('_', '-') %}
+    parser.add_argument(
+        {{ cli_arg | tojson }},
+{% if param.type == "bool" %}
+        action="store_true",
+        default={{ param.default | default(False) | lower }},
+{% else %}
+        type=ALLOWED_TYPES[{{ param.type | tojson }}],
+        default={{ param.default | tojson if param.default is not none else 'None' }},
+{% endif %}
+        help={{ (param.help or param.name) | tojson }}
+    )
+{% endfor %}
+{% endif %}
+
+    args = parser.parse_args()
+
+    # Run the wrapped AgentApp with specified parameters
+    await app.run(
+        host=args.host,
+        port=args.port,
+        embed_task_processor=args.embed_task_processor,
+{% if extra_parameters %}
+        # Additional parameters
+{% for param in extra_parameters %}
+        {{ param.name }}=args.{{ param.name }},
+{% endfor %}
+{% endif %}
+    )
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

agentscope_runtime/engine/deployers/utils/{service_utils → templates}/standalone_main.py.j2

@@ -19,8 +19,6 @@ import uvicorn
 from agentscope_runtime.engine.deployers.utils.deployment_modes import DeploymentMode
 from agentscope_runtime.engine.deployers.utils.service_utils import (
     FastAPIAppFactory,
-    ServicesConfig,
-    ServiceConfig,
 )
 from agentscope_runtime.engine.schemas.agent_schemas import AgentRequest
 from typing import Callable, Optional, Dict, List, Any, Union
@@ -41,45 +39,6 @@ from agent_file import {{endpoint.function_name}}
 
 
 
-def load_services_config() -> ServicesConfig:
-    """Load services configuration from environment variables or config file."""
-    config_file = os.getenv('AGENTSCOPE_SERVICES_CONFIG')
-
-    if config_file and os.path.exists(config_file):
-        # Load from JSON config file
-        import json
-        with open(config_file, 'r', encoding='utf-8') as f:
-            config_data = json.load(f)
-            return ServicesConfig.model_validate(config_data)
-    else:
-        # Load from environment variables
-        memory_provider = os.getenv('MEMORY_PROVIDER', 'in_memory')
-        session_provider = os.getenv('SESSION_HISTORY_PROVIDER', 'in_memory')
-
-        memory_config = {}
-        session_config = {}
-
-        # Add Redis configuration if using Redis
-        if memory_provider == 'redis':
-            memory_config = {
-                'host': os.getenv('REDIS_HOST', 'localhost'),
-                'port': int(os.getenv('REDIS_PORT', 6379)),
-                'db': int(os.getenv('REDIS_MEMORY_DB', 0))
-            }
-
-        if session_provider == 'redis':
-            session_config = {
-                'host': os.getenv('REDIS_HOST', 'localhost'),
-                'port': int(os.getenv('REDIS_PORT', 6379)),
-                'db': int(os.getenv('REDIS_SESSION_DB', 1))
-            }
-
-        return ServicesConfig(
-            memory=ServiceConfig(provider=memory_provider, config=memory_config),
-            session_history=ServiceConfig(provider=session_provider, config=session_config)
-        )
-
-
 def load_celery_config():
     """Load Celery configuration from environment variables or infer from existing config."""
     celery_config = {
@@ -162,9 +121,6 @@ async def after_finish(app, **kwargs):
     pass
 
 
-# Load services configuration
-services_config = load_services_config()
-
 # Load Celery configuration
 celery_config = load_celery_config()
 
@@ -181,7 +137,6 @@ else:
 app = FastAPIAppFactory.create_app(
     endpoint_path="{{endpoint_path}}",
     mode=deployment_mode,
-    services_config=services_config,
     before_start=before_start,
     after_finish=after_finish,
     stream=True,

agentscope_runtime/engine/deployers/utils/wheel_packager.py

@@ -30,7 +30,7 @@ except ImportError:  # pragma: no cover - fallback on older Pythons
     tomllib = None  # type: ignore
 
 
-async def _read_text_file_lines(file_path: Path) -> List[str]:
+def _read_text_file_lines(file_path: Path) -> List[str]:
     if not file_path.is_file():
         return []
     return [
@@ -39,16 +39,32 @@ async def _read_text_file_lines(file_path: Path) -> List[str]:
     ]
 
 
-async def _parse_requirements_txt(req_path: Path) -> List[str]:
-    requirements: List[str] = []
-    for line in await _read_text_file_lines(req_path):
+def _parse_requirements_txt(req_path: Path) -> Tuple[List[str], List[str]]:
+    """
+    Parse requirements.txt, separating standard requirements from local wheel paths.
+
+    Returns:
+        Tuple of (standard_requirements, local_wheel_paths)
+    """
+    standard_requirements: List[str] = []
+    local_wheel_paths: List[str] = []
+
+    for line in _read_text_file_lines(req_path):
         if not line or line.startswith("#"):
             continue
-        requirements.append(line)
-    return requirements
 
+        # Check if this is a local wheel file path
+        if line.endswith(".whl") and (
+            "/" in line or "\\" in line or line.startswith(".")
+        ):
+            local_wheel_paths.append(line)
+        else:
+            standard_requirements.append(line)
+
+    return standard_requirements, local_wheel_paths
 
-async def _parse_pyproject_toml(pyproject_path: Path) -> List[str]:
+
+def _parse_pyproject_toml(pyproject_path: Path) -> List[str]:
     deps: List[str] = []
     if not pyproject_path.is_file():
         return deps
@@ -114,15 +130,30 @@ async def _parse_pyproject_toml(pyproject_path: Path) -> List[str]:
     return deps
 
 
-async def _gather_user_dependencies(project_dir: Path) -> List[str]:
+def _gather_user_dependencies(
+    project_dir: Path,
+) -> Tuple[List[str], List[Path]]:
+    """
+    Gather user dependencies from pyproject.toml and requirements.txt.
+
+    Returns:
+        Tuple of (standard_dependencies, local_wheel_files)
+        where local_wheel_files are absolute paths to wheel files
+    """
     pyproject = project_dir / "pyproject.toml"
     req_txt = project_dir / "requirements.txt"
     deps: List[str] = []
+    local_wheels: List[Path] = []
+
     if pyproject.is_file():
-        dep = await _parse_pyproject_toml(pyproject)
+        dep = _parse_pyproject_toml(pyproject)
         deps.extend(dep)
+
     if req_txt.is_file():
-        # Merge requirements.txt too, avoiding duplicates
+        # Parse requirements.txt to separate standard deps from local wheels
+        standard_reqs, local_wheel_paths = _parse_requirements_txt(req_txt)
+
+        # Merge standard requirements, avoiding duplicates
         existing = set(
             d.split("[", 1)[0]
             .split("=", 1)[0]
@@ -132,7 +163,7 @@ async def _gather_user_dependencies(project_dir: Path) -> List[str]:
             .lower()
             for d in deps
         )
-        for r in await _parse_requirements_txt(req_txt):
+        for r in standard_reqs:
             name_key = (
                 r.split("[", 1)[0]
                 .split("=", 1)[0]
@@ -143,7 +174,18 @@ async def _gather_user_dependencies(project_dir: Path) -> List[str]:
             )
             if name_key not in existing:
                 deps.append(r)
-    return deps
+
+        # Process local wheel paths - convert to absolute paths
+        for wheel_path_str in local_wheel_paths:
+            # Handle relative paths like ./wheels/xxx.whl or wheels/xxx.whl
+            wheel_path = Path(wheel_path_str)
+            if not wheel_path.is_absolute():
+                wheel_path = (project_dir / wheel_path).resolve()
+
+            if wheel_path.exists() and wheel_path.is_file():
+                local_wheels.append(wheel_path)
+
+    return deps, local_wheels
 
 
 def _venv_python(venv_dir: Path) -> Path:
@@ -163,7 +205,7 @@ def _write_file(path: Path, content: str) -> None:
     path.write_text(content, encoding="utf-8")
 
 
-async def generate_wrapper_project(
+def generate_wrapper_project(
     build_root: Path,
     user_project_dir: Path,
     start_cmd: str,
@@ -203,28 +245,47 @@ async def generate_wrapper_project(
     )
 
     # 2) Dependencies
-    user_deps = await _gather_user_dependencies(user_project_dir)
+    _, local_wheels = _gather_user_dependencies(user_project_dir)
+
+    # Copy local wheel files to wrapper project
+    if local_wheels:
+        wheels_dir = wrapper_dir / "deploy_starter" / "wheels"
+        wheels_dir.mkdir(parents=True, exist_ok=True)
+        for wheel_file in local_wheels:
+            dest = wheels_dir / wheel_file.name
+            shutil.copy2(wheel_file, dest)
+
     wrapper_deps = [
         "pyyaml",
         "alibabacloud-oss-v2",
-        "alibabacloud-bailian20231229",
+        "alibabacloud-bailian20231229>=2.6.0",
+        "alibabacloud-agentrun20250910>=2.0.1",
         "alibabacloud-credentials",
         "alibabacloud-tea-openapi",
         "alibabacloud-tea-util",
         "python-dotenv",
+        "jinja2",
+        "psutil",
     ]
     # De-duplicate while preserving order
     seen = set()
+    standard_reqs, local_wheel_paths = _parse_requirements_txt(
+        user_project_dir / "requirements.txt",
+    )
+
     install_requires: List[str] = []
-    for pkg in wrapper_deps + user_deps:
+    for pkg in wrapper_deps + standard_reqs:
         key = pkg.strip().lower()
         if key and key not in seen:
             seen.add(key)
             install_requires.append(pkg)
 
+    req_content = "\n".join(install_requires) + "\n"
+    req_content += "\n".join(local_wheel_paths) + "\n"
+
     # 3) Packaging metadata
     unique_suffix = uuid.uuid4().hex[:8]
-    package_name = f"agentdev_starter_{unique_suffix}"
+    package_name = f"agentscope_runtime_{unique_suffix}"
     version = f"0.1.{int(time.time())}"
 
     # 4) Template package: deploy_starter
@@ -248,7 +309,29 @@ def read_config():
         return yaml.safe_load(f) or {{}}
 
 
+def install_local_wheels():
+    \"\"\"Install local wheel files if they exist.\"\"\"
+    wheels_dir = Path(__file__).resolve().parent / 'wheels'
+    if wheels_dir.exists() and wheels_dir.is_dir():
+        wheel_files = list(wheels_dir.glob('*.whl'))
+        if wheel_files:
+            print(f'[deploy_starter] Installing {{len(wheel_files)}} local wheel(s)...')
+            for wheel in wheel_files:
+                try:
+                    subprocess.run(
+                        ['pip', 'install', '--no-deps', str(wheel)],
+                        check=True,
+                        capture_output=True,
+                    )
+                    print(f'[deploy_starter] Installed: {{wheel.name}}')
+                except subprocess.CalledProcessError as e:
+                    print(f'[deploy_starter] Warning: Failed to install {{wheel.name}}: {{e}}', file=sys.stderr)
+
+
 def main():
+    # Install local wheels first
+    install_local_wheels()
+
     cfg = read_config()
     subdir = cfg.get('APP_SUBDIR_NAME')
     if not subdir:
@@ -336,6 +419,23 @@ APP_SUBDIR_NAME: "{project_basename}"
 
     setup_py = f"""
 from setuptools import setup, find_packages
+import os
+import subprocess
+import sys
+from pathlib import Path
+from setuptools import setup, find_packages
+from setuptools.command.install import install
+
+def run():
+    # Step 1: Install all .whl files in the ./wheel/ directory (relative to setup.py)
+    wheel_dir = Path(__file__).parent / "wheel"
+    if wheel_dir.is_dir():
+        whl_files = sorted(wheel_dir.glob("*.whl"))
+        if whl_files:
+            for whl in whl_files:
+                # Use the same Python interpreter to avoid env issues
+                subprocess.check_call([sys.executable, "-m", "pip", "install", str(whl)])
+
 
 setup(
     name='{package_name}',
@@ -350,13 +450,14 @@ setup(
     manifest_in = """
 recursive-include deploy_starter *.yml
 recursive-include deploy_starter/user_bundle *
+recursive-include deploy_starter/wheels *.whl
 """
     _write_file(wrapper_dir / "MANIFEST.in", manifest_in)
 
     return wrapper_dir, wrapper_dir / "dist"
 
 
-async def build_wheel(project_dir: Path) -> Path:
+def build_wheel(project_dir: Path) -> Path:
     """
     Build a wheel inside an isolated virtual environment to avoid PEP 668
     issues. Returns the path to the built wheel.

agentscope_runtime/engine/helpers/runner.py

@@ -0,0 +1,40 @@
+# -*- coding: utf-8 -*-
+# pylint: disable=unused-argument
+import logging
+
+from agentscope_runtime.engine import Runner
+from agentscope_runtime.engine.schemas.agent_schemas import (
+    AgentRequest,
+)
+
+logger = logging.getLogger(__name__)
+
+
+class SimpleRunner(Runner):
+    def __init__(self) -> None:
+        super().__init__()
+        self.framework_type = "text"
+
+    async def query_handler(
+        self,
+        request: AgentRequest = None,
+        **kwargs,
+    ):
+        print(request)
+        yield "Hi"
+        yield "! My name is Friday"
+        yield "."
+
+
+class ErrorRunner(Runner):
+    def __init__(self) -> None:
+        super().__init__()
+        self.framework_type = "text"
+
+    async def query_handler(
+        self,
+        request: AgentRequest = None,
+        **kwargs,
+    ):
+        yield "Hi"
+        raise RuntimeError("Error")