agentscope-runtime 0.1.5b2__py3-none-any.whl → 0.2.0__py3-none-any.whl

agentscope_runtime/engine/deployers/modelstudio_deployer.py

@@ -7,10 +7,11 @@
 import logging
 import os
 import time
-import uuid
+import json
 from pathlib import Path
 from typing import Dict, Optional, List, Union, Tuple
 
+import requests
 from pydantic import BaseModel, Field
 
 from .adapter.protocol_adapter import ProtocolAdapter
@@ -90,12 +91,15 @@ class ModelstudioConfig(BaseModel):
 
     @classmethod
     def from_env(cls) -> "ModelstudioConfig":
+        raw_ws = os.environ.get("MODELSTUDIO_WORKSPACE_ID")
+        ws = raw_ws.strip() if isinstance(raw_ws, str) else ""
+        resolved_ws = ws if ws else "default"
         return cls(
             endpoint=os.environ.get(
                 "MODELSTUDIO_ENDPOINT",
                 "bailian.cn-beijing.aliyuncs.com",
             ),
-            workspace_id=os.environ.get("MODELSTUDIO_WORKSPACE_ID"),
+            workspace_id=resolved_ws,
             access_key_id=os.environ.get("ALIBABA_CLOUD_ACCESS_KEY_ID"),
             access_key_secret=os.environ.get(
                 "ALIBABA_CLOUD_ACCESS_KEY_SECRET",
@@ -107,8 +111,6 @@ class ModelstudioConfig(BaseModel):
 
     def ensure_valid(self) -> None:
         missing = []
-        if not self.workspace_id:
-            missing.append("MODELSTUDIO_WORKSPACE_ID")
         if not self.access_key_id:
             missing.append("ALIBABA_CLOUD_ACCESS_KEY_ID")
         if not self.access_key_secret:
@@ -201,16 +203,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,
@@ -232,6 +224,180 @@ async def _oss_put_and_presign(
     return pre.url
 
 
+def _upload_to_oss_with_credentials(
+    api_response,
+    file_path,
+) -> str:
+    response_data = (
+        json.loads(api_response)
+        if isinstance(api_response, str)
+        else api_response
+    )
+
+    try:
+        body = response_data["body"]
+        data = body.get("Data")
+        if data is None:
+            messages = [
+                "\n❌ Configuration Error: "
+                "The current RAM user is not assigned to target workspace.",
+                "Bailian requires RAM users to be associated with "
+                "at least one workspace to use temporary storage.",
+                "\n🔧 How to resolve:",
+                "1. Ask the primary account to log in to the "
+                "Bailian Console: https://bailian.console.aliyun.com",
+                "2. Go to [Permission Management]",
+                "3. Go to [Add User]",
+                "4. Assign the user to a workspace",
+                "\n💡 Note: If you are not the primary account holder,"
+                " please contact your administrator to complete this step.",
+                "=" * 80,
+            ]
+
+            for msg in messages:
+                logger.error(msg)
+
+            raise ValueError(
+                "RAM user is not assigned to any workspace in Bailian",
+            )
+        param = data["Param"]
+        signed_url = param["Url"]
+        headers = param["Headers"]
+    except KeyError as e:
+        raise ValueError(f"Missing expected field in API response: {e}") from e
+    try:
+        with open(file_path, "rb") as file:
+            response = requests.put(signed_url, data=file, headers=headers)
+        logger.info("OSS upload status code: %d", response.status_code)
+        response.raise_for_status()  # Raises for 4xx/5xx
+        logger.info("File uploaded successfully using requests")
+        return data["TempStorageLeaseId"]
+    except Exception as e:
+        logger.error("Failed to upload file to OSS: %s", e)
+        raise
+
+
+def _get_presign_url_and_upload_to_oss(
+    cfg: ModelstudioConfig,
+    wheel_path: Path,
+) -> str:
+    """
+    Request a temporary storage lease, obtain a pre-signed OSS URL, and upload the file.
+
+    Args:
+        cfg: ModelStudio configuration with credentials and endpoint.
+        wheel_path: Path to the wheel file to upload.
+
+    Returns:
+        The TempStorageLeaseId returned by the service.
+
+    Raises:
+        Exception: Any error from the SDK or upload process (not swallowed).
+    """
+    try:
+        config = open_api_models.Config(
+            access_key_id=cfg.access_key_id,
+            access_key_secret=cfg.access_key_secret,
+        )
+        config.endpoint = cfg.endpoint
+        client_modelstudio = ModelstudioClient(config)
+
+        filename = wheel_path.name
+        size = wheel_path.stat().st_size
+
+        apply_temp_storage_lease_request = (
+            ModelstudioTypes.ApplyTempStorageLeaseRequest(
+                file_name=filename,
+                size_in_bytes=size,
+            )
+        )
+        runtime = util_models.RuntimeOptions()
+        headers = {}
+        workspace_id = getattr(cfg, "workspace_id", "default")
+        try:
+            response = (
+                client_modelstudio.apply_temp_storage_lease_with_options(
+                    workspace_id,
+                    apply_temp_storage_lease_request,
+                    headers,
+                    runtime,
+                )
+            )
+        except Exception as error:
+            logger.error(
+                "Error during temporary storage lease or upload: %s",
+                error,
+            )
+            error_code = None
+            recommend_url = None
+            if hasattr(error, "code"):
+                error_code = error.code
+            if hasattr(error, "data") and isinstance(error.data, dict):
+                recommend_url = error.data.get("Recommend")
+
+            if error_code == "NoPermission":
+                messages = [
+                    "\n❌ Permission Denied (NoPermission)",
+                    "The current account does not have permission to apply "
+                    "for temporary storage (ApplyTempStorageLease).",
+                    "\n🔧 How to resolve:",
+                    "1. Ask the primary account holder (or an administrator)"
+                    " to grant your RAM user the following permission:",
+                    "   - Action: `AliyunBailianDataFullAccess`",
+                    "\n2. Steps to grant permission:",
+                    "   - Go to Alibaba Cloud RAM Console: https://ram.console.aliyun.com/users",
+                    "   - Locate your RAM user",
+                    "   - Click 'Add Permissions' and attach a policy that includes "
+                    "`AliyunBailianDataFullAccess`",
+                    "\n3. For further diagnostics:",
+                ]
+                official_doc_link = "https://help.aliyun.com/zh/ram/"
+                if recommend_url:
+                    messages.append(
+                        f"   - Official troubleshooting link: {recommend_url}",
+                    )
+                else:
+                    messages.append(
+                        "   - Visit the Alibaba Cloud API troubleshooting page",
+                    )
+                messages.append(
+                    f"   - Official document link: {official_doc_link or 'N/A'}",
+                )
+                messages.append(
+                    "\n💡 Note: If you are not an administrator, please "
+                    "contact your cloud account administrator for assistance.",
+                )
+                messages.append("=" * 80)
+
+                # 一次性记录多行日志（每行单独一条日志，便于解析）
+                for msg in messages:
+                    logger.error(msg)
+
+            logger.error("Original error details: %s", error)
+            raise
+
+        temp_storage_lease_id = _upload_to_oss_with_credentials(
+            response.to_map(),
+            wheel_path,
+        )
+        return temp_storage_lease_id
+
+    except Exception as error:
+        # Log detailed error information
+        logger.error(
+            "Error during temporary storage upload: %s",
+            error,
+        )
+        if hasattr(error, "message"):
+            logger.error("Error message: %s", error.message)
+        if hasattr(error, "data") and isinstance(error.data, dict):
+            recommend = error.data.get("Recommend")
+            if recommend:
+                logger.error("Diagnostic recommendation: %s", recommend)
+        # Re-raise the exception to avoid silent failures
+        raise
+
+
 async def _modelstudio_deploy(
     cfg: ModelstudioConfig,
     file_url: str,
@@ -501,32 +667,19 @@ class ModelstudioDeployManager(DeployManager):
         agent_id: Optional[str] = None,
         agent_desc: Optional[str] = None,
         telemetry_enabled: bool = True,
-    ) -> Tuple[str, str, str]:
-        logger.info("Uploading wheel to OSS and generating presigned URL")
-        client = _oss_get_client(self.oss_config)
-
-        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:
-            file_bytes = f.read()
-        artifact_url = await _oss_put_and_presign(
-            client,
-            bucket_name,
-            filename,
-            file_bytes,
+    ) -> Tuple[str, str]:
+        logger.info("Uploading wheel to OSS")
+        temp_storage_lease_id = _get_presign_url_and_upload_to_oss(
+            self.modelstudio_config,
+            wheel_path,
         )
-
         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,
+            file_url=temp_storage_lease_id,
+            filename=wheel_path.name,
             deploy_name=name,
             telemetry_enabled=telemetry_enabled,
         )
@@ -548,7 +701,7 @@ class ModelstudioDeployManager(DeployManager):
             if deploy_identifier
             else ""
         )
-        return artifact_url, console_url, deploy_identifier
+        return console_url, deploy_identifier
 
     async def deploy(
         self,
@@ -569,6 +722,9 @@ class ModelstudioDeployManager(DeployManager):
         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]:
         """
@@ -579,7 +735,10 @@ class ModelstudioDeployManager(DeployManager):
         """
         if not agent_id:
             if not runner and not project_dir and not external_whl_path:
-                raise ValueError("")
+                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):
@@ -588,6 +747,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(
@@ -595,6 +756,7 @@ 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,
@@ -633,7 +795,6 @@ class ModelstudioDeployManager(DeployManager):
                     telemetry_enabled=telemetry_enabled,
                 )
 
