@oneciel-ai/ciel-runtime 0.2.2 → 0.2.4

package/ciel_runtime_support/prelaunch_shell_context.py

@@ -0,0 +1,394 @@
+"""Prelaunch terminal shell and provider launch-preference bounded context."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Callable, Mapping
+
+from .architecture import ProviderAdapter, ProviderConfig, ProviderUiPolicy
+from .prelaunch_terminal import (
+    PrelaunchInputStyle,
+    PrelaunchRenderServices,
+    TerminalSelectionServices,
+)
+
+
+@dataclass(frozen=True, slots=True)
+class PrelaunchVisualPorts:
+    ansi: Callable[[str, str], str]
+    fit_cells: Callable[[Any, int], str]
+    stdout_isatty: Callable[[], bool]
+    render_intro: Callable[[int, str, str], list[str]]
+    app_name: str
+    credits: str
+
+
+@dataclass(frozen=True, slots=True)
+class PrelaunchInputPorts:
+    enable_ansi: Callable[[], None]
+    status_lines: Callable[[], list[str]]
+    read_terminal_key: Callable[..., str]
+    write_debug: Callable[[Path, str], None]
+    debug_path: Path
+    run_select: Callable[..., int | None]
+
+
+@dataclass(frozen=True, slots=True)
+class PrelaunchProviderPorts:
+    configured_adapter: Callable[[str, dict[str, Any]], ProviderAdapter]
+    contract_config: Callable[[str, dict[str, Any]], ProviderConfig]
+    labels: Mapping[str, str]
+    supports_runtime: Callable[[str, str], bool]
+    load_config: Callable[[], dict[str, Any]]
+    preferred_action: Callable[
+        [
+            dict[str, Any],
+            str,
+            Callable[[str], bool],
+            Callable[[str], bool],
+            Callable[[str], bool],
+        ],
+        str,
+    ]
+
+
+@dataclass(frozen=True, slots=True)
+class PrelaunchPromptPorts:
+    render_services: PrelaunchRenderServices
+    input_style: PrelaunchInputStyle
+    render_screen: Callable[..., bool]
+    read_value_raw: Callable[..., str | None]
+    read_value: Callable[..., str]
+    read_multiline_raw: Callable[..., str | None]
+    read_multiline: Callable[..., str]
+
+
+@dataclass(frozen=True, slots=True)
+class PrelaunchShellContext:
+    visual: PrelaunchVisualPorts
+    input: PrelaunchInputPorts
+    provider: PrelaunchProviderPorts
+    prompt: PrelaunchPromptPorts
+    main_menu_actions: tuple[str, ...]
+
+    def color_line(self, text: str, code: str, width: int) -> str:
+        return self.visual.ansi(self.visual.fit_cells(text, width), code)
+
+    def clean_render_lines(self, lines: list[str], width: int) -> list[str]:
+        return [self.visual.fit_cells(line, width) for line in lines]
+
+    def clear_screen(self) -> None:
+        if self.visual.stdout_isatty():
+            print("\033[2J\033[H", end="")
+
+    def intro_panel_lines(self, width: int) -> list[str]:
+        return self.visual.render_intro(
+            width, self.visual.app_name, self.visual.credits
+        )
+
+    def print_intro_panel(self, width: int) -> None:
+        print("\n".join(self.intro_panel_lines(width)))
+
+    def append_menu_key_debug_log(self, line: str) -> None:
+        self.input.write_debug(self.input.debug_path, line)
+
+    def read_menu_key(self, fd: int | None = None) -> str:
+        return self.input.read_terminal_key(
+            fd, debug_log=self.append_menu_key_debug_log
+        )
+
+    def portable_select(
+        self,
+        title: str,
+        rows: list[str],
+        current: int = 0,
+        footer: str = "",
+        info_lines: list[str] | None = None,
+        show_intro: bool = False,
+    ) -> int | None:
+        return self.input.run_select(
+            title,
+            rows,
+            current,
+            footer,
+            info_lines,
+            show_intro,
+            services=TerminalSelectionServices(
+                enable_ansi=self.input.enable_ansi,
+                ansi=self.visual.ansi,
+                intro_panel_lines=self.intro_panel_lines,
+                status_lines=self.input.status_lines,
+                read_key=self.read_menu_key,
+            ),
+        )
+
+    def compact_text(self, value: Any, width: int = 72) -> str:
+        return self.visual.fit_cells(value, width)
+
+    def provider_ui_policy(
+        self, provider: str, config: dict[str, Any]
+    ) -> ProviderUiPolicy:
+        adapter = self.provider.configured_adapter(provider, config)
+        return adapter.ui_policy(self.provider.contract_config(provider, config))
+
+    def provider_menu_label(self, provider: str, config: dict[str, Any]) -> str:
+        policy = self.provider_ui_policy(provider, config)
+        if config.get("route_through_router") and policy.routed_menu_label:
+            return policy.routed_menu_label
+        return policy.menu_label or self.provider.labels.get(provider, provider)
+
+    def current_provider_panel_choice(
+        self, provider: str, config: dict[str, Any]
+    ) -> str:
+        policy = self.provider_ui_policy(provider, config)
+        if config.get("route_through_router") and policy.routed_choice:
+            return policy.routed_choice
+        return policy.native_choice or provider
+
+    def launch_enabled(self, runtime: str, provider: str) -> bool:
+        return self.provider.supports_runtime(runtime, provider)
+
+    def default_prelaunch_action(self, provider: str) -> str:
+        config = self.provider.load_config()
+        if provider == "kimi":
+            remembered = str(config.get("last_launch_action") or "").strip()
+            if remembered == "launch":
+                return remembered
+            if remembered in {"launch-codex", "launch-codex-app-server"}:
+                return remembered
+            return "launch-kimi"
+        return self.provider.preferred_action(
+            config,
+            provider,
+            lambda name: self.launch_enabled("agy", name),
+            lambda name: self.launch_enabled("claude", name),
+            lambda name: self.launch_enabled("codex", name),
+        )
+
+    def prelaunch_action_index(self, action: str) -> int:
+        try:
+            return self.main_menu_actions.index(action)
+        except ValueError:
+            return 0
+
+    def prelaunch_render_services(self) -> PrelaunchRenderServices:
+        return self.prompt.render_services
+
+    def prelaunch_input_style(self) -> PrelaunchInputStyle:
+        return self.prompt.input_style
+
+    def render_prelaunch_screen(
+        self,
+        main_index: int,
+        panel: str | None,
+        panel_index: int,
+        panel_rows: list[str],
+        checks: list[str],
+        messages: list[str],
+        first_render: bool,
+    ) -> bool:
+        return self.prompt.render_screen(
+            main_index,
+            panel,
+            panel_index,
+            panel_rows,
+            checks,
+            messages,
+            first_render,
+            services=self.prompt.render_services,
+        )
+
+    def prompt_menu_value_raw(
+        self, label: str, default: str = "", secret: bool = False
+    ) -> str | None:
+        return self.prompt.read_value_raw(
+            label, default, secret, style=self.prompt.input_style
+        )
+
+    def prompt_menu_value(
+        self,
+        prompt: str,
+        default: str = "",
+        secret: bool = False,
+        restore_tty: Callable[[], None] | None = None,
+        raw_tty: Callable[[], None] | None = None,
+    ) -> str:
+        return self.prompt.read_value(
+            prompt,
+            default,
+            secret,
+            restore_tty,
+            raw_tty,
+            style=self.prompt.input_style,
+        )
+
+    def prompt_menu_multiline_value_raw(
+        self, label: str, secret: bool = False
+    ) -> str | None:
+        return self.prompt.read_multiline_raw(
+            label, secret, style=self.prompt.input_style
+        )
+
+    def prompt_menu_multiline_value(
+        self,
+        prompt: str,
+        restore_tty: Callable[[], None] | None = None,
+        raw_tty: Callable[[], None] | None = None,
+        secret: bool = True,
+    ) -> str:
+        return self.prompt.read_multiline(
+            prompt,
+            restore_tty,
+            raw_tty,
+            secret,
+            style=self.prompt.input_style,
+        )
+
+
+@dataclass(frozen=True, slots=True)
+class PrelaunchShellCompatibilityApi:
+    context: Callable[[], PrelaunchShellContext]
+
+    def color_line(self, text: str, code: str, width: int) -> str:
+        return self.context().color_line(text, code, width)
+
+    def clean_render_lines(self, lines: list[str], width: int) -> list[str]:
+        return self.context().clean_render_lines(lines, width)
+
+    def clear_screen(self) -> None:
+        self.context().clear_screen()
+
+    def intro_panel_lines(self, width: int) -> list[str]:
+        return self.context().intro_panel_lines(width)
+
+    def print_intro_panel(self, width: int) -> None:
+        self.context().print_intro_panel(width)
+
+    def append_menu_key_debug_log(self, line: str) -> None:
+        self.context().append_menu_key_debug_log(line)
+
+    def read_menu_key(self, fd: int | None = None) -> str:
+        return self.context().read_menu_key(fd)
+
+    def portable_select(
+        self,
+        title: str,
+        rows: list[str],
+        current: int = 0,
+        footer: str = "",
+        info_lines: list[str] | None = None,
+        show_intro: bool = False,
+    ) -> int | None:
+        return self.context().portable_select(
+            title, rows, current, footer, info_lines, show_intro
+        )
+
+    def compact_text(self, value: Any, width: int = 72) -> str:
+        return self.context().compact_text(value, width)
+
+    def provider_ui_policy(
+        self, provider: str, config: dict[str, Any]
+    ) -> ProviderUiPolicy:
+        return self.context().provider_ui_policy(provider, config)
+
+    def provider_menu_label(self, provider: str, config: dict[str, Any]) -> str:
+        return self.context().provider_menu_label(provider, config)
+
+    def current_provider_panel_choice(
+        self, provider: str, config: dict[str, Any]
+    ) -> str:
+        return self.context().current_provider_panel_choice(provider, config)
+
+    def claude_launch_enabled(
+        self, provider: str, config: dict[str, Any] | None = None
+    ) -> bool:
+        del config
+        return self.context().launch_enabled("claude", provider)
+
+    def agy_launch_enabled(
+        self, provider: str, config: dict[str, Any] | None = None
+    ) -> bool:
+        del config
+        return self.context().launch_enabled("agy", provider)
+
+    def codex_launch_enabled(
+        self, provider: str, config: dict[str, Any] | None = None
+    ) -> bool:
+        del config
+        return self.context().launch_enabled("codex", provider)
+
+    def default_prelaunch_action(self, provider: str) -> str:
+        return self.context().default_prelaunch_action(provider)
+
+    def prelaunch_action_index(self, action: str) -> int:
+        return self.context().prelaunch_action_index(action)
+
+    def prelaunch_render_services(self) -> PrelaunchRenderServices:
+        return self.context().prelaunch_render_services()
+
+    def prelaunch_input_style(self) -> PrelaunchInputStyle:
+        return self.context().prelaunch_input_style()
+
+    def render_prelaunch_screen(
+        self,
+        main_index: int,
+        panel: str | None,
+        panel_index: int,
+        panel_rows: list[str],
+        checks: list[str],
+        messages: list[str],
+        first_render: bool,
+    ) -> bool:
+        return self.context().render_prelaunch_screen(
+            main_index,
+            panel,
+            panel_index,
+            panel_rows,
+            checks,
+            messages,
+            first_render,
+        )
+
+    def prompt_menu_value_raw(
+        self, label: str, default: str = "", secret: bool = False
+    ) -> str | None:
+        return self.context().prompt_menu_value_raw(label, default, secret)
+
+    def prompt_menu_value(
+        self,
+        prompt: str,
+        default: str = "",
+        secret: bool = False,
+        restore_tty: Callable[[], None] | None = None,
+        raw_tty: Callable[[], None] | None = None,
+    ) -> str:
+        return self.context().prompt_menu_value(
+            prompt, default, secret, restore_tty, raw_tty
+        )
+
+    def prompt_menu_multiline_value_raw(
+        self, label: str, secret: bool = False
+    ) -> str | None:
+        return self.context().prompt_menu_multiline_value_raw(label, secret)
+
+    def prompt_menu_multiline_value(
+        self,
+        prompt: str,
+        restore_tty: Callable[[], None] | None = None,
+        raw_tty: Callable[[], None] | None = None,
+        secret: bool = True,
+    ) -> str:
+        return self.context().prompt_menu_multiline_value(
+            prompt, restore_tty, raw_tty, secret
+        )
+
+
+__all__ = [
+    "PrelaunchInputPorts",
+    "PrelaunchProviderPorts",
+    "PrelaunchPromptPorts",
+    "PrelaunchShellCompatibilityApi",
+    "PrelaunchShellContext",
+    "PrelaunchVisualPorts",
+]

package/ciel_runtime_support/prompt_compaction.py

@@ -181,6 +181,150 @@ def compact_chat_messages_for_budget(
     return compacted
 
 
+RESPONSES_CALL_TYPES = ("function_call", "custom_tool_call")
+RESPONSES_OUTPUT_TYPES = ("function_call_output", "custom_tool_call_output")
+
+
+def responses_item_as_message(item: dict[str, Any]) -> dict[str, Any]:
+    """Project one Responses input item into the shape the summary builder reads.
+
+    The chunked context-guard summary is written against ``role``/``content``
+    messages. Responses carries the same conversation as typed items, so the
+    projection exists only so one summariser serves both wires.
+    """
+
+    item_type = str(item.get("type") or "")
+    if item_type == "message":
+        return {"role": str(item.get("role") or "user"), "content": item.get("content")}
+    if item_type in RESPONSES_CALL_TYPES:
+        arguments = item.get("arguments")
+        if arguments is None:
+            arguments = item.get("input")
+        return {
+            "role": "assistant",
+            "content": f"{item.get('name') or item_type}({arguments if isinstance(arguments, str) else ''})",
+        }
+    if item_type in RESPONSES_OUTPUT_TYPES:
+        return {"role": "tool", "content": item.get("output")}
+    return {"role": "assistant", "content": item_type}
+
+
+def responses_tail_is_safe(items: list[dict[str, Any]], start: int) -> bool:
+    """Report whether cutting before ``start`` leaves every kept pair intact.
+
+    A tool output replayed without the call it answers is not valid Responses
+    input, so a tail may not begin inside a call/output pair.
+    """
+
+    retained_calls = {
+        str(item.get("call_id") or "")
+        for item in items[start:]
+        if str(item.get("type") or "") in RESPONSES_CALL_TYPES
+    }
+    return not any(
+        str(item.get("type") or "") in RESPONSES_OUTPUT_TYPES
+        and str(item.get("call_id") or "") not in retained_calls
+        for item in items[start:]
+    )
+
+
+def compact_responses_input_for_budget(
+    body: dict[str, Any],
+    budget_tokens: int,
+    *,
+    provider: str = "",
+    model: str = "",
+    services: PromptCompactionServices,
+) -> dict[str, Any]:
+    """Fit a Responses ``input`` array inside the target model's budget.
+
+    The Anthropic and chat wires have had this since the context guard was
+    written; Responses did not, so a session carried across a model change kept
+    a history the new window cannot hold. The upstream then rejects every turn
+    with ``context_length_exceeded``, and the client's own recovery drops one
+    history item per round trip, which does not converge on a transcript whose
+    bulk is a handful of very large tool outputs.
+
+    Same policy as the other wires: keep the newest items that fit, replace the
+    rest with the deterministic chunked summary, and never split a call from
+    its output.
+    """
+
+    items = body.get("input")
+    if not isinstance(items, list) or not items:
+        return body
+    typed = [item for item in items if isinstance(item, dict)]
+    if len(typed) != len(items):
+        return body
+    text = services.text
+    runtime = services.runtime
+    budget_tokens = max(8192, budget_tokens)
+    initial_tokens = runtime.estimate_tokens(body)
+    if initial_tokens <= budget_tokens:
+        return body
+
+    summary_budget = max(1024, min(24576, budget_tokens // 10))
+    tail_budget = max(8192, budget_tokens - summary_budget)
+    tail_start = len(typed)
+    for index in range(len(typed) - 1, -1, -1):
+        candidate = dict(body)
+        candidate["input"] = typed[index:]
+        if runtime.estimate_tokens(candidate) > tail_budget:
+            break
+        tail_start = index
+    while tail_start < len(typed) and not responses_tail_is_safe(typed, tail_start):
+        tail_start += 1
+    if tail_start >= len(typed):
+        tail_start = len(typed) - 1
+        while tail_start > 0 and not responses_tail_is_safe(typed, tail_start):
+            tail_start -= 1
+
+    def projected(omitted: list[dict[str, Any]]) -> dict[str, Any]:
+        summary = text.build_summary(
+            [responses_item_as_message(item) for item in omitted], budget_tokens
+        )
+        return {
+            "type": "message",
+            "role": "user",
+            "content": [{"type": "input_text", "text": summary}],
+        }
+
+    tail = typed[tail_start:]
+    out = dict(body)
+    out["input"] = [projected(typed[:tail_start]), *tail]
+    while runtime.estimate_tokens(out) > budget_tokens and len(tail) > 1:
+        tail = tail[1:]
+        while tail and not responses_tail_is_safe(tail, 0):
+            tail = tail[1:]
+        if not tail:
+            tail = [typed[-1]]
+            break
+        out["input"] = [projected(typed[: len(typed) - len(tail)]), *tail]
+    final_tokens = runtime.estimate_tokens(out)
+    runtime.log(
+        "WARN",
+        f"compacted responses payload provider={provider} model={model} "
+        f"items {len(typed)}->{len(out['input'])} tokens {initial_tokens}->{final_tokens} budget={budget_tokens}",
+    )
+    omitted = typed[: len(typed) - len(tail)]
+    chunk_count = text.chunk_count(
+        [responses_item_as_message(item) for item in omitted], budget_tokens
+    )
+    if chunk_count and (provider or model):
+        runtime.write_activity(
+            provider or "provider",
+            model,
+            chunks=chunk_count,
+            parallel_sessions=1,
+            tokens=initial_tokens,
+            final_tokens=final_tokens,
+            budget=budget_tokens,
+            omitted_messages=len(omitted),
+            retained_messages=len(out["input"]),
+        )
+    return out
+
+
 def anthropic_message_has_tool_result(message: dict[str, Any]) -> bool:
     content = message.get("content")
     return isinstance(content, list) and any(

package/ciel_runtime_support/prompt_injection.py

@@ -174,3 +174,48 @@ def normalize_anthropic_system_role_messages(
     out["messages"] = next_messages
     out["system"] = append_anthropic_system_texts(body.get("system"), system_texts)
     return out
+
+
+def inline_anthropic_system_role_messages(
+    body: Mapping[str, Any],
+    content_to_text: Callable[[Any], str],
+) -> JsonObject:
+    """Make non-standard system history wire-valid without moving its position.
+
+    Anthropic Messages only permits user/assistant roles in ``messages``.  A
+    late runtime reminder must therefore be represented as user context, but
+    moving it into the leading ``system`` field would rewrite the entire cache
+    prefix on every turn.
+    """
+
+    messages = body.get("messages")
+    if not isinstance(messages, list):
+        return dict(body)
+    changed = False
+    projected: list[Any] = []
+    for message in messages:
+        if not isinstance(message, dict) or str(message.get("role") or "").strip() != "system":
+            projected.append(message)
+            continue
+        changed = True
+        text = content_to_text(message.get("content")).strip()
+        projected.append(
+            {
+                **message,
+                "role": "user",
+                "content": f"[Runtime system context]\n{text}" if text else "[Runtime system context]",
+            }
+        )
+    if not changed:
+        return dict(body)
+    return {**body, "messages": projected}
+
+
+def normalize_anthropic_system_role_messages_by_strategy(
+    body: Mapping[str, Any],
+    strategy: str,
+    content_to_text: Callable[[Any], str],
+) -> JsonObject:
+    if strategy == "hoist_top_level":
+        return normalize_anthropic_system_role_messages(body, content_to_text)
+    return inline_anthropic_system_role_messages(body, content_to_text)

package/ciel_runtime_support/protocols/anthropic_thinking_policy.py

@@ -210,7 +210,7 @@ class AnthropicThinkingPolicy:
             self._ports.log(
                 "INFO",
                 "removed top-level Anthropic thinking request but preserved thinking blocks "
-                f"for OpenAI-chat reasoning passback provider={provider} "
+                f"for provider reasoning passback provider={provider} "
                 f"thinking_blocks={block_count}",
             )
             return projected