kyber-cli 4.0.0__tar.gz → 4.0.2__tar.gz

{kyber_cli-4.0.0 → kyber_cli-4.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kyber-cli
-Version: 4.0.0
+Version: 4.0.2
 Summary: Kyber Developer Experience CLI — deploy agents in one command
 Author-email: Symplii <hello@symplii.ai>
 License: Apache-2.0

kyber_cli-4.0.2/kyber/runtimes/__init__.py

@@ -0,0 +1,22 @@
+from kyber.runtimes.go.adapter import GoRuntimeAdapter
+from kyber.runtimes.node.adapter import NodeRuntimeAdapter
+from kyber.runtimes.python.adapter import PythonRuntimeAdapter
+
+
+_ADAPTERS = {
+    "python": PythonRuntimeAdapter(),
+    "node": NodeRuntimeAdapter(),
+    "go": GoRuntimeAdapter(),
+}
+
+
+def get_runtime_adapter(runtime: str):
+    try:
+        return _ADAPTERS[runtime]
+    except KeyError as exc:
+        supported = ", ".join(sorted(_ADAPTERS))
+        raise ValueError(f"Unsupported runtime '{runtime}'. Supported runtimes: {supported}") from exc
+
+
+def supported_runtimes():
+    return tuple(_ADAPTERS)

kyber_cli-4.0.2/kyber/runtimes/base.py

@@ -0,0 +1,113 @@
+import json
+import shutil
+import subprocess
+from pathlib import Path
+from typing import Any, Dict, Iterable, List
+
+from jinja2 import Environment, FileSystemLoader
+
+
+class RuntimeAdapter:
+    name: str
+    default_entrypoint: str
+    template_root: Path
+    managed_files: tuple[Path, ...] = ()
+
+    def scaffold(self, project_dir: Path, context: Dict[str, Any]) -> None:
+        project_dir.mkdir(parents=True)
+        for directory in self.required_directories():
+            (project_dir / directory).mkdir(parents=True, exist_ok=True)
+        self.render_templates(project_dir, context)
+
+    def required_directories(self) -> Iterable[Path]:
+        return (
+            Path("src"),
+            Path(".kyber"),
+            Path("tests"),
+            Path("tests") / "fixtures",
+        )
+
+    def required_files(self) -> Iterable[Path]:
+        return ()
+
+    def local_test_command(self, project_root: Path, include_circuit_tests: bool = False) -> List[str]:
+        return []
+
+    def required_executables(self) -> tuple[str, ...]:
+        return ()
+
+    def missing_executables(self) -> List[str]:
+        return [
+            executable
+            for executable in self.required_executables()
+            if shutil.which(executable) is None
+        ]
+
+    def dependency_errors(self) -> List[str]:
+        return [
+            f"runtime.{self.name}: Required executable not found on PATH: {executable}. "
+            f"Install {self.name} and reopen your terminal, or add {executable} to PATH."
+            for executable in self.missing_executables()
+        ]
+
+    def validate_handler(self, handler_path: Path) -> tuple[bool, str]:
+        return True, ""
+
+    def validate_artifact_contract(
+        self,
+        handler_path: Path,
+        expected_agent_name: str = None,
+        expected_runtime: str = None,
+    ) -> List[str]:
+        return []
+
+    def validate_source_contract(
+        self, project_root: Path, config: Dict[str, Any]
+    ) -> List[str]:
+        return []
+
+    def discover_artifact_types(self, handler_path: Path) -> List[str]:
+        return []
+
+    def run_handler(self, wrapper_path: Path, handler_path: Path, event_payload: Any) -> Any:
+        raise NotImplementedError
+
+    def render_templates(self, project_dir: Path, context: Dict[str, Any]) -> None:
+        env = Environment(loader=FileSystemLoader(self.template_root))
+        for relative_template, relative_output in self.template_outputs():
+            output_path = project_dir / relative_output
+            output_path.parent.mkdir(parents=True, exist_ok=True)
+            rendered = env.get_template(relative_template.as_posix()).render(**context)
+            output_path.write_text(rendered, encoding="utf-8")
+
+    def template_outputs(self):
+        for template_path in self.template_root.rglob("*.j2"):
+            relative_template = template_path.relative_to(self.template_root)
+            yield relative_template, Path(str(relative_template)[:-3])
+
+    def run_json_subprocess(self, command: List[str], event_payload: Any, cwd: Path) -> Any:
+        missing = self.missing_executables()
+        if missing:
+            executable = missing[0]
+            raise RuntimeError(
+                f"Required executable not found on PATH: {executable}. "
+                f"Install {self.name} and reopen your terminal, or add {executable} to PATH."
+            )
+
+        result = subprocess.run(
+            command,
+            input=json.dumps(event_payload),
+            cwd=cwd,
+            capture_output=True,
+            text=True,
+        )
+        if result.returncode != 0:
+            message = result.stderr.strip() or result.stdout.strip()
+            raise RuntimeError(message or f"{self.name} handler exited with code {result.returncode}")
+        try:
+            return json.loads(result.stdout)
+        except json.JSONDecodeError as exc:
+            raise RuntimeError(f"{self.name} handler did not return valid JSON: {exc}") from exc
+
+    def executable(self, name: str) -> str:
+        return shutil.which(name) or name

kyber_cli-4.0.2/kyber/runtimes/go/__init__.py

@@ -0,0 +1,4 @@
+from kyber.runtimes.go.adapter import GoRuntimeAdapter
+
+
+__all__ = ["GoRuntimeAdapter"]

kyber_cli-4.0.2/kyber/runtimes/go/adapter.py

@@ -0,0 +1,34 @@
+from pathlib import Path
+from typing import Any, List
+
+from kyber.runtimes.base import RuntimeAdapter
+
+
+class GoRuntimeAdapter(RuntimeAdapter):
+    name = "go"
+    default_entrypoint = "src/handler.go"
+    template_root = Path(__file__).resolve().parent / "templates"
+    managed_files = (Path(".kyber") / "runtime_wrapper.go",)
+
+    def required_files(self):
+        return (
+            Path("kyber.circuit.json"),
+            Path("go.mod"),
+            Path("src") / "handler.go",
+            Path("tests") / "handler_test.go",
+            Path("tests") / "fixtures" / "sample_event.json",
+            *self.managed_files,
+        )
+
+    def local_test_command(self, project_root: Path, include_circuit_tests: bool = False) -> List[str]:
+        return [self.executable("go"), "test", "./..."]
+
+    def required_executables(self):
+        return ("go",)
+
+    def run_handler(self, wrapper_path: Path, handler_path: Path, event_payload: Any) -> Any:
+        return self.run_json_subprocess(
+            [self.executable("go"), "run", str(wrapper_path), "--", str(handler_path)],
+            event_payload,
+            wrapper_path.parent.parent,
+        )

kyber_cli-4.0.2/kyber/runtimes/node/__init__.py

@@ -0,0 +1,4 @@
+from kyber.runtimes.node.adapter import NodeRuntimeAdapter
+
+
+__all__ = ["NodeRuntimeAdapter"]

kyber_cli-4.0.2/kyber/runtimes/node/adapter.py

@@ -0,0 +1,34 @@
+from pathlib import Path
+from typing import Any, List
+
+from kyber.runtimes.base import RuntimeAdapter
+
+
+class NodeRuntimeAdapter(RuntimeAdapter):
+    name = "node"
+    default_entrypoint = "src/handler.js"
+    template_root = Path(__file__).resolve().parent / "templates"
+    managed_files = (Path(".kyber") / "runtime_wrapper.js",)
+
+    def required_files(self):
+        return (
+            Path("kyber.circuit.json"),
+            Path("package.json"),
+            Path("tests") / "handler.test.js",
+            Path("tests") / "circuit.test.js",
+            Path("tests") / "fixtures" / "sample_event.json",
+            *self.managed_files,
+        )
+
+    def local_test_command(self, project_root: Path, include_circuit_tests: bool = False) -> List[str]:
+        return [self.executable("npm"), "test"]
+
+    def required_executables(self):
+        return ("node", "npm")
+
+    def run_handler(self, wrapper_path: Path, handler_path: Path, event_payload: Any) -> Any:
+        return self.run_json_subprocess(
+            [self.executable("node"), str(wrapper_path), str(handler_path)],
+            event_payload,
+            wrapper_path.parent.parent,
+        )

kyber_cli-4.0.2/kyber/runtimes/python/__init__.py

@@ -0,0 +1,4 @@
+from kyber.runtimes.python.adapter import PythonRuntimeAdapter
+
+
+__all__ = ["PythonRuntimeAdapter"]

kyber_cli-4.0.2/kyber/runtimes/python/adapter.py

@@ -0,0 +1,150 @@
+import ast
+import os
+from pathlib import Path
+from typing import Any, List
+
+from kyber.core.artifact_schema import (
+    discover_python_handler_artifact_types,
+    validate_python_handler_artifact_contract,
+)
+from kyber.core.egress_validation import validate_python_egress
+from kyber.llm import install_llm_instrumentation, invoke_instrumented
+from kyber.runtimes.base import RuntimeAdapter
+
+
+class PythonRuntimeAdapter(RuntimeAdapter):
+    name = "python"
+    default_entrypoint = "src/handler.py"
+    template_root = Path(__file__).resolve().parents[2] / "templates" / "python_agent"
+    managed_files = (
+        Path(".kyber") / "runtime_wrapper.py",
+        Path(".kyber") / "direct_run_guard.py",
+    )
+
+    def required_files(self):
+        return (
+            Path("kyber.circuit.json"),
+            Path("requirements.txt"),
+            Path("pytest.ini"),
+            Path("tests") / "conftest.py",
+            Path("tests") / "test_handler.py",
+            Path("tests") / "test_circuit.py",
+            Path("tests") / "test_guardrails.py",
+            Path("tests") / "fixtures" / "sample_event.json",
+            *self.managed_files,
+        )
+
+    def template_outputs(self):
+        return (
+            (Path("kyber.circuit.json.j2"), Path("kyber.circuit.json")),
+            (Path("src") / "handler.py.j2", Path("src") / "handler.py"),
+            (Path("runtime_wrapper.py.j2"), Path(".kyber") / "runtime_wrapper.py"),
+            (Path("direct_run_guard.py.j2"), Path(".kyber") / "direct_run_guard.py"),
+            (Path("requirements.txt.j2"), Path("requirements.txt")),
+            (Path("pytest.ini.j2"), Path("pytest.ini")),
+            (Path("tests") / "__init__.py.j2", Path("tests") / "__init__.py"),
+            (Path("tests") / "conftest.py.j2", Path("tests") / "conftest.py"),
+            (Path("tests") / "test_handler.py.j2", Path("tests") / "test_handler.py"),
+            (Path("tests") / "test_circuit.py.j2", Path("tests") / "test_circuit.py"),
+            (Path("tests") / "test_guardrails.py.j2", Path("tests") / "test_guardrails.py"),
+            (
+                Path("tests") / "fixtures" / "sample_event.json.j2",
+                Path("tests") / "fixtures" / "sample_event.json",
+            ),
+            (Path("tests") / "README.md.j2", Path("tests") / "README.md"),
+        )
+
+    def local_test_command(self, project_root: Path, include_circuit_tests: bool = False) -> List[str]:
+        import sys
+
+        command = [sys.executable, "-m", "pytest", "-q", "tests"]
+        circuit_test = project_root / "tests" / "test_circuit.py"
+        if circuit_test.exists() and not include_circuit_tests:
+            command.extend(["--ignore", str(circuit_test.relative_to(project_root))])
+        return command
+
+    def validate_handler(self, handler_path: Path) -> tuple[bool, str]:
+        try:
+            tree = ast.parse(handler_path.read_text(encoding="utf-8"), filename=str(handler_path))
+        except SyntaxError as exc:
+            return False, f"Handler has invalid Python syntax: {exc}"
+        except Exception as exc:
+            return False, f"Unable to read handler: {exc}"
+
+        for node in ast.iter_child_nodes(tree):
+            if isinstance(node, ast.If) and _is_main_check(node.test):
+                if _delegates_to_direct_run_guard(node):
+                    return True, ""
+                return False, "Direct handler execution must delegate to .kyber/direct_run_guard.py"
+
+        return (
+            False,
+            "Handler must reject direct execution with an 'if __name__ == \"__main__\"' guard",
+        )
+
+    def validate_artifact_contract(
+        self,
+        handler_path: Path,
+        expected_agent_name: str = None,
+        expected_runtime: str = None,
+    ):
+        _, errors = validate_python_handler_artifact_contract(
+            handler_path,
+            expected_agent_name=expected_agent_name,
+            expected_runtime=expected_runtime,
+        )
+        return errors
+
+    def discover_artifact_types(self, handler_path: Path) -> List[str]:
+        return discover_python_handler_artifact_types(handler_path)
+
+    def validate_source_contract(self, project_root: Path, config: dict) -> List[str]:
+        return validate_python_egress(project_root, config)
+
+    def run_handler(self, wrapper_path: Path, handler_path: Path, event_payload: Any) -> Any:
+        original_cwd = os.getcwd()
+        try:
+            os.chdir(wrapper_path.parent.parent)
+            namespace = {
+                "__file__": str(wrapper_path),
+                "__name__": "_kyber_runtime_wrapper",
+            }
+            exec(wrapper_path.read_text(encoding="utf-8"), namespace)
+
+            if "run_handler" not in namespace:
+                raise RuntimeError(f"Runtime wrapper is missing 'run_handler': {wrapper_path}")
+
+            # Keep instrumentation in the installed CLI so existing managed
+            # wrappers do not need to be rewritten or re-hashed.
+            install_llm_instrumentation()
+            return invoke_instrumented(
+                lambda payload: namespace["run_handler"](handler_path, payload),
+                event_payload,
+            )
+        finally:
+            os.chdir(original_cwd)
+
+
+def _is_main_check(node: ast.AST) -> bool:
+    if not isinstance(node, ast.Compare):
+        return False
+
+    left_is_name = isinstance(node.left, ast.Name) and node.left.id == "__name__"
+    if not left_is_name or len(node.ops) != 1 or not isinstance(node.ops[0], ast.Eq):
+        return False
+
+    return any(
+        isinstance(comparator, ast.Constant) and comparator.value == "__main__"
+        for comparator in node.comparators
+    )
+
+
+def _delegates_to_direct_run_guard(node: ast.AST) -> bool:
+    has_run_path = False
+    has_guard_path = False
+    for child in ast.walk(node):
+        if isinstance(child, ast.Attribute) and child.attr == "run_path":
+            has_run_path = True
+        if isinstance(child, ast.Constant) and child.value == "direct_run_guard.py":
+            has_guard_path = True
+    return has_run_path and has_guard_path

kyber_cli-4.0.2/kyber/tests/test_distribution.py

@@ -0,0 +1,27 @@
+import zipfile
+from pathlib import Path
+
+from setuptools import build_meta
+
+
+PROJECT_ROOT = Path(__file__).resolve().parents[2]
+
+
+def test_wheel_contains_runtime_adapters_and_templates(tmp_path, monkeypatch):
+    """Guard against package globs accidentally excluding ``kyber.runtimes``."""
+    monkeypatch.chdir(PROJECT_ROOT)
+
+    wheel_name = build_meta.build_wheel(str(tmp_path))
+
+    with zipfile.ZipFile(tmp_path / wheel_name) as wheel:
+        packaged_files = set(wheel.namelist())
+
+    assert {
+        "kyber/runtimes/__init__.py",
+        "kyber/runtimes/base.py",
+        "kyber/runtimes/python/adapter.py",
+        "kyber/runtimes/node/adapter.py",
+        "kyber/runtimes/go/adapter.py",
+        "kyber/runtimes/node/templates/package.json.j2",
+        "kyber/runtimes/go/templates/go.mod.j2",
+    } <= packaged_files

{kyber_cli-4.0.0 → kyber_cli-4.0.2}/kyber/tests/test_tool_gateway_commands.py

@@ -26,6 +26,7 @@ SUMMARY = ToolSummary(
 )
 
 DETAIL = ToolDetail(
+    id="11111111-1111-4111-8111-111111111111",
     **SUMMARY.model_dump(),
     supported_operations=["current", "forecast"],
     input_schema={

{kyber_cli-4.0.0 → kyber_cli-4.0.2}/kyber/tool_gateway/dto.py

@@ -21,6 +21,7 @@ class ToolSummary(ToolGatewayModel):
 
 
 class ToolDetail(ToolSummary):
+    id: UUID
     supported_operations: List[str]
     input_schema: Dict[str, Any]
     output_schema: Dict[str, Any]

{kyber_cli-4.0.0 → kyber_cli-4.0.2}/kyber_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kyber-cli
-Version: 4.0.0
+Version: 4.0.2
 Summary: Kyber Developer Experience CLI — deploy agents in one command
 Author-email: Symplii <hello@symplii.ai>
 License: Apache-2.0

{kyber_cli-4.0.0 → kyber_cli-4.0.2}/kyber_cli.egg-info/SOURCES.txt

@@ -102,12 +102,18 @@ kyber/deployment/services/__init__.py
 kyber/deployment/services/candidate.py
 kyber/deployment/services/deployment.py
 kyber/deployment/services/poller.py
+kyber/runtimes/__init__.py
+kyber/runtimes/base.py
+kyber/runtimes/go/__init__.py
+kyber/runtimes/go/adapter.py
 kyber/runtimes/go/templates/go.mod.j2
 kyber/runtimes/go/templates/kyber.circuit.json.j2
 kyber/runtimes/go/templates/.kyber/runtime_wrapper.go.j2
 kyber/runtimes/go/templates/src/handler.go.j2
 kyber/runtimes/go/templates/tests/handler_test.go.j2
 kyber/runtimes/go/templates/tests/fixtures/sample_event.json.j2
+kyber/runtimes/node/__init__.py
+kyber/runtimes/node/adapter.py
 kyber/runtimes/node/templates/kyber.circuit.json.j2
 kyber/runtimes/node/templates/package.json.j2
 kyber/runtimes/node/templates/.kyber/runtime_wrapper.js.j2
@@ -115,6 +121,8 @@ kyber/runtimes/node/templates/src/handler.js.j2
 kyber/runtimes/node/templates/tests/circuit.test.js.j2
 kyber/runtimes/node/templates/tests/handler.test.js.j2
 kyber/runtimes/node/templates/tests/fixtures/sample_event.json.j2
+kyber/runtimes/python/__init__.py
+kyber/runtimes/python/adapter.py
 kyber/templates/__init__.py
 kyber/templates/python_agent/direct_run_guard.py.j2
 kyber/templates/python_agent/kyber.agent.yaml.j2
@@ -142,6 +150,7 @@ kyber/tests/test_defaults_versioning.py
 kyber/tests/test_deploy_manifest.py
 kyber/tests/test_deploy_progress.py
 kyber/tests/test_deployment_workflow.py
+kyber/tests/test_distribution.py
 kyber/tests/test_egress_validation.py
 kyber/tests/test_expanded_config_tier_permissions.py
 kyber/tests/test_expanded_validation.py

{kyber_cli-4.0.0 → kyber_cli-4.0.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "kyber-cli"
-version = "4.0.0"
+version = "4.0.2"
 description = "Kyber Developer Experience CLI — deploy agents in one command"
 readme = "README.md"
 requires-python = ">=3.9"
@@ -48,7 +48,12 @@ kyber = "kyber.cli:cli"
 [tool.setuptools.packages.find]
 where = ["."]
 include = ["kyber*"]
-exclude = ["kyber.memory*", "kyber.tools*", "kyber.runtime*"]
+exclude = [
+  "kyber.memory*",
+  "kyber.tools*",
+  "kyber.runtime",
+  "kyber.runtime.*",
+]
 
 [tool.setuptools.package-data]
 kyber = [