@oneciel-ai/ciel-runtime 0.1.1 → 0.2.0

package/ciel_runtime_support/context_setup.py

@@ -0,0 +1,208 @@
+"""Provider-neutral context setup projection and mutation service."""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from dataclasses import dataclass
+from typing import Any
+
+from .architecture import ProviderContextPolicy
+
+
+ContextMode = tuple[int, int, int]
+
+
+@dataclass(frozen=True, slots=True)
+class ContextSetupPorts:
+    context_capacity: Callable[[str, dict[str, Any]], int | None]
+    context_policy: Callable[[str, dict[str, Any]], ProviderContextPolicy]
+    positive_int: Callable[[Any], int | None]
+    format_context: Callable[[int | None], str]
+    ui_text: Callable[[str, str], str]
+    pad_cells: Callable[[str, int], str]
+    cap_context: Callable[[str, dict[str, Any]], list[str]]
+    cap_output: Callable[[str, dict[str, Any]], list[str]]
+    apply_timeout: Callable[[str, dict[str, Any]], list[str]]
+    context_status: Callable[[str, dict[str, Any]], str]
+
+
+_ORDERED_MODES = (
+    "context-compact",
+    "context-balanced",
+    "context-project",
+    "context-full",
+)
+_TEXT = {
+    "en": {
+        "context-compact": ("Compact / fast", "small context, faster and cheaper"),
+        "context-balanced": (
+            "Balanced",
+            "good default for normal coding sessions",
+        ),
+        "context-project": (
+            "Large project",
+            "more files/history, slower but safer for big work",
+        ),
+        "context-full": (
+            "Full model window",
+            "use the selected model's maximum context",
+        ),
+    },
+    "ko": {
+        "context-compact": ("컴팩트/빠름", "작은 컨텍스트, 빠르고 가벼움"),
+        "context-balanced": ("균형형", "일반 코딩 세션의 권장 기본값"),
+        "context-project": (
+            "대형 프로젝트",
+            "파일/히스토리를 더 많이 사용, 큰 작업에 안정적",
+        ),
+        "context-full": (
+            "모델 최대 컨텍스트",
+            "선택한 모델의 최대 컨텍스트 사용",
+        ),
+    },
+    "ja": {
+        "context-compact": (
+            "コンパクト/高速",
+            "小さなコンテキストで高速かつ軽量",
+        ),
+        "context-balanced": (
+            "バランス",
+            "通常のコーディングセッション向けの既定値",
+        ),
+        "context-project": (
+            "大規模プロジェクト",
+            "より多くのファイル/履歴を使う大型作業向け",
+        ),
+        "context-full": (
+            "モデル最大コンテキスト",
+            "選択モデルの最大コンテキストを使用",
+        ),
+    },
+    "zh": {
+        "context-compact": ("紧凑/快速", "较小上下文，更快更轻"),
+        "context-balanced": ("均衡", "普通编码会话的推荐默认值"),
+        "context-project": ("大型项目", "使用更多文件/历史，适合大任务"),
+        "context-full": ("模型最大上下文", "使用所选模型的最大上下文"),
+    },
+}
+
+
+class ContextSetupService:
+    def __init__(self, ports: ContextSetupPorts) -> None:
+        self.ports = ports
+
+    @staticmethod
+    def mode_values(capacity: int | None) -> dict[str, ContextMode]:
+        cap = capacity or 131072
+
+        def clamp(value: int) -> int:
+            return max(8192, min(cap, value))
+
+        compact = clamp(32768)
+        balanced = clamp(65536 if cap <= 131072 else 131072)
+        project = clamp(262144 if cap >= 262144 else cap)
+        full = clamp(cap)
+        return {
+            "context-compact": (
+                compact,
+                min(2048, max(1024, compact // 16)),
+                4096,
+            ),
+            "context-balanced": (
+                balanced,
+                min(4096, max(2048, balanced // 16)),
+                4096,
+            ),
+            "context-project": (
+                project,
+                min(8192, max(4096, project // 16)),
+                8192,
+            ),
+            "context-full": (
+                full,
+                min(16384, max(4096, full // 16)),
+                8192,
+            ),
+        }
+
+    @staticmethod
+    def text(key: str, language: str) -> tuple[str, str]:
+        entries = _TEXT.get(language, _TEXT["en"])
+        return entries.get(key, _TEXT["en"][key])
+
+    def panel_rows(
+        self,
+        provider: str,
+        config: dict[str, Any],
+        language: str,
+    ) -> tuple[list[str], list[str]]:
+        capacity = self.ports.context_capacity(provider, config)
+        rows = [f"Model context capacity: {self.ports.format_context(capacity)}"]
+        values = ["__info__"]
+        strategy = self.ports.context_policy(provider, config).settings_strategy
+        if strategy == "managed":
+            rows.append("Claude Code manages Anthropic context automatically.")
+            values.append("__info__")
+            rows.append(self.ports.ui_text("back", language))
+            values.append("back")
+            return rows, values
+        current_window = self.ports.positive_int(
+            config.get("num_ctx_max" if strategy == "ollama" else "context_window")
+        )
+        choices = self.mode_values(capacity)
+        visible_modes: list[str] = []
+        seen_windows: set[int] = set()
+        for key in reversed(_ORDERED_MODES):
+            window = choices[key][0]
+            if window not in seen_windows:
+                seen_windows.add(window)
+                visible_modes.append(key)
+        for key in reversed(visible_modes):
+            window, _reserve, output = choices[key]
+            label, description = self.text(key, language)
+            mark = "*" if current_window == window else " "
+            rows.append(
+                f"{mark} {self.ports.pad_cells(label, 22)} "
+                f"{self.ports.format_context(window):>6}  "
+                f"out {self.ports.format_context(output):>5}  {description}"
+            )
+            values.append(key)
+        rows.append(self.ports.ui_text("back", language))
+        values.append("back")
+        return rows, values
+
+    def apply(
+        self,
+        provider: str,
+        config: dict[str, Any],
+        mode: str,
+        language: str,
+    ) -> list[str]:
+        choices = self.mode_values(self.ports.context_capacity(provider, config))
+        if mode not in choices:
+            raise SystemExit(f"Unknown context mode: {mode}")
+        window, reserve, output = choices[mode]
+        label = self.text(mode, language)[0]
+        strategy = self.ports.context_policy(provider, config).settings_strategy
+        if strategy == "ollama":
+            config["num_ctx"] = "auto"
+            config["num_ctx_max"] = window
+            config["num_ctx_min"] = min(
+                window,
+                32768 if window <= 65536 else 65536,
+            )
+            config.setdefault("ollama_options", {})["num_predict"] = output
+        elif strategy == "standard":
+            config["context_window"] = window
+            config["context_reserve_tokens"] = reserve
+            config["max_output_tokens"] = output
+        else:
+            return ["Context setup is managed by Claude Code for this provider."]
+        messages = self.ports.cap_context(provider, config)
+        messages.extend(self.ports.cap_output(provider, config))
+        messages.extend(self.ports.apply_timeout(provider, config))
+        return [
+            f"{self.ports.ui_text('context_setup', language)}: {label}",
+            f"Applied context: {self.ports.context_status(provider, config)}",
+            *messages,
+        ]

package/ciel_runtime_support/context_summary_policy.py

@@ -0,0 +1,392 @@
+"""Pure message projection and chunking policy for context compaction."""
+
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass
+from typing import Any, Callable
+
+
+PROMPT_TOOL_INPUT_FIELD_LIMIT = 1200
+PROMPT_MESSAGE_TEXT_LIMIT = 20000
+CLAUDE_CODE_PERSISTED_OUTPUT_MARKER = "<persisted-output>"
+
+
+@dataclass(frozen=True, slots=True)
+class ContextSummaryPolicy:
+    estimate_tokens: Callable[[Any], int]
+    positive_int: Callable[[Any], int | None]
+    content_to_text: Callable[[Any], str]
+    compact_json: Callable[..., str]
+    latest_user_text: Callable[[dict[str, Any]], str]
+
+    def is_compact_request(self, body: dict[str, Any]) -> bool:
+        if not isinstance(body, dict):
+            return False
+        text = self.latest_user_text(body).lower()
+        return bool(
+            text
+            and (
+                "<command-name>/compact</command-name>" in text
+                or ("<command-message>compact</command-message>" in text and "<command-name>" in text)
+                or ("create a detailed summary of the conversation" in text and "compact" in text)
+                or ("summarize the conversation so far" in text and "compact" in text)
+            )
+        )
+
+    def text_only_body(
+        self,
+        body: dict[str, Any],
+        system_prompt: str,
+        append_system: Callable[[Any, list[str]], Any],
+        log: Callable[[str, str], None],
+    ) -> dict[str, Any]:
+        if not self.is_compact_request(body):
+            return body
+        result = dict(body)
+        removed_tools = bool(result.pop("tools", None))
+        removed_choice = bool(result.pop("tool_choice", None))
+        result.pop("parallel_tool_calls", None)
+        result["system"] = append_system(result.get("system"), [system_prompt])
+        if removed_tools or removed_choice:
+            log(
+                "INFO",
+                "compact_request_text_only removed_tools=%s removed_tool_choice=%s"
+                % (str(removed_tools).lower(), str(removed_choice).lower()),
+            )
+        return result
+
+    @staticmethod
+    def truncate(text: str, limit: int) -> str:
+        if len(text) <= limit:
+            return text
+        return text[:limit] + f"\n...[truncated {len(text) - limit} chars]..."
+
+    @staticmethod
+    def is_persisted_output(text: str) -> bool:
+        return CLAUDE_CODE_PERSISTED_OUTPUT_MARKER in str(text or "")
+
+    def compact_tool_value(self, value: Any, limit: int = PROMPT_TOOL_INPUT_FIELD_LIMIT) -> Any:
+        if isinstance(value, str):
+            return self.truncate(value, limit)
+        if isinstance(value, list):
+            return [self.compact_tool_value(item, limit) for item in value[:20]]
+        if isinstance(value, dict):
+            return {
+                key: self.truncate(item, limit)
+                if key in {"content", "old_string", "new_string", "command"}
+                and isinstance(item, str)
+                else self.compact_tool_value(item, limit)
+                for key, item in value.items()
+            }
+        return value
+
+    def tool_input(self, tool_input: Any) -> str:
+        if not tool_input:
+            return "{}"
+        return json.dumps(self.compact_tool_value(tool_input), ensure_ascii=False, sort_keys=True)
+
+    def message_text(self, text: str) -> str:
+        return self.truncate(text, PROMPT_MESSAGE_TEXT_LIMIT)
+
+    @staticmethod
+    def tool_markers(message: dict[str, Any]) -> list[str]:
+        content = message.get("content")
+        if not isinstance(content, list):
+            return []
+        markers: list[str] = []
+        for block in content:
+            if not isinstance(block, dict):
+                continue
+            if block.get("type") == "tool_use":
+                name = str(block.get("name") or "tool")
+                tool_id = str(block.get("id") or "")
+                markers.append(f"tool_use:{name}{('/' + tool_id) if tool_id else ''}")
+            elif block.get("type") == "tool_result":
+                markers.append(f"tool_result:{str(block.get('tool_use_id') or 'tool')}")
+        return markers
+
+    def summary_line(self, index: int, message: dict[str, Any], text_limit: int = 700) -> str:
+        role = str(message.get("role") or "unknown")
+        text = " ".join(self.content_to_text(message.get("content")).split())
+        parts = [f"message {index}", f"role={role}"]
+        if markers := self.tool_markers(message):
+            parts.append("markers=" + ",".join(markers[:6]))
+        if text:
+            parts.append("text=" + self.truncate(text, text_limit))
+        return "- " + " | ".join(parts)
+
+    @staticmethod
+    def chunk_ranges(count: int, chunks: int) -> list[tuple[int, int]]:
+        chunks = max(1, min(chunks, count))
+        return [
+            (start, end)
+            for index in range(chunks)
+            if (start := (index * count) // chunks) < (end := ((index + 1) * count) // chunks)
+        ]
+
+    def guard_chunk_count(
+        self,
+        omitted_messages: list[dict[str, Any]],
+        budget_tokens: int | None = None,
+    ) -> int:
+        if not omitted_messages:
+            return 0
+        omitted_tokens = sum(self.estimate_tokens(message) for message in omitted_messages)
+        target = 32768
+        if budget := self.positive_int(budget_tokens):
+            target = max(target, min(262144, max(1, budget // 4)))
+        return max(1, min(12, (omitted_tokens + target - 1) // target))
+
+    def guard_summary(
+        self,
+        omitted_messages: list[dict[str, Any]],
+        budget_tokens: int,
+        start_index: int = 0,
+    ) -> str:
+        count = len(omitted_messages)
+        tokens = sum(self.estimate_tokens(message) for message in omitted_messages)
+        if count <= 0:
+            return (
+                "[ciel-runtime context guard: older conversation history was compacted because "
+                f"the provider context budget is {budget_tokens} tokens.]"
+            )
+        max_tokens = max(1024, min(24576, max(1, budget_tokens) // 10))
+        max_chars = max_tokens * 4
+        chunks = self.guard_chunk_count(omitted_messages, budget_tokens)
+        lines = [
+            f"[ciel-runtime context guard: compacted {count} older messages, approx {tokens} tokens, because the provider context budget is {budget_tokens} tokens.]",
+            "The recent tail is preserved verbatim. Older history is represented below as deterministic chunk summaries; use file reads or MCP queries if exact old content is needed.",
+        ]
+        for number, (start, end) in enumerate(self.chunk_ranges(count, chunks), start=1):
+            chunk = omitted_messages[start:end]
+            chunk_tokens = sum(self.estimate_tokens(message) for message in chunk)
+            lines.append(
+                f"Chunk {number}/{chunks}: messages {start_index + start}-{start_index + end - 1}, approx {chunk_tokens} tokens."
+            )
+            offsets = list(range(len(chunk))) if len(chunk) <= 4 else [0, 1, len(chunk) - 2, len(chunk) - 1]
+            for offset in dict.fromkeys(offsets):
+                lines.append(self.summary_line(start_index + start + offset, chunk[offset]))
+            if len("\n".join(lines)) > max_chars:
+                lines.append(f"...[context guard summary truncated to {max_tokens} tokens]...")
+                break
+        summary = "\n".join(lines)
+        return self.truncate(summary, max_chars) if len(summary) > max_chars else summary
+
+    def compact_message(self, message: dict[str, Any], index: int) -> str:
+        role = str(message.get("role") or "unknown")
+        parts = [f"Message {index} role={role}"]
+        if name := message.get("name") or message.get("tool_name"):
+            parts.append(f"name={name}")
+        if message.get("tool_call_id"):
+            parts.append(f"tool_call_id={message.get('tool_call_id')}")
+        content = self.content_to_text(message.get("content"))
+        if message.get("tool_calls"):
+            tool_calls = "tool_calls=" + self.compact_json(message.get("tool_calls"), max_chars=6000)
+            content = f"{content}\n\n{tool_calls}" if content else tool_calls
+        return f"{' '.join(parts)}\n{self.message_text(content)}"
+
+    def instruction_index(self, messages: list[dict[str, Any]]) -> int | None:
+        fallback: int | None = None
+        for index, message in enumerate(messages):
+            if str(message.get("role") or "") != "user":
+                continue
+            text = self.content_to_text(message.get("content")).lower()
+            if text:
+                fallback = index
+            if (
+                "<command-name>/compact</command-name>" in text
+                or ("<command-message>compact</command-message>" in text and "<command-name>" in text)
+                or ("create a detailed summary of the conversation" in text and "compact" in text)
+                or ("summarize the conversation so far" in text and "compact" in text)
+            ):
+                return index
+        return fallback
+
+    def chunk_target_tokens(self, config: dict[str, Any] | None, budget_tokens: int) -> int:
+        configured = self.positive_int((config or {}).get("context_compact_chunk_tokens"))
+        return max(8192, configured) if configured else max(8192, min(65536, max(1, budget_tokens) // 4))
+
+    def summary_output_tokens(self, config: dict[str, Any] | None, budget_tokens: int) -> int:
+        configured = self.positive_int((config or {}).get("context_compact_summary_tokens"))
+        return max(512, configured) if configured else max(1024, min(8192, max(1, budget_tokens) // 64))
+
+    def split_messages(
+        self,
+        messages: list[dict[str, Any]],
+        target_tokens: int,
+    ) -> list[tuple[int, list[dict[str, Any]]]]:
+        chunks: list[tuple[int, list[dict[str, Any]]]] = []
+        current: list[dict[str, Any]] = []
+        current_start = 0
+        current_tokens = 0
+        for index, message in enumerate(messages):
+            tokens = max(1, self.estimate_tokens(message))
+            if current and current_tokens + tokens > target_tokens:
+                chunks.append((current_start, current))
+                current, current_tokens, current_start = [], 0, index
+            if not current:
+                current_start = index
+            current.append(message)
+            current_tokens += tokens
+        if current:
+            chunks.append((current_start, current))
+        return chunks
+
+    def chunk_prompt(
+        self,
+        chunk: list[dict[str, Any]],
+        start_index: int,
+        chunk_number: int,
+        chunk_total: int,
+    ) -> str:
+        parts = [
+            f"Segment {chunk_number}/{chunk_total}. Summarize messages {start_index}-{start_index + len(chunk) - 1}.",
+            "Return only the segment summary.",
+        ]
+        parts.extend(
+            self.compact_message(message, start_index + offset)
+            for offset, message in enumerate(chunk)
+        )
+        return "\n\n".join(parts)
+
+    def extract_response_text(self, data: Any, wire: str) -> str:
+        if not isinstance(data, dict):
+            return ""
+        if wire == "ollama":
+            message = data.get("message") if isinstance(data.get("message"), dict) else {}
+            return str(message.get("content") or data.get("response") or "").strip()
+        if wire == "openai":
+            choices = data.get("choices")
+            if isinstance(choices, list) and choices:
+                choice = choices[0] if isinstance(choices[0], dict) else {}
+                message = choice.get("message") if isinstance(choice.get("message"), dict) else {}
+                return str(message.get("content") or "").strip()
+            return ""
+        if wire == "anthropic":
+            return self.content_to_text(data.get("content")).strip()
+        return ""
+
+    def reduce_prompt(
+        self,
+        summaries: list[str],
+        compact_instruction: str,
+        budget_tokens: int,
+        source_message_count: int,
+    ) -> str:
+        parts = [
+            "[ciel-runtime segmented compact]",
+            f"The previous conversation was too large for a single compact request. It was summarized in {len(summaries)} segment(s) from {source_message_count} message(s).",
+            "Segment summaries:",
+        ]
+        parts.extend(
+            f"## Segment {index}\n{summary.strip()}"
+            for index, summary in enumerate(summaries, start=1)
+        )
+        parts.extend(
+            (
+                "Claude Code compact instruction:",
+                self.message_text(compact_instruction),
+                "Using the segment summaries above, return only the final compact summary text requested by Claude Code.",
+            )
+        )
+        text = "\n\n".join(parts)
+        max_chars = max(8192, max(1, budget_tokens) * 3)
+        return self.truncate(text, max_chars) if len(text) > max_chars else text
+
+
+@dataclass(frozen=True, slots=True)
+class ContextSummaryCompatibilityApi:
+    """Typed facade adapter for context-summary projections."""
+
+    policy_factory: Callable[[], ContextSummaryPolicy]
+    compact_system_prompt: str
+    append_system: Callable[[Any, list[str]], Any]
+    log: Callable[[str, str], None]
+
+    def is_compact_request(self, body: dict[str, Any]) -> bool:
+        return self.policy_factory().is_compact_request(body)
+
+    def text_only_body(self, body: dict[str, Any]) -> dict[str, Any]:
+        return self.policy_factory().text_only_body(
+            body, self.compact_system_prompt, self.append_system, self.log
+        )
+
+    def compact_tool_value(self, value: Any, limit: int = PROMPT_TOOL_INPUT_FIELD_LIMIT) -> Any:
+        return self.policy_factory().compact_tool_value(value, limit)
+
+    def tool_input(self, tool_input: Any) -> str:
+        return self.policy_factory().tool_input(tool_input)
+
+    def message_text(self, text: str) -> str:
+        return self.policy_factory().message_text(text)
+
+    def summary_line(
+        self, index: int, message: dict[str, Any], *, text_limit: int = 700
+    ) -> str:
+        return self.policy_factory().summary_line(index, message, text_limit)
+
+    def guard_chunk_count(
+        self,
+        omitted_messages: list[dict[str, Any]],
+        budget_tokens: int | None = None,
+    ) -> int:
+        return self.policy_factory().guard_chunk_count(omitted_messages, budget_tokens)
+
+    def guard_summary(
+        self,
+        omitted_messages: list[dict[str, Any]],
+        budget_tokens: int,
+        *,
+        start_index: int = 0,
+    ) -> str:
+        return self.policy_factory().guard_summary(
+            omitted_messages, budget_tokens, start_index
+        )
+
+    def compact_message(self, message: dict[str, Any], index: int) -> str:
+        return self.policy_factory().compact_message(message, index)
+
+    def instruction_index(self, messages: list[dict[str, Any]]) -> int | None:
+        return self.policy_factory().instruction_index(messages)
+
+    def chunk_target_tokens(
+        self, config: dict[str, Any] | None, budget_tokens: int
+    ) -> int:
+        return self.policy_factory().chunk_target_tokens(config, budget_tokens)
+
+    def summary_output_tokens(
+        self, config: dict[str, Any] | None, budget_tokens: int
+    ) -> int:
+        return self.policy_factory().summary_output_tokens(config, budget_tokens)
+
+    def split_messages(
+        self, messages: list[dict[str, Any]], target_tokens: int
+    ) -> list[tuple[int, list[dict[str, Any]]]]:
+        return self.policy_factory().split_messages(messages, target_tokens)
+
+    def chunk_prompt(
+        self,
+        chunk: list[dict[str, Any]],
+        start_index: int,
+        chunk_no: int,
+        chunk_total: int,
+    ) -> str:
+        return self.policy_factory().chunk_prompt(
+            chunk, start_index, chunk_no, chunk_total
+        )
+
+    def extract_response_text(self, data: Any, wire: str) -> str:
+        return self.policy_factory().extract_response_text(data, wire)
+
+    def reduce_prompt(
+        self,
+        summaries: list[str],
+        compact_instruction: str,
+        *,
+        budget_tokens: int,
+        source_message_count: int,
+    ) -> str:
+        return self.policy_factory().reduce_prompt(
+            summaries, compact_instruction, budget_tokens, source_message_count
+        )