-            artifact_url = ""
             console_url = ""
             deploy_identifier = ""
             if not skip_upload:
@@ -642,7 +803,6 @@ class ModelstudioDeployManager(DeployManager):
                 self.oss_config.ensure_valid()
                 self.modelstudio_config.ensure_valid()
                 (
-                    artifact_url,
                     console_url,
                     deploy_identifier,
                 ) = await self._upload_and_deploy(
@@ -655,11 +815,12 @@ class ModelstudioDeployManager(DeployManager):
 
             result: Dict[str, str] = {
                 "wheel_path": str(wheel_path),
-                "artifact_url": artifact_url,
                 "resource_name": name,
-                "workspace_id": self.modelstudio_config.workspace_id or "",
                 "url": console_url,
             }
+            env_ws = os.environ.get("MODELSTUDIO_WORKSPACE_ID")
+            if env_ws and env_ws.strip():
+                result["workspace_id"] = env_ws.strip()
             if deploy_identifier:
                 result["deploy_id"] = deploy_identifier
 

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,
         )
 

agentscope_runtime/engine/deployers/utils/package_project_utils.py

@@ -12,7 +12,7 @@ import shutil
 import tarfile
 import tempfile
 from pathlib import Path
-from typing import List, Optional, Any, Tuple
+from typing import List, Optional, Any, Tuple, Dict
 
 from pydantic import BaseModel
 
