agentengine-sdk-python 0.8.0__py3-none-any.whl → 0.8.2__py3-none-any.whl

ksadk/harness/app.py

@@ -1,20 +1,7 @@
-"""HarnessApp — 统一 Runtime 的可部署交付物 / composition root。
-
-H2 §4.2:HarnessApp 是 composition root,**不包装复制 3000+ 行全局 app**——复用
-G0.1 ``create_runtime_app`` 装配;A2A、Responses、session、files 等**数据面** route
-group 装配,**控制面 action 不进入**;不 import 全局 ``base_app`` 再过滤复制路由。
-
-本层保持 AgentDraft 的最小字段面，但执行路径会运行真实模型推理、MCP transport 与
-Harness read-only sandbox policy。不含完整 AgentDraft v1 字段面、plugin 生态或 deploy 自动化。
-
-分层职责:yaml → RuntimeAdapter ``start(request)`` 的映射在**本层**;平台请求 →
-codex 配置(config.toml/AGENTS.md/mcp_servers)的翻译是 goal-09 CodexRuntime 的职责,
-不在本层做。
-"""
+"""RuntimeAdapter-first deployable Harness composition root."""
 
 from __future__ import annotations
 
-import logging
 import tempfile
 from dataclasses import dataclass, replace
 from pathlib import Path
@@ -24,34 +11,32 @@ from fastapi import FastAPI
 
 from ksadk.harness.config import HarnessConfig
 from ksadk.harness.reasoner import HarnessReasoner
-from ksadk.harness.runner import YamlAgentRunner
-from ksadk.runners.base_runner import BaseRunner
-from ksadk.runtime.adapter import RuntimeAdapter, StartRequest
-from ksadk.runtime.runner_adapter import RunnerRuntimeAdapter
+from ksadk.harness.runtime import HarnessRuntimeAdapter
+from ksadk.runtime import (
+    RuntimeAdapter,
+    RuntimeExecutor,
+    RuntimeLaunchContext,
+    RuntimeRegistry,
+    StartRequest,
+)
+from ksadk.runtime.factory import create_runtime_adapter
 from ksadk.server.factory import RuntimeAppConfig, create_runtime_app
 from ksadk.server.routes.routers import GROUP_ROUTERS, load_route_modules
 
-logger = logging.getLogger(__name__)
-
 
 class HarnessPlugin(Protocol):
-    """基础 plugin host 的插件协议(骨架期最小钩子)。"""
-
-    def before_build(self, config: HarnessConfig) -> None:  # pragma: no cover - 协议
+    def before_build(self, config: HarnessConfig) -> None:  # pragma: no cover
         ...
 
     def after_build(self, app: FastAPI, config: HarnessConfig) -> None:  # pragma: no cover
         ...
 
 
-#: per-invocation override 允许覆盖的字段(最小子集内)。
 _OVERRIDEABLE = ("model", "prompt")
 
 
 @dataclass(frozen=True)
 class HarnessCapabilities:
-    """Protocol/data surfaces backed by this Harness composition."""
-
     responses: bool = True
     sessions: bool = True
     files: bool = False
@@ -60,14 +45,16 @@ class HarnessCapabilities:
 
 
 class HarnessApp:
-    """统一 Runtime 的 composition root(skeleton)。"""
+    """Own one adapter/executor/context tuple for a deployable YAML agent."""
 
     def __init__(
         self,
         config: HarnessConfig,
         *,
         plugins: Sequence[HarnessPlugin] = (),
-        adapter_builder: Optional[Callable[[BaseRunner], RuntimeAdapter]] = None,
+        adapter_builder: Optional[
+            Callable[[HarnessConfig, Path, HarnessReasoner | None], RuntimeAdapter]
+        ] = None,
         reasoner: HarnessReasoner | None = None,
         workspace_root: str | Path | None = None,
         a2a: Any | None = None,
@@ -85,31 +72,59 @@ class HarnessApp:
             self._owned_workspace = None
             resolved_workspace = workspace_root
         self._workspace_root = Path(resolved_workspace).resolve()
-        self._runner: BaseRunner | None = None
         self._adapter: RuntimeAdapter | None = None
         self._fastapi_app: FastAPI | None = None
         self._capabilities = HarnessCapabilities(a2a=a2a is not None)
-        # Each Harness owns its session backend.  Route handlers may use this
-        # marker even when a host does not provide the optional session seam.
+        self._runtime_type = "codex" if config.runtime == "codex" else "harness"
+        self._launch_context = RuntimeLaunchContext(
+            runtime_type=self._runtime_type,
+            project_dir=self._workspace_root,
+            config={
+                "model": config.model,
+                "base_instructions": config.prompt,
+                "sandbox_read_only": config.sandbox.read_only,
+            },
+        )
+        registry = RuntimeRegistry()
+        registry.register(self._runtime_type, lambda _context: self.adapter())
+        self._executor = RuntimeExecutor(registry)
+
         from ksadk.sessions import create_session_service
 
         self._session_service = create_session_service(
-            backend="memory", project_dir=str(self._workspace_root)
+            backend="memory",
+            project_dir=str(self._workspace_root),
         )
 
     @classmethod
     def from_yaml(cls, path: str | Path, **kwargs: Any) -> "HarnessApp":
-        """从 yaml 装配(最小子集,超出明确报错)。"""
         return cls(HarnessConfig.from_yaml(path), **kwargs)
 
     @property
     def config(self) -> HarnessConfig:
         return self._config
 
-    # ---- override ----
+    @property
+    def workspace_root(self) -> Path:
+        return self._workspace_root
+
+    @property
+    def session_service(self) -> Any:
+        return self._session_service
+
+    @property
+    def capabilities(self) -> HarnessCapabilities:
+        return self._capabilities
+
+    @property
+    def executor(self) -> RuntimeExecutor:
+        return self._executor
+
+    @property
+    def launch_context(self) -> RuntimeLaunchContext:
+        return self._launch_context
 
     def apply_overrides(self, overrides: Optional[dict[str, Any]]) -> HarnessConfig:
-        """per-invocation override:只允许最小子集内字段,超出报错(不静默忽略)。"""
         if not overrides:
             return self._config
         unknown = set(overrides) - set(_OVERRIDEABLE)
@@ -119,60 +134,31 @@ class HarnessApp:
             )
         return replace(self._config, **overrides)
 
