agentengine-sdk-python 0.8.3__py3-none-any.whl → 0.8.4__py3-none-any.whl

ksadk/studio/dsh_models.py

@@ -0,0 +1,59 @@
+"""Compose Core model routes from Studio's authoritative model resources.
+
+Only references and provider metadata enter the temporary Cordis patch. Resolved
+credentials live in the supervised process environment, never in DSH settings.
+"""
+from __future__ import annotations
+
+import hashlib
+import os
+from dataclasses import dataclass, field
+
+from ksadk.studio.contracts import ModelSpec
+from ksadk.studio.errors import StudioError
+
+
+@dataclass
+class DshStudioModels:
+    providers: dict = field(default_factory=dict)
+    environment: dict[str, str] = field(default_factory=dict, repr=False)
+    default_provider: str | None = None
+    default_model: str | None = None
+
+
+def studio_model_projection(catalog, credentials) -> DshStudioModels:
+    result = DshStudioModels()
+    specs = []
+    base = os.getenv("OPENAI_BASE_URL") or os.getenv("OPENAI_API_BASE")
+    default = os.getenv("OPENAI_MODEL_NAME") or os.getenv("MODEL_NAME")
+    if base and default:
+        specs.append(ModelSpec(model=default, base_url=base, credential_ref="env://OPENAI_API_KEY"))
+    for item in catalog.list(kind="model", limit=1000):
+        specs.append(ModelSpec.model_validate(item.contract))
+    for spec in specs:
+        resolved = catalog.resolver.resolve_model(spec)
+        try:
+            key = credentials.resolve(resolved.credential_ref)
+        except StudioError:
+            # An unconfigured resource must not prevent other plugins starting.
+            continue
+        endpoint = resolved.endpoint_url
+        suffix = "/responses" if resolved.wire_api == "responses" else "/chat/completions"
+        if not endpoint.endswith(suffix):
+            continue
+        base_url = endpoint[:-len(suffix)]
+        identity = f"{base_url}\0{resolved.credential_ref}\0{resolved.wire_api}"
+        digest = hashlib.sha256(identity.encode()).hexdigest()[:12]
+        route = f"studio-{digest}"
+        reference = f"KSADK_STUDIO_MODEL_{digest.upper()}"
+        result.environment[reference] = key
+        provider = result.providers.setdefault(route, {
+            "displayName": "Studio", "baseURL": base_url,
+            "api": "openai-responses" if resolved.wire_api == "responses" else "openai-completions",
+            "apiKeyEnv": reference, "models": [],
+        })
+        if not any(model["id"] == resolved.model for model in provider["models"]):
+            provider["models"].append({"id": resolved.model, "name": resolved.model})
+        if result.default_provider is None:
+            result.default_provider, result.default_model = route, resolved.model
+    return result

ksadk/studio/dsh_provider_registration.py

@@ -19,6 +19,7 @@ from dataclasses import dataclass
 from pathlib import Path
 from typing import Any, Literal
 
