@oneciel-ai/ciel-runtime 0.1.1 → 0.2.0

package/ciel_runtime_support/anthropic_model_policy.py

@@ -0,0 +1,186 @@
+"""Anthropic model metadata and Claude Code capability policy."""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+from typing import Any, Callable
+
+
+SUPPORTED_CAPABILITIES = (
+    "effort",
+    "xhigh_effort",
+    "max_effort",
+    "thinking",
+    "adaptive_thinking",
+    "interleaved_thinking",
+)
+
+
+def model_family(model_id: str) -> str:
+    model = (model_id or "").strip().lower()
+    for family in ("fable", "mythos", "opus", "sonnet", "haiku"):
+        if re.search(rf"(?:^|-)claude-(?:\d+(?:-\d+){{0,2}}-)?{family}(?:-|$)", model) or f"-{family}-" in model:
+            return family
+    return "claude"
+
+
+def limit_hints(model_id: str) -> dict[str, Any]:
+    model = (model_id or "").strip().lower()
+    family = model_family(model)
+    if family in ("fable", "mythos") or (
+        family == "opus" and re.search(r"(?:^|-)opus-(?:5|4-[678])(?:-|$)", model)
+    ):
+        return {
+            "context_window": 1048576,
+            "max_output_tokens": 128000,
+            "source": "anthropic-models-overview-current-table",
+        }
+    if family == "sonnet" and re.search(r"(?:^|-)sonnet-5(?:-|$)", model):
+        return {
+            "context_window": 1048576,
+            "max_output_tokens": 128000,
+            "source": "anthropic-models-overview-current-table",
+        }
+    if family == "sonnet" and re.search(r"(?:^|-)sonnet-4-6(?:-|$)", model):
+        return {
+            "context_window": 1048576,
+            "max_output_tokens": 128000,
+            "source": "anthropic-models-overview-current-table",
+        }
+    if family == "haiku" and re.search(r"(?:^|-)haiku-4-5(?:-|$)", model):
+        return {
+            "context_window": 200000,
+            "max_output_tokens": 64000,
+            "source": "anthropic-models-overview-current-table",
+        }
+    return {"context_window": 200000, "source": "anthropic-default-compatibility"}
+
+
+def runtime_hints(model_id: str) -> dict[str, Any]:
+    model = (model_id or "").strip().lower()
+    if model_family(model) in ("fable", "mythos"):
+        return {
+            "claude_code_default_effort": "high",
+            "claude_code_max_effort": "xhigh",
+            "thinking_mode": "adaptive",
+            "extended_thinking": False,
+            "adaptive_thinking_always_on": True,
+            "unsupported_sampling_parameters": ["temperature", "top_p", "top_k"],
+            "source": "anthropic-models-overview-current-table",
+        }
+    if re.search(r"(?:^|-)opus-5(?:-|$)", model):
+        return {
+            "claude_code_default_effort": "high",
+            "claude_code_max_effort": "xhigh",
+            "thinking_mode": "adaptive",
+            "adaptive_thinking_default_on": True,
+            "thinking_disabled_max_effort": "high",
+            "extended_thinking": False,
+            "fast_mode": {"available": True, "preview": True},
+            "prompt_cache_min_tokens": 512,
+            "unsupported_sampling_parameters": ["temperature", "top_p", "top_k"],
+            "source": "anthropic-opus-5-launch-notes",
+        }
+    if re.search(r"(?:^|-)sonnet-5(?:-|$)", model):
+        return {
+            "claude_code_default_effort": "high",
+            "claude_code_max_effort": "xhigh",
+            "thinking_mode": "adaptive",
+            "adaptive_thinking_default_on": True,
+            "extended_thinking": False,
+            "unsupported_sampling_parameters": ["temperature", "top_p", "top_k"],
+            "source": "anthropic-sonnet-5-launch-notes",
+        }
+    if re.search(r"(?:^|-)opus-4-8(?:-|$)", model):
+        return {
+            "claude_code_default_effort": "high",
+            "claude_code_max_effort": "xhigh",
+            "thinking_mode": "adaptive",
+            "fast_mode": {"available": True, "preview": True},
+            "unsupported_sampling_parameters": ["temperature", "top_p", "top_k"],
+            "source": "anthropic-opus-4-8-launch-notes",
+        }
+    if re.search(r"(?:^|-)opus-4-7(?:-|$)", model):
+        return {
+            "claude_code_default_effort": "high",
+            "claude_code_max_effort": "xhigh",
+            "thinking_mode": "adaptive",
+            # Fast mode was removed on 4.7: speed="fast" errors, unlike 4.8.
+            "fast_mode": {"available": False, "preview": False},
+            "unsupported_sampling_parameters": ["temperature", "top_p", "top_k"],
+            "source": "anthropic-opus-4-7-launch-notes",
+        }
+    return {}
+
+
+def normalize_capabilities(value: Any) -> list[str]:
+    if value is None or value is False:
+        return []
+    if isinstance(value, str):
+        raw_items = re.split(r"[,;\s]+", value.strip())
+    elif isinstance(value, (list, tuple, set)):
+        raw_items = [str(item) for item in value]
+    else:
+        raw_items = [str(value)]
+    allowed = set(SUPPORTED_CAPABILITIES)
+    result: list[str] = []
+    for raw in raw_items:
+        item = str(raw or "").strip().lower().replace("-", "_")
+        if item and item in allowed and item not in result:
+            result.append(item)
+    return result
+
+
+def infer_capabilities(model_id: str, strip_context_suffix: Callable[[str], str]) -> list[str]:
+    model = strip_context_suffix(model_id).strip().lower()
+    if re.search(r"(?:^|-)claude-(?:fable|mythos)(?:-|$)", model):
+        return ["effort", "xhigh_effort", "max_effort", "thinking", "adaptive_thinking"]
+    if re.search(r"(?:^|-)(?:opus-5|sonnet-5|opus-4-[78])(?:-|$)", model):
+        return [
+            "effort", "xhigh_effort", "max_effort", "thinking",
+            "adaptive_thinking", "interleaved_thinking",
+        ]
+    if re.search(r"(?:^|-)(?:opus-4-6|sonnet-4-6)(?:-|$)", model):
+        return ["effort", "max_effort", "thinking", "adaptive_thinking", "interleaved_thinking"]
+    if re.search(r"(?:^|-)opus-4-5(?:-|$)", model):
+        # Opus 4.5 takes effort at low/medium/high only, and thinks through the
+        # pre-4.6 budget_tokens contract rather than adaptive thinking.
+        return ["effort", "thinking"]
+    return []
+
+
+def recommended_preset(model_id: str) -> str:
+    return "fast" if model_family(model_id) == "haiku" else "balanced"
+
+
+@dataclass(frozen=True, slots=True)
+class AnthropicModelRecommendations:
+    unique_ids: Callable[[str, list[str]], list[str]]
+    preset_timeout_ms: Callable[[str], int]
+    idle_timeout_ms: Callable[[int], int]
+
+    def build(self, provider: str, models: list[str]) -> dict[str, Any]:
+        if provider != "anthropic":
+            return {}
+        recommendations: dict[str, Any] = {}
+        for model_id in self.unique_ids(provider, models):
+            preset = recommended_preset(model_id)
+            timeout = self.preset_timeout_ms(preset)
+            recommendations[model_id] = {
+                "schema": 1,
+                "model_family": model_family(model_id),
+                "recommended_preset": preset,
+                "parameters": {
+                    "max_output_tokens": 2048 if preset == "fast" else 4096,
+                    "request_timeout_ms": timeout,
+                    "stream_idle_timeout_ms": self.idle_timeout_ms(timeout),
+                },
+                "limits": limit_hints(model_id),
+                "runtime": runtime_hints(model_id),
+                "notes": [
+                    "Native Claude Code manages the real context window; ciel-runtime stores context limits as model metadata only.",
+                    "Recommended max_output_tokens is intentionally lower than the provider hard limit for interactive CLI use.",
+                ],
+            }
+        return recommendations

