agentscope-runtime 0.1.5b1__py3-none-any.whl → 0.2.0b1__py3-none-any.whl

agentscope_runtime/engine/deployers/kubernetes_deployer.py

@@ -6,10 +6,6 @@ from typing import Optional, Dict, List, Union, Any
 
 from pydantic import BaseModel, Field
 
-from agentscope_runtime.engine.runner import Runner
-from agentscope_runtime.sandbox.manager.container_clients import (
-    KubernetesClient,
-)
 from .adapter.protocol_adapter import ProtocolAdapter
 from .base import DeployManager
 from .utils.docker_image_utils import (
@@ -19,6 +15,10 @@ from .utils.docker_image_utils import (
 from .utils.service_utils import (
     ServicesConfig,
 )
+from ..runner import Runner
+from ...common.container_clients.kubernetes_client import (
+    KubernetesClient,
+)
 
 logger = logging.getLogger(__name__)
 
@@ -77,6 +77,7 @@ class KubernetesDeployManager(DeployManager):
         endpoint_path: str = "/process",
         stream: bool = True,
         services_config: Optional[Union[ServicesConfig, dict]] = None,
+        custom_endpoints: Optional[List[Dict]] = None,
         protocol_adapters: Optional[list[ProtocolAdapter]] = None,
         requirements: Optional[Union[str, List[str]]] = None,
         extra_packages: Optional[List[str]] = None,
@@ -100,6 +101,7 @@ class KubernetesDeployManager(DeployManager):
             endpoint_path: API endpoint path
             stream: Enable streaming responses
             services_config: Services configuration for context manager
+            custom_endpoints: Custom endpoints from agent app
             protocol_adapters: protocol adapters
             requirements: PyPI dependencies (following _agent_engines.py
                 pattern)
@@ -156,6 +158,7 @@ class KubernetesDeployManager(DeployManager):
                     port=port,
                     services_config=services_config,  # type: ignore[arg-type]
                     protocol_adapters=protocol_adapters,
+                    custom_endpoints=custom_endpoints,
                     **kwargs,
                 )
                 if not built_image_name:
@@ -205,7 +208,11 @@ class KubernetesDeployManager(DeployManager):
                     f"{resource_name}, {traceback.format_exc()}",
                 )
 
-            url = f"http://{ip}:{ports[0]}"
+            if ports:
+                url = f"http://{ip}:{ports[0]}"
+            else:
+                url = f"http://{ip}:8080"
+
             logger.info(f"Deployment {deploy_id} successful: {url}")
 
             self._deployed_resources[deploy_id] = {

agentscope_runtime/engine/deployers/local_deployer.py

@@ -29,7 +29,8 @@ class LocalDeployManager(DeployManager):
         self,
         host: str = "127.0.0.1",
         port: int = 8000,
-        shutdown_timeout: int = 120,
+        shutdown_timeout: int = 30,
+        startup_timeout: int = 30,
         logger: Optional[logging.Logger] = None,
     ):
         """Initialize LocalDeployManager.
@@ -44,6 +45,7 @@ class LocalDeployManager(DeployManager):
         self.host = host
         self.port = port
         self._shutdown_timeout = shutdown_timeout
+        self._startup_timeout = startup_timeout
         self._logger = logger or logging.getLogger(__name__)
 
         # State management
@@ -66,6 +68,7 @@ class LocalDeployManager(DeployManager):
 
     async def deploy(
         self,
+        app=None,
         runner: Optional[Any] = None,
         endpoint_path: str = "/process",
         request_model: Optional[Type] = None,
@@ -75,7 +78,11 @@ class LocalDeployManager(DeployManager):
         after_finish: Optional[Callable] = None,
         mode: DeploymentMode = DeploymentMode.DAEMON_THREAD,
         services_config: Optional[ServicesConfig] = None,
+        custom_endpoints: Optional[List[Dict]] = None,
         protocol_adapters: Optional[list[ProtocolAdapter]] = None,
+        broker_url: Optional[str] = None,
+        backend_url: Optional[str] = None,
+        enable_embedded_worker: bool = False,
         **kwargs: Any,
     ) -> Dict[str, str]:
         """Deploy using unified FastAPI architecture.
