@oneciel-ai/ciel-runtime 0.1.1 → 0.2.0

package/ciel_runtime_support/synthetic_tool_policy.py

@@ -0,0 +1,105 @@
+"""Policies and controller for locally synthesized Claude Code tool uses."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Callable
+
+
+@dataclass(frozen=True, slots=True)
+class SyntheticTasklistPorts:
+    provider_enabled: Callable[[str], bool]
+    content_to_text: Callable[[Any], str]
+    should_continue: Callable[..., bool]
+    now_ms: Callable[[], int]
+    log: Callable[[str, str], None]
+
+
+@dataclass(frozen=True, slots=True)
+class SyntheticTasklistPolicy:
+    ports: SyntheticTasklistPorts
+
+    def append(
+        self,
+        message: dict[str, Any],
+        model: str,
+        source_body: dict[str, Any],
+        reason: str,
+        provider: str = "",
+    ) -> dict[str, Any]:
+        if not self.ports.provider_enabled(provider):
+            return message
+        content = message.get("content")
+        if not isinstance(content, list):
+            content = [{"type": "text", "text": self.ports.content_to_text(content)}] if content else []
+        tool_calls = [block for block in content if isinstance(block, dict) and block.get("type") == "tool_use"]
+        if not self.ports.should_continue(source_body, self.ports.content_to_text(content), tool_calls):
+            return message
+        projected = dict(message)
+        projected["content"] = [
+            *content,
+            {
+                "type": "tool_use",
+                "id": f"toolu_ciel_runtime_TaskList_{reason}_{self.ports.now_ms()}",
+                "name": "TaskList",
+                "input": {},
+            },
+        ]
+        projected["stop_reason"] = "tool_use"
+        projected.setdefault("model", model or message.get("model") or "ciel-runtime-router")
+        self.ports.log("WARN", f"auto-synthesized TaskList after clarification question ({reason})")
+        return projected
+
+
+@dataclass(frozen=True, slots=True)
+class ForcedPlanModePorts:
+    forced_choice_name: Callable[[dict[str, Any]], str]
+    should_defer: Callable[..., bool]
+    tool_names: Callable[[dict[str, Any]], set[str]]
+    plan_mode_active: Callable[[dict[str, Any]], bool]
+    synthetic_response: Callable[..., dict[str, Any]]
+    write_json: Callable[..., Any]
+    log: Callable[[str, str], None]
+
+
+@dataclass(frozen=True, slots=True)
+class ForcedPlanModeController:
+    ports: ForcedPlanModePorts
+
+    def handle(
+        self,
+        handler: Any,
+        provider: str,
+        provider_config: dict[str, Any],
+        body: dict[str, Any],
+    ) -> bool:
+        if provider == "anthropic":
+            return False
+        name = self.ports.forced_choice_name(body)
+        if name != "EnterPlanMode":
+            return False
+        if self.ports.should_defer(provider, provider_config, body, name):
+            self.ports.log(
+                "INFO",
+                f"deferred forced {name} tool_choice to native Anthropic-compatible upstream because thinking is enabled",
+            )
+            return False
+        available = self.ports.tool_names(body)
+        if available and name not in available:
+            return False
+        if self.ports.plan_mode_active(body):
+            self.ports.log("WARN", f"ignored forced {name} tool_choice because plan mode is already active")
+            return False
+        self.ports.log("INFO", f"synthesized {name} tool_use for {provider} forced tool_choice")
+        self.ports.write_json(
+            handler,
+            self.ports.synthetic_response(str(body.get("model") or ""), name, {}),
+        )
+        return True
+
+
+__all__ = [
+    "ForcedPlanModeController",
+    "ForcedPlanModePorts",
+    "SyntheticTasklistPolicy",
+    "SyntheticTasklistPorts",
+]

package/ciel_runtime_support/terminal_platform_io.py

@@ -0,0 +1,127 @@
+"""Terminal sizing, POSIX PTY sizing, and input-mode reset policy."""
+
+from __future__ import annotations
+
+import os
+import shutil
+import subprocess
+import sys
+from collections.abc import Callable, Mapping
+from dataclasses import dataclass
+from typing import Any
+
+
+TERMINAL_INPUT_MODE_RESET = (
+    "\x1b[?1000l\x1b[?1002l\x1b[?1003l\x1b[?1004l"
+    "\x1b[?1005l\x1b[?1006l\x1b[?1015l"
+)
+
+
+def read_clipboard_text() -> str:
+    if os.name == "nt":
+        commands = [["powershell", "-NoProfile", "-Command", "Get-Clipboard -Raw"]]
+    elif sys.platform == "darwin":
+        commands = [["pbpaste"]]
+    else:
+        commands = [
+            ["xclip", "-selection", "clipboard", "-o"],
+            ["xsel", "--clipboard", "--output"],
+        ]
+    for command in commands:
+        try:
+            process = subprocess.run(
+                command,
+                text=True,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.DEVNULL,
+                timeout=5,
+            )
+            if process.returncode == 0 and process.stdout.strip():
+                return process.stdout.strip()
+        except Exception:
+            continue
+    return ""
+
+
+def terminal_winsize_from_fd(fd: int) -> tuple[int, int]:
+    """Return terminal size as (rows, columns), never 0x0."""
+    try:
+        size = os.get_terminal_size(fd)
+        rows = int(size.lines)
+        columns = int(size.columns)
+    except Exception:
+        rows = 0
+        columns = 0
+    if rows > 0 and columns > 0:
+        return rows, columns
+    fallback = shutil.get_terminal_size((80, 24))
+    rows = int(getattr(fallback, "lines", 0) or 0)
+    columns = int(getattr(fallback, "columns", 0) or 0)
+    if rows <= 0:
+        rows = 24
+    if columns <= 0:
+        columns = 80
+    return rows, columns
+
+
+def apply_pty_winsize(
+    pty_fd: int,
+    rows: int,
+    columns: int,
+    *,
+    platform_name: str | None = None,
+) -> bool:
+    if (platform_name or os.name) != "posix" or rows <= 0 or columns <= 0:
+        return False
+    try:
+        import fcntl
+        import struct
+        import termios
+
+        fcntl.ioctl(
+            pty_fd,
+            termios.TIOCSWINSZ,
+            struct.pack("HHHH", rows, columns, 0, 0),
+        )
+        return True
+    except Exception:
+        return False
+
+
+@dataclass(frozen=True, slots=True)
+class TerminalInputModeResetPolicy:
+    platform_name: str
+    environment: Mapping[str, str]
+    parse_bool: Callable[..., bool]
+    default_stream: Callable[[], Any]
+
+    def enabled(self) -> bool:
+        configured = self.environment.get(
+            "CIEL_RUNTIME_TERMINAL_INPUT_MODE_RESET"
+        )
+        if self.platform_name == "nt" and configured is None:
+            return False
+        return self.parse_bool(configured, True)
+
+    def interval_seconds(self, default: float = 2.0) -> float:
+        raw = self.environment.get(
+            "CIEL_RUNTIME_TERMINAL_INPUT_MODE_RESET_INTERVAL_SECONDS"
+        )
+        if raw is None:
+            return default
+        try:
+            return max(0.25, min(60.0, float(raw)))
+        except Exception:
+            return default
+
+    def write(self, stream: Any | None = None) -> None:
+        if not self.enabled():
+            return
+        target = stream if stream is not None else self.default_stream()
+        try:
+            if hasattr(target, "isatty") and not target.isatty():
+                return
+            target.write(TERMINAL_INPUT_MODE_RESET)
+            target.flush()
+        except Exception:
+            return

package/ciel_runtime_support/timeout_profile.py

@@ -0,0 +1,196 @@
+"""User-selectable timeout profile projection and mutation service."""
+
+from __future__ import annotations
+
+from collections.abc import Callable, Mapping
+from dataclasses import dataclass
+from typing import Any
+
+
+TimeoutPreset = tuple[int, str, str]
+LocalizedText = tuple[str, str]
+
+
+@dataclass(frozen=True, slots=True)
+class TimeoutProfileSettings:
+    default_timeout_ms: int
+    profiles: Mapping[str, TimeoutPreset]
+    localized_profiles: Mapping[str, Mapping[str, LocalizedText]]
+    llm_preset_timeouts: Mapping[str, int]
+
+
+@dataclass(frozen=True, slots=True)
+class TimeoutProfilePorts:
+    positive_int: Callable[[Any], int | None]
+    pad_cells: Callable[[str, int], str]
+    ui_text: Callable[[str, str], str]
+    format_minutes: Callable[[int, str], str]
+
+
+class TimeoutProfileService:
+    def __init__(
+        self,
+        settings: TimeoutProfileSettings,
+        ports: TimeoutProfilePorts,
+    ) -> None:
+        self.settings = settings
+        self.ports = ports
+
+    def llm_preset_timeout(self, preset_id: str) -> int:
+        return self.settings.llm_preset_timeouts.get(
+            preset_id,
+            self.settings.default_timeout_ms,
+        )
+
+    def active_llm_preset_timeout(self, config: dict[str, Any]) -> int | None:
+        preset_id = str(config.get("llm_preset") or "").strip()
+        if not preset_id:
+            return None
+        return self.ports.positive_int(
+            self.settings.llm_preset_timeouts.get(preset_id)
+        )
+
+    def profile_id(self, milliseconds: int | None) -> str | None:
+        if not milliseconds:
+            return None
+        for profile_id, (profile_ms, _label, _description) in self.settings.profiles.items():
+            if milliseconds == profile_ms:
+                return profile_id
+        return None
+
+    def text(self, profile_id: str, language: str) -> LocalizedText:
+        if profile_id == "__custom__":
+            return {
+                "ko": ("사용자 지정", "직접 입력한 timeout 값"),
+                "ja": ("カスタム", "直接入力した timeout 値"),
+                "zh": ("自定义", "手动输入的 timeout 值"),
+            }.get(language, ("Custom", "manually entered timeout value"))
+        fallback = self.settings.profiles[profile_id]
+        return self.settings.localized_profiles.get(language, {}).get(
+            profile_id,
+            (fallback[1], fallback[2]),
+        )
+
+    def status(self, config: dict[str, Any], language: str) -> str:
+        milliseconds = (
+            self.ports.positive_int(config.get("request_timeout_ms"))
+            or self.settings.default_timeout_ms
+        )
+        profile_id = self.profile_id(milliseconds)
+        label = self.text(profile_id or "__custom__", language)[0]
+        idle = self.ports.positive_int(config.get("stream_idle_timeout_ms"))
+        idle_text = f"; idle {idle}ms" if idle and idle != milliseconds else ""
+        return f"{label}; {milliseconds}ms{idle_text}"
+
+    @staticmethod
+    def idle_timeout(milliseconds: int) -> int:
+        return min(milliseconds, 300000)
+
+    def panel_rows(
+        self,
+        config: dict[str, Any],
+        language: str,
+    ) -> tuple[list[str], list[str]]:
+        current_ms = (
+            self.ports.positive_int(config.get("request_timeout_ms"))
+            or self.settings.default_timeout_ms
+        )
+        rows = [
+            f"Current timeout: {current_ms} ms = "
+            f"{self.ports.format_minutes(current_ms, language)}"
+        ]
+        values = ["__info__"]
+        current_profile = self.profile_id(current_ms)
+        for profile_id, (milliseconds, _label, _description) in self.settings.profiles.items():
+            label, description = self.text(profile_id, language)
+            mark = "*" if profile_id == current_profile else " "
+            rows.append(
+                f"{mark} {self.ports.pad_cells(label, 22)} "
+                f"{milliseconds:>7} ms  {description}"
+            )
+            values.append(profile_id)
+        rows.append(self.ports.ui_text("back", language))
+        values.append("back")
+        return rows, values
+
+    def apply(
+        self,
+        config: dict[str, Any],
+        profile_id: str,
+        language: str,
+    ) -> list[str]:
+        if profile_id not in self.settings.profiles:
+            raise SystemExit(f"Unknown timeout preset: {profile_id}")
+        milliseconds, _label, _description = self.settings.profiles[profile_id]
+        idle_ms = self.idle_timeout(milliseconds)
+        config["request_timeout_ms"] = milliseconds
+        config["stream_idle_timeout_ms"] = idle_ms
+        label = self.text(profile_id, language)[0]
+        return [
+            f"Timeout preset: {label}",
+            f"request_timeout_ms: {milliseconds}",
+            f"stream_idle_timeout_ms: {idle_ms}",
+        ]
+
+    def with_llm_preset_timeout(
+        self,
+        tokens: list[str],
+        preset_id: str,
+    ) -> list[str]:
+        filtered = [
+            token
+            for token in tokens
+            if not token.startswith(
+                (
+                    "timeout=",
+                    "timeout_ms=",
+                    "request_timeout=",
+                    "request_timeout_ms=",
+                    "stream_idle_timeout=",
+                    "stream_idle_timeout_ms=",
+                )
+            )
+        ]
+        timeout_ms = self.llm_preset_timeout(preset_id)
+        idle_ms = self.idle_timeout(timeout_ms)
+        filtered.append(f"timeout={timeout_ms}")
+        filtered.append(f"stream_idle_timeout_ms={idle_ms}")
+        return filtered
+
+
+@dataclass(frozen=True, slots=True)
+class TimeoutProfileApi:
+    """Explicit compatibility API with an injected default-language source."""
+
+    service_factory: Callable[[], TimeoutProfileService]
+    default_language: Callable[[], str]
+
+    def _language(self, language: str | None) -> str:
+        return language or self.default_language()
+
+    def llm_preset_timeout_ms(self, preset_id: str) -> int:
+        return self.service_factory().llm_preset_timeout(preset_id)
+
+    def active_llm_preset_timeout_ms(self, pcfg: dict[str, Any]) -> int | None:
+        return self.service_factory().active_llm_preset_timeout(pcfg)
+
+    def timeout_profile_id_for_ms(self, ms: int | None) -> str | None:
+        return self.service_factory().profile_id(ms)
+
+    def timeout_profile_text(self, profile_id: str, lang: str | None = None) -> LocalizedText:
+        return self.service_factory().text(profile_id, self._language(lang))
+
+    def timeout_profile_status(self, pcfg: dict[str, Any], lang: str | None = None) -> str:
+        return self.service_factory().status(pcfg, self._language(lang))
+
+    def timeout_profile_idle_ms(self, request_timeout_ms: int) -> int:
+        return self.service_factory().idle_timeout(request_timeout_ms)
+
+    def timeout_profile_panel_rows(self, pcfg: dict[str, Any], lang: str | None = None) -> tuple[list[str], list[str]]:
+        return self.service_factory().panel_rows(pcfg, self._language(lang))
+
+    def apply_timeout_profile_to_provider(self, pcfg: dict[str, Any], profile_id: str, lang: str | None = None) -> list[str]:
+        return self.service_factory().apply(pcfg, profile_id, self._language(lang))
+
+    def with_preset_timeout_tokens(self, tokens: list[str], preset_id: str) -> list[str]:
+        return self.service_factory().with_llm_preset_timeout(tokens, preset_id)

package/ciel_runtime_support/tool_dialects.py

@@ -0,0 +1,85 @@
+"""Runtime-specific tool-name dialects and their registry."""
+
+from __future__ import annotations
+
+import re
+from collections.abc import Callable, Mapping
+from typing import Any
+
+from .architecture import ToolDialect
+from .registry import AdapterRegistry
+
+
+def mcp_server_normalized_key(name: str) -> tuple[str, str] | None:
+    match = re.fullmatch(r"mcp__(.+)__(.+)", str(name or ""))
+    if not match:
+        return None
+    server, tool = match.groups()
+    return re.sub(r"[-_]", "", server).lower(), tool.lower()
+
+
+def match_available_tool_name(name: str, available: set[str]) -> str | None:
+    if not available:
+        return None
+    if name in available:
+        return name
+    lowered = str(name or "").lower()
+    case_matches = [candidate for candidate in available if candidate.lower() == lowered]
+    if len(case_matches) == 1:
+        return case_matches[0]
+    if not name.startswith("mcp__"):
+        normalized = re.sub(r"[^a-z0-9]+", "", lowered)
+        matches = [
+            candidate
+            for candidate in available
+            if not candidate.startswith("mcp__")
+            and re.sub(r"[^a-z0-9]+", "", candidate.lower()) == normalized
+        ]
+        if len(matches) == 1:
+            return matches[0]
+    requested_mcp = mcp_server_normalized_key(name)
+    if requested_mcp is not None:
+        matches = [candidate for candidate in available if mcp_server_normalized_key(candidate) == requested_mcp]
+        if len(matches) == 1:
+            return matches[0]
+    substring_matches = [
+        candidate for candidate in available if lowered and (lowered in candidate.lower() or candidate.lower() in lowered)
+    ]
+    return sorted(substring_matches)[0] if substring_matches else None
+
+
+class ClaudeToolDialect(ToolDialect):
+    name = "claude"
+
+    def __init__(
+        self,
+        *,
+        available_tools: set[str] | None = None,
+        repair: Callable[[str, dict[str, Any]], Mapping[str, Any]] | None = None,
+        blocked: set[str] | None = None,
+    ) -> None:
+        self._available_tools = available_tools or set()
+        self._repair = repair
+        self._blocked = frozenset(blocked or ())
+
+    def normalize_tool_name(self, name: str) -> str:
+        return match_available_tool_name(name, self._available_tools) or str(name)
+
+    def repair_tool_input(self, tool_name: str, value: Mapping[str, Any]) -> Mapping[str, Any]:
+        payload = dict(value)
+        return self._repair(tool_name, payload) if self._repair else payload
+
+    def blocked_tools(self) -> frozenset[str]:
+        return self._blocked
+
+
+TOOL_DIALECTS: AdapterRegistry[ToolDialect] = AdapterRegistry()
+TOOL_DIALECTS.register("claude", lambda **kwargs: ClaudeToolDialect(**kwargs), aliases=("claude-code",))
+
+
+__all__ = [
+    "TOOL_DIALECTS",
+    "ClaudeToolDialect",
+    "match_available_tool_name",
+    "mcp_server_normalized_key",
+]

package/ciel_runtime_support/tool_exposure_policy.py

@@ -0,0 +1,63 @@
+"""Policy for removing tools that must not be exposed to an upstream provider."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Callable
+
+
+@dataclass(frozen=True, slots=True)
+class ToolExposurePorts:
+    blocked_tools: Callable[[str, dict[str, Any]], set[str]]
+    ultracode_workflow_preferred: Callable[[dict[str, Any]], bool]
+    plan_mode_active: Callable[[dict[str, Any]], bool]
+    log: Callable[[str, str], None]
+
+
+@dataclass(frozen=True, slots=True)
+class ToolExposurePolicy:
+    ports: ToolExposurePorts
+
+    def filter(self, provider: str, provider_config: dict[str, Any], body: dict[str, Any]) -> dict[str, Any]:
+        blocked = set(self.ports.blocked_tools(provider, provider_config))
+        dynamic_blocked: set[str] = set()
+        if provider != "anthropic" and self.ports.ultracode_workflow_preferred(body) and not self.ports.plan_mode_active(body):
+            dynamic_blocked.add("EnterPlanMode")
+        blocked.update(dynamic_blocked)
+        if not blocked:
+            return body
+        tools = body.get("tools")
+        tool_choice = body.get("tool_choice") if isinstance(body.get("tool_choice"), dict) else None
+        tool_choice_name = tool_choice.get("name") if tool_choice else None
+        drop_choice = isinstance(tool_choice_name, str) and tool_choice_name in blocked
+        if not isinstance(tools, list) or not tools:
+            return self._without_blocked_choice(body, provider, tool_choice_name) if drop_choice else body
+        kept: list[Any] = []
+        dropped: list[str] = []
+        for tool in tools:
+            name = tool.get("name") if isinstance(tool, dict) else None
+            if isinstance(name, str) and name in blocked:
+                dropped.append(name)
+            else:
+                kept.append(tool)
+        if not dropped:
+            return self._without_blocked_choice(body, provider, tool_choice_name) if drop_choice else body
+        reason = " ultracode_workflow_preferred=true" if dynamic_blocked.intersection(dropped) else ""
+        self.ports.log("INFO", f"filtered upstream tools for {provider}: {', '.join(sorted(set(dropped)))}{reason}")
+        filtered = dict(body)
+        filtered["tools"] = kept
+        if drop_choice:
+            filtered.pop("tool_choice", None)
+            self._log_removed_choice(provider, tool_choice_name)
+        return filtered
+
+    def _without_blocked_choice(self, body: dict[str, Any], provider: str, tool_choice_name: Any) -> dict[str, Any]:
+        filtered = dict(body)
+        filtered.pop("tool_choice", None)
+        self._log_removed_choice(provider, tool_choice_name)
+        return filtered
+
+    def _log_removed_choice(self, provider: str, tool_choice_name: Any) -> None:
+        self.ports.log("WARN", f"removed blocked tool_choice for {provider}: {tool_choice_name}")
+
+
+__all__ = ["ToolExposurePolicy", "ToolExposurePorts"]