+import yaml
 from pydantic import BaseModel, ConfigDict
 
 from ksadk.plugins.bridges.dsh import (
@@ -27,7 +28,7 @@ from ksadk.plugins.bridges.dsh import (
     DshProfileProjection,
 )
 from ksadk.plugins.contracts import CompositionProfile, PluginManifest
-from ksadk.plugins.dsh_toolchain import DshToolchainManager
+from ksadk.plugins.dsh_toolchain import DSH_CORE_PACKAGES, DshToolchainManager
 from ksadk.plugins.host import ManagedPlugin, PluginHostError
 from ksadk.plugins.providers.codex_dsh import (
     SHIPPED_CODEX_DSH_PACKAGE,
@@ -51,8 +52,16 @@ from ksadk.plugins.providers.harness_dsh import (
 
 _PROFILE_FILES = ("package.json", "cordis.patch.yml", "index.mjs")
 _MAX_PACKAGE_JSON_BYTES = 2 * 1024 * 1024
-_DSH_PLATFORM_BUNDLES = frozenset({"@deepseek-ai/dsh-base"})
+_DSH_PLATFORM_BUNDLES = frozenset(DSH_CORE_PACKAGES)
 _SHIPPED_PROVIDER_PACKAGES = frozenset({SHIPPED_CODEX_DSH_PACKAGE, SHIPPED_HARNESS_DSH_PACKAGE})
+_SHIPPED_RESOURCE_PACKAGES = (
+    ("@kingsoftcloud/dsh-platform-resources", "dsh-platform-resources"),
+    ("@kingsoftcloud/dsh-knowledge", "dsh-knowledge"),
+    ("@kingsoftcloud/dsh-memory", "dsh-memory"),
+    ("@kingsoftcloud/dsh-skill-center", "dsh-skill-center"),
+)
+_SHIPPED_RESOURCE_VERSION = "0.1.0"
+_RESOURCE_RUNTIME_BUNDLE = "@deepseek-ai/dsh-web-app"
 
 
 class StudioDshProviderRegistrationError(RuntimeError):
@@ -154,6 +163,63 @@ class _FreshDshAgentProviderFactory:
             raise
 
 
+class _FreshShippedDshBridgeFactory:
+    """Bind a shipped provider to a host owned by the consuming PluginHost loop."""
+
+    def __init__(
+        self,
+        command: Sequence[str],
+        *,
+        projection: DshProfileProjection,
+        cwd: Path,
+        environment: Mapping[str, str],
+        registration: DshAgentProviderRegistration,
+        package_name: str,
+        host_factory: HostFactory,
+    ) -> None:
+        self._command = tuple(command)
+        self._projection = projection
+        self._cwd = cwd
+        self._environment = dict(environment)
+        self._registration = registration
+        self._package_name = package_name
+        self._host_factory = host_factory
+
+    async def stage(
+        self,
+        manifest: PluginManifest,
+        *,
+        profile: CompositionProfile,
+        services: Mapping[str, Any],
+    ) -> ManagedPlugin:
+        host = self._host_factory(
+            self._command,
+            projection=self._projection,
+            cwd=self._cwd,
+            environment=self._environment,
+        )
+        try:
+            current = await host.registration()
+            if current != self._registration:
+                raise PluginHostError(
+                    "dsh_provider_registration_changed",
+                    "DSH provider registration changed after Studio discovery",
+                )
+            if self._package_name == SHIPPED_CODEX_DSH_PACKAGE:
+                factory: Any = KsADKCodexDshBridgeFactory(host, current, owns_host=True)
+            elif self._package_name == SHIPPED_HARNESS_DSH_PACKAGE:
+                factory = KsADKHarnessDshBridgeFactory(host, current, owns_host=True)
+            else:  # guarded by _register_package
+                raise PluginHostError(
+                    "dsh_provider_package_unsupported",
+                    "shipped DSH provider package is unsupported",
+                )
+            return await factory.stage(manifest, profile=profile, services=services)
+        except BaseException:
+            await host.dispose()
+            raise
+
+
 class StudioDshProviderRegistrationManager:
     """Own Profile discovery, provider preflight, registration, and disposal."""
 
@@ -162,7 +228,7 @@ class StudioDshProviderRegistrationManager:
         workspace: Path,
         *,
         dsh_home: Path,
-        profile: str = "studio",
+        profile: str = "web",
         dsh_command: Sequence[str] | None = None,
         node_command: Sequence[str] | None = None,
         cordis_module: Path | None = None,
@@ -192,7 +258,7 @@ class StudioDshProviderRegistrationManager:
             if configured_home
             else workspace / ".agentkit" / "dsh-home"
         )
-        profile = os.environ.get("KSADK_DSH_PROFILE", "").strip() or "studio"
+        profile = os.environ.get("KSADK_DSH_PROFILE", "").strip() or "web"
         configured_bin = os.environ.get("KSADK_DSH_BIN", "").strip()
         manifest = home / "profiles" / profile / "package.json"
         if not manifest.is_file():
@@ -216,7 +282,7 @@ class StudioDshProviderRegistrationManager:
         """Discover DSH or prepare the isolated first-run Studio Profile.
 
         The default is deliberately narrower than :meth:`discover`: only the
-        Studio-owned ``.agentkit/dsh-home`` and ``studio`` Profile qualify for
+        Studio-owned ``.agentkit/dsh-home`` and official ``web`` Profile qualify for
         automatic official-provider bootstrap.  Explicit DSH homes/profiles
         are user-owned and are never mutated by Studio startup.
         """
@@ -237,7 +303,33 @@ class StudioDshProviderRegistrationManager:
                 # DSH is optional.  A missing toolchain must not make the
                 # normal Studio/legacy Codex path unavailable.
                 return None
-        return cls(root, dsh_home=home, profile="studio", dsh_command=command)
+        return cls(root, dsh_home=home, profile="web", dsh_command=command)
+
+    @classmethod
+    def create_workspace_resource_default(
+        cls, workspace: Path
+    ) -> "StudioDshProviderRegistrationManager | None":
+        """Own the official-only Profile frozen into resource Builds."""
+
+        if os.environ.get("KSADK_DSH_HOME", "").strip() or os.environ.get(
+            "KSADK_DSH_PROFILE", ""
+        ).strip():
+            return None
+        root = workspace.resolve()
+        configured_bin = os.environ.get("KSADK_DSH_BIN", "").strip()
+        if configured_bin:
+            command: Sequence[str] | None = (str(Path(configured_bin).expanduser()),)
+        else:
+            try:
+                command = DshToolchainManager().require_command()
+            except Exception:
+                return None
+        return cls(
+            root,
+            dsh_home=root / ".agentkit" / "dsh-home",
+            profile="agentkit-resources",
+            dsh_command=command,
+        )
 
     @property
     def inventory(self) -> StudioDshProviderInventory:
@@ -251,7 +343,7 @@ class StudioDshProviderRegistrationManager:
         return (
             not configured_home
             and not configured_profile
-            and self._profile == "studio"
+            and self._profile in {"web", "agentkit-resources"}
             and self._dsh_home == expected_home
         )
 
@@ -287,6 +379,7 @@ class StudioDshProviderRegistrationManager:
             dsh_command=command,
             cwd=self._workspace,
         ) as bridge:
+            self._repair_owned_profile_layout(bridge)
             installed = {item.name: item for item in bridge.list_plugins()}
             current = installed.get(SHIPPED_CODEX_DSH_PACKAGE)
             if current is None:
@@ -318,6 +411,7 @@ class StudioDshProviderRegistrationManager:
             self._write_default_marker(
                 marker,
                 {
+                    **marker_payload,
                     "version": 1,
                     "codexProviderApplied": True,
                     "codexProviderVersion": SHIPPED_CODEX_PROVIDER_VERSION,
@@ -325,9 +419,174 @@ class StudioDshProviderRegistrationManager:
             )
         return result
 
+    async def bootstrap_official_resource_plugins(
+        self,
+    ) -> Literal["installed", "already_enabled", "disabled", "skipped"]:
+        """Apply the wheel-owned platform-resource stack once to Studio's Profile."""
+
+        if not self._owns_workspace_default_profile:
+            return "skipped"
+        async with self._lock:
+            return await asyncio.to_thread(self._bootstrap_official_resource_plugins_sync)
+
+    def _bootstrap_official_resource_plugins_sync(
+        self,
+    ) -> Literal["installed", "already_enabled", "disabled", "skipped"]:
+        if not self._owns_workspace_default_profile:
+            return "skipped"
+        marker = self._default_marker_path
+        marker_payload = self._read_default_marker(marker)
+        command = self._dsh_command or DshToolchainManager().require_command()
+        installed_any = False
+        disabled = False
+        enable_defaults = marker_payload.get("platformResourcesEnabled") is not True
+        with self._bridge_factory(
+            dsh_home=self._dsh_home,
+            profile=self._profile,
+            dsh_command=command,
+            cwd=self._workspace,
+        ) as bridge:
+            self._repair_owned_profile_layout(bridge)
+            inventory = {item.name: item for item in bridge.list_plugins()}
+            for package_name, directory_name in _SHIPPED_RESOURCE_PACKAGES:
+                current = inventory.get(package_name)
+                if current is None:
+                    # A completed marker plus a missing package records a later,
+                    # explicit uninstall. Startup must preserve that choice.
+                    if marker_payload.get("platformResourcesApplied") is True:
+                        continue
+                    root = (
+                        Path(__file__).parents[1]
+                        / "plugins"
+                        / "providers"
+                        / "bundles"
+                        / directory_name
+                    )
+                    current = bridge.install_plugin(
+                        str(root), accept_host_permissions=True
+                    )
+                    if current.name != package_name:
+                        raise StudioDshProviderRegistrationError(
+                            "resource_dsh_package_mismatch",
+                            "an official resource install returned a different package",
+                        )
+                    installed_any = True
+                if current.version != _SHIPPED_RESOURCE_VERSION:
+                    raise StudioDshProviderRegistrationError(
+                        "resource_dsh_bundle_not_active",
+                        "an official platform resource Bundle version is not supported",
+                    )
+                if not current.enabled and enable_defaults:
+                    current = bridge.set_enabled(package_name, enabled=True)
+                    if not current.enabled:
+                        raise StudioDshProviderRegistrationError(
+                            "resource_dsh_enable_failed",
+                            "an official platform resource Bundle did not become enabled",
+                        )
+                disabled = disabled or not current.enabled
+                self._verify_shipped_resource_bundle_bytes(package_name, directory_name)
+        if self._profile == "agentkit-resources":
+            self._ensure_resource_runtime_bundle()
+        if marker_payload.get("platformResourcesApplied") is not True:
+            self._write_default_marker(
+                marker,
+                {
+                    **marker_payload,
+                    "version": 1,
+                    "platformResourcesApplied": True,
+                    "platformResourcesEnabled": True,
+                    "platformResourcesVersion": _SHIPPED_RESOURCE_VERSION,
+                },
+            )
+        elif enable_defaults:
+            self._write_default_marker(
+                marker,
+                {**marker_payload, "platformResourcesEnabled": True},
+            )
+        if disabled:
+            return "disabled"
+        return "installed" if installed_any else "already_enabled"
+
+    def _ensure_resource_runtime_bundle(self) -> None:
+        """Give the private resource Profile the official loopback transport.
+
+        The capability exporter uses DSH's authenticated ``webServer`` and
+        ``connection`` services even when no browser UI is mounted. Custom
+        Profiles start with only ``dsh-base``, so the Studio-owned execution
+        Profile must explicitly include DSH's official web runtime layer.
+        """
+
+        manifest_path = self._profile_root / "package.json"
+        try:
+            if manifest_path.stat().st_size > _MAX_PACKAGE_JSON_BYTES:
+                raise ValueError("package.json is too large")
+            payload = json.loads(manifest_path.read_text(encoding="utf-8"))
+            dsh = payload.get("dsh")
+            profile = dsh.get("profile") if isinstance(dsh, dict) else None
+            bundles = profile.get("bundles") if isinstance(profile, dict) else None
+            if not isinstance(bundles, list) or any(
+                not isinstance(item, str) for item in bundles
+            ):
+                raise ValueError("bundle order is invalid")
+        except (OSError, UnicodeError, json.JSONDecodeError, ValueError) as error:
+            raise StudioDshProviderRegistrationError(
+                "resource_dsh_profile_invalid",
+                "the official resource execution Profile is invalid",
+            ) from error
+        if _RESOURCE_RUNTIME_BUNDLE in bundles:
+            return
+        try:
+            base_index = bundles.index("@deepseek-ai/dsh-base")
+        except ValueError as error:
+            raise StudioDshProviderRegistrationError(
+                "resource_dsh_profile_invalid",
+                "the official resource execution Profile has no DSH base Bundle",
+            ) from error
+        bundles.insert(base_index + 1, _RESOURCE_RUNTIME_BUNDLE)
+        self._write_default_marker(manifest_path, payload)
+
+    def _repair_owned_profile_layout(self, bridge: DshProfilePluginBridge) -> None:
+        """Repair only Studio's default legacy Profile before projecting it.
+
+        Older Studio versions created the ``web`` Profile with pnpm's hoisted
+        linker. Some community dependency graphs then contained links to the
+        ambient pnpm store and could not form a closed Build snapshot. The
+        frozen lock remains the authority; the bridge keeps the original tree
+        as an atomic rollback point while reinstalling the isolated layout.
+        """
+
+        if not self._owns_workspace_default_profile:
+            return
+        settings_path = self._dsh_home / "profiles" / self._profile / "pnpm-workspace.yaml"
+        if not settings_path.is_file():
+            return
+        try:
+            settings = yaml.safe_load(settings_path.read_text(encoding="utf-8"))
+        except (OSError, UnicodeError, yaml.YAMLError) as error:
+            raise StudioDshProviderRegistrationError(
+                "dsh_profile_layout_invalid",
+                "the Studio-owned DSH Profile layout settings are unreadable",
+            ) from error
+        if not isinstance(settings, dict):
+            raise StudioDshProviderRegistrationError(
+                "dsh_profile_layout_invalid",
+                "the Studio-owned DSH Profile layout settings are invalid",
+            )
+        if settings.get("nodeLinker") not in {"hoisted", "isolated"}:
+            return
+        bridge.migrate_to_isolated_layout(
+            accept_host_permissions=True,
+            recover_external_dependency_links=True,
+        )
+
     @property
     def _default_marker_path(self) -> Path:
-        return self._workspace / ".agentkit" / "official-dsh-defaults.json"
+        # Scope the bootstrap receipt to the owned Profile.  Older Studio
+        # builds used one workspace-wide marker while their default Profile
+        # was ``studio``.  Reusing that marker after the default moved to
+        # official Core's ``web`` Profile incorrectly skipped first-run
+        # installation and left Studio with no runnable DSH Profile.
+        return self._workspace / ".agentkit" / f"official-dsh-defaults-{self._profile}.json"
 
     @staticmethod
     def _read_default_marker(path: Path) -> dict[str, object]:
@@ -525,7 +784,12 @@ class StudioDshProviderRegistrationManager:
                 provider_packages[provider_ref] = package.name
                 manifests[provider_ref] = registration.manifest
                 factories[provider_ref] = factory
-                self._hosts[package.name] = host
+                # Discovery is a bounded admission probe. Keeping its process
+                # alive would bind Studio construction to that event loop and
+                # make later API or Scheduler loops reuse foreign transports.
+                # The fresh factory repeats the exact registration fence and
+                # owns its execution host in the consuming PluginHost loop.
+                await host.dispose()
                 statuses[index] = statuses[index].model_copy(
                     update={
                         "state": "ready",
@@ -617,10 +881,16 @@ class StudioDshProviderRegistrationManager:
                     "dsh_provider_inventory_not_ready",
                     "DSH AgentProvider inventory is not ready",
                 )
-            if package.name == SHIPPED_CODEX_DSH_PACKAGE:
-                factory: Any = KsADKCodexDshBridgeFactory(host, registration, owns_host=False)
-            elif package.name == SHIPPED_HARNESS_DSH_PACKAGE:
-                factory: Any = KsADKHarnessDshBridgeFactory(host, registration, owns_host=False)
+            if package.name in _SHIPPED_PROVIDER_PACKAGES:
+                factory: Any = _FreshShippedDshBridgeFactory(
+                    command,
+                    projection=projection,
+                    cwd=cwd,
+                    environment=environment,
+                    registration=registration,
+                    package_name=package.name,
+                    host_factory=self._host_factory,
+                )
             else:
                 factory = _FreshDshAgentProviderFactory(
                     command,
@@ -730,6 +1000,43 @@ class StudioDshProviderRegistrationManager:
                 "the installed DSH AgentProvider Bundle differs from the wheel-owned Bundle",
             )
 
+    def _verify_shipped_resource_bundle_bytes(
+        self, package_name: str, directory_name: str
+    ) -> None:
+        shipped = (
+            Path(__file__).parents[1]
+            / "plugins"
+            / "providers"
+            / "bundles"
+            / directory_name
+        )
+        installed = self._profile_root / "node_modules"
+        for segment in package_name.split("/"):
+            installed /= segment
+        names = ["package.json", "cordis.patch.yml", "index.mjs"]
+        if directory_name == "dsh-platform-resources":
+            names.append("client.mjs")
+        try:
+            package_matches = json.loads(
+                (installed / "package.json").read_text(encoding="utf-8")
+            ) == json.loads((shipped / "package.json").read_text(encoding="utf-8"))
+            matches = package_matches and all(
+                (installed / name).read_bytes().rstrip()
+                == (shipped / name).read_bytes().rstrip()
+                for name in names
+                if name != "package.json"
+            )
+        except (OSError, UnicodeError, json.JSONDecodeError) as error:
+            raise StudioDshProviderRegistrationError(
+                "resource_dsh_bundle_unreadable",
+                "an installed platform resource Bundle cannot be verified",
+            ) from error
+        if not matches:
+            raise StudioDshProviderRegistrationError(
+                "resource_dsh_bundle_digest_mismatch",
+                "an installed platform resource Bundle differs from the wheel-owned Bundle",
+            )
+
 
 def merge_provider_registrations(
     *registrations: StudioDshProviderRegistrations,

ksadk/studio/hosted_kernel.py

@@ -45,9 +45,35 @@ def build_hosted_kernel_requirement(
     entry_point: str | None,
     agent_variable: str | None,
     launch_config: bytes | None,
+    composition_profile_digest: str | None = None,
+    plugin_lock_digest: str | None = None,
+    provider_ref: str | None = None,
 ) -> dict[str, Any]:
     """Build the immutable local requirement embedded into every Studio ZIP."""
 
+    if runtime_type == "plugin":
+        if not composition_profile_digest or not plugin_lock_digest or not provider_ref:
+            raise ValueError("plugin runtime requires a resolved composition launch contract")
+        runtime_requirement = {
+            "type": runtime_type,
+            "launchMode": "plugin-host",
+            "compositionProfile": "composition-profile.json",
+            "compositionProfileDigest": composition_profile_digest,
+            "pluginLock": "plugin-lock.json",
+            "pluginLockDigest": plugin_lock_digest,
+            "providerRef": provider_ref,
+        }
+    else:
+        runtime_requirement = {
+            "type": runtime_type,
+            "entryPoint": entry_point or "",
+            "agentVariable": agent_variable or "",
+            "launchConfig": "runtime/agentengine.yaml" if launch_config is not None else "",
+            "launchConfigSha256": (
+                sha256_digest(launch_config) if launch_config is not None else ""
+            ),
+        }
+
     return {
         "format": HOSTED_KERNEL_REQUIREMENTS_FORMAT,
         "kernelContract": {
@@ -56,13 +82,7 @@ def build_hosted_kernel_requirement(
         },
         "bundleLayout": HOSTED_KERNEL_BUNDLE_FORMAT,
         "runtimeContract": HOSTED_KERNEL_RUNTIME_CONTRACT,
-        "runtime": {
-            "type": runtime_type,
-            "entryPoint": entry_point or "",
-            "agentVariable": agent_variable or "",
-            "launchConfig": "runtime/agentengine.yaml" if launch_config is not None else "",
-            "launchConfigSha256": sha256_digest(launch_config) if launch_config is not None else "",
-        },
+        "runtime": runtime_requirement,
     }
 
 
@@ -207,17 +227,24 @@ def _validate_requirement(
             "Bundle 缺少受支持的 runtime 启动 requirement", reason="missing_runtime"
         )
     runtime_type = str(runtime.get("type") or "").strip().lower()
-    entry_point = str(runtime.get("entryPoint") or "").strip()
-    agent_variable = str(runtime.get("agentVariable") or "").strip()
-    launch_path = str(runtime.get("launchConfig") or "").strip()
-    launch_digest = str(runtime.get("launchConfigSha256") or "").strip()
+    manifest_runtime_type = str(manifest.get("runtimeType") or "").strip().lower()
+    if runtime_type != manifest_runtime_type:
+        raise _incompatible_error(
+            "Bundle runtime requirement 与 manifest 不一致", reason="runtime_type"
+        )
+    if runtime_type == "plugin":
+        _validate_plugin_launch(manifest, runtime, entries)
+        return
     if runtime_type not in _RUNTIME_TYPES:
         raise _incompatible_error(
             "Bundle runtime 类型不受 Hosted Agent Kernel 支持", reason="runtime_type"
         )
+    entry_point = str(runtime.get("entryPoint") or "").strip()
+    agent_variable = str(runtime.get("agentVariable") or "").strip()
+    launch_path = str(runtime.get("launchConfig") or "").strip()
+    launch_digest = str(runtime.get("launchConfigSha256") or "").strip()
     if (
-        runtime_type != str(manifest.get("runtimeType") or "").strip().lower()
-        or not entry_point
+        not entry_point
         or not agent_variable
         or launch_path != "runtime/agentengine.yaml"
         or not launch_digest
@@ -249,6 +276,54 @@ def _validate_requirement(
         )
 
 
+def _validate_plugin_launch(
+    manifest: dict[str, Any],
+    runtime: dict[str, Any],
+    entries: dict[str, bytes],
+) -> None:
+    profile_path = str(runtime.get("compositionProfile") or "").strip()
+    profile_digest = str(runtime.get("compositionProfileDigest") or "").strip()
+    lock_path = str(runtime.get("pluginLock") or "").strip()
+    lock_digest = str(runtime.get("pluginLockDigest") or "").strip()
+    provider_ref = str(runtime.get("providerRef") or "").strip()
+    if (
+        runtime.get("launchMode") != "plugin-host"
+        or manifest.get("compositionMode") != "composed"
+        or profile_path != "composition-profile.json"
+        or lock_path != "plugin-lock.json"
+        or not profile_digest
+        or not lock_digest
+        or not provider_ref
+        or manifest.get("compositionProfileDigest") != profile_digest
+        or manifest.get("pluginLockDigest") != lock_digest
+    ):
+        raise _incompatible_error(
+            "Bundle 缺少可验证的 PluginHost 启动配置", reason="plugin_launch"
+        )
+    profile = _json_object(entries, profile_path)
+    lock = _json_object(entries, lock_path)
+    if sha256_digest(canonical_json(profile)) != profile_digest:
+        raise _incompatible_error(
+            "Bundle composition profile digest 不一致", reason="plugin_profile_digest"
+        )
+    if sha256_digest(canonical_json(lock)) != lock_digest:
+        raise _incompatible_error(
+            "Bundle plugin lock digest 不一致", reason="plugin_lock_digest"
+        )
+    agent_provider = profile.get("agentProvider")
+    if not isinstance(agent_provider, dict) or agent_provider.get("ref") != provider_ref:
+        raise _incompatible_error(
+            "Bundle Agent Provider 与 PluginHost requirement 不一致",
+            reason="plugin_provider",
+        )
+    runtime_lock = _json_object(entries, "runtime-lock.json")
+    if str(runtime_lock.get("type") or "").strip().lower() != "plugin":
+        raise _incompatible_error(
+            "Bundle runtime lock 与 PluginHost requirement 不一致",
+            reason="runtime_lock",
+        )
+
+
 def _validate_content_manifest(manifest: dict[str, Any], entries: dict[str, bytes]) -> None:
     files = manifest.get("files")
     if not isinstance(files, list):

ksadk/studio/mcp_runtime.py

@@ -142,9 +142,11 @@ class MCPRuntimeAdapter:
                 yield read_stream, write_stream
         elif transport in {"http", "streamable-http", "streamable_http"}:
             headers = self._http_headers(server)
-            async with streamablehttp_client(
-                server.endpoint_url or "", headers=headers
-            ) as (read_stream, write_stream, _):
+            async with streamablehttp_client(server.endpoint_url or "", headers=headers) as (
+                read_stream,
+                write_stream,
+                _,
+            ):
                 yield read_stream, write_stream
         elif transport == "sse":
             headers = self._http_headers(server)
@@ -193,6 +195,12 @@ class MCPRuntimeAdapter:
 
     @staticmethod
     def _validate(server: MCPServerRef) -> None:
+        if server.materialization == "dsh-profile":
+            raise StudioError(
+                "DSH_MCP_MANAGED_RESOURCE_REQUIRED",
+                "DSH Profile MCP 必须通过受管理的 PluginHost 租约使用",
+                status_code=422,
+            )
         transport = (server.transport or "stdio").lower()
         if transport == "stdio":
             command = Path(server.command or "").name.lower()

ksadk/studio/model_client.py

@@ -220,9 +220,9 @@ class CredentialResolver:
             "persistence": source,
         }
 
-    def resolve(self, reference: str) -> str:
+    def resolve(self, reference: str, *, allow_aliases: bool = True) -> str:
         name = self._environment_name(reference)
-        fallback = self._fallback_name(name)
+        fallback = self._fallback_name(name) if allow_aliases else None
         aliases = [name, *([fallback] if fallback else [])]
         for candidate in aliases:
             value = self._session_value(candidate)