@@ -90,7 +97,12 @@ class LocalDeployManager(DeployManager):
             after_finish: Callback function called after server finishes
             mode: Deployment mode
             services_config: Services configuration
+            custom_endpoints: Custom endpoints from agent app
             protocol_adapters: Protocol adapters
+            broker_url: Celery broker URL for background task processing
+            backend_url: Celery backend URL for result storage
+            enable_embedded_worker: Whether to run Celery worker
+                embedded in the app
             **kwargs: Additional keyword arguments
 
         Returns:
@@ -102,6 +114,19 @@ class LocalDeployManager(DeployManager):
         if self.is_running:
             raise RuntimeError("Service is already running")
 
+        self._app = app
+        if self._app is not None:
+            runner = self._app._runner
+            endpoint_path = self._app.endpoint_path
+            response_type = self._app.response_type
+            stream = self._app.stream
+            request_model = self._app.request_model
+            before_start = self._app.before_start
+            after_finish = self._app.after_finish
+            backend_url = self._app.backend_url
+            broker_url = self._app.broker_url
+            custom_endpoints = self._app.custom_endpoints
+            protocol_adapters = self._app.protocol_adapters
         try:
             if mode == DeploymentMode.DAEMON_THREAD:
                 return await self._deploy_daemon_thread(
@@ -113,7 +138,11 @@ class LocalDeployManager(DeployManager):
                     before_start=before_start,
                     after_finish=after_finish,
                     services_config=services_config,
+                    custom_endpoints=custom_endpoints,
                     protocol_adapters=protocol_adapters,
+                    broker_url=broker_url,
+                    backend_url=backend_url,
+                    enable_embedded_worker=enable_embedded_worker,
                     **kwargs,
                 )
             elif mode == DeploymentMode.DETACHED_PROCESS:
@@ -126,6 +155,7 @@ class LocalDeployManager(DeployManager):
                     before_start=before_start,
                     after_finish=after_finish,
                     services_config=services_config,
+                    custom_endpoints=custom_endpoints,
                     protocol_adapters=protocol_adapters,
                     **kwargs,
                 )
@@ -143,16 +173,22 @@ class LocalDeployManager(DeployManager):
         self,
         runner: Optional[Any] = None,
         protocol_adapters: Optional[list[ProtocolAdapter]] = None,
+        broker_url: Optional[str] = None,
+        backend_url: Optional[str] = None,
+        enable_embedded_worker: bool = False,
         **kwargs,
     ) -> Dict[str, str]:
         """Deploy in daemon thread mode."""
         self._logger.info("Deploying FastAPI service in daemon thread mode...")
 
-        # Create FastAPI app using factory
+        # Create FastAPI app using factory with Celery support
         app = FastAPIAppFactory.create_app(
             runner=runner,
             mode=DeploymentMode.DAEMON_THREAD,
             protocol_adapters=protocol_adapters,
+            broker_url=broker_url,
+            backend_url=backend_url,
+            enable_embedded_worker=enable_embedded_worker,
             **kwargs,
         )
 
@@ -174,7 +210,7 @@ class LocalDeployManager(DeployManager):
         self._server_thread.start()
 
         # Wait for server to start
-        await self._wait_for_server_ready()
+        await self._wait_for_server_ready(self._startup_timeout)
 
         self.is_running = True
         self.deploy_id = f"daemon_{self.host}_{self.port}"
@@ -207,6 +243,8 @@ class LocalDeployManager(DeployManager):
             )
 
         agent = runner._agent
+        if "agent" in kwargs:
+            kwargs.pop("agent")
 
         # Create package project for detached deployment
         project_dir = await self.create_detached_project(
@@ -272,6 +310,13 @@ class LocalDeployManager(DeployManager):
         extra_packages: Optional[List[str]] = None,
         services_config: Optional[ServicesConfig] = None,
         protocol_adapters: Optional[list[ProtocolAdapter]] = None,
+        custom_endpoints: Optional[
+            List[Dict]
+        ] = None,  # New parameter for custom endpoints
+        # Celery parameters
+        broker_url: Optional[str] = None,
+        backend_url: Optional[str] = None,
+        enable_embedded_worker: bool = False,
         **kwargs,  # pylint: disable=unused-argument
     ) -> str:
         """Create detached project using package_project method."""
