agentengine-sdk-python 0.6.4__py3-none-any.whl → 0.7.0__py3-none-any.whl

ksadk/skills/runtime/request.py

@@ -0,0 +1,67 @@
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+from ksadk.skills.runtime.base import normalize_skill_names
+
+
+class SkillWorkflowRequestError(ValueError):
+    pass
+
+
+@dataclass(frozen=True)
+class SkillWorkflowRequest:
+    workflow_prompt: str = ""
+    skill_names: list[str] = field(default_factory=list)
+
+
+def parse_workflow_request(argv: list[str]) -> SkillWorkflowRequest:
+    args = list(argv)
+    has_prompt_file = "--prompt-file" in args
+    has_request_file = "--request-file" in args
+    if has_prompt_file and has_request_file:
+        raise SkillWorkflowRequestError("--prompt-file and --request-file cannot be used together")
+
+    if has_request_file:
+        return _request_from_json_file(_option_value(args, "--request-file"))
+    if has_prompt_file:
+        return SkillWorkflowRequest(workflow_prompt=Path(_option_value(args, "--prompt-file")).read_text(encoding="utf-8"))
+    if not args:
+        return SkillWorkflowRequest()
+    return SkillWorkflowRequest(workflow_prompt=args[0])
+
+
+def _option_value(args: list[str], name: str) -> str:
+    try:
+        index = args.index(name)
+        value = args[index + 1]
+    except (ValueError, IndexError) as exc:
+        raise SkillWorkflowRequestError(f"{name} requires a file path") from exc
+    if value.startswith("--"):
+        raise SkillWorkflowRequestError(f"{name} requires a file path")
+    return value
+
+
+def _request_from_json_file(path: str) -> SkillWorkflowRequest:
+    try:
+        payload = json.loads(Path(path).read_text(encoding="utf-8"))
+    except json.JSONDecodeError as exc:
+        raise SkillWorkflowRequestError(f"invalid request file JSON: {exc}") from exc
+    if not isinstance(payload, dict):
+        raise SkillWorkflowRequestError("request file must contain a JSON object")
+    prompt = payload.get("workflow_prompt", payload.get("prompt", ""))
+    skill_names = _skill_names_from_payload(payload)
+    return SkillWorkflowRequest(
+        workflow_prompt=str(prompt or ""),
+        skill_names=skill_names,
+    )
+
+
+def _skill_names_from_payload(payload: dict[str, Any]) -> list[str]:
+    for key in ("skill_names", "selected_skills"):
+        if key in payload:
+            return normalize_skill_names(payload.get(key))
+    return []

ksadk/skills/service_client.py