@@ -61,6 +61,173 @@ def _get_package_version() -> str:
         return ""
 
 
+def _prepare_custom_endpoints_for_template(
+    custom_endpoints: Optional[List[Dict]],
+    temp_dir: str,
+) -> Tuple[Optional[List[Dict]], List[str]]:
+    """
+    Prepare custom endpoints for template rendering.
+    Copy handler source directories to ensure all dependencies are available.
+
+    Args:
+        custom_endpoints: List of custom endpoint configurations
+        temp_dir: Temporary directory where files will be copied
+
+    Returns:
+        Tuple of:
+        - Prepared endpoint configurations with file information
+        - List of copied directory names (for sys.path setup)
+    """
+    if not custom_endpoints:
+        return None, []
+
+    prepared_endpoints = []
+    handler_dirs_copied = set()  # Track copied directories to avoid duplicates
+    copied_dir_names = []  # Track directory names for sys.path
+
+    for endpoint in custom_endpoints:
+        prepared_endpoint = {
+            "path": endpoint.get("path", "/unknown"),
+            "methods": endpoint.get("methods", ["POST"]),
+            "module": endpoint.get("module"),
+            "function_name": endpoint.get("function_name"),
+        }
+
+        # Try to get handler source file if handler is provided
+        handler = endpoint.get("handler")
+        if handler and callable(handler):
+            try:
+                # Get the source file of the handler
+                handler_file = inspect.getfile(handler)
+                handler_name = handler.__name__
+
+                # Skip if it's a built-in or from site-packages
+                if (
+                    not handler_file.endswith(".py")
+                    or "site-packages" in handler_file
+                ):
+                    raise ValueError("Handler from non-user code")
+
+                # Get the directory containing the handler file
+                handler_dir = os.path.dirname(os.path.abspath(handler_file))
+
+                # Copy the entire working directory if not already copied
+                if handler_dir not in handler_dirs_copied:
+                    # Create a subdirectory name for this handler's context
+                    dir_name = os.path.basename(handler_dir)
+                    if not dir_name or dir_name == ".":
+                        dir_name = "handler_context"
+
+                    # Sanitize directory name
+                    dir_name = re.sub(r"[^a-zA-Z0-9_]", "_", dir_name)
+
+                    # Ensure unique directory name
+                    counter = 1
+                    base_dir_name = dir_name
+                    dest_context_dir = os.path.join(temp_dir, dir_name)
+                    while os.path.exists(dest_context_dir):
+                        dir_name = f"{base_dir_name}_{counter}"
+                        dest_context_dir = os.path.join(temp_dir, dir_name)
+                        counter += 1
+
+                    # Copy entire directory structure
+                    # Exclude common non-essential directories
+                    ignore_patterns = shutil.ignore_patterns(
+                        "__pycache__",
+                        "*.pyc",
+                        "*.pyo",
+                        ".git",
+                        ".gitignore",
+                        ".pytest_cache",
+                        ".mypy_cache",
+                        ".tox",
+                        "venv",
+                        "env",
+                        ".venv",
+                        ".env",
+                        "node_modules",
+                        ".DS_Store",
+                        "*.egg-info",
+                        "build",
+                        "dist",
+                    )
+
+                    shutil.copytree(
+                        handler_dir,
+                        dest_context_dir,
+                        ignore=ignore_patterns,
+                        dirs_exist_ok=True,
+                    )
+
+                    handler_dirs_copied.add(handler_dir)
+                    copied_dir_names.append(dir_name)
+                else:
+                    # Find the existing copied directory name
+                    for existing_dir in os.listdir(temp_dir):
+                        existing_path = os.path.join(temp_dir, existing_dir)
+                        if os.path.isdir(existing_path):
+                            # Check if this is the directory we already copied
+                            original_handler_basename = os.path.basename(
+                                handler_dir,
+                            )
+                            if existing_dir.startswith(
+                                re.sub(
+                                    r"[^a-zA-Z0-9_]",
+                                    "_",
+                                    original_handler_basename,
+                                ),
+                            ):
+                                dir_name = existing_dir
+                                break
+                    else:
+                        # Fallback if not found
+                        dir_name = re.sub(
+                            r"[^a-zA-Z0-9_]",
+                            "_",
+                            os.path.basename(handler_dir),
+                        )
+
+                # Calculate the module path relative to the handler directory
+                handler_file_rel = os.path.relpath(handler_file, handler_dir)
+                # Convert file path to module path
+                module_parts = os.path.splitext(handler_file_rel)[0].split(
+                    os.sep,
+                )
+                if module_parts[-1] == "__init__":
+                    module_parts = module_parts[:-1]
+
+                # Construct the full import path
+                if module_parts:
+                    module_path = f"{dir_name}.{'.'.join(module_parts)}"
+                else:
+                    module_path = dir_name
+
+                # Set the module and function name for template
+                prepared_endpoint["handler_module"] = module_path
+                prepared_endpoint["function_name"] = handler_name
+
+            except (OSError, TypeError, ValueError) as e:
+                # If source file extraction fails, try module/function_name
+                import traceback
+
+                print(f"Warning: Failed to copy handler directory: {e}")
+                traceback.print_exc()
+
+        # Add inline code if no handler module/function available
+        if not prepared_endpoint.get("handler_module") and (
+            not prepared_endpoint["module"]
+            or not prepared_endpoint["function_name"]
+        ):
+            prepared_endpoint["inline_code"] = endpoint.get(
+                "inline_code",
+                'lambda request: {"error": "Handler not available"}',
+            )
+
+        prepared_endpoints.append(prepared_endpoint)
+
+    return prepared_endpoints, copied_dir_names
+
+
 class PackageConfig(BaseModel):
     """Configuration for project packaging"""
 
