@oneciel-ai/ciel-runtime 0.1.0 → 0.1.1

package/ciel_runtime_support/agent_router.py

@@ -0,0 +1,97 @@
+"""HTTP runtime router contracts for ciel-runtime.
+
+Runtime routers own request paths and feature parity for a local coding
+runtime.  They stay dependency-light and receive concrete transport callbacks
+from the portable entrypoint.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Protocol
+
+
+@dataclass(frozen=True)
+class RouterCapability:
+    """One externally visible router behavior."""
+
+    name: str
+    description: str
+
+
+COMMON_RUNTIME_ROUTER_CAPABILITIES: tuple[str, ...] = (
+    "auth_forwarding",
+    "sse_stream_proxy",
+    "channel_context_injection",
+    "pending_delivery_ack",
+    "request_observability",
+    "upstream_error_mapping",
+)
+
+
+class RuntimeRouter(Protocol):
+    """Dispatch contract for one runtime's HTTP routes."""
+
+    name: str
+    runtime: str
+    protocol: str
+    request_paths: tuple[str, ...]
+    capabilities: tuple[RouterCapability, ...]
+
+    def can_handle_get(self, path: str, provider: str, pcfg: dict[str, Any]) -> bool:
+        """Return whether this router owns a GET path."""
+
+    def handle_get(self, handler: Any, path: str, provider: str, pcfg: dict[str, Any]) -> bool:
+        """Handle a GET request.  Return True when consumed."""
+
+    def can_handle_post(self, path: str, provider: str, pcfg: dict[str, Any]) -> bool:
+        """Return whether this router owns a POST path."""
+
+    def handle_post(
+        self,
+        handler: Any,
+        cfg: dict[str, Any],
+        provider: str,
+        pcfg: dict[str, Any],
+        path: str,
+        body: dict[str, Any],
+    ) -> bool:
+        """Handle a POST request.  Return True when consumed."""
+
+
+def capability_names(router: RuntimeRouter) -> set[str]:
+    return {capability.name for capability in router.capabilities}
+
+
+def router_capability_matrix(routers: tuple[RuntimeRouter, ...]) -> dict[str, dict[str, Any]]:
+    return {
+        router.name: {
+            "runtime": router.runtime,
+            "protocol": router.protocol,
+            "request_paths": list(router.request_paths),
+            "capabilities": sorted(capability_names(router)),
+        }
+        for router in routers
+    }
+
+
+def missing_common_capabilities(
+    routers: tuple[RuntimeRouter, ...],
+    required: tuple[str, ...] = COMMON_RUNTIME_ROUTER_CAPABILITIES,
+) -> dict[str, list[str]]:
+    required_set = set(required)
+    return {
+        router.name: sorted(required_set - capability_names(router))
+        for router in routers
+        if required_set - capability_names(router)
+    }
+
+
+__all__ = [
+    "COMMON_RUNTIME_ROUTER_CAPABILITIES",
+    "RouterCapability",
+    "RuntimeRouter",
+    "capability_names",
+    "missing_common_capabilities",
+    "router_capability_matrix",
+]

package/ciel_runtime_support/agy_cli.py

