@oneciel-ai/ciel-runtime 0.1.1 → 0.2.0

package/ciel_runtime_support/protocols/anthropic_thinking_policy.py

@@ -0,0 +1,336 @@
+"""Anthropic thinking and tool-choice compatibility policies.
+
+The policy owns protocol-level message transformations. Provider discovery and
+logging remain injected ports so this module does not depend on the runtime
+facade or on concrete provider adapters.
+"""
+
+from __future__ import annotations
+
+import time
+from collections.abc import Callable
+from dataclasses import dataclass
+from typing import Any
+
+
+THINKING_BLOCK_TYPES: tuple[str, ...] = ("thinking", "redacted_thinking")
+
+
+def message_content_blocks(message: dict[str, Any]) -> list[Any]:
+    content = message.get("content")
+    if isinstance(content, list):
+        return content
+    if isinstance(content, str):
+        return [{"type": "text", "text": content}]
+    return []
+
+
+def thinking_requested(body: dict[str, Any]) -> bool:
+    thinking = body.get("thinking")
+    if isinstance(thinking, dict):
+        thinking_type = str(thinking.get("type") or "").strip().lower()
+        return thinking_type not in ("", "disabled", "none", "off", "false")
+    return bool(thinking)
+
+
+def thinking_block_count(body: dict[str, Any]) -> int:
+    return sum(
+        1
+        for message in body.get("messages") or []
+        if isinstance(message, dict)
+        for block in message_content_blocks(message)
+        if isinstance(block, dict) and block.get("type") in THINKING_BLOCK_TYPES
+    )
+
+
+def tool_continuation_block_count(body: dict[str, Any]) -> int:
+    count = 0
+    for message in body.get("messages") or []:
+        if not isinstance(message, dict):
+            continue
+        role = message.get("role")
+        for block in message_content_blocks(message):
+            if not isinstance(block, dict):
+                continue
+            block_type = block.get("type")
+            if (role == "assistant" and block_type == "tool_use") or (
+                role == "user" and block_type == "tool_result"
+            ):
+                count += 1
+    return count
+
+
+def assistant_history_count(body: dict[str, Any]) -> int:
+    return sum(
+        1
+        for message in body.get("messages") or []
+        if isinstance(message, dict) and message.get("role") == "assistant"
+    )
+
+
+def strip_thinking_blocks(body: dict[str, Any]) -> dict[str, Any]:
+    messages = body.get("messages")
+    if not isinstance(messages, list):
+        return body
+    changed = False
+    projected: list[Any] = []
+    for message in messages:
+        content = message.get("content") if isinstance(message, dict) else None
+        if not isinstance(content, list):
+            projected.append(message)
+            continue
+        filtered = [
+            block
+            for block in content
+            if not (
+                isinstance(block, dict)
+                and block.get("type") in THINKING_BLOCK_TYPES
+            )
+        ]
+        if len(filtered) == len(content):
+            projected.append(message)
+            continue
+        projected.append({**message, "content": filtered})
+        changed = True
+    return {**body, "messages": projected} if changed else body
+
+
+def has_synthetic_tool_use(body: dict[str, Any]) -> bool:
+    return any(
+        str(block.get("id") or "").startswith("toolu_ciel_runtime_")
+        for message in body.get("messages") or []
+        if isinstance(message, dict) and message.get("role") == "assistant"
+        for block in message_content_blocks(message)
+        if isinstance(block, dict) and block.get("type") == "tool_use"
+    )
+
+
+def copy_thinking_blocks(blocks: Any) -> list[dict[str, Any]]:
+    if not isinstance(blocks, list):
+        return []
+    return [
+        dict(block)
+        for block in blocks
+        if isinstance(block, dict) and block.get("type") in THINKING_BLOCK_TYPES
+    ]
+
+
+@dataclass(frozen=True, slots=True)
+class ThinkingPolicyPorts:
+    preserves_contract: Callable[[str, dict[str, Any]], bool]
+    reasoning_passback_enabled: Callable[[str, dict[str, Any], dict[str, Any]], bool]
+    suggestion_mode: Callable[[dict[str, Any]], bool]
+    log: Callable[[str, str], None]
+
+
+@dataclass(frozen=True, slots=True)
+class ToolChoicePorts:
+    normalize: Callable[[str, dict[str, Any], dict[str, Any], Any], Any]
+    supports: Callable[[str, dict[str, Any], dict[str, Any]], bool]
+    log: Callable[[str, str], None]
+
+
+class SuppressedThinkingRepository:
+    """Bounded in-memory repository for passback blocks hidden from clients."""
+
+    def __init__(
+        self,
+        records: list[dict[str, Any]],
+        capacity: Callable[[], int],
+    ) -> None:
+        self._records = records
+        self._capacity = capacity
+
+    def clear(self) -> None:
+        self._records.clear()
+
+    def remember(self, provider: str, model: str, blocks: list[Any]) -> int:
+        copied = copy_thinking_blocks(blocks)
+        if not copied:
+            return 0
+        self._records.append(
+            {
+                "time": time.strftime("%Y-%m-%dT%H:%M:%S"),
+                "provider": provider,
+                "model": model,
+                "blocks": copied,
+            }
+        )
+        capacity = max(1, self._capacity())
+        del self._records[:-capacity]
+        return len(copied)
+
+    def recent_for(self, provider: str, limit: int) -> list[dict[str, Any]]:
+        if limit <= 0:
+            return []
+        matches = [record for record in self._records if record.get("provider") == provider]
+        return matches[-limit:]
+
+    def __len__(self) -> int:
+        return len(self._records)
+
+
+class AnthropicThinkingPolicy:
+    def __init__(
+        self,
+        ports: ThinkingPolicyPorts,
+        repository: SuppressedThinkingRepository,
+    ) -> None:
+        self._ports = ports
+        self._repository = repository
+
+    def normalize_request(
+        self, provider: str, config: dict[str, Any], body: dict[str, Any]
+    ) -> dict[str, Any]:
+        requested = thinking_requested(body)
+        block_count = thinking_block_count(body)
+        if (not requested and block_count <= 0) or self._ports.preserves_contract(
+            provider, config
+        ):
+            return body
+        if self._ports.reasoning_passback_enabled(provider, config, body):
+            if not requested:
+                return body
+            projected = dict(body)
+            projected.pop("thinking", None)
+            self._ports.log(
+                "INFO",
+                "removed top-level Anthropic thinking request but preserved thinking blocks "
+                f"for OpenAI-chat reasoning passback provider={provider} "
+                f"thinking_blocks={block_count}",
+            )
+            return projected
+        projected = dict(strip_thinking_blocks(body))
+        projected.pop("thinking", None)
+        self._ports.log(
+            "WARN",
+            "removed Anthropic thinking request and thinking content blocks for "
+            f"non-Anthropic provider provider={provider} "
+            f"synthetic_tool={has_synthetic_tool_use(body)} "
+            f"continuation_blocks={tool_continuation_block_count(body)} "
+            f"assistant_history={assistant_history_count(body)} "
+            f"thinking_blocks={block_count}",
+        )
+        return projected
+
+    def normalize_response(
+        self,
+        provider: str,
+        config: dict[str, Any],
+        message: dict[str, Any],
+        model: str | None = None,
+    ) -> dict[str, Any]:
+        if self._ports.preserves_contract(provider, config):
+            return message
+        content = message.get("content")
+        if not isinstance(content, list):
+            return message
+        filtered = [
+            block
+            for block in content
+            if not (
+                isinstance(block, dict)
+                and block.get("type") in THINKING_BLOCK_TYPES
+            )
+        ]
+        if len(filtered) == len(content):
+            return message
+        self.remember(provider, str(model or message.get("model") or ""), content)
+        self._ports.log(
+            "WARN",
+            "removed Anthropic thinking response blocks for non-Anthropic provider "
+            f"provider={provider} thinking_blocks={len(content) - len(filtered)}",
+        )
+        return {**message, "content": filtered or [{"type": "text", "text": ""}]}
+
+    def remember(self, provider: str, model: str, blocks: list[Any]) -> None:
+        copied = self._repository.remember(provider, model, blocks)
+        if copied:
+            self._ports.log(
+                "WARN",
+                "stored suppressed Anthropic thinking passback blocks "
+                f"provider={provider} model={model} blocks={copied} "
+                f"cache={len(self._repository)}",
+            )
+
+    def rehydrate(
+        self, provider: str, config: dict[str, Any], body: dict[str, Any]
+    ) -> dict[str, Any]:
+        if (
+            self._ports.preserves_contract(provider, config)
+            or self._ports.suggestion_mode(body)
+            or not len(self._repository)
+        ):
+            return body
+        messages = body.get("messages")
+        if not isinstance(messages, list):
+            return body
+        indices = [
+            index
+            for index, message in enumerate(messages)
+            if isinstance(message, dict)
+            and message.get("role") == "assistant"
+            and not thinking_block_count({"messages": [message]})
+            and (
+                (isinstance(message.get("content"), list) and bool(message["content"]))
+                or (isinstance(message.get("content"), str) and bool(message["content"]))
+            )
+        ]
+        records = self._repository.recent_for(provider, len(indices))
+        if not records:
+            return body
+        selected = indices[-len(records) :]
+        projected = list(messages)
+        inserted = 0
+        for index, record in zip(selected, records):
+            message = projected[index]
+            blocks = copy_thinking_blocks(record.get("blocks"))
+            if not isinstance(message, dict) or not blocks:
+                continue
+            content = message.get("content")
+            if isinstance(content, list):
+                new_content = blocks + list(content)
+            elif isinstance(content, str):
+                new_content = blocks + [{"type": "text", "text": content}]
+            else:
+                continue
+            projected[index] = {**message, "content": new_content}
+            inserted += len(blocks)
+        if not inserted:
+            return body
+        self._ports.log(
+            "WARN",
+            "rehydrated suppressed Anthropic thinking passback blocks for upstream "
+            f"provider={provider} blocks={inserted} "
+            f"assistant_messages={len(selected)} cache={len(self._repository)}",
+        )
+        return {**body, "messages": projected}
+
+
+def normalize_tool_choice(
+    provider: str,
+    config: dict[str, Any],
+    body: dict[str, Any],
+    ports: ToolChoicePorts,
+) -> dict[str, Any]:
+    tool_choice = body.get("tool_choice")
+    if tool_choice is None:
+        return body
+    normalized = ports.normalize(provider, config, body, tool_choice)
+    if normalized != tool_choice:
+        ports.log(
+            "WARN",
+            f"normalized unsupported forced tool_choice for provider={provider}: "
+            f"model={body.get('model')} tool_choice={tool_choice}",
+        )
+        return {**body, "tool_choice": normalized}
+    if ports.supports(provider, config, body):
+        return body
+    projected = dict(body)
+    removed = projected.pop("tool_choice", None)
+    ports.log(
+        "WARN",
+        f"removed unsupported tool_choice for {provider}: "
+        f"model={body.get('model')} tool_choice={removed}",
+    )
+    return projected