-    # ---- 组装 ----
-
-    def build_runner(self, overrides: Optional[dict[str, Any]] = None) -> BaseRunner:
-        if overrides is not None:
-            raise ValueError("build_runner 不接受 invocation override;请传给 start(request)")
-        if self._runner is None:
-            self._runner = self._build_runner(self._config)
-        return self._runner
-
-    def _build_runner(self, config: HarnessConfig) -> BaseRunner:
-        for plugin in self._plugins:
-            plugin.before_build(config)
-        if config.runtime == "codex":
-            # codex runtime:CodexRunner(经 ksadk web 已验证路径),detector stub 用 CODEX
-            from ksadk.detection.detector import FrameworkType
-            from ksadk.runners.codex_runner import CodexRunner
-
-            detection = type(
-                "D", (), {"name": config.model, "type": FrameworkType.CODEX}
-            )()
-            return CodexRunner(detection, str(self._workspace_root))
-        return YamlAgentRunner(
-            config,
-            reasoner=self._reasoner,
-            workspace_root=self._workspace_root,
-        )
-
     def adapter(self, overrides: Optional[dict[str, Any]] = None) -> RuntimeAdapter:
-        """yaml → RuntimeAdapter(goal-07);start(request) 在此层映射。"""
         if overrides is not None:
             raise ValueError("adapter 不接受 invocation override;请传给 start(request)")
         if self._adapter is not None:
             return self._adapter
-        rt = "codex" if self._config.runtime == "codex" else "harness"
-
-        def _default_builder(runner: BaseRunner) -> RuntimeAdapter:
-            return RunnerRuntimeAdapter(runner, runtime_type=rt)
-
-        builder = self._adapter_builder or _default_builder
-        self._adapter = builder(self.build_runner())
-        return self._adapter
-
-    @property
-    def runner(self) -> BaseRunner:
-        """The one runner owned by this Harness composition root."""
-        return self.build_runner()
-
-    @property
-    def session_service(self) -> Any:
-        return self._session_service
-
-    @property
-    def capabilities(self) -> HarnessCapabilities:
-        return self._capabilities
+        for plugin in self._plugins:
+            plugin.before_build(self._config)
+        if self._adapter_builder is not None:
+            adapter = self._adapter_builder(
+                self._config,
+                self._workspace_root,
+                self._reasoner,
+            )
+        elif self._runtime_type == "codex":
+            adapter = create_runtime_adapter(self._launch_context)
+        else:
+            adapter = HarnessRuntimeAdapter(
+                self._config,
+                reasoner=self._reasoner,
+                workspace_root=self._workspace_root,
+            )
+        if not isinstance(adapter, RuntimeAdapter):
+            raise TypeError("Harness adapter builder must return RuntimeAdapter")
+        self._adapter = adapter
+        return adapter
 
     def _route_groups(self) -> set[str]:
         groups = {"health_meta", "models", "feedback", "tools", "ui_bootstrap"}
@@ -187,49 +173,58 @@ class HarnessApp:
         return groups
 
     def _request_with_overrides(
-        self, request: StartRequest, overrides: Optional[dict[str, Any]]
+        self,
+        request: StartRequest,
+        overrides: Optional[dict[str, Any]],
     ) -> StartRequest:
+        effective = self.apply_overrides(overrides)
         metadata = dict(request.metadata or {})
