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

ksadk/memory/models.py

@@ -127,6 +127,8 @@ class MemoryExtractionStatus:
     status: str
     searchable: bool = False
     message: str = ""
+    # Query failure does not prove that the previously submitted write failed.
+    error_code: str = ""
 
 
 def map_session_state(state: int | None) -> str:
@@ -176,7 +178,7 @@ class MemoryConflictError(MemoryOperationError):
 MEMORY_MODEL_VERSION = "v1"
 
 MemoryScope = Literal["user", "agent", "workspace", "org"]
-MemoryType = Literal["profile", "fact", "episode"]
+MemoryType = Literal["profile", "fact", "episode", "unknown"]
 MemoryStatus = Literal["active", "superseded", "deleted", "expired"]
 MemoryOperation = Literal["add", "update", "delete", "ignore"]
 MemorySearchStatus = Literal["ok", "not_configured", "timeout", "unauthorized", "failed"]
@@ -206,8 +208,8 @@ class MemoryRecord:
     content: str
     summary: str
     status: MemoryStatus
-    confidence: float
-    importance: float
+    confidence: float | None
+    importance: float | None
     valid_from: str
     valid_to: str
     expires_at: str
@@ -215,7 +217,8 @@ class MemoryRecord:
     source_event_ids: list[str]
     source_seq_range: tuple[int, int] | None
     content_hash: str
-    version: int
+    # None means the provider has no record revision/CAS contract.
+    version: int | None
     metadata: dict[str, Any] = field(default_factory=dict)
     created_at: str = ""
     updated_at: str = ""

ksadk/memory/provider_resolver.py