@@ -0,0 +1,239 @@
+from __future__ import annotations
+
+import os
+from collections.abc import Mapping
+from typing import Any
+from urllib.parse import quote, urlsplit, urlunsplit
+
+import httpx
+import requests
+
+from ksadk.common.auth import AWSV4Auth
+
+from ksadk.skills.models import SkillListResponse, SkillRef
+
+
+class SkillServiceClient:
+    def __init__(
+        self,
+        *,
+        base_url: str,
+        token: str = "",
+        access_key: str = "",
+        secret_key: str = "",
+        account_id: str = "",
+        region: str = "",
+        api_version: str = "",
+        sign_service: str = "",
+        extra_headers: Mapping[str, str] | None = None,
+        timeout: float = 60.0,
+        transport: httpx.BaseTransport | None = None,
+    ):
+        self.base_url = _normalize_base_url(base_url)
+        self.token = token
+        self.access_key = access_key or _env("KSADK_SKILL_SERVICE_ACCESS_KEY", "KSYUN_ACCESS_KEY", "KS3_ACCESS_KEY")
+        self.secret_key = secret_key or _env("KSADK_SKILL_SERVICE_SECRET_KEY", "KSYUN_SECRET_KEY", "KS3_SECRET_KEY")
+        self.account_id = account_id or _env("KSADK_SKILL_SERVICE_ACCOUNT_ID", "KSYUN_ACCOUNT_ID")
+        self.logical_region = region or _env("KSADK_SKILL_SERVICE_REGION", "KSYUN_REGION") or "cn-beijing-6"
+        self.region = _normalize_control_region(self.logical_region)
+        self.custom_source = _resolve_custom_source(self.logical_region)
+        self.api_version = api_version or os.environ.get("KSADK_SKILL_SERVICE_API_VERSION", "2024-06-12")
+        self.sign_service = sign_service or os.environ.get("KSADK_SKILL_SERVICE_SIGN_SERVICE", "aicp")
+        self.extra_headers = dict(extra_headers or {})
+        self.timeout = timeout
+        self.transport = transport
+        self._requests_session: requests.Session | None = None
+        self._auth = AWSV4Auth(
+            access_key_id=self.access_key,
+            secret_access_key=self.secret_key,
+            region=self.region,
+            service=self.sign_service,
+        )
+
+    def action_url(self, action: str) -> str:
+        if self._is_kop_mode():
+            return (
+                f"{self._kop_base_url()}/?Action={quote(action.lstrip('/'))}"
+                f"&Version={quote(self.api_version)}"
+            )
+        return f"{self.base_url}/{action.lstrip('/')}"
+
+    def list_skill_spaces(self, *, page_number: int = 1, page_size: int = 100) -> dict[str, Any]:
+        return self._get_json(
+            "ListSkillSpaces",
+            {"PageNumber": page_number, "PageSize": page_size},
+        )
+
+    def list_skills_by_space_id(self, space_id: str) -> SkillListResponse:
+        if self._is_kop_mode():
+            payload = self._get_json(
+                "ListSkillsBySpaceId",
+                {"SpaceId": space_id, "PageNumber": 1, "PageSize": 100},
+            )
+        else:
+            payload = self._get_json("ListSkillsBySpaceId", {"SpaceId": space_id})
+        return SkillListResponse.from_payload(payload, space_id=space_id)
+
+    def list_available_premade_skills(self) -> SkillListResponse:
+        payload = self._get_json("ListAvailablePremadeSkills", {})
+        return SkillListResponse.from_payload(payload, space_id="public", space_name="Public Skills")
+
+    def get_skill_download_url(self, skill: SkillRef) -> str:
+        action = "GetSkillDownloadUrl" if skill.version_id else "GetPremadeSkillDownloadUrl"
+        payload = self._get_json(
+            action,
+            {
+                "SkillId": skill.skill_id,
+                "VersionId": skill.version_id,
+            },
+        )
+        data = payload.get("Data") or payload.get("data") or {}
+        return str(data.get("DownloadUrl") or data.get("download_url") or "")
+
+    def download_skill_archive(self, skill: SkillRef) -> bytes:
+        download_url = self.get_skill_download_url(skill)
+        if not download_url:
+            raise ValueError(f"Skill Service did not return DownloadUrl for {skill.skill_id}")
+        with httpx.Client(**self._client_kwargs()) as client:
+            response = client.get(download_url)
+            response.raise_for_status()
+            return response.content
+
+    def _get_json(self, action: str, params: dict[str, Any]) -> dict[str, Any]:
+        if self._is_kop_mode():
+            return self._get_json_kop(action, params)
+        with httpx.Client(**self._client_kwargs()) as client:
+            response = client.get(self.action_url(action), params=params, headers=self._headers())
+            response.raise_for_status()
+            return self._decode_response(action, response)
+
+    def _post_json(self, action: str, payload: dict[str, Any]) -> dict[str, Any]:
+        with httpx.Client(**self._client_kwargs()) as client:
+            response = client.post(self.action_url(action), json=payload, headers=self._headers())
+            response.raise_for_status()
+            return self._decode_response(action, response)
+
+    def _decode_response(self, action: str, response: httpx.Response) -> dict[str, Any]:
+        data = response.json()
+        if not isinstance(data, dict):
+            raise ValueError(f"Skill Service returned non-object response for {action}")
+        code = data.get("Code", data.get("code"))
+        if code not in (None, 0, 200, "0", "200"):
+            request_id = str(data.get("RequestId") or data.get("request_id") or "")
+            message = str(data.get("Message") or data.get("message") or "")
+            raise ValueError(
+                f"Skill Service {action} failed: code={code}, "
+                f"request_id={request_id}, message={message}"
+            )
+        return data
+
+    def _client_kwargs(self) -> dict[str, Any]:
+        kwargs: dict[str, Any] = {"timeout": self.timeout}
+        if self.transport is not None:
+            kwargs["transport"] = self.transport
+        return kwargs
+
+    def _headers(self, *, action: str = "") -> dict[str, str]:
+        headers = {"Accept": "application/json", "Content-Type": "application/json"}
+        if self.token:
+            headers["Authorization"] = f"Bearer {self.token}"
+        if self.account_id:
+            headers["X-Ksc-Account-Id"] = self.account_id
+        if self._is_kop_mode():
+            headers.update(
+                {
+                    "Host": urlsplit(self._kop_base_url()).netloc,
+                    "X-Ksc-Region": self.region,
+                    "X-Ksc-Source": "ksadk-skill-runtime",
+                }
+            )
+            if self.custom_source:
+                headers["X-KSC-CUSTOM-SOURCE"] = self.custom_source
+            if action:
+                headers["X-Action"] = action
+                headers["X-Version"] = self.api_version
+        headers.update(self.extra_headers)
+        return headers
+
+    def _get_json_kop(self, action: str, params: dict[str, Any]) -> dict[str, Any]:
+        query = {"Action": action, "Version": self.api_version, **params}
+        headers = self._headers(action=action)
+        if self.transport is not None:
+            with httpx.Client(**self._client_kwargs()) as client:
+                response = client.get(self._kop_base_url() + "/", params=query, headers=headers)
+                response.raise_for_status()
+                return self._decode_response(action, response)
+        if not self._auth.is_enabled:
+            raise ValueError(
+                "AICP Skill Service endpoint requires signing credentials. "
+                "Set KSADK_SKILL_SERVICE_ACCESS_KEY/KSADK_SKILL_SERVICE_SECRET_KEY "
+                "or KSYUN_ACCESS_KEY/KSYUN_SECRET_KEY."
+            )
+        response = self._requests().get(
+            self._kop_base_url() + "/",
+            params=query,
+            headers=headers,
+            auth=self._auth.get_auth(),
+            timeout=self.timeout,
+        )
+        response.raise_for_status()
+        data = response.json()
+        if not isinstance(data, dict):
+            raise ValueError(f"Skill Service returned non-object response for {action}")
+        code = data.get("Code", data.get("code"))
+        if code not in (None, 0, 200, "0", "200"):
+            request_id = str(data.get("RequestId") or data.get("request_id") or "")
+            message = str(data.get("Message") or data.get("message") or data.get("Error") or "")
+            raise ValueError(
+                f"Skill Service {action} failed: code={code}, "
+                f"request_id={request_id}, message={message}"
+            )
+        return data
+
+    def _requests(self) -> requests.Session:
+        if self._requests_session is None:
+            self._requests_session = requests.Session()
+        return self._requests_session
+
+    def _is_kop_mode(self) -> bool:
+        host = urlsplit(self.base_url).netloc.lower()
+        return (
+            host.endswith("aicp.inner.api.ksyun.com")
+            or host.endswith("aicp.internal.api.ksyun.com")
+            or host.endswith("aicp.api.ksyun.com")
+        )
+
+    def _kop_base_url(self) -> str:
+        parsed = urlsplit(self.base_url)
+        return urlunsplit((parsed.scheme, parsed.netloc, "", "", "")).rstrip("/")
+
+
+def _env(*names: str) -> str:
+    for name in names:
+        value = os.environ.get(name, "").strip()
+        if value:
+            return value
+    return ""
+
+
+def _normalize_control_region(region: str) -> str:
+    region = (region or "cn-beijing-6").strip()
+    if region.lower() == "pre-online":
+        return os.environ.get("AGENTENGINE_PRE_CONTROL_REGION", "cn-beijing-6")
+    return region
+
+
+def _resolve_custom_source(region: str) -> str:
+    if (region or "").strip().lower() == "pre-online":
+        return os.environ.get("AGENTENGINE_PRE_CUSTOM_SOURCE", "pre")
+    return ""
+
+
+def _normalize_base_url(base_url: str) -> str:
+    parsed = urlsplit(base_url.strip())
+    path = parsed.path.rstrip("/")
+    if path.endswith("/openapi.json"):
+        path = path[: -len("/openapi.json")]
+    elif path.endswith("/docs"):
+        path = path[: -len("/docs")] + "/api/v1"
+    return urlunsplit((parsed.scheme, parsed.netloc, path, "", "")).rstrip("/")