-        changed = False
-        if request.model:
-            metadata["model_override"] = request.model
-            changed = True
-        request_prompt = request.config.get("prompt") or request.config.get("instructions")
-        if request_prompt is not None:
-            metadata["prompt_override"] = str(request_prompt)
-            changed = True
-        if overrides:
-            config = self.apply_overrides(overrides)
-            metadata["model_override"] = config.model
-            metadata["prompt_override"] = config.prompt
-            changed = True
-        if not changed:
-            return request
-        if hasattr(request, "model_copy"):
-            return request.model_copy(update={"metadata": metadata})
-        return request.copy(update={"metadata": metadata})
-
-    async def start(self, request: StartRequest, overrides: Optional[dict[str, Any]] = None):
-        """yaml → RuntimeAdapter.start(request)(本层映射)。"""
-        return await self.adapter().start(self._request_with_overrides(request, overrides))
+        model = request.model or effective.model
+        prompt = str(
+            request.config.get("base_instructions")
+            or request.config.get("instructions")
+            or request.config.get("prompt")
+            or effective.prompt
+        )
+        metadata["model_override"] = model
+        metadata["prompt_override"] = prompt
+        config = dict(request.config)
+        config["base_instructions"] = prompt
+        return request.model_copy(
+            update={
+                "model": model,
+                "config": config,
+                "metadata": metadata,
+            }
+        )
+
+    async def start(
+        self,
+        request: StartRequest,
+        overrides: Optional[dict[str, Any]] = None,
+    ):
+        return await self._executor.start(
+            self._launch_context,
+            self._request_with_overrides(request, overrides),
+        )
 
     def stream(self, handle: Any):
-        return self.adapter().stream(handle)
+        return self._executor.stream(handle)
 
     async def cancel(self, handle: Any):
-        return await self.adapter().cancel(handle)
+        return await self._executor.cancel(handle)
 
     async def resume(self, handle: Any, target: Any, payload: Any = None):
-        return await self.adapter().resume(handle, target, payload)
+        return await self._executor.resume(handle, target, payload)
 
     async def checkpoint(self, handle: Any):
-        return await self.adapter().checkpoint(handle)
+        return await self._executor.checkpoint(handle)
 
     async def close(self, handle: Any):
-        return await self.adapter().close(handle)
+        return await self._executor.close(handle)
 
-    def _configure_routes(self, app: FastAPI, state: Any, groups: set[str]) -> None:
-        """Attach only route groups; never install integrated workspace/terminal routes."""
+    @staticmethod
+    def _configure_routes(app: FastAPI, state: Any, groups: set[str]) -> None:
         del state
         load_route_modules()
         ordered = sorted(group for group in groups if group != "health_meta")
@@ -241,21 +236,19 @@ class HarnessApp:
                 app.include_router(router)
 
     def build_app(self, overrides: Optional[dict[str, Any]] = None) -> FastAPI:
-        """装配可部署 app:复用 create_runtime_app,只挂数据面 route group(控制面不进)。"""
         if overrides is not None:
-            # Overrides belong to StartRequest and must never create a second
-            # process-wide runner for the deployed app.
             raise ValueError("build_app 不接受 invocation override;请传给 start(request)")
         if self._fastapi_app is not None:
             return self._fastapi_app
-        runner = self.build_runner()
+        adapter = self.adapter()
         app = create_runtime_app(
             RuntimeAppConfig(
-                runner=runner,
-                runtime_type="codex" if self._config.runtime == "codex" else "harness",
+                runtime_type=self._runtime_type,
                 route_groups=self._route_groups(),
                 a2a=self._a2a,
-                runtime_adapter=self.adapter() if self._a2a is not None else None,
+                a2a_runtime_adapter=adapter if self._a2a is not None else None,
+                runtime_executor=self._executor,
+                launch_context=self._launch_context,
                 session_backend_provider=lambda: {
                     "Backend": "memory",
                     "Shared": False,
@@ -265,10 +258,8 @@ class HarnessApp:
             ),
             self._configure_routes,
         )
-        app.state.runtime.runtime_adapter = self.adapter()
         app.state.runtime.session_service = self._session_service
         app.state.runtime.harness_capabilities = self._capabilities
-
         for plugin in self._plugins:
             plugin.after_build(app, self._config)
         self._fastapi_app = app

ksadk/harness/config.py

@@ -63,7 +63,7 @@ class HarnessConfig:
     mcp_tools: tuple[McpToolSpec, ...] = ()
     sandbox: SandboxPolicy = field(default_factory=SandboxPolicy)
     runtime: str = "yaml"
-    """runtime 后端:``yaml``(YamlAgentRunner+LiteLLM)| ``codex``(CodexRunner+codex CLI)。"""
+    """runtime 后端:``yaml``(HarnessRuntimeAdapter)| ``codex``(CodexRuntimeAdapter)。"""
 
     @classmethod
     def from_dict(cls, data: dict[str, Any], *, source: str = "yaml") -> "HarnessConfig":