modelscope 1.40.0__tar.gz → 1.40.2__tar.gz

{modelscope-1.40.0/modelscope.egg-info → modelscope-1.40.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: modelscope
-Version: 1.40.0
+Version: 1.40.2
 Summary: ModelScope: bring the notion of Model-as-a-Service to life.
 Author: ModelScope team
 Author-email: contact@modelscope.cn
@@ -18,7 +18,7 @@ Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: filelock
-Requires-Dist: modelscope-hub>=0.3.0
+Requires-Dist: modelscope-hub>=0.4.6
 Requires-Dist: packaging
 Requires-Dist: requests>=2.25
 Requires-Dist: setuptools
@@ -26,7 +26,7 @@ Requires-Dist: tqdm>=4.64.0
 Requires-Dist: urllib3>=1.26
 Provides-Extra: hub
 Requires-Dist: filelock; extra == "hub"
-Requires-Dist: modelscope-hub>=0.3.0; extra == "hub"
+Requires-Dist: modelscope-hub>=0.4.6; extra == "hub"
 Requires-Dist: packaging; extra == "hub"
 Requires-Dist: requests>=2.25; extra == "hub"
 Requires-Dist: setuptools; extra == "hub"
@@ -438,7 +438,7 @@ Requires-Dist: tqdm; extra == "audio"
 Requires-Dist: umap-learn; extra == "audio"
 Provides-Extra: all
 Requires-Dist: filelock; extra == "all"
-Requires-Dist: modelscope-hub>=0.3.0; extra == "all"
+Requires-Dist: modelscope-hub>=0.4.6; extra == "all"
 Requires-Dist: packaging; extra == "all"
 Requires-Dist: requests>=2.25; extra == "all"
 Requires-Dist: setuptools; extra == "all"

modelscope-1.40.2/modelscope/cli/agent_idp.py

@@ -0,0 +1,16 @@
+# Copyright (c) Alibaba, Inc. and its affiliates.
+"""Import-compatible Agent-IDP CLI shim.
+
+The four ModelScope console scripts are owned by modelscope-hub. This module
+keeps direct imports from the umbrella SDK working without registering a
+second CLI plugin or implementation.
+"""
+from modelscope_hub.cli.agent_idp import AgentIdpCommand
+
+
+def subparser_func(args):
+    """Return the hub-owned Agent-IDP command for a parsed namespace."""
+    return AgentIdpCommand(args)
+
+
+__all__ = ['AgentIdpCommand', 'subparser_func']

modelscope-1.40.2/modelscope/cli/studio.py

@@ -0,0 +1,22 @@
+# Copyright (c) Alibaba, Inc. and its affiliates.
+"""ModelScope Studio runtime management CLI.
+
+The ``studio`` command is built into ``modelscope_hub`` so that hub-only
+installs can manage Studio spaces too, and this package no longer registers a
+competing ``studio`` plugin. This module therefore re-exports the hub
+implementation, which keeps ``from modelscope.cli.studio import StudioCMD``
+working while leaving exactly one implementation to maintain.
+
+Run ``modelscope studio --help`` for the current command surface; it now also
+covers ``list``, ``variable``, ``hardware``, ``base-images`` and
+``sdk-versions``.
+"""
+from modelscope_hub.cli.studio import StudioCMD, StudioCommand
+
+
+def subparser_func(args):
+    """Function which will be called for a specific sub parser."""
+    return StudioCMD(args)
+
+
+__all__ = ['StudioCMD', 'StudioCommand', 'subparser_func']

{modelscope-1.40.0 → modelscope-1.40.2}/modelscope/hub/__init__.py

@@ -7,6 +7,7 @@ from modelscope_hub import HubConfig as _HubConfig
 from modelscope_hub import get_default_config as _get_default_config
 from modelscope_hub import set_default_config as _set_default_config
 
+from .agent_idp_api import AgentIdpApi
 from .callback import ProgressCallback, TqdmCallback
 from .commit_scheduler import CommitScheduler
 from .snapshot_download import snapshot_download
@@ -42,6 +43,7 @@ def _sync_config() -> None:
 _sync_config()
 
 __all__ = [
+    'AgentIdpApi',
     'CommitScheduler',
     'ProgressCallback',
     'TqdmCallback',

modelscope-1.40.2/modelscope/hub/agent_idp_api.py

@@ -0,0 +1,142 @@
+# Copyright (c) Alibaba, Inc. and its affiliates.
+"""Agent-IDP API shim delegating to :mod:`modelscope_hub`.
+
+Agent-IDP manages Ed25519 identities, OIDC discovery, and JWT issuance. It is
+unrelated to Agent repository file transfer and deliberately owns no HTTP
+transport: all protocol handling lives in ``modelscope_hub``'s OpenAPI client.
+"""
+from __future__ import annotations
+from collections.abc import Mapping
+from typing import Any, Optional
+
+from modelscope_hub.agent_idp import (generate_agent_key_pair,
+                                      load_private_jwk,
+                                      public_jwk_from_private,
+                                      sign_agent_token_request,
+                                      write_private_jwk)
+from modelscope_hub.types import (AgentIdConfiguration, AgentIdentity,
+                                  AgentIdentitySummary, AgentJWK, AgentToken,
+                                  AgentTokenRecord, PagedResult)
+
+from modelscope.hub.api import HubApi
+
+__all__ = [
+    'AgentIdpApi',
+    'generate_agent_key_pair',
+    'load_private_jwk',
+    'public_jwk_from_private',
+    'sign_agent_token_request',
+    'write_private_jwk',
+]
+
+
+class AgentIdpApi(HubApi):
+    """OpenAPI-first SDK surface for ModelScope Agent-IDP.
+
+    The inherited ``HubApi`` remains the source of endpoint and ambient token
+    configuration. Per-call tokens create a temporary hub client, matching the
+    MCP delegation pattern without duplicating HTTP or signing logic upstream.
+    """
+
+    def _delegate(self, token: Optional[str] = None):
+        if token:
+            from modelscope_hub.api import HubApi as _HubApi
+            return _HubApi(token=token, endpoint=self.endpoint)
+        return self._api
+
+    def create_agent_identity(self,
+                              payload: Mapping[str, Any],
+                              *,
+                              token: Optional[str] = None) -> AgentIdentity:
+        return self._delegate(token).create_agent_identity(payload)
+
+    def get_agent_identity(self,
+                           agent_id: str,
+                           *,
+                           token: Optional[str] = None) -> AgentIdentity:
+        return self._delegate(token).get_agent_identity(agent_id)
+
+    def update_agent_identity(
+        self,
+        agent_id: str,
+        payload: Mapping[str, Any],
+        *,
+        token: Optional[str] = None,
+    ) -> AgentIdentity:
+        return self._delegate(token).update_agent_identity(agent_id, payload)
+
+    def delete_agent_identity(self,
+                              agent_id: str,
+                              *,
+                              token: Optional[str] = None) -> dict:
+        return self._delegate(token).delete_agent_identity(agent_id)
+
+    def reset_agent_key_pair(
+        self,
+        agent_id: str,
+        payload: Mapping[str, Any],
+        *,
+        token: Optional[str] = None,
+    ) -> AgentIdentity:
+        return self._delegate(token).reset_agent_key_pair(agent_id, payload)
+
+    def pause_agent(self,
+                    agent_id: str,
+                    *,
+                    paused: bool,
+                    token: Optional[str] = None) -> dict:
+        return self._delegate(token).pause_agent(agent_id, paused=paused)
+
+    def list_agent_token_records(
+        self,
+        agent_id: str,
+        *,
+        page: int = 1,
+        page_size: int = 20,
+        token: Optional[str] = None,
+    ) -> PagedResult[AgentTokenRecord]:
+        return self._delegate(token).list_agent_token_records(
+            agent_id, page=page, page_size=page_size)
+
+    def list_user_agent_identities(
+        self,
+        username: str,
+        *,
+        status: str | None = None,
+        page: int = 1,
+        page_size: int = 20,
+        token: Optional[str] = None,
+    ) -> PagedResult[AgentIdentitySummary]:
+        return self._delegate(token).list_user_agent_identities(
+            username,
+            status=status,
+            page=page,
+            page_size=page_size,
+        )
+
+    def issue_agent_token(self, payload: Mapping[str, Any]) -> AgentToken:
+        """Exchange a signed Agent-IDP request; this OpenAPI operation is anonymous."""
+        return self._api.issue_agent_token(payload)
+
+    def issue_agent_token_with_private_key(
+        self,
+        private_jwk: AgentJWK | Mapping[str, Any],
+        *,
+        agent_id: str,
+        audience: str,
+        timestamp: int | None = None,
+    ) -> AgentToken:
+        return self._api.issue_agent_token_with_private_key(
+            private_jwk,
+            agent_id=agent_id,
+            audience=audience,
+            timestamp=timestamp,
+        )
+
+    def get_agent_id_configuration(self) -> AgentIdConfiguration:
+        """Return anonymous Agent-IDP OIDC discovery metadata."""
+        return self._api.get_agent_id_configuration()
+
+    def get_agent_id_jwks(self) -> list[AgentJWK]:
+        """Return anonymous Agent-IDP JWT verification keys."""
+        return self._api.get_agent_id_jwks()

{modelscope-1.40.0 → modelscope-1.40.2}/modelscope/hub/constants.py

@@ -6,30 +6,34 @@ Constants unique to this project (endpoint configs, enum classes, env-driven tun
 are retained locally.
 """
 import os
-from pathlib import Path
 
 # --- Delegated constants (from modelscope_hub) ---
 from modelscope_hub.compat.constants import (  # noqa: F401
-    DEFAULT_DATASET_REVISION, DEFAULT_MAX_WORKERS, FILE_HASH,
-    MODELSCOPE_DOMAIN, MODELSCOPE_PREFER_AI_SITE, REPO_TYPE_DATASET,
-    REPO_TYPE_MODEL, REPO_TYPE_STUDIO, REPO_TYPE_SUPPORT,
-    TEMPORARY_FOLDER_NAME, ModelVisibility_INTERNAL, ModelVisibility_PRIVATE,
-    ModelVisibility_PUBLIC)
+    DEFAULT_CREDENTIALS_PATH, DEFAULT_DATASET_REVISION, DEFAULT_MAX_WORKERS,
+    DEFAULT_MODELSCOPE_DATA_ENDPOINT, DEFAULT_MODELSCOPE_DOMAIN,
+    DEFAULT_MODELSCOPE_GROUP, DEFAULT_MODELSCOPE_INTL_DATA_ENDPOINT,
+    DEFAULT_MODELSCOPE_INTL_DOMAIN, DEFAULT_SKILLS_DIR, FILE_HASH,
+    MODEL_ID_SEPARATOR, MODELSCOPE_DOMAIN, MODELSCOPE_PREFER_AI_SITE,
+    REPO_TYPE_DATASET, REPO_TYPE_MODEL, REPO_TYPE_STUDIO, REPO_TYPE_SUPPORT,
+    TEMPORARY_FOLDER_NAME, UPLOAD_ADAPTIVE_BATCH_SIZE, UPLOAD_BLOB_MAX_RETRIES,
+    UPLOAD_BLOB_RETRY_BACKOFF, UPLOAD_BLOB_RETRY_MAX_WAIT, UPLOAD_BLOB_TIMEOUT,
+    UPLOAD_BLOB_TQDM_DISABLE_THRESHOLD, UPLOAD_COMMIT_BATCH_SIZE,
+    UPLOAD_FAILED_FILE_MAX_RETRIES, UPLOAD_MAX_FILE_COUNT,
+    UPLOAD_MAX_FILE_COUNT_IN_DIR, UPLOAD_MAX_FILE_SIZE,
+    UPLOAD_NORMAL_FILE_SIZE_TOTAL_LIMIT, UPLOAD_REACT_BACKOFF_MAX_EXPONENT,
+    UPLOAD_REACT_ENABLED, UPLOAD_REACT_MAX_DELAY,
+    UPLOAD_REACT_ROUND2_BASE_DELAY, UPLOAD_REACT_ROUND3_FILE_DELAY,
+    UPLOAD_RETRY_ALLOWED_METHODS, UPLOAD_SIZE_THRESHOLD_TO_ENFORCE_LFS,
+    UPLOAD_USE_CACHE, UPLOAD_VALIDATE_BLOB_BATCH_SIZE,
+    ModelVisibility_INTERNAL, ModelVisibility_PRIVATE, ModelVisibility_PUBLIC)
 
 # --- Local constants (not in modelscope_hub) ---
 MODELSCOPE_URL_SCHEME = 'https://'
-DEFAULT_MODELSCOPE_DOMAIN = 'www.modelscope.cn'
-DEFAULT_MODELSCOPE_INTL_DOMAIN = 'www.modelscope.ai'
-DEFAULT_MODELSCOPE_DATA_ENDPOINT = MODELSCOPE_URL_SCHEME + DEFAULT_MODELSCOPE_DOMAIN
-DEFAULT_MODELSCOPE_INTL_DATA_ENDPOINT = MODELSCOPE_URL_SCHEME + DEFAULT_MODELSCOPE_INTL_DOMAIN
 MODELSCOPE_PARALLEL_DOWNLOAD_THRESHOLD_MB = int(
     os.environ.get('MODELSCOPE_PARALLEL_DOWNLOAD_THRESHOLD_MB', 500))
 MODELSCOPE_DOWNLOAD_PARALLELS = int(
     os.environ.get('MODELSCOPE_DOWNLOAD_PARALLELS', 1))
-DEFAULT_MODELSCOPE_GROUP = 'damo'
-MODEL_ID_SEPARATOR = '/'
 LOGGER_NAME = 'ModelScopeHub'
-DEFAULT_CREDENTIALS_PATH = Path.home().joinpath('.modelscope', 'credentials')
 MODELSCOPE_CREDENTIALS_PATH = os.environ.get(
     'MODELSCOPE_CREDENTIALS_PATH', DEFAULT_CREDENTIALS_PATH.as_posix())
 REQUESTS_API_HTTP_METHOD = ['get', 'head', 'post', 'put', 'patch', 'delete']
@@ -50,30 +54,8 @@ CREATE_TAG_MAX_RETRIES = int(
 CREATE_TAG_RETRY_BACKOFF = int(
     os.environ.get('MODELSCOPE_CREATE_TAG_RETRY_BACKOFF', 2))
 
-# Application-level retry for blob upload
-UPLOAD_BLOB_MAX_RETRIES = int(os.environ.get('UPLOAD_BLOB_MAX_RETRIES', 5))
-UPLOAD_BLOB_RETRY_BACKOFF = int(os.environ.get('UPLOAD_BLOB_RETRY_BACKOFF', 2))
-UPLOAD_BLOB_RETRY_MAX_WAIT = int(
-    os.environ.get('UPLOAD_BLOB_RETRY_MAX_WAIT', 60))
-
-# Failed file retry within upload_folder
-UPLOAD_FAILED_FILE_MAX_RETRIES = int(
-    os.environ.get('UPLOAD_FAILED_FILE_MAX_RETRIES', 3))
-
-# Per-socket-operation timeout for blob upload (not total transfer time).
-# Each individual socket send/recv must complete within this limit.
-# Safe for any file size: a 100GB upload's total time can exceed this,
-# but each chunk I/O operation finishes in milliseconds.
-UPLOAD_BLOB_TIMEOUT = (30,
-                       int(
-                           os.environ.get('UPLOAD_BLOB_TIMEOUT_SECONDS',
-                                          3600)))
-
-# Methods that are safe for urllib3 transport-level retry.
-# PUT is excluded because blob uploads use streaming data that cannot be replayed.
-UPLOAD_RETRY_ALLOWED_METHODS = frozenset(
-    os.environ.get('UPLOAD_RETRY_ALLOWED_METHODS',
-                   'GET,HEAD,DELETE,OPTIONS,TRACE').split(','))
+# Upload runtime configuration is owned by modelscope-hub and re-exported
+# above under the historical modelscope constant names.
 
 API_RESPONSE_FIELD_DATA = 'Data'
 API_FILE_DOWNLOAD_RETRY_TIMES = 5
@@ -89,37 +71,6 @@ MODELSCOPE_SDK_DEBUG = 'MODELSCOPE_SDK_DEBUG'
 MODELSCOPE_ENABLE_DEFAULT_HASH_VALIDATION = 'MODELSCOPE_ENABLE_DEFAULT_HASH_VALIDATION'
 ONE_YEAR_SECONDS = 24 * 365 * 60 * 60
 MODELSCOPE_REQUEST_ID = 'X-Request-ID'
-DEFAULT_SKILLS_DIR = os.path.join(os.path.expanduser('~'), '.agents', 'skills')
-
-# Upload check env
-UPLOAD_MAX_FILE_SIZE = int(
-    os.environ.get('UPLOAD_MAX_FILE_SIZE_MB', 100 * 1024)) * 1024 * 1024
-UPLOAD_SIZE_THRESHOLD_TO_ENFORCE_LFS = int(
-    os.environ.get('UPLOAD_SIZE_THRESHOLD_TO_ENFORCE_LFS', 1 * 1024 * 1024))
-UPLOAD_MAX_FILE_COUNT = int(os.environ.get('UPLOAD_MAX_FILE_COUNT', 100_000))
-UPLOAD_MAX_FILE_COUNT_IN_DIR = int(
-    os.environ.get('UPLOAD_MAX_FILE_COUNT_IN_DIR', 50_000))
-UPLOAD_NORMAL_FILE_SIZE_TOTAL_LIMIT = int(
-    os.environ.get('UPLOAD_NORMAL_FILE_SIZE_TOTAL_LIMIT', 500 * 1024 * 1024))
-UPLOAD_COMMIT_BATCH_SIZE = int(os.environ.get('UPLOAD_COMMIT_BATCH_SIZE', 256))
-UPLOAD_VALIDATE_BLOB_BATCH_SIZE = int(
-    os.environ.get('UPLOAD_VALIDATE_BLOB_BATCH_SIZE', 64))
-UPLOAD_ADAPTIVE_BATCH_SIZE = os.environ.get('UPLOAD_ADAPTIVE_BATCH_SIZE',
-                                            'true').lower() == 'true'
-
-# ReAct progressive retry fallback
-UPLOAD_REACT_ENABLED = os.environ.get('UPLOAD_REACT_ENABLED',
-                                      'true').lower() == 'true'
-UPLOAD_REACT_ROUND2_BASE_DELAY = int(
-    os.environ.get('UPLOAD_REACT_ROUND2_BASE_DELAY', 2))
-UPLOAD_REACT_ROUND3_FILE_DELAY = int(
-    os.environ.get('UPLOAD_REACT_ROUND3_FILE_DELAY', 30))
-UPLOAD_REACT_BACKOFF_MAX_EXPONENT = int(
-    os.environ.get('UPLOAD_REACT_BACKOFF_MAX_EXPONENT', 5))
-UPLOAD_REACT_MAX_DELAY = int(os.environ.get('UPLOAD_REACT_MAX_DELAY', 120))
-
-UPLOAD_BLOB_TQDM_DISABLE_THRESHOLD = 5 * 1024 * 1024
-UPLOAD_USE_CACHE = os.environ.get('UPLOAD_USE_CACHE', 'true').lower() == 'true'
 
 
 MODELSCOPE_ASCII = r"""

{modelscope-1.40.0 → modelscope-1.40.2}/modelscope/hub/mcp_api.py

@@ -7,19 +7,26 @@ ModelScope MCP plaza (https://www.modelscope.cn/mcp).
 """
 from typing import Any, Dict, Optional
 
-import requests
-
 from modelscope.hub.api import HubApi
-from modelscope.hub.errors import RequestError, raise_for_http_status
 from modelscope.utils.logger import get_logger
 
 # Configure logging
 logger = get_logger()
 
-# MCP API path
+# MCP API path. Retained for backward compatibility with callers that imported
+# it; the requests themselves are issued by modelscope_hub, which owns the URL.
 MCP_API_PATH = '/openapi/v1/mcp/servers'
 
 
+def _operational_url_entry(operational_url: Dict[str, Any]) -> Dict[str, str]:
+    """Render one hosted endpoint as the {type, url} pair callers expect.
+
+    The transport is the final path segment (``sse`` / ``streamable_http``).
+    """
+    url = operational_url.get('url') or ''
+    return {'type': url.split('/')[-1], 'url': url}
+
+
 class MCPApiError(Exception):
     """Base exception for MCP API errors."""
     pass
@@ -60,6 +67,17 @@ class MCPApi(HubApi):
 
         self.mcp_base_url = self.endpoint + MCP_API_PATH
 
+    def _delegate(self, token: Optional[str] = None):
+        """Return the modelscope_hub client that should serve this call.
+
+        The ambient client is reused unless a one-time ``token`` was supplied, in
+        which case a dedicated client is built so the override actually applies.
+        """
+        if token:
+            from modelscope_hub.api import HubApi as _HubApi
+            return _HubApi(token=token, endpoint=self.endpoint)
+        return self._api
+
     @staticmethod
     def _get_server_name_from_id(server_id: str) -> str:
         """Extract server name from server ID."""
@@ -113,40 +131,27 @@ class MCPApi(HubApi):
         if total_count is None or total_count < 1 or total_count > 100:
             raise ValueError('total_count must be between 1 and 100')
 
-        body = {
-            'filter': filter or {},
-            'page_number': 1,
-            'page_size': total_count,
-            'search': search
-        }
-
         try:
-            headers = self._build_bearer_headers(
-                token=token, token_required=False)
-            r = self.session.put(
-                url=self.mcp_base_url, headers=headers, json=body)
-            raise_for_http_status(r)
-        except requests.exceptions.RequestException as e:
+            result = self._delegate(token).list_mcp_servers(
+                search=search,
+                page_number=1,
+                page_size=total_count,
+                filter=filter,
+            )
+        except Exception as e:
             logger.error('Failed to get MCP servers: %s', e)
             raise MCPApiRequestError(f'Failed to get MCP servers: {e}') from e
 
-        try:
-            data = self._parse_openapi_response(r)
-        except RequestError as e:
-            raise MCPApiResponseError(
-                f'Invalid response from MCP servers list: {e}') from e
-
-        mcp_server_list = data.get('mcp_server_list', [])
         mcp_config_list = [{
-            'name': item.get('name', ''),
-            'id': item.get('id', ''),
-            'description': item.get('description', '')
-        } for item in mcp_server_list]
-
-        return {
-            'total_count': data.get('total_count', 0),
-            'servers': mcp_config_list
-        }
+            'name':
+            item.get('name') or item.get('Name') or '',
+            'id':
+            item.get('id') or item.get('Id') or '',
+            'description':
+            item.get('description') or item.get('Description') or ''
+        } for item in result.items]
+
+        return {'total_count': result.total_count, 'servers': mcp_config_list}
 
     def list_operational_mcp_servers(self,
                                      token: str = None) -> Dict[str, Any]:
@@ -186,46 +191,25 @@ class MCPApi(HubApi):
                 ]
             }
         """
-        url = f'{self.mcp_base_url}/operational'
-
         try:
-            headers = self._build_bearer_headers(
-                token=token, token_required=True)
-            r = self.session.get(url, headers=headers)
-            raise_for_http_status(r)
-        except requests.exceptions.RequestException as e:
+            result = self._delegate(token).list_operational_mcp_servers()
+        except Exception as e:
             logger.error(f'Failed to get operational MCP servers: {e}')
             raise MCPApiRequestError(
                 f'Failed to get operational MCP servers: {e}') from e
 
-        logger.debug(f'Response status code: {r.status_code}')
-
-        try:
-            data = self._parse_openapi_response(r)
-        except RequestError as e:
-            raise MCPApiResponseError(
-                f'Invalid response from operational MCP servers: {e}') from e
-
-        mcp_server_list = data.get('mcp_server_list', [])
-
         mcp_config_list = []
-        for item in mcp_server_list:
+        for item in result.items:
             mcp_config = {}
             mcp_config['name'] = item.get('name', '')
             mcp_config['id'] = item.get('id', '')
             mcp_config['description'] = item.get('description', '')
-            mcp_config['mcp_servers'] = []
-            for operational_url in item.get('operational_urls', []):
-                mcp_config['mcp_servers'].append({
-                    'type': (operational_url.get('url') or '').split('/')[-1],
-                    'url':
-                    operational_url.get('url', '')
-                })
+            mcp_config['mcp_servers'] = [
+                _operational_url_entry(operational_url)
+                for operational_url in item.get('operational_urls') or []
+            ]
             mcp_config_list.append(mcp_config)
-        return {
-            'total_count': data.get('total_count', 0),
-            'servers': mcp_config_list
-        }
+        return {'total_count': result.total_count, 'servers': mcp_config_list}
 
     def get_mcp_server(self,
                        server_id: str,
@@ -243,7 +227,7 @@ class MCPApi(HubApi):
                 - name: Server name
                 - description: Server description
                 - id: Server ID
-                - service_config: Connection configuration with type and url
+                - servers: Connection configurations, each with type and url
 
         Raises:
             ValueError: If server_id is empty or None
@@ -271,24 +255,17 @@ class MCPApi(HubApi):
         if not server_id:
             raise ValueError('server_id cannot be empty')
 
-        url = f'{self.mcp_base_url}/{server_id}'
-
         try:
-            headers = self._build_bearer_headers(
-                token=token, token_required=False)
-            r = self.session.get(
-                url, headers=headers, params={'get_operational_url': True})
-            raise_for_http_status(r)
-        except requests.exceptions.RequestException as e:
+            data = self._delegate(token).get_mcp_server(
+                server_id, get_operational_url=True)
+        except Exception as e:
             logger.error(f'Failed to get MCP server {server_id}: {e}')
             raise MCPApiRequestError(
                 f'Failed to get MCP server {server_id}: {e}') from e
 
-        try:
-            data = self._parse_openapi_response(r)
-        except RequestError as e:
+        if not isinstance(data, dict):
             raise MCPApiResponseError(
-                f'Invalid response from MCP server {server_id}: {e}') from e
+                f'Invalid response from MCP server {server_id}: {data!r}')
 
         result = {
             'name': data.get('name', ''),
@@ -296,18 +273,97 @@ class MCPApi(HubApi):
             'id': data.get('id', '')
         }
 
-        server_id = data.get('id', '')
-        server_name = MCPApi._get_server_name_from_id(server_id)
-
-        operational_urls = data.get('operational_urls', [])
+        server_name = MCPApi._get_server_name_from_id(data.get('id', ''))
+        operational_urls = data.get('operational_urls') or []
         mcp_config_list = []
         if server_name and operational_urls:
-            for operational_url in operational_urls:
-                mcp_config = {
-                    'type': (operational_url.get('url') or '').split('/')[-1],
-                    'url': operational_url.get('url', '')
-                }
-                mcp_config_list.append(mcp_config)
+            mcp_config_list = [
+                _operational_url_entry(operational_url)
+                for operational_url in operational_urls
+            ]
 
         result['servers'] = mcp_config_list
         return result
+
+    def deploy_mcp_server(self,
+                          server_id: str,
+                          transport_type: Optional[str] = None,
+                          expiration_minutes: Optional[int] = None,
+                          auth_check: Optional[bool] = None,
+                          env_info: Optional[Dict[str, str]] = None,
+                          token: Optional[str] = None) -> Dict[str, Any]:
+        """
+        Host an MCP server under your own account.
+
+        Args:
+            server_id: MCP server ID (e.g., "@amap/amap-maps")
+            transport_type: 'sse' (default) or 'streamable_http'
+            expiration_minutes: Lifetime in minutes; -1 for no expiration
+            auth_check: Require a ModelScope token when connecting to the URL
+            env_info: Environment variables, as listed in the server's env_schema
+            token: Optional access token for authentication
+
+        Returns:
+            Dict describing the deployment::
+
+                {
+                    'id': '...',
+                    'url': 'https://mcp.api-inference.modelscope.net/{uuid}/sse',
+                    'transport_type': 'sse',
+                    'auth_required': False,
+                    'expiration': '2025-10-01 21:00:00',
+                    'accessible': True
+                }
+
+        Raises:
+            ValueError: If server_id is empty or None
+            MCPApiRequestError: If the deployment request fails
+
+        Authentication:
+            Required. A token with 'write' permission or higher.
+        """
+        if not server_id:
+            raise ValueError('server_id cannot be empty')
+
+        payload = {
+            'transport_type': transport_type,
+            'expiration_minutes': expiration_minutes,
+            'auth_check': auth_check,
+            'env_info': env_info,
+        }
+        payload = {k: v for k, v in payload.items() if v is not None}
+
+        try:
+            return self._delegate(token).deploy_mcp_server(
+                server_id, payload=payload or None)
+        except Exception as e:
+            logger.error(f'Failed to deploy MCP server {server_id}: {e}')
+            raise MCPApiRequestError(
+                f'Failed to deploy MCP server {server_id}: {e}') from e
+
+    def undeploy_mcp_server(self,
+                            server_id: str,
+                            token: Optional[str] = None) -> Dict[str, Any]:
+        """
+        Tear down an MCP server you are hosting.
+
+        Args:
+            server_id: MCP server ID (e.g., "@amap/amap-maps")
+            token: Optional access token for authentication
+
+        Raises:
+            ValueError: If server_id is empty or None
+            MCPApiRequestError: If the request fails
+
+        Authentication:
+            Required. A token with 'write' permission or higher.
+        """
+        if not server_id:
+            raise ValueError('server_id cannot be empty')
+
+        try:
+            return self._delegate(token).undeploy_mcp_server(server_id)
+        except Exception as e:
+            logger.error(f'Failed to undeploy MCP server {server_id}: {e}')
+            raise MCPApiRequestError(
+                f'Failed to undeploy MCP server {server_id}: {e}') from e