@@ -0,0 +1,248 @@
+from __future__ import annotations
+
+
+AGY_COMMAND_NAMES = {
+    "changelog",
+    "help",
+    "install",
+    "models",
+    "plugin",
+    "plugins",
+    "update",
+}
+
+
+AGY_OPTIONS_WITH_VALUE = {
+    "--add-dir",
+    "--conversation",
+    "--log-file",
+    "--model",
+    "--new-project",
+    "--print-timeout",
+    "--project",
+    "--sandbox",
+}
+
+
+AGY_CLAUDE_ONLY_VALUE_FLAGS = {
+    "--allowedTools",
+    "--append-system-prompt",
+    "--disallowedTools",
+    "--fallback-model",
+    "--input-format",
+    "--mcp-config",
+    "--output-format",
+    "--permission-prompt-tool",
+    "--settings",
+    "--system-prompt",
+}
+
+
+def agy_passthrough_first_non_option_arg(passthrough: list[str]) -> str:
+    i = 0
+    while i < len(passthrough):
+        arg = str(passthrough[i])
+        if arg == "--":
+            return str(passthrough[i + 1]) if i + 1 < len(passthrough) else ""
+        if arg.startswith("--") and "=" in arg:
+            i += 1
+            continue
+        if arg in AGY_OPTIONS_WITH_VALUE:
+            i += 2 if i + 1 < len(passthrough) else 1
+            continue
+        if arg.startswith("-") and arg != "-":
+            i += 1
+            continue
+        return arg
+    return ""
+
+
+def agy_passthrough_has_command(passthrough: list[str]) -> bool:
+    return agy_passthrough_first_non_option_arg(passthrough) in AGY_COMMAND_NAMES
+
+
+def _agy_consume_optional_value(passthrough: list[str], index: int) -> tuple[str, int]:
+    if index + 1 < len(passthrough):
+        value = str(passthrough[index + 1])
+        if value != "--" and not value.startswith("-"):
+            return value, index + 2
+    return "", index + 1
+
+
+def _is_channel_spec_tagged(spec: str) -> bool:
+    return spec.startswith("plugin:") or spec.startswith("server:")
+
+
+def _agy_drop_passthrough_channel_args(passthrough: list[str], index: int) -> int:
+    arg = str(passthrough[index])
+    if arg.startswith("--channels=") or arg.startswith("--dangerously-load-development-channels="):
+        return index + 1
+    i = index + 1
+    while i < len(passthrough) and _is_channel_spec_tagged(str(passthrough[i])):
+        i += 1
+    return i
+
+
+def _agy_drop_greedy_passthrough_values(passthrough: list[str], index: int) -> int:
+    i = index + 1
+    while i < len(passthrough) and not str(passthrough[i]).startswith("-"):
+        i += 1
+    return i
+
+
+def agy_passthrough_args_for_launch(passthrough: list[str]) -> tuple[list[str], list[str]]:
+    """Translate shared Claude/Codex-oriented flags before launching AGY.
+
+    AGY exposes a smaller native CLI surface than Claude Code and Codex. Keep
+    intent-preserving mappings and drop flags that AGY does not parse.
+    """
+    out: list[str] = []
+    notes: list[str] = []
+    existing_agy_command = agy_passthrough_has_command(passthrough)
+    mapped_permission_bypass = False
+    i = 0
+    while i < len(passthrough):
+        arg = str(passthrough[i])
+
+        if arg == "resume" and i == 0 and not existing_agy_command:
+            session_id = str(passthrough[i + 1]) if i + 1 < len(passthrough) else ""
+            if session_id and not session_id.startswith("-"):
+                out.extend(["--conversation", session_id])
+                notes.append("resume <conversation> -> --conversation <conversation>")
+                i += 2
+            else:
+                out.append("--continue")
+                notes.append("resume -> --continue")
+                i += 1
+            continue
+
+        if arg in ("--continue", "-c"):
+            out.append(arg)
+            i += 1
+            continue
+        if arg.startswith("--continue="):
+            out.append("--continue")
+            prompt = arg.split("=", 1)[1]
+            if prompt:
+                out.append(prompt)
+            notes.append("--continue=<prompt> -> --continue <prompt>")
+            i += 1
+            continue
+
+        if arg in ("--resume", "-r"):
+            session_id, i = _agy_consume_optional_value(passthrough, i)
+            if session_id:
+                out.extend(["--conversation", session_id])
+                notes.append(f"{arg} <session> -> --conversation <session>")
+            else:
+                out.append("--continue")
+                notes.append(f"{arg} -> --continue")
+            continue
+        if arg.startswith("--resume="):
+            session_id = arg.split("=", 1)[1]
+            if session_id:
+                out.extend(["--conversation", session_id])
+                notes.append("--resume=<session> -> --conversation <session>")
+            else:
+                out.append("--continue")
+                notes.append("--resume= -> --continue")
+            i += 1
+            continue
+
+        if arg == "--session-id":
+            session_id, i = _agy_consume_optional_value(passthrough, i)
+            if session_id:
+                out.extend(["--conversation", session_id])
+                notes.append("--session-id <session> -> --conversation <session>")
+            continue
+        if arg.startswith("--session-id="):
+            session_id = arg.split("=", 1)[1]
+            if session_id:
+                out.extend(["--conversation", session_id])
+                notes.append("--session-id=<session> -> --conversation <session>")
+            i += 1
+            continue
+
+        if arg in ("--print", "-p", "--prompt"):
+            out.append("--print")
+            i += 1
+            continue
+        if arg.startswith(("--print=", "--prompt=")):
+            prompt = arg.split("=", 1)[1]
+            out.append("--print")
+            if prompt:
+                out.append(prompt)
+            notes.append(f"{arg.split('=', 1)[0]}=<prompt> -> --print <prompt>")
+            i += 1
+            continue
+
+        if arg == "exec" and i == 0 and not existing_agy_command:
+            out.append("--print")
+            notes.append("exec -> --print")
+            i += 1
+            continue
+
+        if arg in ("--yolo", "--dangerously-bypass-approvals-and-sandbox"):
+            if not mapped_permission_bypass:
+                out.append("--dangerously-skip-permissions")
+                mapped_permission_bypass = True
+                notes.append(f"{arg} -> --dangerously-skip-permissions")
+            i += 1
+            continue
+
+        if arg == "--dangerously-skip-permissions":
+            if not mapped_permission_bypass:
+                out.append(arg)
+                mapped_permission_bypass = True
+            i += 1
+            continue
+
+        if arg == "--permission-mode" or arg.startswith("--permission-mode="):
+            if arg == "--permission-mode":
+                value, i = _agy_consume_optional_value(passthrough, i)
+            else:
+                value = arg.split("=", 1)[1]
+                i += 1
+            if value == "bypassPermissions" and not mapped_permission_bypass:
+                out.append("--dangerously-skip-permissions")
+                mapped_permission_bypass = True
+                notes.append("--permission-mode bypassPermissions -> --dangerously-skip-permissions")
+            else:
+                notes.append("--permission-mode ignored for AGY")
+            continue
+
+        if arg in ("--channels", "--dangerously-load-development-channels") or arg.startswith(
+            ("--channels=", "--dangerously-load-development-channels=")
+        ):
+            i = _agy_drop_passthrough_channel_args(passthrough, i)
+            notes.append(f"{arg.split('=', 1)[0]} ignored for AGY launch")
+            continue
+
+        if arg in AGY_CLAUDE_ONLY_VALUE_FLAGS:
+            if arg == "--mcp-config":
+                i = _agy_drop_greedy_passthrough_values(passthrough, i)
+            else:
+                _, i = _agy_consume_optional_value(passthrough, i)
+            notes.append(f"{arg} ignored for AGY launch")
+            continue
+        if any(arg.startswith(flag + "=") for flag in AGY_CLAUDE_ONLY_VALUE_FLAGS):
+            notes.append(f"{arg.split('=', 1)[0]} ignored for AGY launch")
+            i += 1
+            continue
+
+        if arg == "--fork-session" or arg.startswith("--fork-session="):
+            if arg == "--fork-session":
+                i += 1
+            else:
+                i += 1
+            notes.append("--fork-session ignored for AGY launch")
+            continue
+
+        out.append(arg)
+        i += 1
+
+    return out, notes
+
+
+def agy_dangerous_launch_args(passthrough: list[str]) -> list[str]:
+    return [] if "--dangerously-skip-permissions" in passthrough else ["--dangerously-skip-permissions"]