@oneciel-ai/ciel-runtime 0.1.1 → 0.2.0

package/ciel_runtime_support/codex_config.py

@@ -0,0 +1,323 @@
+"""Codex configuration discovery and TOML projection policies."""
+
+from __future__ import annotations
+
+import json
+import os
+import re
+from collections.abc import Callable
+from pathlib import Path
+from typing import Any
+
+
+def toml_string(value: str) -> str:
+    return json.dumps(str(value))
+
+
+def codex_config_override_keys(passthrough: list[str]) -> set[str]:
+    keys: set[str] = set()
+    index = 0
+    while index < len(passthrough):
+        argument = str(passthrough[index])
+        value = ""
+        if argument in ("-c", "--config") and index + 1 < len(passthrough):
+            value = str(passthrough[index + 1])
+            index += 2
+        elif argument.startswith("--config="):
+            value = argument.split("=", 1)[1]
+            index += 1
+        else:
+            index += 1
+            continue
+        if "=" in value:
+            keys.add(value.split("=", 1)[0].strip())
+    return keys
+
+
+def toml_scalar_without_comment(raw: str) -> str:
+    in_single = False
+    in_double = False
+    escaped = False
+    out: list[str] = []
+    for character in raw:
+        if escaped:
+            out.append(character)
+            escaped = False
+            continue
+        if character == "\\" and in_double:
+            out.append(character)
+            escaped = True
+            continue
+        if character == '"' and not in_single:
+            in_double = not in_double
+        elif character == "'" and not in_double:
+            in_single = not in_single
+        elif character == "#" and not in_single and not in_double:
+            break
+        out.append(character)
+    return "".join(out).strip()
+
+
+def unquote_toml_string(raw: str) -> str:
+    value = raw.strip()
+    if len(value) >= 2 and value[0] == value[-1] and value[0] in ("'", '"'):
+        return value[1:-1].strip()
+    return value
+
+
+def codex_alternate_screen_value_from_config_text(text: str) -> str | None:
+    table = ""
+    for line in text.splitlines():
+        stripped = toml_scalar_without_comment(line)
+        if not stripped:
+            continue
+        table_match = re.fullmatch(r"\[([A-Za-z0-9_.-]+)\]", stripped)
+        if table_match:
+            table = table_match.group(1).strip()
+            continue
+        match = re.match(r"alternate_screen\s*=\s*(.+)$", stripped) if table == "tui" else None
+        if match is None:
+            match = re.match(r"tui\.alternate_screen\s*=\s*(.+)$", stripped)
+        if match is None:
+            continue
+        value = unquote_toml_string(match.group(1)).casefold()
+        if value in ("false", "0", "off", "no", "disabled", "disable"):
+            return "never"
+        if value in ("true", "1", "on", "yes", "enabled", "enable"):
+            return "always"
+        if value in ("auto", "always", "never"):
+            return None
+        return "auto"
+    return None
+
+
+def codex_config_paths_for_launch(
+    passthrough: list[str],
+    env: dict[str, str] | None = None,
+    cwd: Path | None = None,
+) -> list[Path]:
+    env = env or os.environ
+    configured_home = str(env.get("CODEX_HOME") or "").strip()
+    default_home = Path.home() / ".codex"
+    home = Path(configured_home or default_home).expanduser()
+    paths = [home / "config.toml"]
+    profiles: list[str] = []
+    index = 0
+    while index < len(passthrough):
+        argument = str(passthrough[index])
+        if argument in ("-p", "--profile") and index + 1 < len(passthrough):
+            profiles.append(str(passthrough[index + 1]))
+            index += 2
+            continue
+        if argument.startswith("--profile="):
+            profiles.append(argument.split("=", 1)[1])
+        index += 1
+    for profile in profiles:
+        if re.fullmatch(r"[A-Za-z0-9_-]+", profile or ""):
+            paths.append(home / f"{profile}.config.toml")
+    current = (cwd or Path.cwd()).resolve()
+    for parent in (current, *current.parents):
+        path = parent / ".codex" / "config.toml"
+        # An explicit CODEX_HOME is an isolation boundary.  When cwd happens
+        # to live below the OS home directory, parent discovery must not pull
+        # the default ~/.codex/config.toml back into that isolated config.
+        if configured_home and path.resolve() == (default_home / "config.toml").resolve():
+            continue
+        if path not in paths:
+            paths.append(path)
+    return paths
+
+
+def normalize_codex_mcp_server(
+    raw_name: Any, raw_server: Any
+) -> tuple[str, dict[str, Any]] | None:
+    name = str(raw_name or "").strip()
+    if not name or not isinstance(raw_server, dict):
+        return None
+    url = str(raw_server.get("url") or raw_server.get("endpoint") or "").strip()
+    if not url.startswith(("http://", "https://")):
+        return None
+    explicit_type = raw_server.get("type") is not None or raw_server.get("transport") is not None
+    server_type = str(raw_server.get("type") or raw_server.get("transport") or "http").strip().lower()
+    if server_type in {"streamable-http", "streamable_http"}:
+        server_type = "http"
+    if server_type not in {"http", "sse"}:
+        server_type = "http"
+    out: dict[str, Any] = {"type": server_type, "url": url}
+    if explicit_type:
+        out["_ciel_runtime_explicit_type"] = True
+    for key in (
+        "headers",
+        "env_http_headers",
+        "bearer_token_env_var",
+        "token_env_var",
+        "bearer_token",
+        "token",
+        "streamable_requires_session",
+        "require_session",
+        "mcp_session_required",
+        "mcp_protocol_version",
+        "protocolVersion",
+        "protocol_version",
+        "mcp_timeout_seconds",
+        "timeout",
+    ):
+        value = raw_server.get(key)
+        if value is not None:
+            out[key] = value
+    return name, out
+
+
+def codex_mcp_servers_from_toml_data(data: Any) -> dict[str, dict[str, Any]]:
+    if not isinstance(data, dict) or not isinstance(data.get("mcp_servers"), dict):
+        return {}
+    out: dict[str, dict[str, Any]] = {}
+    for raw_name, raw_server in data["mcp_servers"].items():
+        normalized = normalize_codex_mcp_server(raw_name, raw_server)
+        if normalized is not None:
+            name, server = normalized
+            out[name] = server
+    return out
+
+
+def toml_table_parts(raw: str) -> list[str]:
+    parts: list[str] = []
+    current: list[str] = []
+    quote = ""
+    escaped = False
+    for character in raw:
+        if escaped:
+            current.append(character)
+            escaped = False
+            continue
+        if character == "\\" and quote == '"':
+            current.append(character)
+            escaped = True
+            continue
+        if character in {"'", '"'}:
+            quote = "" if quote == character else character if not quote else quote
+            current.append(character)
+            continue
+        if character == "." and not quote:
+            part = unquote_toml_string("".join(current).strip())
+            if part:
+                parts.append(part)
+            current = []
+            continue
+        current.append(character)
+    part = unquote_toml_string("".join(current).strip())
+    if part:
+        parts.append(part)
+    return parts
+
+
+def parse_simple_toml_value(raw: str) -> Any:
+    value = toml_scalar_without_comment(raw).strip()
+    if not value:
+        return ""
+    if len(value) >= 2 and value[0] == value[-1] and value[0] in {"'", '"'}:
+        return unquote_toml_string(value)
+    low = value.lower()
+    if low in {"true", "false"}:
+        return low == "true"
+    if value.startswith("[") and value.endswith("]"):
+        items: list[str] = []
+        current: list[str] = []
+        quote = ""
+        escaped = False
+        for character in value[1:-1]:
+            if escaped:
+                current.append(character)
+                escaped = False
+                continue
+            if character == "\\" and quote == '"':
+                current.append(character)
+                escaped = True
+                continue
+            if character in {"'", '"'}:
+                quote = "" if quote == character else character if not quote else quote
+                current.append(character)
+                continue
+            if character == "," and not quote:
+                item = unquote_toml_string("".join(current).strip())
+                if item:
+                    items.append(item)
+                current = []
+                continue
+            current.append(character)
+        item = unquote_toml_string("".join(current).strip())
+        if item:
+            items.append(item)
+        return items
+    try:
+        return int(value)
+    except ValueError:
+        return value
+
+
+def fallback_codex_mcp_servers_from_config_text(text: str) -> dict[str, dict[str, Any]]:
+    raw_servers: dict[str, dict[str, Any]] = {}
+    current_name = ""
+    current_subtable = ""
+    for line in text.splitlines():
+        stripped = toml_scalar_without_comment(line)
+        if not stripped:
+            continue
+        table_match = re.fullmatch(r"\[(.+)\]", stripped)
+        if table_match:
+            parts = toml_table_parts(table_match.group(1).strip())
+            current_name = ""
+            current_subtable = ""
+            if len(parts) >= 2 and parts[0] == "mcp_servers":
+                current_name = parts[1]
+                current_subtable = parts[2] if len(parts) >= 3 else ""
+                raw_servers.setdefault(current_name, {})
+            continue
+        if not current_name or "=" not in stripped:
+            continue
+        key, raw_value = stripped.split("=", 1)
+        value = parse_simple_toml_value(raw_value)
+        server = raw_servers.setdefault(current_name, {})
+        if current_subtable:
+            nested = server.setdefault(current_subtable, {})
+            if isinstance(nested, dict):
+                nested[key.strip()] = value
+        else:
+            server[key.strip()] = value
+    return codex_mcp_servers_from_toml_data({"mcp_servers": raw_servers})
+
+
+def codex_mcp_servers_from_config_text(text: str) -> dict[str, dict[str, Any]]:
+    try:
+        import tomllib
+
+        parsed = codex_mcp_servers_from_toml_data(tomllib.loads(text))
+        if parsed:
+            return parsed
+    except (ImportError, TypeError, ValueError):
+        pass
+    return fallback_codex_mcp_servers_from_config_text(text)
+
+
+def discover_codex_mcp_servers(
+    passthrough: list[str] | None = None,
+    env: dict[str, str] | None = None,
+    cwd: Path | None = None,
+    *,
+    log: Callable[[str, str], None],
+) -> dict[str, dict[str, Any]]:
+    servers: dict[str, dict[str, Any]] = {}
+    for path in codex_config_paths_for_launch(passthrough or [], env=env, cwd=cwd):
+        if not path.is_file():
+            continue
+        try:
+            parsed = codex_mcp_servers_from_config_text(path.read_text(encoding="utf-8"))
+        except (OSError, UnicodeError) as exc:
+            log(
+                "WARN",
+                f"codex_mcp_config_read_failed path={path} "
+                f"error={type(exc).__name__}: {exc}",
+            )
+            continue
+        servers.update(parsed)
+    return servers