@@ -288,6 +333,11 @@ class LocalDeployManager(DeployManager):
             extra_packages=extra_packages,
             protocol_adapters=protocol_adapters,
             services_config=services_config,
+            custom_endpoints=custom_endpoints,  # Add custom endpoints
+            # Celery configuration
+            broker_url=broker_url,
+            backend_url=backend_url,
+            enable_embedded_worker=enable_embedded_worker,
             requirements=requirements
             + (
                 ["redis"]
@@ -301,6 +351,14 @@ class LocalDeployManager(DeployManager):
                     if config
                 )
                 else []
+            )
+            + (
+                [
+                    "celery",
+                    "redis",
+                ]  # Add Celery and Redis if Celery is configured
+                if broker_url or backend_url
+                else []
             ),
         )
 

agentscope_runtime/engine/deployers/modelstudio_deployer.py

@@ -163,7 +163,24 @@ async def _oss_create_bucket_if_not_exists(client, bucket_name: str) -> None:
                 storage_class="IA",
             ),
         )
-        client.put_bucket(req)
+        try:
+            put_bucket_result = client.put_bucket(req)
+            logger.info(
+                f"put bucket status code: {put_bucket_result.status_code},"
+                f" request id: {put_bucket_result.request_id}",
+            )
+        except oss.exceptions.OperationError as e:
+            logger.error(
+                "OSS PutBucket failed: Http Status: %s, ErrorCode: %s, RequestId: %s, Message: %s",
+                getattr(e, "http_code", None),
+                getattr(e, "error_code", None),
+                getattr(e, "request_id", None),
+                getattr(e, "message", str(e)),
+            )
+            raise
+        except Exception as e:
+            logger.error("Unexpected put bucket failure: %s", e, exc_info=True)
+            raise
         result = client.put_bucket_tags(
             oss.PutBucketTagsRequest(
                 bucket=bucket_name,
@@ -184,16 +201,6 @@ async def _oss_create_bucket_if_not_exists(client, bucket_name: str) -> None:
         )
 
 
-def _create_bucket_name(prefix: str, base_name: str) -> str:
-    import re as _re
-
-    ts = time.strftime("%Y%m%d-%H%M%S", time.gmtime())
-    base = _re.sub(r"\s+", "-", base_name)
-    base = _re.sub(r"[^a-zA-Z0-9-]", "", base).lower().strip("-")
-    name = f"{prefix}-{base}-{ts}"
-    return name[:63]
-
-
 async def _oss_put_and_presign(
     client,
     bucket_name: str,
@@ -220,6 +227,8 @@ async def _modelstudio_deploy(
     file_url: str,
     filename: str,
     deploy_name: str,
+    agent_id: Optional[str] = None,
+    agent_desc: Optional[str] = None,
     telemetry_enabled: bool = True,
 ) -> str:
     cfg.ensure_valid()
@@ -230,6 +239,8 @@ async def _modelstudio_deploy(
     config.endpoint = cfg.endpoint
     client_modelstudio = ModelstudioClient(config)
     req = ModelstudioTypes.HighCodeDeployRequest(
+        agent_desc=agent_desc,
+        agent_id=agent_id,
         source_code_name=filename,
         source_code_oss_url=file_url,
         agent_name=deploy_name,
@@ -244,6 +255,10 @@ async def _modelstudio_deploy(
         runtime,
     )
 
+    # logger.info(json.dumps(resp.to_map(), indent=2, ensure_ascii=False))
+    request_id = resp.to_map()["headers"].get("x-acs-request-id")
+    logger.info("deploy request id: %s", request_id)
+
     # Extract deploy identifier string from response
     def _extract_deploy_identifier(response_obj) -> str:
         try:
@@ -473,14 +488,17 @@ class ModelstudioDeployManager(DeployManager):
         self,
         wheel_path: Path,
         name: str,
+        agent_id: Optional[str] = None,
+        agent_desc: Optional[str] = None,
         telemetry_enabled: bool = True,
-    ) -> Tuple[str, str]:
+    ) -> Tuple[str, str, str]:
         logger.info("Uploading wheel to OSS and generating presigned URL")
         client = _oss_get_client(self.oss_config)
-        bucket_name = (
-            f"tmp-bucket-for-code-deployment-"
-            f"{os.getenv('MODELSTUDIO_WORKSPACE_ID', str(uuid.uuid4()))}"
-        )
+
+        bucket_suffix = (
+            os.getenv("MODELSTUDIO_WORKSPACE_ID", str(uuid.uuid4()))
+        ).lower()
+        bucket_name = (f"tmp-code-deploy-" f"{bucket_suffix}")[:63]
         await _oss_create_bucket_if_not_exists(client, bucket_name)
         filename = wheel_path.name
         with wheel_path.open("rb") as f:
@@ -494,6 +512,8 @@ class ModelstudioDeployManager(DeployManager):
 
         logger.info("Triggering Modelstudio Full-Code deploy for %s", name)
         deploy_identifier = await _modelstudio_deploy(
+            agent_desc=agent_desc,
+            agent_id=agent_id,
             cfg=self.modelstudio_config,
             file_url=artifact_url,
             filename=filename,
@@ -501,25 +521,24 @@ class ModelstudioDeployManager(DeployManager):
             telemetry_enabled=telemetry_enabled,
         )
 
-        def _build_console_url(endpoint: str, identifier: str) -> str:
+        def _build_console_url(endpoint: str) -> str:
             # Map API endpoint to console domain (no fragment in base)
             base = (
-                "https://pre-bailian.console.aliyun.com/?tab=app&efm_v=3.4.108#"
+                "https://pre-bailian.console.aliyun.com/?tab=app#"
                 if ("bailian-pre" in endpoint or "pre" in endpoint)
-                else "https://bailian.console.aliyun.com/?tab=app"
+                else "https://bailian.console.aliyun.com/?tab=app#"
             )
             # Optional query can be appended if needed; keep path clean
-            return f"{base}/app-center/high-code-detail/{identifier}"
+            return f"{base}/app-center"
 
         console_url = (
             _build_console_url(
                 self.modelstudio_config.endpoint,
-                deploy_identifier,
             )
             if deploy_identifier
             else ""
         )
-        return artifact_url, console_url
+        return artifact_url, console_url, deploy_identifier
 
     async def deploy(
         self,
@@ -538,6 +557,11 @@ class ModelstudioDeployManager(DeployManager):
         skip_upload: bool = False,
         telemetry_enabled: bool = True,
         external_whl_path: Optional[str] = None,
+        agent_id: Optional[str] = None,
+        agent_desc: Optional[str] = None,
+        custom_endpoints: Optional[
+            List[Dict]
+        ] = None,  # New parameter for custom endpoints
         **kwargs,
     ) -> Dict[str, str]:
         """
@@ -546,8 +570,12 @@ class ModelstudioDeployManager(DeployManager):
         Returns a dict containing deploy_id, wheel_path, artifact_url (if uploaded),
         resource_name (deploy_name), and workspace_id.
         """
-        if not runner and not project_dir and not external_whl_path:
-            raise ValueError("")
+        if not agent_id:
+            if not runner and not project_dir and not external_whl_path:
+                raise ValueError(
+                    "Either runner, project_dir, "
+                    "or external_whl_path must be provided.",
+                )
 
         # convert services_config to Model body
         if services_config and isinstance(services_config, dict):
@@ -556,6 +584,8 @@ class ModelstudioDeployManager(DeployManager):
         try:
             if runner:
                 agent = runner._agent
+                if "agent" in kwargs:
+                    kwargs.pop("agent")
 
                 # Create package project for detached deployment
                 project_dir = await LocalDeployManager.create_detached_project(
@@ -563,14 +593,23 @@ class ModelstudioDeployManager(DeployManager):
                     endpoint_path=endpoint_path,
                     services_config=services_config,  # type: ignore[arg-type]
                     protocol_adapters=protocol_adapters,
+                    custom_endpoints=custom_endpoints,  # Pass custom endpoints
                     requirements=requirements,
                     extra_packages=extra_packages,
                     **kwargs,
                 )
-                self._generate_env_file(project_dir, environment)
+                if project_dir:
+                    self._generate_env_file(project_dir, environment)
                 cmd = "python main.py"
                 deploy_name = deploy_name or default_deploy_name()
 
+            if agent_id:
+                if not external_whl_path:
+                    raise FileNotFoundError(
+                        "wheel file not found. "
+                        "Please specify your .whl file path by "
+                        "'--whl-path <whlpath>' in command line.",
+                    )
             # if whl exists then skip the project package method
             if external_whl_path:
                 wheel_path = Path(external_whl_path).resolve()
@@ -579,6 +618,9 @@ class ModelstudioDeployManager(DeployManager):
                         f"External wheel file not found: {wheel_path}",
                     )
                 name = deploy_name or default_deploy_name()
+                # 如果是更新agent，且没有传deploy_name, 则不更新名字
+                if agent_id and (deploy_name is None):
+                    name = None
             else:
                 (
                     wheel_path,
@@ -592,25 +634,33 @@ class ModelstudioDeployManager(DeployManager):
 
             artifact_url = ""
             console_url = ""
+            deploy_identifier = ""
             if not skip_upload:
                 # Only require cloud SDKs and credentials when performing upload/deploy
                 _assert_cloud_sdks_available()
                 self.oss_config.ensure_valid()
                 self.modelstudio_config.ensure_valid()
-                artifact_url, console_url = await self._upload_and_deploy(
+                (
+                    artifact_url,
+                    console_url,
+                    deploy_identifier,
+                ) = await self._upload_and_deploy(
                     wheel_path,
                     name,
+                    agent_id,
+                    agent_desc,
                     telemetry_enabled,
                 )
 
             result: Dict[str, str] = {
-                "deploy_id": self.deploy_id,
                 "wheel_path": str(wheel_path),
                 "artifact_url": artifact_url,
                 "resource_name": name,
                 "workspace_id": self.modelstudio_config.workspace_id or "",
                 "url": console_url,
             }
+            if deploy_identifier:
+                result["deploy_id"] = deploy_identifier
 
             return result
         except Exception as e:

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

@@ -103,12 +103,12 @@ class DockerImageBuilder:
         """
         if not os.path.exists(build_context):
             raise ValueError(f"Build context does not exist: {build_context}")
-
         config = config or BuildConfig()
         full_image_name = self.get_full_name(image_name, image_tag)
 
-        if not source_updated:
-            return full_image_name
+        # if not source_updated:
+        #     return full_image_name
+        logger.info(f"Source Updated: {source_updated}")
 
         # Prepare docker build command
         build_cmd = ["docker", "build", "-t", full_image_name]

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

@@ -39,6 +39,9 @@ class RunnerImageConfig(BaseModel):
     endpoint_path: str = "/process"
     protocol_adapters: Optional[List] = None  # New: protocol adapters
     services_config: Optional[ServicesConfig] = None
+    custom_endpoints: Optional[
+        List[Dict]
+    ] = None  # New: custom endpoints configuration
 
     # Docker configuration
     base_image: str = "python:3.10-slim-bookworm"
@@ -184,6 +187,7 @@ class RunnerImageFactory:
                     endpoint_path=config.endpoint_path,
                     protocol_adapters=config.protocol_adapters,
                     services_config=config.services_config,
+                    custom_endpoints=config.custom_endpoints,
                 ),
                 dockerfile_path=dockerfile_path,
                 # caller_depth is no longer needed due to automatic
@@ -245,6 +249,9 @@ class RunnerImageFactory:
         push_to_registry: bool = False,
         services_config: Optional[ServicesConfig] = None,
         protocol_adapters: Optional[List] = None,  # New: protocol adapters
+        custom_endpoints: Optional[
+            List[Dict]
+        ] = None,  # New parameter for custom endpoints
         **kwargs,
     ) -> str:
         """
@@ -261,6 +268,7 @@ class RunnerImageFactory:
             push_to_registry: Whether to push to registry
             services_config: Optional services config
             protocol_adapters: Protocol adapters
+            custom_endpoints: Custom endpoints from agent app
             **kwargs: Additional configuration options
 
         Returns:
@@ -276,6 +284,7 @@ class RunnerImageFactory:
             push_to_registry=push_to_registry,
             protocol_adapters=protocol_adapters,
             services_config=services_config,
+            custom_endpoints=custom_endpoints,
             **kwargs,
         )