@@ -73,6 +240,13 @@ class PackageConfig(BaseModel):
         ServicesConfig
     ] = None  # New: services configuration
     protocol_adapters: Optional[List[Any]] = None  # New: protocol adapters
+    custom_endpoints: Optional[
+        List[Dict]
+    ] = None  # New: custom endpoints configuration
+    # Celery configuration parameters
+    broker_url: Optional[str] = None
+    backend_url: Optional[str] = None
+    enable_embedded_worker: bool = False
 
 
 def _find_agent_source_file(
@@ -742,6 +916,41 @@ def package_project(
                     f"# Protocol adapters\nprotocol_adapters = {instances_str}"
                 )
 
+        # Convert celery_config to string representation for template
+        celery_config_str = None
+        config_lines = []
+
+        # Generate celery configuration code
+        config_lines.append("# Celery configuration")
+
+        if config.broker_url:
+            config_lines.append(
+                f'celery_config["broker_url"] = "{config.broker_url}"',
+            )
+
+        if config.backend_url:
+            config_lines.append(
+                f'celery_config["backend_url"] = "{config.backend_url}"',
+            )
+
+        if config.enable_embedded_worker:
+            config_lines.append(
+                f'celery_config["enable_embedded_worker"] = '
+                f"{config.enable_embedded_worker}",
+            )
+
+        if config_lines:
+            celery_config_str = "\n".join(config_lines)
+
+        # Prepare custom endpoints and get copied directory names
+        (
+            custom_endpoints_data,
+            handler_dirs,
+        ) = _prepare_custom_endpoints_for_template(
+            config.custom_endpoints,
+            temp_dir,
+        )
+
         # Render template - use template file by default,
         # or user-provided string
         if template is None:
@@ -751,6 +960,9 @@ def package_project(
                 endpoint_path=config.endpoint_path or "/process",
                 deployment_mode=config.deployment_mode or "standalone",
                 protocol_adapters=protocol_adapters_str,
+                celery_config=celery_config_str,
+                custom_endpoints=custom_endpoints_data,
+                handler_dirs=handler_dirs,
             )
         else:
             # Use user-provided template string
@@ -760,6 +972,9 @@ def package_project(
                 endpoint_path=config.endpoint_path,
                 deployment_mode=config.deployment_mode or "standalone",
                 protocol_adapters=protocol_adapters_str,
+                celery_config=celery_config_str,
+                custom_endpoints=custom_endpoints_data,
+                handler_dirs=handler_dirs,
             )
 
         # Write main.py
@@ -802,9 +1017,25 @@ def package_project(
             if not config.requirements:
                 config.requirements = []
 
-            # Combine base requirements with user requirements
+            # Add Celery requirements if Celery is configured
+            celery_requirements = []
+            if (
+                config.broker_url
+                or config.backend_url
+                or config.enable_embedded_worker
+            ):
+                celery_requirements = ["celery", "redis"]
+
+            # Combine base requirements with user requirements and Celery
+            # requirements
             all_requirements = sorted(
-                list(set(base_requirements + config.requirements)),
+                list(
+                    set(
+                        base_requirements
+                        + config.requirements
+                        + celery_requirements,
+                    ),
+                ),
             )
             for req in all_requirements:
                 f.write(f"{req}\n")