ksadk/skills/service_env.py

@@ -0,0 +1,58 @@
+from __future__ import annotations
+
+import os
+
+from ksadk.common.aicp_env import resolve_aicp_connection
+
+
+def parse_skill_space_ids(*raw_values: str) -> list[str]:
+    spaces: list[str] = []
+    seen: set[str] = set()
+    for raw in raw_values:
+        for part in raw.split(","):
+            space_id = part.strip()
+            if not space_id or space_id in seen:
+                continue
+            seen.add(space_id)
+            spaces.append(space_id)
+    return spaces
+
+
+def user_skill_space_ids() -> list[str]:
+    return parse_skill_space_ids(
+        os.environ.get("KSADK_SKILL_SPACE_IDS") or os.environ.get("SKILL_SPACE_ID") or ""
+    )
+
+
+def public_skill_space_ids() -> list[str]:
+    return parse_skill_space_ids(os.environ.get("KSADK_PUBLIC_SKILL_SPACE_IDS") or "")
+
+
+def skill_space_ids() -> list[str]:
+    return parse_skill_space_ids(
+        os.environ.get("KSADK_SKILL_SPACE_IDS") or os.environ.get("SKILL_SPACE_ID") or "",
+        os.environ.get("KSADK_PUBLIC_SKILL_SPACE_IDS") or "",
+    )
+
+
+def resolve_skill_service_url(*, require_spaces: bool = True) -> str:
+    explicit = os.environ.get("KSADK_SKILL_SERVICE_URL", "").strip()
+    if explicit:
+        return explicit
+    if require_spaces and not skill_space_ids():
+        return ""
+
+    connection = resolve_aicp_connection("KSADK_SKILL_SERVICE")
+    return f"{connection['scheme']}://{connection['endpoint']}".rstrip("/")
+
+
+def should_resolve_child_skill_service_url() -> bool:
+    if os.environ.get("KSADK_SKILL_SERVICE_URL", "").strip():
+        return True
+    if os.environ.get("KSADK_SKILL_SERVICE_ENDPOINT", "").strip():
+        return True
+    if os.environ.get("KSADK_SKILL_SERVICE_SCHEME", "").strip():
+        return True
+
+    mode = os.environ.get("KSADK_AICP_ENDPOINT_MODE", "").strip().lower()
+    return mode not in {"", "auto", "detect"}