package/ciel_runtime_support/codex_launch_configuration.py

@@ -0,0 +1,240 @@
+"""Codex launch configuration and routed model catalog orchestration."""
+
+from __future__ import annotations
+
+from collections.abc import Callable, Mapping
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+from ciel_runtime_support.codex_config import (
+    codex_alternate_screen_value_from_config_text,
+    codex_config_override_keys,
+    codex_config_paths_for_launch,
+    toml_string,
+)
+from ciel_runtime_support.codex_model_catalog import CodexModelCatalogSpec
+from ciel_runtime_support.runtime_constants import (
+    CODEX_NATIVE_PROVIDER_ID_ENV,
+    CODEX_ROUTED_PROVIDER_ID,
+    CODEX_RUNTIME_API_KEY_ENV,
+    CODEX_RUNTIME_PROVIDER_ID,
+    CODEX_TUI_ALTERNATE_SCREEN_KEY,
+)
+
+
+@dataclass(frozen=True, slots=True)
+class CodexLaunchConfigurationConstants:
+    runtime_provider_id: str
+    runtime_api_key_env: str
+    native_provider_id_env: str
+    routed_provider_id: str
+    alternate_screen_key: str
+
+
+@dataclass(frozen=True, slots=True)
+class CodexLaunchPolicyPorts:
+    has_option: Callable[..., bool]
+    config_override_keys: Callable[[list[str]], set[str]]
+    config_paths: Callable[..., list[Path]]
+    alternate_screen_value: Callable[[str], str | None]
+    toml_string: Callable[[str], str]
+
+
+def build_default_codex_launch_constants() -> CodexLaunchConfigurationConstants:
+    """Build immutable routed Codex provider configuration constants."""
+    return CodexLaunchConfigurationConstants(
+        runtime_provider_id=CODEX_RUNTIME_PROVIDER_ID,
+        runtime_api_key_env=CODEX_RUNTIME_API_KEY_ENV,
+        native_provider_id_env=CODEX_NATIVE_PROVIDER_ID_ENV,
+        routed_provider_id=CODEX_ROUTED_PROVIDER_ID,
+        alternate_screen_key=CODEX_TUI_ALTERNATE_SCREEN_KEY,
+    )
+
+
+def build_default_codex_launch_policy(
+    has_option: Callable[..., bool],
+) -> CodexLaunchPolicyPorts:
+    """Build the standard Codex config-file and CLI projection policy."""
+    return CodexLaunchPolicyPorts(
+        has_option=has_option,
+        config_override_keys=codex_config_override_keys,
+        config_paths=codex_config_paths_for_launch,
+        alternate_screen_value=codex_alternate_screen_value_from_config_text,
+        toml_string=toml_string,
+    )
+
+
+@dataclass(frozen=True, slots=True)
+class CodexLaunchModelPorts:
+    current_provider: Callable[[dict[str, Any]], tuple[str, dict[str, Any]]]
+    native_enabled: Callable[[str], bool]
+    current_alias: Callable[[dict[str, Any]], str]
+    context_limit: Callable[[str, dict[str, Any]], int | None]
+    context_capacity: Callable[[str, dict[str, Any]], int | None]
+
+
+@dataclass(frozen=True, slots=True)
+class CodexLaunchCatalogPorts:
+    write: Callable[[str, CodexModelCatalogSpec, dict[str, str]], Path | None]
+    provider_label: Callable[[str], str]
+    path_value: Callable[[dict[str, str]], str]
+    current_model_args: Callable[..., list[str]]
+    native_routed_args: Callable[..., list[str]]
+
+
+@dataclass(frozen=True, slots=True)
+class CodexLaunchConfigurationEffects:
+    environ: Callable[[], Mapping[str, str]]
+    router_base: Callable[[], str]
+    read_text: Callable[[Path], str]
+    log: Callable[[str, str], None]
+    output: Callable[[str], None]
+
+
+@dataclass(frozen=True, slots=True)
+class CodexLaunchConfigurationService:
+    constants: CodexLaunchConfigurationConstants
+    policy: CodexLaunchPolicyPorts
+    model: CodexLaunchModelPorts
+    catalog: CodexLaunchCatalogPorts
+    effects: CodexLaunchConfigurationEffects
+
+    def alternate_screen_compat_args(
+        self,
+        passthrough: list[str],
+        env: dict[str, str] | None = None,
+        cwd: Path | None = None,
+    ) -> list[str]:
+        key = self.constants.alternate_screen_key
+        if self.policy.has_option(passthrough, "--no-alt-screen"):
+            return []
+        if key in self.policy.config_override_keys(passthrough):
+            return []
+        for path in self.policy.config_paths(passthrough, env=env, cwd=cwd):
+            try:
+                text = self.effects.read_text(path)
+            except Exception:
+                continue
+            value = self.policy.alternate_screen_value(text)
+            if value:
+                self.effects.log(
+                    "WARN",
+                    f"codex_compat_alternate_screen_override path={path} value={value}",
+                )
+                self.effects.output(
+                    "Ciel Runtime warning: applying Codex config compatibility "
+                    f'override {key}="{value}".'
+                )
+                return ["-c", f"{key}={self.policy.toml_string(value)}"]
+        return []
+
+    def runtime_config_args(self, router_base: str | None = None) -> list[str]:
+        provider = self.constants.runtime_provider_id
+        configured_base = (
+            self.effects.router_base() if router_base is None else router_base
+        )
+        base = configured_base.rstrip("/") + "/v1"
+        toml = self.policy.toml_string
+        return [
+            "-c",
+            f"model_provider={toml(provider)}",
+            "-c",
+            f"model_providers.{provider}.name={toml('Ciel Runtime')}",
+            "-c",
+            f"model_providers.{provider}.base_url={toml(base)}",
+            "-c",
+            f"model_providers.{provider}.wire_api={toml('responses')}",
+            "-c",
+            f"model_providers.{provider}.env_key={toml(self.constants.runtime_api_key_env)}",
+            "-c",
+            f"model_providers.{provider}.request_max_retries=0",
+            "-c",
+            f"model_providers.{provider}.stream_max_retries=0",
+        ]
+
+    def write_runtime_model_catalog(
+        self, codex: str, cfg: dict[str, Any]
+    ) -> Path | None:
+        provider, provider_config = self.model.current_provider(cfg)
+        if self.model.native_enabled(provider):
+            return None
+        alias = self.model.current_alias(cfg)
+        if not alias:
+            return None
+        context_window = (
+            self.model.context_limit(provider, provider_config)
+            or self.model.context_capacity(provider, provider_config)
+            or 272000
+        )
+        catalog_env = dict(self.effects.environ())
+        catalog_env["PATH"] = self.catalog.path_value(catalog_env)
+        configured_auto_compact = provider_config.get(
+            "codex_auto_compact_window"
+        )
+        try:
+            auto_compact_token_limit = int(configured_auto_compact)
+        except (TypeError, ValueError):
+            auto_compact_token_limit = None
+        if auto_compact_token_limit is not None and auto_compact_token_limit <= 0:
+            auto_compact_token_limit = None
+        return self.catalog.write(
+            codex,
+            CodexModelCatalogSpec(
+                alias=alias,
+                provider_label=self.catalog.provider_label(provider),
+                context_window=context_window,
+                effort=str(provider_config.get("effort_level") or "").strip().lower(),
+                auto_compact_token_limit=auto_compact_token_limit,
+            ),
+            catalog_env,
+        )
+
+    def runtime_model_catalog_args(
+        self, codex: str, cfg: dict[str, Any]
+    ) -> list[str]:
+        path = self.write_runtime_model_catalog(codex, cfg)
+        if path is None:
+            return []
+        value = self.policy.toml_string(str(path.resolve()))
+        return ["-c", f"model_catalog_json={value}"]
+
+    def native_routed_config_args(
+        self, router_base: str | None = None
+    ) -> list[str]:
+        env = self.effects.environ()
+        provider = str(env.get(self.constants.native_provider_id_env) or "").strip()
+        provider = provider or self.constants.routed_provider_id
+        configured_base = (
+            self.effects.router_base() if router_base is None else router_base
+        )
+        return self.catalog.native_routed_args(
+            configured_base,
+            provider,
+            toml_string=self.policy.toml_string,
+        )
+
+    def passthrough_has_model_override(self, passthrough: list[str]) -> bool:
+        return self.policy.has_option(
+            passthrough, "-m", "--model"
+        ) or "model" in self.policy.config_override_keys(passthrough)
+
+    def current_model_cli_args(
+        self, provider_config: dict[str, Any], passthrough: list[str]
+    ) -> list[str]:
+        return self.catalog.current_model_args(
+            provider_config,
+            passthrough,
+            overridden=self.passthrough_has_model_override,
+        )
+
+    def current_model_config_args(
+        self, provider_config: dict[str, Any], passthrough: list[str]
+    ) -> list[str]:
+        return self.catalog.current_model_args(
+            provider_config,
+            passthrough,
+            overridden=self.passthrough_has_model_override,
+            config_style=True,
+            toml_string=self.policy.toml_string,
+        )