package/ciel_runtime_support/anthropic_response_writer.py

@@ -0,0 +1,255 @@
+"""HTTP/SSE adapter for locally generated Anthropic message responses."""
+
+from __future__ import annotations
+
+import json
+import time
+from collections.abc import Callable
+from typing import Any
+
+
+def anthropic_text_response(
+    model: str, text: str, stop_reason: str = "end_turn"
+) -> dict[str, Any]:
+    return {
+        "id": f"msg_ollama_advisor_{int(time.time() * 1000)}",
+        "type": "message",
+        "role": "assistant",
+        "model": model,
+        "content": [{"type": "text", "text": text}],
+        "stop_reason": stop_reason,
+        "stop_sequence": None,
+        "usage": {"input_tokens": 0, "output_tokens": max(1, len(text) // 4)},
+    }
+
+
+def prepend_anthropic_text(
+    message: dict[str, Any], text: str
+) -> dict[str, Any]:
+    if not text:
+        return message
+    projected = dict(message)
+    content = projected.get("content")
+    blocks = list(content) if isinstance(content, list) else []
+    blocks.insert(0, {"type": "text", "text": text})
+    projected["content"] = blocks
+    return projected
+
+
+class AnthropicResponseWriter:
+    def __init__(self, write_json: Callable[[Any, Any], None]) -> None:
+        self.write_json = write_json
+
+    @staticmethod
+    def _event(handler: Any, name: str, payload: dict[str, Any]) -> None:
+        data = json.dumps(payload, ensure_ascii=False)
+        handler.wfile.write(f"event: {name}\ndata: {data}\n\n".encode())
+
+    @staticmethod
+    def _start_headers(handler: Any) -> None:
+        handler.send_response(200)
+        handler.send_header("content-type", "text/event-stream")
+        handler.send_header("cache-control", "no-cache")
+        handler.send_header("connection", "close")
+        handler.end_headers()
+
+    def text(self, handler: Any, model: str, text: str, stream: bool) -> None:
+        message = anthropic_text_response(model, text)
+        if not stream:
+            self.write_json(handler, message)
+            return
+        self._start_headers(handler)
+        started = {
+            **message,
+            "content": [],
+            "stop_reason": None,
+            "usage": {"input_tokens": 0, "output_tokens": 0},
+        }
+        self._event(
+            handler,
+            "message_start",
+            {"type": "message_start", "message": started},
+        )
+        self.blocks(handler, message["content"], flush=False)
+        self.stop(handler, message, flush=False)
+        handler.wfile.flush()
+
+    def message(
+        self, handler: Any, message: dict[str, Any], stream: bool
+    ) -> None:
+        if not stream:
+            self.write_json(handler, message)
+            return
+        self._start_headers(handler)
+        self._event(
+            handler,
+            "message_start",
+            {
+                "type": "message_start",
+                "message": {**message, "content": [], "stop_reason": None},
+            },
+        )
+        self.blocks(handler, message.get("content") or [], flush=False)
+        self.stop(handler, message, flush=False)
+        handler.wfile.flush()
+
+    def block(self, handler: Any, index: int, block: dict[str, Any]) -> None:
+        block_type = block.get("type")
+        if block_type == "text":
+            self._event(
+                handler,
+                "content_block_start",
+                {
+                    "type": "content_block_start",
+                    "index": index,
+                    "content_block": {"type": "text", "text": ""},
+                },
+            )
+            self._event(
+                handler,
+                "content_block_delta",
+                {
+                    "type": "content_block_delta",
+                    "index": index,
+                    "delta": {
+                        "type": "text_delta",
+                        "text": block.get("text", ""),
+                    },
+                },
+            )
+        elif block_type == "thinking":
+            self._event(
+                handler,
+                "content_block_start",
+                {
+                    "type": "content_block_start",
+                    "index": index,
+                    "content_block": {"type": "thinking", "thinking": ""},
+                },
+            )
+            thinking = str(block.get("thinking") or "")
+            if thinking:
+                self._event(
+                    handler,
+                    "content_block_delta",
+                    {
+                        "type": "content_block_delta",
+                        "index": index,
+                        "delta": {"type": "thinking_delta", "thinking": thinking},
+                    },
+                )
+            signature = str(block.get("signature") or "")
+            if signature:
+                self._event(
+                    handler,
+                    "content_block_delta",
+                    {
+                        "type": "content_block_delta",
+                        "index": index,
+                        "delta": {"type": "signature_delta", "signature": signature},
+                    },
+                )
+        elif block_type == "redacted_thinking":
+            self._event(
+                handler,
+                "content_block_start",
+                {
+                    "type": "content_block_start",
+                    "index": index,
+                    "content_block": block,
+                },
+            )
+        elif block_type == "tool_use":
+            tool_input = block.get("input") or {}
+            self._event(
+                handler,
+                "content_block_start",
+                {
+                    "type": "content_block_start",
+                    "index": index,
+                    "content_block": {**block, "input": {}},
+                },
+            )
+            self._event(
+                handler,
+                "content_block_delta",
+                {
+                    "type": "content_block_delta",
+                    "index": index,
+                    "delta": {
+                        "type": "input_json_delta",
+                        "partial_json": json.dumps(tool_input, ensure_ascii=False),
+                    },
+                },
+            )
+        else:
+            return
+        self._event(
+            handler,
+            "content_block_stop",
+            {"type": "content_block_stop", "index": index},
+        )
+
+    def start(self, handler: Any, model: str, input_tokens: int = 0) -> None:
+        self._start_headers(handler)
+        self._event(
+            handler,
+            "message_start",
+            {
+                "type": "message_start",
+                "message": {
+                    "id": f"msg_ciel_runtime_{int(time.time() * 1000)}",
+                    "type": "message",
+                    "role": "assistant",
+                    "content": [],
+                    "model": model,
+                    "stop_reason": None,
+                    "stop_sequence": None,
+                    "usage": {
+                        "input_tokens": max(0, int(input_tokens or 0)),
+                        "output_tokens": 0,
+                    },
+                },
+            },
+        )
+        handler.wfile.flush()
+
+    def blocks(
+        self,
+        handler: Any,
+        blocks: list[dict[str, Any]],
+        start_index: int = 0,
+        *,
+        flush: bool = True,
+    ) -> int:
+        index = start_index
+        for block in blocks:
+            self.block(handler, index, block)
+            index += 1
+        if flush:
+            handler.wfile.flush()
+        return index
+
+    def stop(
+        self,
+        handler: Any,
+        message: dict[str, Any] | None = None,
+        *,
+        flush: bool = True,
+    ) -> None:
+        message = message or {}
+        self._event(
+            handler,
+            "message_delta",
+            {
+                "type": "message_delta",
+                "delta": {
+                    "stop_reason": message.get("stop_reason") or "end_turn",
+                    "stop_sequence": None,
+                },
+                "usage": message.get("usage") or {"output_tokens": 1},
+            },
+        )
+        self._event(handler, "message_stop", {"type": "message_stop"})
+        if flush:
+            handler.wfile.flush()

package/ciel_runtime_support/anthropic_tool_turns.py

@@ -0,0 +1,130 @@
+"""Normalize retained Anthropic tool turns for non-native provider wires."""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from dataclasses import dataclass
+from typing import Any
+
+
+@dataclass(frozen=True, slots=True)
+class AnthropicToolTurnServices:
+    tool_use_as_text: Callable[[dict[str, Any]], dict[str, str]]
+    tool_result_as_text: Callable[[dict[str, Any]], dict[str, str]]
+    log: Callable[[str, str], Any]
+
+
+def normalize_historical_anthropic_tool_turns(
+    provider: str,
+    body: dict[str, Any],
+    services: AnthropicToolTurnServices,
+) -> dict[str, Any]:
+    """Downgrade unmatched historical tool blocks instead of synthesizing success."""
+    messages = body.get("messages")
+    if not isinstance(messages, list):
+        return body
+
+    changed = False
+    converted_tool_uses = 0
+    converted_tool_results = 0
+    normalized_messages: list[Any] = []
+    retained_tool_ids_for_next_user: set[str] = set()
+
+    for index, message in enumerate(messages):
+        if not isinstance(message, dict):
+            normalized_messages.append(message)
+            retained_tool_ids_for_next_user = set()
+            continue
+
+        role = str(message.get("role") or "")
+        content = message.get("content")
+        if role == "assistant" and isinstance(content, list):
+            tool_ids = _tool_use_ids(message)
+            if not tool_ids:
+                normalized_messages.append(message)
+                retained_tool_ids_for_next_user = set()
+                continue
+            next_message = messages[index + 1] if index + 1 < len(messages) else None
+            next_result_ids = (
+                set(_tool_result_ids(next_message))
+                if isinstance(next_message, dict) and str(next_message.get("role") or "") == "user"
+                else set()
+            )
+            retained = {tool_id for tool_id in tool_ids if tool_id in next_result_ids}
+            next_content: list[Any] = []
+            content_changed = False
+            for block in content:
+                if isinstance(block, dict) and block.get("type") == "tool_use":
+                    tool_id = str(block.get("id") or "")
+                    if not tool_id or tool_id not in retained:
+                        next_content.append(services.tool_use_as_text(block))
+                        converted_tool_uses += 1
+                        content_changed = True
+                        continue
+                next_content.append(block)
+            normalized_messages.append(_with_content(message, next_content) if content_changed else message)
+            changed = changed or content_changed
+            retained_tool_ids_for_next_user = retained
+            continue
+
+        if role == "user" and isinstance(content, list):
+            next_content = []
+            content_changed = False
+            for block in content:
+                if isinstance(block, dict) and block.get("type") == "tool_result":
+                    tool_id = str(block.get("tool_use_id") or "")
+                    if tool_id and tool_id in retained_tool_ids_for_next_user:
+                        next_content.append(block)
+                    else:
+                        next_content.append(services.tool_result_as_text(block))
+                        converted_tool_results += 1
+                        content_changed = True
+                    continue
+                next_content.append(block)
+            normalized_messages.append(_with_content(message, next_content) if content_changed else message)
+            changed = changed or content_changed
+            retained_tool_ids_for_next_user = set()
+            continue
+
+        normalized_messages.append(message)
+        retained_tool_ids_for_next_user = set()
+
+    if not changed:
+        return body
+    out = dict(body)
+    out["messages"] = normalized_messages
+    services.log(
+        "WARN",
+        "normalized historical Anthropic tool turns for provider=%s converted_tool_uses=%d converted_tool_results=%d"
+        % (provider, converted_tool_uses, converted_tool_results),
+    )
+    return out
+
+
+def _content_blocks(message: dict[str, Any]) -> list[Any]:
+    content = message.get("content")
+    return content if isinstance(content, list) else []
+
+
+def _tool_use_ids(message: dict[str, Any]) -> list[str]:
+    return [
+        tool_id
+        for block in _content_blocks(message)
+        if isinstance(block, dict) and block.get("type") == "tool_use"
+        if (tool_id := str(block.get("id") or ""))
+    ]
+
+
+def _tool_result_ids(message: dict[str, Any]) -> list[str]:
+    return [
+        tool_id
+        for block in _content_blocks(message)
+        if isinstance(block, dict) and block.get("type") == "tool_result"
+        if (tool_id := str(block.get("tool_use_id") or ""))
+    ]
+
+
+def _with_content(message: dict[str, Any], content: list[Any]) -> dict[str, Any]:
+    updated = dict(message)
+    updated["content"] = content
+    return updated