@@ -32,6 +32,9 @@ def resolve_memory_provider(provider_ref: str) -> MemoryProviderLike:
     """
     ref = str(provider_ref or "").strip().lower()
 
+    if ref.startswith("binding://"):
+        raise ValueError("RESOURCE_MEMORY_BINDING_REQUIRES_ACTIVATION")
+
     if ref in ("local-inmemory", "inmemory"):
         from ksadk.memory.adk.backends.inmemory_ltm_backend import (
             InMemoryLTMBackend,

ksadk/model_proxy/server.py

@@ -444,13 +444,18 @@ class ProxyServer:
             # 应用层取消信号:让活动 SSE 的 _stream_gen 主动 break
             self._app.state.cancel_event.set()
         if self._server is not None:
-            # should_exit 触发主循环进入 shutdown;force_exit 让 shutdown 跳过等待
-            # connections/tasks 完成(活动 SSE 下不再无限等)。两者缺一:只 should_exit
-            # 会被活动连接卡死,只 force_exit 主循环根本不进 shutdown。
+            # Enter Uvicorn's normal shutdown so its lifespan task receives a
+            # shutdown event.  Setting force_exit here skips that event and
+            # makes every completed Studio turn print a CancelledError.
             self._server.should_exit = True
-            self._server.force_exit = True
         if self._thread is not None:
-            self._thread.join(timeout=5)
+            self._thread.join(timeout=3)
+            if self._thread.is_alive() and self._server is not None:
+                # The application cancel signal normally drains active SSE
+                # generators.  Keep a bounded last resort for a broken client
+                # or upstream that ignores cancellation.
+                self._server.force_exit = True
+                self._thread.join(timeout=2)
         if self._sock is not None:
             try:
                 self._sock.close()

ksadk/plugins/__init__.py

@@ -27,8 +27,10 @@ from ksadk.plugins.context_contributor import (
 from ksadk.plugins.contracts import (
     CapabilityDefinition,
     CompositionProfile,
+    LockedPluginComponent,
     PluginInventory,
     PluginLock,
+    PluginSourceSnapshot,
     canonical_plugin_lock,
     plugin_lock_digest,
 )
@@ -120,6 +122,7 @@ __all__ = [
     "BridgeTransitionPlan",
     "CapabilityDefinition",
     "CompositionProfile",
+    "LockedPluginComponent",
     "ContextClassification",
     "ContextContributorCacheability",
     "ContextContributorCapabilities",
@@ -135,6 +138,7 @@ __all__ = [
     "EcosystemPluginInventory",
     "PluginInventory",
     "PluginLock",
+    "PluginSourceSnapshot",
     "PluginDesiredState",
     "PluginEcosystem",
     "PluginEcosystemBridge",

ksadk/plugins/artifacts.py

@@ -0,0 +1,275 @@
+"""Portable plugin bytes; credentials and machine state never belong here.
+
+The caller supplies an already verified, selected plugin tree. Delivery and
+credential authorization remain separate from this bounded archive format.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+import shutil
+import stat
+import tempfile
+import zipfile
+from pathlib import Path, PurePosixPath
+from typing import Literal
+
+from pydantic import BaseModel, ConfigDict, Field
+
+MAX_FILES = 10000
+MAX_BYTES = 256 * 1024 * 1024
+SCHEMA = "ksadk.plugin-artifact/v1"
+
+
+class PluginArtifactReceipt(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+    schema_version: Literal["ksadk.plugin-artifact/v1"] = SCHEMA
+    ecosystem: Literal["codex"] = "codex"
+    runtime_version: str = Field(min_length=1)
+    plugin_lock_digest: str = Field(pattern=r"^sha256:[0-9a-f]{64}$")
+    artifact_digest: str = Field(pattern=r"^sha256:[0-9a-f]{64}$")
+    size_bytes: int = Field(gt=0, le=MAX_BYTES)
+
+
+def _digest(raw: bytes) -> str:
+    return "sha256:" + hashlib.sha256(raw).hexdigest()
+
+
+def _safe_path(value: str) -> str:
+    path = PurePosixPath(value)
+    if (
+        not value
+        or "\\" in value
+        or path.is_absolute()
+        or str(path) != value
+        or any(p in {".", ".."} for p in path.parts)
+    ):
+        raise ValueError("Invalid plugin artifact path")
+    forbidden = {".credentials.json", "auth.json", "config.toml", ".git", "sessions"}
+    if any(part.lower() in forbidden or part.lower().startswith(".env") for part in path.parts):
+        raise ValueError("Plugin artifact contains credential or host state paths")
+    return value
+
+
+def _zip_entry(name: str, mode: int) -> zipfile.ZipInfo:
+    info = zipfile.ZipInfo(name, date_time=(1980, 1, 1, 0, 0, 0))
+    info.create_system = 3
+    info.external_attr = (stat.S_IFREG | mode) << 16
+    info.compress_type = zipfile.ZIP_STORED
+    return info
+
+
+def export_plugin_artifact(
+    root: Path,
+    output_dir: Path,
+    *,
+    runtime_version: str,
+    plugin_lock_digest: str,
+) -> tuple[PluginArtifactReceipt, Path]:
+    """Package only the pinned Codex marketplace, independent of local paths."""
+    if root.is_symlink() or not root.is_dir():
+        raise ValueError("Plugin artifact root must be a real directory")
+    if output_dir.resolve().is_relative_to(root.resolve()):
+        raise ValueError("Plugin artifact output must be outside its source tree")
+    files = []
+    total = 0
+    output_dir.mkdir(parents=True, exist_ok=True)
+    fd, temporary = tempfile.mkstemp(prefix=".plugin-artifact-", dir=output_dir)
+    os.close(fd)
+    temporary_path = Path(temporary)
+    try:
+        with zipfile.ZipFile(temporary_path, "w") as archive:
+            for source in sorted(root.rglob("*")):
+                if source.is_symlink():
+                    raise ValueError("Plugin artifacts cannot contain symlinks")
+                if source.is_dir():
+                    _safe_path(source.relative_to(root).as_posix())
+                    continue
+                if not source.is_file():
+                    raise ValueError("Plugin artifacts require regular files")
+                name = _safe_path(source.relative_to(root).as_posix())
+                size = source.stat().st_size
+                total += size
+                if total > MAX_BYTES or len(files) >= MAX_FILES:
+                    raise ValueError("Plugin artifact exceeds size limits")
+                with source.open("rb") as stream:
+                    raw = stream.read(size + 1)
+                if len(raw) != size:
+                    raise ValueError("Plugin artifact source changed during export")
+                mode = 0o644 | (source.stat().st_mode & 0o111)
+                files.append({"path": name, "digest": _digest(raw), "size": len(raw), "mode": mode})
+                archive.writestr(_zip_entry("payload/" + name, mode), raw)
+            if not files:
+                raise ValueError("Plugin artifact is empty")
+            manifest = {
+                "schema_version": SCHEMA,
+                "ecosystem": "codex",
+                "runtime_version": runtime_version,
+                "plugin_lock_digest": plugin_lock_digest,
+                "files": files,
+            }
+            archive.writestr(
+                _zip_entry("manifest.json", 0o644),
+                json.dumps(manifest, sort_keys=True, separators=(",", ":")).encode(),
+            )
+        if temporary_path.stat().st_size > MAX_BYTES:
+            raise ValueError("Plugin artifact exceeds size limits")
+        raw = temporary_path.read_bytes()
+        receipt = PluginArtifactReceipt(
+            runtime_version=runtime_version,
+            plugin_lock_digest=plugin_lock_digest,
+            artifact_digest=_digest(raw),
+            size_bytes=len(raw),
+        )
+        target = output_dir / (receipt.artifact_digest.removeprefix("sha256:") + ".zip")
+        os.replace(temporary_path, target)
+        return receipt, target
+    finally:
+        temporary_path.unlink(missing_ok=True)
+
+
+def restore_plugin_artifact(
+    archive_path: Path, receipt: PluginArtifactReceipt, target: Path
+) -> Path:
+    """Verify a downloaded archive before atomic installation into a fresh path."""
+    if archive_path.stat().st_size != receipt.size_bytes:
+        raise ValueError("Plugin artifact size mismatch")
+    if _digest(archive_path.read_bytes()) != receipt.artifact_digest:
+        raise ValueError("Plugin artifact digest mismatch")
+    if target.exists() or target.is_symlink():
+        raise ValueError("Plugin artifact target already exists")
+    target.parent.mkdir(parents=True, exist_ok=True)
+    staging = Path(tempfile.mkdtemp(prefix=".plugin-restore-", dir=target.parent))
+    try:
+        with zipfile.ZipFile(archive_path) as archive:
+            entries = archive.infolist()
+            names = [entry.filename for entry in entries]
+            if len(names) != len(set(names)) or len(names) > MAX_FILES + 1:
+                raise ValueError("Duplicate or excessive plugin archive entries")
+            if sum(entry.file_size for entry in entries) > MAX_BYTES:
+                raise ValueError("Plugin archive expands beyond size limit")
+            manifest = json.loads(archive.read("manifest.json"))
+            for key in ("schema_version", "ecosystem", "runtime_version", "plugin_lock_digest"):
+                if manifest.get(key) != getattr(receipt, key):
+                    raise ValueError("Plugin artifact manifest mismatch")
+            files = manifest.get("files")
+            if not isinstance(files, list) or not files:
+                raise ValueError("Missing plugin artifact file index")
+            expected = ["payload/" + _safe_path(item["path"]) for item in files]
+            if len(expected) != len(set(expected)) or set(names) != {"manifest.json", *expected}:
+                raise ValueError("Plugin artifact file index mismatch")
+            for item, name in zip(files, expected, strict=True):
+                info = archive.getinfo(name)
+                mode = info.external_attr >> 16
+                if not stat.S_ISREG(mode) or (item["mode"] & ~0o111) != 0o644:
+                    raise ValueError("Plugin artifact has invalid file type or mode")
+                raw = archive.read(name)
+                if len(raw) != item["size"] or _digest(raw) != item["digest"]:
+                    raise ValueError("Plugin artifact file digest mismatch")
+                destination = staging / item["path"]
+                destination.parent.mkdir(parents=True, exist_ok=True)
+                destination.write_bytes(raw)
+                destination.chmod(item["mode"])
+        os.replace(staging, target)
+        return target
+    finally:
+        if staging.exists():
+            shutil.rmtree(staging)
+
+
+def restore_materialized_plugin_artifact(
+    source: Path, receipt: PluginArtifactReceipt, target: Path
+) -> Path:
+    """Verify an init-container-extracted artifact before atomic installation.
+
+    The init container verifies the downloaded archive digest before extraction.
+    The runtime independently verifies the portable manifest and every extracted
+    file before the marketplace becomes visible to Codex.
+    """
+    if source.is_symlink() or not source.is_dir():
+        raise ValueError("Materialized plugin artifact must be a real directory")
+    if target.exists() or target.is_symlink():
+        raise ValueError("Plugin artifact target already exists")
+
+    manifest_path = source / "manifest.json"
+    if manifest_path.is_symlink() or not manifest_path.is_file():
+        raise ValueError("Missing plugin artifact manifest")
+    if manifest_path.stat().st_size > MAX_BYTES:
+        raise ValueError("Plugin artifact manifest exceeds size limit")
+    try:
+        manifest = json.loads(manifest_path.read_bytes())
+    except (json.JSONDecodeError, UnicodeError) as exc:
+        raise ValueError("Invalid plugin artifact manifest") from exc
+    if not isinstance(manifest, dict):
+        raise ValueError("Plugin artifact manifest must be an object")
+    for key in ("schema_version", "ecosystem", "runtime_version", "plugin_lock_digest"):
+        if manifest.get(key) != getattr(receipt, key):
+            raise ValueError("Plugin artifact manifest mismatch")
+
+    files = manifest.get("files")
+    if not isinstance(files, list) or not files or len(files) > MAX_FILES:
+        raise ValueError("Missing or excessive plugin artifact file index")
+
+    indexed: list[tuple[dict, str]] = []
+    expected = {"manifest.json"}
+    for item in files:
+        if not isinstance(item, dict):
+            raise ValueError("Invalid plugin artifact file index")
+        try:
+            name = _safe_path(item["path"])
+            size = int(item["size"])
+            mode = int(item["mode"])
+            digest = str(item["digest"])
+        except (KeyError, TypeError, ValueError) as exc:
+            raise ValueError("Invalid plugin artifact file index") from exc
+        if size < 0 or size > MAX_BYTES or (mode & ~0o111) != 0o644:
+            raise ValueError("Plugin artifact has invalid file size or mode")
+        if not digest.startswith("sha256:") or len(digest) != 71:
+            raise ValueError("Plugin artifact has invalid file digest")
+        relative = "payload/" + name
+        if relative in expected:
+            raise ValueError("Duplicate plugin artifact file index")
+        expected.add(relative)
+        indexed.append((item, relative))
+
+    actual: set[str] = set()
+    for path in source.rglob("*"):
+        relative = path.relative_to(source).as_posix()
+        if path.is_symlink():
+            raise ValueError("Plugin artifacts cannot contain symlinks")
+        if path.is_dir():
+            _safe_path(relative)
+            continue
+        if not path.is_file():
+            raise ValueError("Plugin artifacts require regular files")
+        actual.add(relative)
+    if actual != expected:
+        raise ValueError("Plugin artifact file index mismatch")
+
+    target.parent.mkdir(parents=True, exist_ok=True)
+    staging = Path(tempfile.mkdtemp(prefix=".plugin-restore-", dir=target.parent))
+    total = 0
+    try:
+        for item, relative in indexed:
+            source_file = source / relative
+            size = int(item["size"])
+            with source_file.open("rb") as stream:
+                raw = stream.read(size + 1)
+            total += len(raw)
+            if (
+                len(raw) != size
+                or total > MAX_BYTES
+                or _digest(raw) != item["digest"]
+            ):
+                raise ValueError("Plugin artifact file digest mismatch")
+            destination = staging / item["path"]
+            destination.parent.mkdir(parents=True, exist_ok=True)
+            destination.write_bytes(raw)
+            destination.chmod(int(item["mode"]))
+        os.replace(staging, target)
+        return target
+    finally:
+        if staging.exists():
+            shutil.rmtree(staging)

ksadk/plugins/bridges/__init__.py

@@ -7,6 +7,8 @@ not add a generic plugin execution API to KsADK.
 from ksadk.plugins.bridges.codex import (
     CodexAppServerPluginBridge,
     CodexBridgeError,
+    CodexHostComponentDetail,
+    CodexMarketplaceAddResult,
     CodexPluginApprovalRequired,
     CodexPluginDetail,
     CodexPluginInventory,
@@ -15,7 +17,6 @@ from ksadk.plugins.bridges.codex import (
 from ksadk.plugins.bridges.dsh import (
     DshBridgeError,
     DshBridgeHost,
-    DshClientBundle,
     DshHostUnavailableError,
     DshPluginApprovalRequired,
     DshPluginInventory,
@@ -28,13 +29,14 @@ from ksadk.plugins.bridges.dsh import (
 __all__ = [
     "CodexAppServerPluginBridge",
     "CodexBridgeError",
+    "CodexHostComponentDetail",
+    "CodexMarketplaceAddResult",
     "CodexPluginApprovalRequired",
     "CodexPluginDetail",
     "CodexPluginInventory",
     "CodexPluginNotFoundError",
     "DshBridgeError",
     "DshBridgeHost",
-    "DshClientBundle",
     "DshHostUnavailableError",
     "DshPluginApprovalRequired",
     "DshPluginInventory",

ksadk/plugins/bridges/codex.py

@@ -21,7 +21,7 @@ def _to_camel(value: str) -> str:
     return head + "".join(part.capitalize() for part in tail)
 
 
-class _CodexWireModel(BaseModel):
+class _CodexPublicModel(BaseModel):
     model_config = ConfigDict(
         alias_generator=_to_camel,
         populate_by_name=True,
@@ -30,6 +30,17 @@ class _CodexWireModel(BaseModel):
     )
 
 
+class _CodexWireModel(_CodexPublicModel):
+    """Forward-compatible model for the experimental App Server surface."""
+
+    model_config = ConfigDict(
+        alias_generator=_to_camel,
+        populate_by_name=True,
+        extra="allow",
+        frozen=True,
+    )
+
+
 class _LocalSource(_CodexWireModel):
     type: Literal["local"]
     path: str
@@ -130,7 +141,7 @@ class _PluginUninstallResponse(_CodexWireModel):
     pass
 
 
-class CodexPluginInventory(_CodexWireModel):
+class CodexPluginInventory(_CodexPublicModel):
     """Normalized observed state; install receipt never implies these fields."""
 
     plugin_id: str
@@ -142,6 +153,7 @@ class CodexPluginInventory(_CodexWireModel):
     enabled: bool
     availability: str
     source: CodexPluginSource = Field(discriminator="type")
+    interface: dict[str, Any] = Field(default_factory=dict)
     permissions_declared: Literal[False] = False
     risk_disclosures: tuple[str, ...] = (
         "Codex plugin permissions are host-managed and not declared in the plugin manifest.",
@@ -149,29 +161,47 @@ class CodexPluginInventory(_CodexWireModel):
     )
 
 
-class CodexPluginDetail(_CodexWireModel):
+class CodexHostComponentDetail(_CodexPublicModel):
+    """Lossless-enough projection of a component reported by ``plugin/read``."""
+
+    kind: Literal["skill", "mcp", "hook", "app", "app-template", "scheduled-task"]
+    name: str
+    path: str | None = None
+    metadata: dict[str, Any] = Field(default_factory=dict)
+
+
+class CodexPluginDetail(_CodexPublicModel):
     inventory: CodexPluginInventory
     description: str | None = None
+    share_url: str | None = None
     skills: tuple[str, ...] = ()
     mcp_servers: tuple[str, ...] = ()
     hooks: tuple[str, ...] = ()
     apps: tuple[str, ...] = ()
     scheduled_tasks: tuple[str, ...] = ()
+    components: tuple[CodexHostComponentDetail, ...] = ()
+    host_metadata: dict[str, Any] = Field(default_factory=dict)
+
+
+class CodexMarketplaceAddResult(_CodexPublicModel):
+    marketplace_name: str
+    installed_root: str
+    already_added: bool
 
 
-class CodexPluginInstallResult(_CodexWireModel):
+class CodexPluginInstallResult(_CodexPublicModel):
     inventory: CodexPluginInventory
     auth_policy: Literal["ON_INSTALL", "ON_USE"]
     apps_needing_auth: tuple[str, ...] = ()
 
 
-class CodexPluginUninstallResult(_CodexWireModel):
+class CodexPluginUninstallResult(_CodexPublicModel):
     plugin_id: str
     installed: Literal[False] = False
     enabled: Literal[False] = False
 
 
-class CodexBridgeHost(_CodexWireModel):
+class CodexBridgeHost(_CodexPublicModel):
     host_id: Literal["codex-app-server"] = "codex-app-server"
     version: str
     protocol: Literal["codex.app-server/v1"] = "codex.app-server/v1"
@@ -231,6 +261,63 @@ def _reported_host_version(metadata: Any) -> str:
     return match.group(1) if match is not None else "unreported"
 
 
+def _component_path(metadata: dict[str, Any]) -> str | None:
+    for field in (
+        "path",
+        "filePath",
+        "file_path",
+        "skillPath",
+        "skill_path",
+        "manifestPath",
+        "manifest_path",
+    ):
+        value = metadata.get(field)
+        if isinstance(value, str) and value:
+            return value
+    return None
+
+
+def _reported_components(plugin: _PluginDetailWire) -> tuple[CodexHostComponentDetail, ...]:
+    components: list[CodexHostComponentDetail] = []
+
+    def append(
+        kind: Literal["skill", "hook", "app", "app-template", "scheduled-task"],
+        items: tuple[dict[str, Any], ...],
+        identity_fields: tuple[str, ...],
+    ) -> None:
+        for index, item in enumerate(items):
+            name = next(
+                (
+                    str(item[field])
+                    for field in identity_fields
+                    if item.get(field) not in (None, "")
+                ),
+                f"{kind}:{index}",
+            )
+            components.append(
+                CodexHostComponentDetail(
+                    kind=kind,
+                    name=name,
+                    path=_component_path(item),
+                    metadata=dict(item),
+                )
+            )
+
+    append("skill", plugin.skills, ("name", "id", "key"))
+    append("hook", plugin.hooks, ("key", "name", "id"))
+    append("app", plugin.apps, ("id", "name", "key"))
+    append("app-template", plugin.app_templates, ("id", "name", "key"))
+    append(
+        "scheduled-task",
+        plugin.scheduled_tasks or (),
+        ("key", "name", "id"),
+    )
+    components.extend(
+        CodexHostComponentDetail(kind="mcp", name=name) for name in plugin.mcp_servers
+    )
+    return tuple(components)
+
+
 class CodexAppServerPluginBridge:
     """Allowlisted Codex plugin manager backed by one App Server process."""
 
@@ -290,12 +377,27 @@ class CodexAppServerPluginBridge:
             await transport.close()
 
     async def add_marketplace(self, source: str, *, ref_name: str | None = None) -> str:
+        result = await self.add_marketplace_with_receipt(source, ref_name=ref_name)
+        return result.marketplace_name
+
+    async def add_marketplace_with_receipt(
+        self,
+        source: str,
+        *,
+        ref_name: str | None = None,
+    ) -> CodexMarketplaceAddResult:
+        """Add a marketplace while retaining its host-materialized root."""
+
         response = await self._request(
             "marketplace/add",
             {"source": source, "refName": ref_name, "sparsePaths": None},
             _MarketplaceAddResponse,
         )
-        return response.marketplace_name
+        return CodexMarketplaceAddResult(
+            marketplace_name=response.marketplace_name,
+            installed_root=response.installed_root,
+            already_added=response.already_added,
+        )
 
     async def list_plugins(
         self, *, force_refetch: bool = False
@@ -324,18 +426,20 @@ class CodexAppServerPluginBridge:
             _PluginReadResponse,
         )
         plugin = response.plugin
+        components = _reported_components(plugin)
         return CodexPluginDetail(
             inventory=self._inventory(marketplace, plugin.summary),
             description=plugin.description,
-            skills=tuple(str(item.get("name", "")) for item in plugin.skills if item.get("name")),
+            share_url=plugin.share_url,
+            skills=tuple(component.name for component in components if component.kind == "skill"),
             mcp_servers=plugin.mcp_servers,
-            hooks=tuple(str(item.get("key", "")) for item in plugin.hooks if item.get("key")),
-            apps=tuple(str(item.get("id", "")) for item in plugin.apps if item.get("id")),
+            hooks=tuple(component.name for component in components if component.kind == "hook"),
+            apps=tuple(component.name for component in components if component.kind == "app"),
             scheduled_tasks=tuple(
-                str(item.get("key", ""))
-                for item in (plugin.scheduled_tasks or ())
-                if item.get("key")
+                component.name for component in components if component.kind == "scheduled-task"
             ),
+            components=components,
+            host_metadata=dict(plugin.model_extra or {}),
         )
 
     async def install_plugin(
@@ -536,6 +640,7 @@ class CodexAppServerPluginBridge:
             enabled=summary.enabled,
             availability=summary.availability,
             source=summary.source,
+            interface=summary.interface or {},
         )
 
 
@@ -543,6 +648,8 @@ __all__ = [
     "CodexAppServerPluginBridge",
     "CodexBridgeError",
     "CodexBridgeHost",
+    "CodexHostComponentDetail",
+    "CodexMarketplaceAddResult",
     "CodexPluginApprovalRequired",
     "CodexPluginDetail",
     "CodexPluginInstallResult",