@oneciel-ai/ciel-runtime 0.1.1 → 0.2.0

package/ciel_runtime_support/protocols/ollama_chat.py

@@ -0,0 +1,111 @@
+"""Pure Anthropic-to-Ollama chat wire projections."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+from ciel_runtime_support.protocols.anthropic_content import content_to_text
+
+
+@dataclass(frozen=True, slots=True)
+class DecodedOllamaChatResponse:
+    """Provider-neutral values decoded from one Ollama `/api/chat` response."""
+
+    text: str
+    tool_calls: tuple[dict[str, Any], ...]
+    done_reason: str
+    input_tokens: int
+    output_tokens: int
+
+
+def decode_ollama_chat_response(data: dict[str, Any]) -> DecodedOllamaChatResponse:
+    """Decode the Ollama envelope without applying runtime/tool policies."""
+
+    message = data.get("message") if isinstance(data.get("message"), dict) else {}
+    calls = message.get("tool_calls") if isinstance(message, dict) else None
+    return DecodedOllamaChatResponse(
+        text=str(message.get("content") or ""),
+        tool_calls=tuple(call for call in (calls or []) if isinstance(call, dict)),
+        done_reason=str(data.get("done_reason") or ""),
+        input_tokens=max(0, int(data.get("prompt_eval_count") or 0)),
+        output_tokens=max(0, int(data.get("eval_count") or 0)),
+    )
+
+
+def encode_anthropic_message(
+    *,
+    message_id: str,
+    model: str,
+    content: list[dict[str, Any]],
+    done_reason: str,
+    input_tokens: int,
+    output_tokens: int,
+) -> dict[str, Any]:
+    """Encode finalized content blocks as an Anthropic Messages response."""
+
+    has_tool_use = any(block.get("type") == "tool_use" for block in content)
+    stop_reason = "tool_use" if has_tool_use else "end_turn"
+    if done_reason == "length":
+        stop_reason = "max_tokens"
+    return {
+        "id": message_id,
+        "type": "message",
+        "role": "assistant",
+        "model": model,
+        "content": content or [{"type": "text", "text": ""}],
+        "stop_reason": stop_reason,
+        "stop_sequence": None,
+        "usage": {
+            "input_tokens": input_tokens,
+            "output_tokens": output_tokens,
+        },
+    }
+
+
+def anthropic_system_to_ollama_messages(system: Any) -> list[dict[str, Any]]:
+    if not system:
+        return []
+    text = content_to_text(system)
+    return [{"role": "system", "content": text}] if text else []
+
+
+def ollama_claude_code_reminder() -> dict[str, str]:
+    return {
+        "role": "system",
+        "content": (
+            "Claude Code execution reminder: when the user asks to create, edit, or run code, "
+            "use the available tools such as Write, Edit, Read, and Bash. Do not stop after saying "
+            "you will run something. Do not present a code block as a substitute for creating the file "
+            "unless the user explicitly asks for code only. Exception: while Claude Code is in Plan Mode, "
+            "do not implement normal project files; explore as needed, write or update the plan file, "
+            "then call ExitPlanMode when the plan is ready for approval."
+        ),
+    }
+
+
+def anthropic_tools_to_ollama(tools: Any) -> list[dict[str, Any]]:
+    if not isinstance(tools, list):
+        return []
+    return [
+        {
+            "type": "function",
+            "function": {
+                "name": tool["name"],
+                "description": tool.get("description", ""),
+                "parameters": tool.get("input_schema") or {"type": "object", "properties": {}},
+            },
+        }
+        for tool in tools
+        if isinstance(tool, dict) and tool.get("name")
+    ]
+
+
+__all__ = [
+    "DecodedOllamaChatResponse",
+    "anthropic_system_to_ollama_messages",
+    "anthropic_tools_to_ollama",
+    "decode_ollama_chat_response",
+    "encode_anthropic_message",
+    "ollama_claude_code_reminder",
+]

package/ciel_runtime_support/protocols/ollama_response.py

@@ -0,0 +1,231 @@
+"""Ollama response projection into Anthropic Messages content."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Callable
+
+
+@dataclass(frozen=True, slots=True)
+class OllamaResponseText:
+    decode: Callable[[dict[str, Any]], Any]
+    strip_thinking: Callable[[str], str]
+    parse_pseudo_tools: Callable[..., tuple[str, list[dict[str, Any]]]]
+    log: Callable[[str, str], Any]
+
+
+@dataclass(frozen=True, slots=True)
+class OllamaResponseTools:
+    resolve_name: Callable[..., str]
+    normalize_arguments: Callable[..., dict[str, Any]]
+    validate_input: Callable[..., dict[str, Any]]
+    plan_mode_name: Callable[..., tuple[str | None, dict[str, Any]]]
+    cap_notification_wait: Callable[..., dict[str, Any]]
+    should_drop: Callable[..., bool]
+    append_log: Callable[..., Any]
+
+
+@dataclass(frozen=True, slots=True)
+class OllamaResponseRecovery:
+    auto_enter_plan: Callable[..., bool]
+    recover_empty_with_tasklist: Callable[..., bool]
+    keep_alive_with_tasklist: Callable[..., bool]
+    auto_continue_choice: Callable[..., bool]
+    empty_notice: Callable[[dict[str, Any]], str]
+    latest_tool_result_names: Callable[[dict[str, Any]], list[str]]
+    synthetic_tool_response: Callable[..., dict[str, Any]]
+
+
+@dataclass(frozen=True, slots=True)
+class OllamaResponseOutput:
+    encode_message: Callable[..., dict[str, Any]]
+    estimate_tokens: Callable[[dict[str, Any]], int]
+    timestamp_ms: Callable[[], int]
+    process_id: Callable[[], int]
+
+
+@dataclass(frozen=True, slots=True)
+class OllamaResponseServices:
+    text: OllamaResponseText
+    tools: OllamaResponseTools
+    recovery: OllamaResponseRecovery
+    output: OllamaResponseOutput
+
+
+def project_ollama_response(
+    data: dict[str, Any],
+    model: str,
+    source_body: dict[str, Any] | None,
+    services: OllamaResponseServices,
+) -> dict[str, Any]:
+    decoded = services.text.decode(data)
+    content: list[dict[str, Any]] = []
+    raw_text = decoded.text
+    text = services.text.strip_thinking(raw_text)
+    if text != raw_text:
+        services.text.log(
+            "WARN",
+            f"suppressed visible Ollama thinking markup model={model} removed_chars={len(raw_text) - len(text)}",
+        )
+    text, pseudo_tool_calls = services.text.parse_pseudo_tools(text, source_body)
+    if text:
+        content.append({"type": "text", "text": text})
+    tool_id_prefix = f"toolu_ollama_{services.output.timestamp_ms()}_{services.output.process_id()}"
+    for index, call in enumerate(list(decoded.tool_calls) + pseudo_tool_calls):
+        tool_block = _project_tool_call(call, index, tool_id_prefix, model, source_body, services)
+        if tool_block is not None:
+            content.append(tool_block)
+
+    emitted = [block for block in content if block.get("type") == "tool_use"]
+    recovered = _recover_response(model, source_body, text, emitted, content, tool_id_prefix, services)
+    if recovered is not None:
+        return recovered
+    if source_body is not None and not text.strip() and not emitted:
+        text = services.recovery.empty_notice(source_body)
+        names = ",".join(services.recovery.latest_tool_result_names(source_body)) or "-"
+        services.text.log("WARN", f"ollama_empty_end_turn_notice model={model} latest_tool_results={names}")
+        content.append({"type": "text", "text": text})
+
+    input_tokens = decoded.input_tokens
+    if input_tokens <= 0 and isinstance(source_body, dict):
+        input_tokens = services.output.estimate_tokens(source_body)
+    output_tokens = decoded.output_tokens or max(1, len(text) // 4)
+    return services.output.encode_message(
+        message_id=f"msg_ollama_{services.output.timestamp_ms()}",
+        model=model,
+        content=content,
+        done_reason=decoded.done_reason,
+        input_tokens=input_tokens,
+        output_tokens=output_tokens,
+    )
+
+
+def project_openai_chat_response(
+    data: dict[str, Any],
+    model: str,
+    source_body: dict[str, Any] | None,
+    *,
+    services: OllamaResponseServices,
+    positive_int: Callable[[Any], int | None],
+    reasoning_to_block: Callable[[Any], dict[str, Any] | None],
+    content_to_text: Callable[[Any], str],
+) -> dict[str, Any]:
+    """Project an OpenAI-compatible chat response through the shared codec."""
+    choices = data.get("choices")
+    choice = (
+        choices[0]
+        if isinstance(choices, list)
+        and choices
+        and isinstance(choices[0], dict)
+        else {}
+    )
+    raw_message = choice.get("message")
+    message = raw_message if isinstance(raw_message, dict) else {}
+    usage_value = data.get("usage")
+    usage = usage_value if isinstance(usage_value, dict) else {}
+    wrapped = {
+        "message": {
+            "content": message.get("content") or "",
+            "tool_calls": message.get("tool_calls") or [],
+        },
+        "done_reason": (
+            "length"
+            if choice.get("finish_reason") == "length"
+            else "stop"
+        ),
+        "prompt_eval_count": positive_int(usage.get("prompt_tokens"))
+        or (
+            services.output.estimate_tokens(source_body)
+            if isinstance(source_body, dict)
+            else 0
+        ),
+        "eval_count": positive_int(usage.get("completion_tokens")) or 0,
+    }
+    output = project_ollama_response(
+        wrapped,
+        model,
+        source_body,
+        services,
+    )
+    thinking_block = reasoning_to_block(message.get("reasoning_content"))
+    if thinking_block is None:
+        return output
+    content = output.get("content")
+    if not isinstance(content, list):
+        content = [{"type": "text", "text": content_to_text(content)}]
+    output = dict(output)
+    output["content"] = [thinking_block, *content]
+    return output
+
+
+def _project_tool_call(
+    call: dict[str, Any],
+    index: int,
+    id_prefix: str,
+    model: str,
+    source_body: dict[str, Any] | None,
+    services: OllamaResponseServices,
+) -> dict[str, Any] | None:
+    function = call.get("function") if isinstance(call, dict) else {}
+    if not isinstance(function, dict) or not function.get("name"):
+        return None
+    raw_name = str(function["name"])
+    name = services.tools.resolve_name(raw_name, source_body)
+    raw_arguments = function.get("arguments")
+    normalized = services.tools.normalize_arguments(name, raw_arguments)
+    tool_input = services.tools.validate_input(name, normalized)
+    if source_body is not None:
+        name, tool_input = services.tools.plan_mode_name(source_body, name, tool_input)
+        if name is None:
+            return None
+    tool_input = services.tools.cap_notification_wait(name, tool_input)
+    if services.tools.should_drop(name, tool_input, raw_name, source_body):
+        return None
+    services.tools.append_log(
+        "ollama_nonstream_tool_call",
+        {
+            "model": model,
+            "raw_name": raw_name,
+            "matched_name": name,
+            "raw_arguments": raw_arguments,
+            "normalized_arguments": normalized,
+            "emitted_input": tool_input,
+        },
+    )
+    return {"type": "tool_use", "id": f"{id_prefix}_{index}", "name": name, "input": tool_input}
+
+
+def _recover_response(
+    model: str,
+    source_body: dict[str, Any] | None,
+    text: str,
+    emitted: list[dict[str, Any]],
+    content: list[dict[str, Any]],
+    id_prefix: str,
+    services: OllamaResponseServices,
+) -> dict[str, Any] | None:
+    if source_body is None:
+        return None
+    recovery = services.recovery
+    if recovery.auto_enter_plan(source_body, text, emitted):
+        services.text.log("WARN", "auto-synthesized EnterPlanMode from short/empty upstream response")
+        return recovery.synthetic_tool_response(model, "EnterPlanMode")
+    if recovery.recover_empty_with_tasklist(source_body, text, emitted):
+        services.text.log("WARN", "auto-synthesized TaskList from empty upstream end_turn")
+        return recovery.synthetic_tool_response(model, "TaskList")
+    if recovery.keep_alive_with_tasklist(source_body, text, emitted):
+        services.text.log("WARN", "auto-synthesized TaskList to keep work moving after tool result")
+        block = {"type": "tool_use", "id": f"{id_prefix}_keepalive", "name": "TaskList", "input": {}}
+        content.append(block)
+        emitted.append(block)
+    if recovery.auto_continue_choice(source_body, text, emitted):
+        services.text.log("WARN", "auto-synthesized TaskList after clarification question")
+        block = {
+            "type": "tool_use",
+            "id": f"toolu_ollama_choice_{services.output.timestamp_ms()}",
+            "name": "TaskList",
+            "input": {},
+        }
+        content.append(block)
+        emitted.append(block)
+    return None

package/ciel_runtime_support/protocols/openai_reasoning.py

@@ -0,0 +1,75 @@
+"""OpenAI reasoning/tool-choice projection and provider policy orchestration."""
+
+from __future__ import annotations
+
+import hashlib
+from dataclasses import dataclass
+from typing import Any, Callable
+
+from ..architecture import ProviderAdapter, ProviderConfig
+
+
+def anthropic_tool_choice_to_openai(tool_choice: Any) -> Any:
+    if not isinstance(tool_choice, dict):
+        return tool_choice
+    choice_type = tool_choice.get("type")
+    if choice_type == "tool" and tool_choice.get("name"):
+        return {"type": "function", "function": {"name": str(tool_choice["name"])}}
+    if choice_type == "any":
+        return "required"
+    if choice_type == "auto":
+        return "auto"
+    return tool_choice
+
+
+def openai_reasoning_to_anthropic_thinking_block(
+    reasoning_content: Any,
+) -> dict[str, Any] | None:
+    reasoning = str(reasoning_content or "")
+    if not reasoning:
+        return None
+    digest = hashlib.sha256(reasoning.encode("utf-8", errors="replace")).hexdigest()[:24]
+    return {
+        "type": "thinking",
+        "thinking": reasoning,
+        "signature": f"ciel-runtime-openai-reasoning-{digest}",
+    }
+
+
+@dataclass(frozen=True, slots=True)
+class OpenAiReasoningPolicy:
+    """Delegate provider-specific reasoning support to its registered adapter."""
+
+    adapter_for: Callable[[str, dict[str, Any]], ProviderAdapter]
+    config_for: Callable[[str, dict[str, Any]], ProviderConfig]
+
+    def passback_enabled(
+        self, provider: str, model: str | None, config: dict[str, Any]
+    ) -> bool:
+        adapter = self.adapter_for(provider, config)
+        return adapter.openai_reasoning_passback_enabled(
+            self.config_for(provider, config), model
+        )
+
+    def passback_enabled_for_body(
+        self, provider: str, config: dict[str, Any], body: dict[str, Any]
+    ) -> bool:
+        return self.passback_enabled(provider, str(body.get("model") or ""), config)
+
+    def should_omit_tool_choice(
+        self,
+        provider: str,
+        model: str,
+        body: dict[str, Any],
+        config: dict[str, Any],
+    ) -> bool:
+        if body.get("tool_choice") is None:
+            return False
+        return self.passback_enabled(provider, model, config)
+
+
+__all__ = [
+    "OpenAiReasoningPolicy",
+    "anthropic_tool_choice_to_openai",
+    "openai_reasoning_to_anthropic_thinking_block",
+]

package/ciel_runtime_support/protocols/openai_responses.py

@@ -0,0 +1,271 @@
+"""Pure OpenAI Responses <-> Anthropic Messages conversions.
+
+This module intentionally has no router, configuration, or network dependencies.
+"""
+
+from __future__ import annotations
+
+import json
+import time
+import uuid
+from typing import Any
+
+from ..architecture import MessageProtocolAdapter
+
+
+def _positive_int(value: Any) -> int | None:
+    try:
+        parsed = int(value)
+    except (TypeError, ValueError):
+        return None
+    return parsed if parsed > 0 else None
+
+
+def _json_object(value: Any) -> dict[str, Any]:
+    if isinstance(value, dict):
+        return value
+    if isinstance(value, str):
+        try:
+            parsed = json.loads(value)
+            return parsed if isinstance(parsed, dict) else {}
+        except (TypeError, ValueError, json.JSONDecodeError):
+            return {}
+    return {}
+
+
+def _content_text(content: Any) -> str:
+    if isinstance(content, str):
+        return content
+    if isinstance(content, dict):
+        content_type = str(content.get("type") or "")
+        if content_type in ("input_text", "output_text", "text"):
+            return str(content.get("text") or "")
+        if content_type == "refusal":
+            return str(content.get("refusal") or "")
+        return str(content.get("text") or content.get("output") or "")
+    if isinstance(content, list):
+        parts = [_content_text(item) for item in content]
+        return "\n".join(part for part in parts if part)
+    return ""
+
+
+def _content_blocks(content: Any) -> list[dict[str, Any]]:
+    text = _content_text(content)
+    return [{"type": "text", "text": text}] if text else []
+
+
+def _tools_to_anthropic(tools: Any) -> list[dict[str, Any]]:
+    out: list[dict[str, Any]] = []
+    if not isinstance(tools, list):
+        return out
+    for tool in tools:
+        if not isinstance(tool, dict):
+            continue
+        name = tool.get("name")
+        description = tool.get("description", "")
+        parameters = tool.get("parameters")
+        if not name and isinstance(tool.get("function"), dict):
+            function = tool["function"]
+            name = function.get("name")
+            description = function.get("description", description)
+            parameters = function.get("parameters", parameters)
+        if tool.get("type") not in (None, "function") and not name:
+            continue
+        if not name:
+            continue
+        out.append(
+            {
+                "name": str(name),
+                "description": str(description or ""),
+                "input_schema": parameters if isinstance(parameters, dict) else {"type": "object", "properties": {}},
+            }
+        )
+    return out
+
+
+def _tool_choice_to_anthropic(tool_choice: Any) -> Any:
+    if tool_choice is None:
+        return None
+    if isinstance(tool_choice, str):
+        lowered = tool_choice.strip().lower()
+        if lowered == "required":
+            return {"type": "any"}
+        if lowered in ("auto", "none"):
+            return {"type": "auto"} if lowered == "auto" else None
+        return tool_choice
+    if not isinstance(tool_choice, dict):
+        return tool_choice
+    if tool_choice.get("type") == "function":
+        name = tool_choice.get("name")
+        if not name and isinstance(tool_choice.get("function"), dict):
+            name = tool_choice["function"].get("name")
+        if name:
+            return {"type": "tool", "name": str(name)}
+    return tool_choice
+
+
+def openai_responses_to_anthropic_messages(body: dict[str, Any], fallback_model: str) -> dict[str, Any]:
+    system_parts: list[str] = []
+    instructions = str(body.get("instructions") or "").strip()
+    if instructions:
+        system_parts.append(instructions)
+    messages: list[dict[str, Any]] = []
+    raw_input = body.get("input", [])
+    if isinstance(raw_input, str):
+        raw_input = [{"type": "message", "role": "user", "content": [{"type": "input_text", "text": raw_input}]}]
+    if isinstance(raw_input, dict):
+        raw_input = [raw_input]
+    if not isinstance(raw_input, list):
+        raw_input = []
+    for item in raw_input:
+        if not isinstance(item, dict):
+            continue
+        item_type = str(item.get("type") or "message")
+        if item_type == "function_call":
+            call_id = str(item.get("call_id") or item.get("id") or f"call_{len(messages) + 1}")
+            messages.append(
+                {
+                    "role": "assistant",
+                    "content": [
+                        {
+                            "type": "tool_use",
+                            "id": call_id,
+                            "name": str(item.get("name") or "tool"),
+                            "input": _json_object(item.get("arguments")),
+                        }
+                    ],
+                }
+            )
+            continue
+        if item_type == "function_call_output":
+            call_id = str(item.get("call_id") or item.get("id") or "call_tool")
+            messages.append(
+                {
+                    "role": "user",
+                    "content": [
+                        {
+                            "type": "tool_result",
+                            "tool_use_id": call_id,
+                            "content": _content_text(item.get("output")),
+                        }
+                    ],
+                }
+            )
+            continue
+        role = str(item.get("role") or "user").strip().lower()
+        blocks = _content_blocks(item.get("content", item.get("text", "")))
+        if not blocks:
+            continue
+        if role in ("system", "developer"):
+            system_parts.append(_content_text(blocks))
+            continue
+        if role not in ("user", "assistant"):
+            role = "user"
+        messages.append({"role": role, "content": blocks})
+    if not messages:
+        messages.append({"role": "user", "content": [{"type": "text", "text": ""}]})
+    out: dict[str, Any] = {
+        "model": str(body.get("model") or fallback_model or "model"),
+        "messages": messages,
+        "stream": bool(body.get("stream", True)),
+    }
+    tools = _tools_to_anthropic(body.get("tools"))
+    if tools:
+        out["tools"] = tools
+    tool_choice = _tool_choice_to_anthropic(body.get("tool_choice"))
+    if tool_choice is not None:
+        out["tool_choice"] = tool_choice
+    max_tokens = _positive_int(body.get("max_output_tokens")) or _positive_int(body.get("max_tokens"))
+    if max_tokens:
+        out["max_tokens"] = max_tokens
+    reasoning = body.get("reasoning")
+    if isinstance(reasoning, dict) and reasoning.get("effort") is not None:
+        out["thinking"] = {
+            "type": "enabled",
+            "effort": str(reasoning["effort"]),
+        }
+    if system_parts:
+        out["system"] = [{"type": "text", "text": part} for part in system_parts if part]
+    return out
+
+
+def _usage_from_anthropic(message: dict[str, Any]) -> dict[str, int]:
+    usage = message.get("usage") if isinstance(message.get("usage"), dict) else {}
+    input_tokens = _positive_int(usage.get("input_tokens")) or 0
+    output_tokens = _positive_int(usage.get("output_tokens")) or 0
+    return {
+        "input_tokens": input_tokens,
+        "output_tokens": output_tokens,
+        "total_tokens": input_tokens + output_tokens,
+    }
+
+
+def anthropic_message_to_openai_response(
+    message: dict[str, Any], source_body: dict[str, Any] | None = None
+) -> dict[str, Any]:
+    response_id = f"resp_{uuid.uuid4().hex}"
+    created_at = int(time.time())
+    model = str(message.get("model") or (source_body or {}).get("model") or "")
+    output: list[dict[str, Any]] = []
+    for index, block in enumerate(message.get("content") or []):
+        if not isinstance(block, dict):
+            continue
+        block_type = block.get("type")
+        if block_type == "text":
+            text = str(block.get("text") or "")
+            output.append(
+                {
+                    "id": f"msg_{response_id[5:13]}_{index}",
+                    "type": "message",
+                    "status": "completed",
+                    "role": "assistant",
+                    "content": [{"type": "output_text", "text": text, "annotations": []}],
+                }
+            )
+        elif block_type == "tool_use":
+            call_id = str(block.get("id") or f"call_{index + 1}")
+            output.append(
+                {
+                    "id": f"fc_{response_id[5:13]}_{index}",
+                    "type": "function_call",
+                    "status": "completed",
+                    "call_id": call_id,
+                    "name": str(block.get("name") or "tool"),
+                    "arguments": json.dumps(block.get("input") or {}, ensure_ascii=False),
+                }
+            )
+    return {
+        "id": response_id,
+        "object": "response",
+        "created_at": created_at,
+        "status": "completed",
+        "model": model,
+        "output": output,
+        "parallel_tool_calls": bool((source_body or {}).get("parallel_tool_calls", True)),
+        "tool_choice": (source_body or {}).get("tool_choice", "auto"),
+        "tools": (source_body or {}).get("tools", []),
+        "usage": _usage_from_anthropic(message),
+    }
+
+
+class OpenAIResponsesProtocolAdapter(MessageProtocolAdapter):
+    """Concrete adapter between OpenAI Responses and Anthropic Messages."""
+
+    name = "openai_responses"
+
+    def __init__(self, *, fallback_model: str = "model", source_body: dict[str, Any] | None = None) -> None:
+        self._fallback_model = fallback_model
+        self._source_body = source_body
+
+    def normalize_request(self, request: Any) -> dict[str, Any]:
+        return openai_responses_to_anthropic_messages(dict(request), self._fallback_model)
+
+    def normalize_response(self, response: Any) -> dict[str, Any]:
+        return anthropic_message_to_openai_response(dict(response), self._source_body)
+
+
+__all__ = [
+    "OpenAIResponsesProtocolAdapter",
+    "anthropic_message_to_openai_response",
+    "openai_responses_to_anthropic_messages",
+]