package/ciel_runtime_support/protocols/chat_projection.py

@@ -0,0 +1,315 @@
+"""Anthropic Messages projections for chat-style provider protocols."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+import json
+from typing import Any, Callable
+
+
+@dataclass(frozen=True, slots=True)
+class ChatProjectionText:
+    system_messages: Callable[..., list[dict[str, Any]]]
+    execution_reminder: Callable[..., dict[str, str]]
+    state_messages: Callable[..., list[dict[str, Any]]]
+    content_to_text: Callable[..., str]
+    compact_text: Callable[..., str]
+    skip_message: Callable[..., bool]
+    attachment_only: Callable[..., bool]
+
+
+@dataclass(frozen=True, slots=True)
+class ChatProjectionTools:
+    collect_result_context: Callable[..., tuple[dict[str, str], set[str]]]
+    plan_mode_active: Callable[..., bool]
+    input_for_prompt: Callable[..., str]
+    persisted_output: Callable[..., bool]
+    truncate_for_prompt: Callable[..., str]
+    canonical_signature: Callable[..., str]
+    format_result: Callable[..., tuple[str, str]]
+
+
+@dataclass(frozen=True, slots=True)
+class ChatProjectionPolicy:
+    thinking_block_types: frozenset[str] | set[str] | tuple[str, ...]
+    tool_result_limit: int
+
+
+@dataclass(frozen=True, slots=True)
+class ChatProjectionServices:
+    text: ChatProjectionText
+    tools: ChatProjectionTools
+    policy: ChatProjectionPolicy
+
+
+@dataclass(frozen=True, slots=True)
+class OpenAiHistoryServices:
+    log: Callable[[str, str], None]
+
+
+def anthropic_messages_to_ollama(body: dict[str, Any], *, services: ChatProjectionServices) -> list[dict[str, Any]]:
+    text = services.text
+    tools = services.tools
+    messages = text.system_messages(body.get("system"))
+    messages.append(text.execution_reminder())
+    messages.extend(text.state_messages(body))
+    prior_tool_results, latest_noop_result_ids = tools.collect_result_context(body)
+    in_plan_mode = tools.plan_mode_active(body)
+    tool_names_by_id: dict[str, str] = {}
+    tool_inputs_by_id: dict[str, Any] = {}
+    for message in body.get("messages", []) or []:
+        if not isinstance(message, dict) or text.attachment_only(message) or text.skip_message(message):
+            continue
+        role = message.get("role", "user")
+        content = message.get("content", "")
+        if role == "user" and isinstance(content, list):
+            text_blocks: list[Any] = []
+            tool_blocks: list[dict[str, Any]] = []
+            for block in content:
+                if isinstance(block, dict) and block.get("type") == "tool_result":
+                    tool_blocks.append(block)
+                else:
+                    text_blocks.append(block)
+            user_text = text.content_to_text(text_blocks)
+            if user_text:
+                messages.append({"role": "user", "content": text.compact_text(user_text)})
+            for block in tool_blocks:
+                tool_use_id = str(block.get("tool_use_id") or "")
+                tool_name = tool_names_by_id.get(tool_use_id, "tool")
+                tool_input = tool_inputs_by_id.get(tool_use_id)
+                tool_input_text = tools.input_for_prompt(tool_input)
+                raw_result_text = text.content_to_text(block.get("content", ""))
+                if tools.persisted_output(raw_result_text):
+                    result_text = raw_result_text
+                    tool_text = raw_result_text
+                    tool_summary = ""
+                else:
+                    result_text = tools.truncate_for_prompt(raw_result_text, services.policy.tool_result_limit)
+                    signature = tools.canonical_signature(tool_name, tool_input)
+                    tool_text, tool_summary = tools.format_result(
+                        tool_name=tool_name,
+                        tool_input_text=tool_input_text,
+                        result_text=result_text,
+                        is_error=bool(block.get("is_error")),
+                        prior_success_text=prior_tool_results.get(signature, ""),
+                        include_prior_success=tool_use_id in latest_noop_result_ids,
+                        in_plan_mode=in_plan_mode,
+                    )
+                    if not block.get("is_error") and tool_name == "TaskList":
+                        tool_summary = (
+                            f"The task list is current:\n{result_text}\n\n"
+                            "If any task is in_progress and the user's request is not finished, your next response "
+                            "must call a concrete work tool such as Write, Edit, Read, or Bash. Do not respond with "
+                            "another progress announcement like 'I will write the files now'. If everything is "
+                            "actually complete, provide the final answer."
+                        )
+                messages.append({"role": "tool", "tool_name": tool_name, "content": tool_text})
+                if tool_summary:
+                    messages.append({"role": "user", "content": tool_summary})
+            continue
+        message_text = text.content_to_text(content)
+        out: dict[str, Any] = {"role": role, "content": text.compact_text(message_text)}
+        if role == "assistant" and isinstance(content, list):
+            calls = []
+            for block in content:
+                if isinstance(block, dict) and block.get("type") == "tool_use":
+                    name = str(block.get("name") or "tool")
+                    tool_id = str(block.get("id") or "")
+                    if tool_id:
+                        tool_names_by_id[tool_id] = name
+                        tool_inputs_by_id[tool_id] = block.get("input") or {}
+                    calls.append({"function": {"name": name, "arguments": block.get("input") or {}}})
+            if calls:
+                out["tool_calls"] = calls
+        messages.append(out)
+    return messages
+
+
+def anthropic_messages_to_openai(
+    body: dict[str, Any],
+    reasoning_passback: bool = False,
+    *,
+    services: ChatProjectionServices,
+) -> list[dict[str, Any]]:
+    text = services.text
+    tools = services.tools
+    messages = text.system_messages(body.get("system"))
+    messages.append(text.execution_reminder())
+    messages.extend(text.state_messages(body))
+    prior_tool_results, latest_noop_result_ids = tools.collect_result_context(body)
+    in_plan_mode = tools.plan_mode_active(body)
+    tool_names_by_id: dict[str, str] = {}
+    tool_inputs_by_id: dict[str, Any] = {}
+    for message in body.get("messages", []) or []:
+        if not isinstance(message, dict) or text.attachment_only(message) or text.skip_message(message):
+            continue
+        role = message.get("role", "user")
+        content = message.get("content", "")
+        if role == "assistant" and isinstance(content, list):
+            text_blocks: list[Any] = []
+            tool_calls: list[dict[str, Any]] = []
+            reasoning_seen = False
+            reasoning_parts: list[str] = []
+            for block in content:
+                if isinstance(block, dict) and block.get("type") in services.policy.thinking_block_types:
+                    reasoning_seen = True
+                    if block.get("type") == "thinking":
+                        reasoning_parts.append(str(block.get("thinking") or ""))
+                    continue
+                if isinstance(block, dict) and block.get("type") == "tool_use":
+                    tool_id = str(block.get("id") or f"call_{len(tool_calls) + 1}")
+                    name = str(block.get("name") or "tool")
+                    tool_input = block.get("input") if isinstance(block.get("input"), dict) else {}
+                    tool_names_by_id[tool_id] = name
+                    tool_inputs_by_id[tool_id] = tool_input
+                    tool_calls.append({
+                        "id": tool_id,
+                        "type": "function",
+                        "function": {"name": name, "arguments": json.dumps(tool_input, ensure_ascii=False)},
+                    })
+                else:
+                    text_blocks.append(block)
+            out: dict[str, Any] = {"role": "assistant", "content": text.compact_text(text.content_to_text(text_blocks))}
+            if reasoning_seen or reasoning_passback:
+                out["reasoning_content"] = "\n".join(reasoning_parts)
+            if tool_calls:
+                out["tool_calls"] = tool_calls
+            messages.append(out)
+            continue
+        if role == "user" and isinstance(content, list):
+            text_blocks = []
+            for block in content:
+                if isinstance(block, dict) and block.get("type") == "tool_result":
+                    tool_id = str(block.get("tool_use_id") or "call_tool")
+                    raw_result_text = text.content_to_text(block.get("content", ""))
+                    if tool_id not in tool_names_by_id:
+                        result_text = raw_result_text if tools.persisted_output(raw_result_text) else tools.truncate_for_prompt(raw_result_text, services.policy.tool_result_limit)
+                        if tools.persisted_output(result_text):
+                            text_blocks.append({"type": "text", "text": result_text})
+                        else:
+                            text_blocks.append({"type": "text", "text": f"Historical tool result without a retained assistant tool call ({tool_id}):\n{result_text}"})
+                        continue
+                    tool_name = tool_names_by_id.get(tool_id, "tool")
+                    tool_input = tool_inputs_by_id.get(tool_id)
+                    if tools.persisted_output(raw_result_text):
+                        tool_text = raw_result_text
+                    else:
+                        result_text = tools.truncate_for_prompt(raw_result_text, services.policy.tool_result_limit)
+                        tool_text, _ = tools.format_result(
+                            tool_name=tool_name,
+                            tool_input_text=tools.input_for_prompt(tool_input),
+                            result_text=result_text,
+                            is_error=bool(block.get("is_error")),
+                            prior_success_text=prior_tool_results.get(tools.canonical_signature(tool_name, tool_input), ""),
+                            include_prior_success=tool_id in latest_noop_result_ids,
+                            in_plan_mode=in_plan_mode,
+                        )
+                    messages.append({"role": "tool", "tool_call_id": tool_id, "id": tool_id, "content": tool_text})
+                else:
+                    text_blocks.append(block)
+            user_text = text.content_to_text(text_blocks)
+            if user_text:
+                messages.append({"role": "user", "content": text.compact_text(user_text)})
+            continue
+        out = {"role": role, "content": text.compact_text(text.content_to_text(content))}
+        if role == "assistant" and reasoning_passback:
+            out["reasoning_content"] = ""
+        messages.append(out)
+    return messages
+
+
+def missing_openai_tool_result_message(tool_call: dict[str, Any]) -> dict[str, Any]:
+    tool_id = str(tool_call.get("id") or "call_tool")
+    function = tool_call.get("function") if isinstance(tool_call.get("function"), dict) else {}
+    name = str(function.get("name") or "tool")
+    return {
+        "role": "tool",
+        "tool_call_id": tool_id,
+        "id": tool_id,
+        "content": (
+            f"Tool result for historical tool call `{name}` was not present in the retained "
+            "Claude Code transcript. Treat this as missing historical context, not as a "
+            "successful tool execution."
+        ),
+    }
+
+
+def orphan_openai_tool_message_to_user(message: dict[str, Any]) -> dict[str, str]:
+    tool_id = str(message.get("tool_call_id") or message.get("id") or "unknown")
+    content = str(message.get("content") or "")
+    return {
+        "role": "user",
+        "content": (
+            f"Historical tool message without a retained assistant tool call ({tool_id}):\n"
+            f"{content}"
+        ),
+    }
+
+
+def repair_openai_tool_call_adjacency(
+    messages: list[dict[str, Any]],
+    services: OpenAiHistoryServices,
+) -> list[dict[str, Any]]:
+    """Repair OpenAI's immediate tool-result adjacency invariant."""
+    repaired: list[dict[str, Any]] = []
+    missing_count = 0
+    orphan_count = 0
+    index = 0
+    while index < len(messages):
+        message = messages[index]
+        tool_calls = message.get("tool_calls") if isinstance(message, dict) else None
+        if not (message.get("role") == "assistant" and isinstance(tool_calls, list) and tool_calls):
+            if message.get("role") == "tool":
+                repaired.append(orphan_openai_tool_message_to_user(message))
+                orphan_count += 1
+            else:
+                repaired.append(message)
+            index += 1
+            continue
+        repaired.append(message)
+        index += 1
+        immediate_tools: list[dict[str, Any]] = []
+        while (
+            index < len(messages)
+            and isinstance(messages[index], dict)
+            and messages[index].get("role") == "tool"
+        ):
+            immediate_tools.append(messages[index])
+            index += 1
+        by_id: dict[str, list[dict[str, Any]]] = {}
+        for tool_message in immediate_tools:
+            tool_id = str(tool_message.get("tool_call_id") or tool_message.get("id") or "")
+            by_id.setdefault(tool_id, []).append(tool_message)
+        required_ids: list[str] = []
+        for call in tool_calls:
+            if not isinstance(call, dict):
+                continue
+            tool_id = str(call.get("id") or "")
+            if not tool_id:
+                continue
+            required_ids.append(tool_id)
+            matches = by_id.get(tool_id) or []
+            if matches:
+                repaired.append(matches.pop(0))
+            else:
+                repaired.append(missing_openai_tool_result_message(call))
+                missing_count += 1
+        required = set(required_ids)
+        for tool_message in immediate_tools:
+            tool_id = str(tool_message.get("tool_call_id") or tool_message.get("id") or "")
+            if tool_id in required:
+                remaining = by_id.get(tool_id) or []
+                if tool_message in remaining:
+                    remaining.remove(tool_message)
+                    repaired.append(orphan_openai_tool_message_to_user(tool_message))
+                    orphan_count += 1
+            else:
+                repaired.append(orphan_openai_tool_message_to_user(tool_message))
+                orphan_count += 1
+    if missing_count or orphan_count:
+        services.log(
+            "WARN",
+            f"openai_tool_call_adjacency_repaired missing_tool_results={missing_count} "
+            f"orphan_tool_messages={orphan_count}",
+        )
+    return repaired