ksadk/skills/tool_defs.py

@@ -0,0 +1,221 @@
+from __future__ import annotations
+
+import os
+from uuid import uuid4
+
+from ksadk.skills.loader import LocalSkill
+from ksadk.skills.models import SkillRef
+from ksadk.skills.runtime.base import SkillRuntimeBackend, normalize_skill_names
+from ksadk.skills.service_client import SkillServiceClient
+from ksadk.skills.service_env import (
+    parse_skill_space_ids,
+    public_skill_space_ids,
+    resolve_skill_service_url,
+    should_resolve_child_skill_service_url,
+    skill_space_ids as configured_skill_space_ids,
+    user_skill_space_ids,
+)
+
+RUNTIME_AGENT_ENV_NAMES = (
+    "KSADK_SKILL_SERVICE_URL",
+    "KSADK_SKILL_SERVICE_TOKEN",
+    "KSADK_SKILL_SERVICE_ACCESS_KEY",
+    "KSADK_SKILL_SERVICE_SECRET_KEY",
+    "KSADK_SKILL_SERVICE_ACCOUNT_ID",
+    "KSADK_SKILL_SERVICE_REGION",
+    "KSADK_SKILL_SERVICE_API_VERSION",
+    "KSADK_SKILL_SERVICE_SIGN_SERVICE",
+    "KSADK_SKILL_CACHE_DIR",
+    "KSADK_SKILL_WORKDIR",
+    "KSADK_SKILL_ARTIFACT_PROJECT",
+    "KSADK_PUBLIC_SKILL_SPACE_IDS",
+    "KSADK_PUBLIC_SKILL_ALLOWLIST",
+)
+
+_SKILL_SERVICE_SECRET_FALLBACKS = {
+    "KSADK_SKILL_SERVICE_ACCESS_KEY": ("KSYUN_ACCESS_KEY", "KS3_ACCESS_KEY"),
+    "KSADK_SKILL_SERVICE_SECRET_KEY": ("KSYUN_SECRET_KEY", "KS3_SECRET_KEY"),
+}
+
+
+def resolve_skill_space_ids() -> list[str]:
+    return configured_skill_space_ids()
+
+
+def resolve_user_skill_space_ids() -> list[str]:
+    return user_skill_space_ids()
+
+
+def _parse_skill_space_ids(*raw_values: str) -> list[str]:
+    return parse_skill_space_ids(*raw_values)
+
+
+def runtime_agent_env_from_process(skill_space_ids: list[str] | None = None) -> dict[str, str]:
+    env = {
+        name: value
+        for name in RUNTIME_AGENT_ENV_NAMES
+        if (value := os.environ.get(name))
+    }
+    if "KSADK_SKILL_SERVICE_ACCOUNT_ID" not in env and (
+        account_id := os.environ.get("KSYUN_ACCOUNT_ID")
+    ):
+        env["KSADK_SKILL_SERVICE_ACCOUNT_ID"] = account_id
+    if "KSADK_SKILL_SERVICE_REGION" not in env and (region := os.environ.get("KSYUN_REGION")):
+        env["KSADK_SKILL_SERVICE_REGION"] = region
+    has_spaces = bool(skill_space_ids) or bool(resolve_skill_space_ids())
+    if has_spaces:
+        for target, sources in _SKILL_SERVICE_SECRET_FALLBACKS.items():
+            if target in env:
+                continue
+            for source in sources:
+                value = os.environ.get(source, "").strip()
+                if value:
+                    env[target] = value
+                    break
+    if has_spaces and should_resolve_child_skill_service_url() and "KSADK_SKILL_SERVICE_URL" not in env:
+        service_url = resolve_skill_service_url(require_spaces=False)
+        if service_url:
+            env["KSADK_SKILL_SERVICE_URL"] = service_url
+    return env
+
+
+def build_execute_skills_tool(
+    *,
+    backend: SkillRuntimeBackend,
+    skill_space_ids: list[str] | None = None,
+    session_id: str | None = None,
+):
+    spaces = list(skill_space_ids or resolve_user_skill_space_ids())
+    default_session_id = session_id or f"ksadk-{uuid4().hex}"
+
+    def execute_skills(workflow_prompt: str, skill_names: list[str] | str | None = None) -> dict:
+        """Execute a workflow with the configured Skill Runtime."""
+
+        result = backend.run_workflow(
+            workflow_prompt,
+            skill_space_ids=spaces,
+            skill_names=normalize_skill_names(skill_names),
+            session_id=default_session_id,
+            env=runtime_agent_env_from_process(spaces),
+            timeout=int(os.environ.get("KSADK_SKILL_RUNTIME_TIMEOUT", "900")),
+        )
+        return result.to_dict()
+
+    execute_skills.__name__ = "execute_skills"
+    return execute_skills
+
+
+def load_remote_skill_manifests(skill_space_ids: list[str] | None = None) -> list[dict[str, str]]:
+    spaces = list(skill_space_ids or resolve_skill_space_ids())
+    public_spaces = set(public_skill_space_ids())
+    user_spaces = [space_id for space_id in spaces if space_id not in public_spaces]
+    if not user_spaces and not public_spaces:
+        return []
+
+    service_url = resolve_skill_service_url(require_spaces=True)
+    if not service_url:
+        return []
+
+    client = SkillServiceClient(
+        base_url=service_url,
+        token=os.environ.get("KSADK_SKILL_SERVICE_TOKEN", ""),
+        timeout=float(os.environ.get("KSADK_SKILL_MANIFEST_TIMEOUT", "5")),
+    )
+    manifests: list[dict[str, str]] = []
+    seen: set[str] = set()
+    limit = _manifest_limit()
+    public_allowlist = {
+        name.lower() for name in normalize_skill_names(os.environ.get("KSADK_PUBLIC_SKILL_ALLOWLIST", ""))
+    }
+    for space_id in user_spaces:
+        listing = client.list_skills_by_space_id(space_id)
+        for skill in listing.active_skills():
+            item = _skill_manifest_item(skill, space_id=space_id)
+            name_key = item["name"].lower()
+            if not item["name"] or name_key in seen:
+                continue
+            seen.add(name_key)
+            manifests.append(item)
+            if len(manifests) >= limit:
+                return manifests
+    if public_spaces:
+        listing = client.list_available_premade_skills()
+        for skill in listing.active_skills():
+            if public_allowlist and skill.name.lower() not in public_allowlist:
+                continue
+            item = _skill_manifest_item(skill, space_id=listing.space_id or "public")
+            name_key = item["name"].lower()
+            if not item["name"] or name_key in seen:
+                continue
+            seen.add(name_key)
+            manifests.append(item)
+            if len(manifests) >= limit:
+                return manifests
+    return manifests
+
+
+def build_skill_manifest_instruction(manifests: list[dict[str, str]]) -> str:
+    if not manifests:
+        return ""
+
+    lines = [
+        "",
+        "Available remote skills are listed below. Use them only when they match the user's task.",
+        "When a skill is useful, call execute_skills with the original workflow_prompt and skill_names set to the exact skill name.",
+        "Do not assume full skill instructions are already loaded; execute_skills loads selected skills on demand.",
+        "",
+        "Remote skills:",
+    ]
+    for item in manifests:
+        description = item.get("description") or "No description"
+        version = item.get("version") or ""
+        suffix = f" ({version})" if version else ""
+        lines.append(f"- {item['name']}{suffix}: {description}")
+    return "\n".join(lines)
+
+
+def _skill_manifest_item(skill: SkillRef, *, space_id: str) -> dict[str, str]:
+    item = {
+        "name": str(skill.name or "").strip(),
+        "description": _single_line(skill.description),
+        "version": str(skill.version or "").strip(),
+        "space_id": str(space_id or "").strip(),
+    }
+    if skill.aliases:
+        item["aliases"] = _single_line(", ".join(skill.aliases))
+    if skill.tags:
+        item["tags"] = _single_line(", ".join(skill.tags))
+    return item
+
+
+def _single_line(value: str, *, limit: int = 240) -> str:
+    text = " ".join(str(value or "").split())
+    return text[:limit].rstrip()
+
+
+def _manifest_limit() -> int:
+    try:
+        return max(1, int(os.environ.get("KSADK_SKILL_MANIFEST_LIMIT", "30")))
+    except ValueError:
+        return 30
+
+
+def build_skills_tool(skills: list[LocalSkill]):
+    def skills_tool(action: str = "list") -> dict:
+        """List locally loaded skills and their instructions."""
+
+        return {
+            "action": action,
+            "skills": [
+                {
+                    "name": skill.name,
+                    "description": skill.description,
+                    "body": skill.body,
+                    "root_dir": str(skill.root_dir),
+                }
+                for skill in skills
+            ],
+        }
+
+    skills_tool.__name__ = "skills_tool"
+    return skills_tool