package/ciel_runtime_support/codex_launch_policy.py

@@ -0,0 +1,66 @@
+"""Pure Codex command-line launch argument policies."""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from typing import Any
+
+
+def native_routed_config_args(
+    router_base: str,
+    provider: str,
+    *,
+    toml_string: Callable[[str], str],
+) -> list[str]:
+    base = router_base.rstrip("/") + "/backend-api/codex"
+    if provider == "openai":
+        return ["-c", 'model_provider="openai"', "-c", f"openai_base_url={toml_string(base)}"]
+    return [
+        "-c",
+        f"model_provider={toml_string(provider)}",
+        "-c",
+        f"model_providers.{provider}.name={toml_string('Ciel Runtime Codex')}",
+        "-c",
+        f"model_providers.{provider}.base_url={toml_string(base)}",
+        "-c",
+        f"model_providers.{provider}.wire_api={toml_string('responses')}",
+        "-c",
+        f"model_providers.{provider}.requires_openai_auth=true",
+        "-c",
+        f"model_providers.{provider}.supports_websockets=false",
+    ]
+
+
+def passthrough_has_model_override(
+    passthrough: list[str],
+    *,
+    has_option: Callable[..., bool],
+    config_override_keys: Callable[[list[str]], set[str]],
+) -> bool:
+    return has_option(passthrough, "-m", "--model") or "model" in config_override_keys(
+        passthrough
+    )
+
+
+def current_model_args(
+    config: dict[str, Any],
+    passthrough: list[str],
+    *,
+    overridden: Callable[[list[str]], bool],
+    config_style: bool = False,
+    toml_string: Callable[[str], str] = repr,
+) -> list[str]:
+    model = str(config.get("current_model") or "").strip()
+    if not model or overridden(passthrough):
+        return []
+    return ["-c", f"model={toml_string(model)}"] if config_style else ["-m", model]
+
+
+def help_requested(passthrough: list[str]) -> bool:
+    return any(argument in ("help", "--help", "-h") for argument in passthrough)
+
+
+def yolo_launch_args(
+    passthrough: list[str], *, has_option: Callable[..., bool]
+) -> list[str]:
+    return [] if has_option(passthrough, "--yolo") else ["--yolo"]