ksadk/terminal_client.py

@@ -0,0 +1,69 @@
+"""通用远程终端 websocket client。
+
+当前 Hermes 与 OpenClaw runtime proxy 都使用同一套 `ks-terminal.v1`
+协议。Hermes 仍保留 `ksadk.hermes_terminal` 的兼容入口；新框架应优先
+引用本模块，避免把协议命名绑定到某一个框架。
+"""
+
+from __future__ import annotations
+
+from typing import Any, Mapping, Sequence
+
+from ksadk.hermes_terminal import (
+    TERMINAL_SUBPROTOCOL,
+    TERMINAL_WS_PATH,
+    TerminalSize,
+    build_start_frame,
+    build_terminal_exec_validator,
+    build_terminal_ws_url,
+    detect_terminal_size,
+    run_hermes_terminal_session,
+    validate_terminal_exec_argv,
+)
+from ksadk.terminal_exec_policy import GENERIC_TERMINAL_EXEC_POLICY, TerminalExecPolicy
+
+
+async def run_terminal_session(
+    *,
+    endpoint: str,
+    api_key: str | None = None,
+    session_id: str | None = None,
+    insecure: bool = False,
+    mode: str = "tui",
+    argv: Sequence[str] | None = None,
+    cwd: str | None = None,
+    options: Mapping[str, Any] | None = None,
+    exec_policy: TerminalExecPolicy | None = None,
+    stdin: Any | None = None,
+    stdout: Any | None = None,
+) -> int:
+    """Attach to a framework-native terminal session over ks-terminal.v1."""
+
+    return await run_hermes_terminal_session(
+        endpoint=endpoint,
+        api_key=api_key,
+        session_id=session_id,
+        insecure=insecure,
+        mode=mode,
+        argv=argv,
+        cwd=cwd,
+        options=options,
+        stdin=stdin,
+        stdout=stdout,
+        exec_argv_validator=(
+            build_terminal_exec_validator(exec_policy)
+            if exec_policy is not None and exec_policy != GENERIC_TERMINAL_EXEC_POLICY
+            else validate_terminal_exec_argv
+        ),
+    )
+
+
+__all__ = [
+    "TERMINAL_SUBPROTOCOL",
+    "TERMINAL_WS_PATH",
+    "TerminalSize",
+    "build_start_frame",
+    "build_terminal_ws_url",
+    "detect_terminal_size",
+    "run_terminal_session",
+]