@oneciel-ai/ciel-runtime 0.2.2 → 0.2.3

package/ciel_runtime_support/runtime_primitives.py

@@ -0,0 +1,78 @@
+from __future__ import annotations
+
+import hashlib
+from pathlib import Path
+from typing import Any, Callable, Mapping
+
+
+def source_fingerprint(path: Path) -> str:
+    try:
+        return hashlib.sha256(path.read_bytes()).hexdigest()[:16]
+    except Exception:
+        try:
+            stat = path.stat()
+            return f"{int(stat.st_mtime_ns)}-{int(stat.st_size)}"
+        except Exception:
+            return "unknown"
+
+
+def positive_environment_int(environment: Mapping[str, str], name: str, default: int) -> int:
+    raw = str(environment.get(name) or "").strip()
+    if raw:
+        try:
+            value = int(raw)
+            if value > 0:
+                return value
+        except ValueError:
+            pass
+    return default
+
+
+def model_preset(
+    model_id: str,
+    presets: Mapping[str, dict[str, Any]],
+    lookup_ids: Callable[[str], tuple[str, ...] | list[str]],
+) -> dict[str, Any]:
+    for candidate in lookup_ids(model_id):
+        if candidate in presets:
+            return presets[candidate]
+        candidate_base = candidate.split(":", 1)[0]
+        for key, value in presets.items():
+            if candidate.startswith(key) or (":" not in candidate and key.startswith(candidate_base)):
+                return value
+    return {}
+
+
+def join_url(base: str, path: str) -> str:
+    base = base.rstrip("/")
+    if base.endswith("/v1") and path.startswith("/v1/"):
+        return base + path[3:]
+    return base + path
+
+
+def url_is_up(url: str, request_json: Callable[..., Any]) -> bool:
+    try:
+        request_json(url, timeout=1.5)
+        return True
+    except Exception:
+        return False
+
+
+def colorize_status_text(
+    text: str,
+    *,
+    enabled: bool,
+    palette: tuple[int, ...],
+    monotonic: Callable[[], float],
+) -> str:
+    if not enabled:
+        return text
+    parts: list[str] = []
+    phase = int(monotonic() * 8)
+    for index, char in enumerate(text):
+        if char.isspace():
+            parts.append(char)
+            continue
+        color = palette[(phase + index) % len(palette)]
+        parts.append(f"\033[1;38;5;{color}m{char}\033[0m")
+    return "".join(parts)

package/ciel_runtime_support/sse_stream_collection.py

@@ -0,0 +1,236 @@
+"""Collect SSE chat responses into one message, cutting loops short.
+
+The Ollama collection path reads NDJSON; the other two protocols the
+Codex-facing collector speaks are SSE. DeepSeek publishes both formats -- an
+OpenAI-compatible endpoint at ``https://api.deepseek.com`` and an
+Anthropic-compatible one at ``https://api.deepseek.com/anthropic`` -- and
+ciel-runtime uses the Anthropic one, so a repetition loop on deepseek.com
+arrives through :func:`collect_anthropic_message_stream`. Switching endpoints
+would not have helped: both collectors used one blocking POST, which is what
+let a loop run to completion before anything could look at it.
+
+Each collector assembles exactly the payload the matching decoder already
+expects, so nothing downstream changes.
+"""
+
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass, field
+from typing import Any, Iterable
+
+from .runaway_output_guard import (
+    RunawayOutputDetector,
+    RunawayOutputPolicy,
+    RunawayVerdict,
+)
+
+
+@dataclass(frozen=True, slots=True)
+class SseStreamCollection:
+    response: dict[str, Any]
+    verdict: RunawayVerdict | None = None
+    chunks: int = 0
+
+
+def iter_sse_payloads(lines: Iterable[Any]) -> Iterable[dict[str, Any]]:
+    """Yield decoded ``data:`` payloads, ignoring framing and keepalives."""
+
+    for raw in lines:
+        line = (
+            raw.decode("utf-8", errors="ignore")
+            if isinstance(raw, (bytes, bytearray))
+            else str(raw)
+        ).strip()
+        if not line or not line.startswith("data:"):
+            continue
+        body = line[5:].strip()
+        if not body or body == "[DONE]":
+            continue
+        try:
+            payload = json.loads(body)
+        except ValueError:
+            continue
+        if isinstance(payload, dict):
+            yield payload
+
+
+@dataclass
+class _ToolFragment:
+    call_id: str = ""
+    name: str = ""
+    arguments: str = ""
+
+
+def collect_openai_chat_stream(
+    lines: Iterable[Any], policy: RunawayOutputPolicy | None = None
+) -> SseStreamCollection:
+    """Merge OpenAI chat-completion chunks into one non-streaming response."""
+
+    text_runaway = RunawayOutputDetector(policy)
+    reasoning_runaway = RunawayOutputDetector(policy)
+    verdict: RunawayVerdict | None = None
+    content: list[str] = []
+    reasoning: list[str] = []
+    fragments: dict[int, _ToolFragment] = {}
+    finish_reason = ""
+    usage: dict[str, Any] = {}
+    envelope: dict[str, Any] = {}
+    chunks = 0
+    for payload in iter_sse_payloads(lines):
+        chunks += 1
+        for key in ("id", "model", "created", "system_fingerprint"):
+            if payload.get(key) is not None:
+                envelope[key] = payload[key]
+        if isinstance(payload.get("usage"), dict):
+            usage = payload["usage"]
+        choices = payload.get("choices")
+        choice = choices[0] if isinstance(choices, list) and choices and isinstance(choices[0], dict) else {}
+        if choice.get("finish_reason"):
+            finish_reason = str(choice["finish_reason"])
+        delta = choice.get("delta") if isinstance(choice.get("delta"), dict) else {}
+        reasoning_chunk = str(delta.get("reasoning_content") or "")
+        if reasoning_chunk:
+            reasoning.append(reasoning_chunk)
+            verdict = verdict or reasoning_runaway.feed(reasoning_chunk)
+        text_chunk = str(delta.get("content") or "")
+        if text_chunk:
+            content.append(text_chunk)
+            verdict = verdict or text_runaway.feed(text_chunk)
+        for call in delta.get("tool_calls") or []:
+            if not isinstance(call, dict):
+                continue
+            try:
+                index = int(call.get("index") or 0)
+            except (TypeError, ValueError):
+                index = 0
+            fragment = fragments.setdefault(index, _ToolFragment())
+            if call.get("id"):
+                fragment.call_id = str(call["id"])
+            function = call.get("function") if isinstance(call.get("function"), dict) else {}
+            if function.get("name"):
+                fragment.name = str(function["name"])
+            if function.get("arguments"):
+                fragment.arguments += str(function["arguments"])
+        if verdict is not None:
+            break
+    message: dict[str, Any] = {"role": "assistant", "content": "".join(content)}
+    if reasoning:
+        message["reasoning_content"] = "".join(reasoning)
+    if fragments:
+        message["tool_calls"] = [
+            {
+                "id": fragment.call_id or f"call_{index + 1}",
+                "type": "function",
+                "function": {"name": fragment.name, "arguments": fragment.arguments},
+            }
+            for index, fragment in sorted(fragments.items())
+        ]
+    response = {
+        **envelope,
+        "choices": [{"index": 0, "message": message, "finish_reason": finish_reason or "stop"}],
+    }
+    if usage:
+        response["usage"] = usage
+    return SseStreamCollection(response=response, verdict=verdict, chunks=chunks)
+
+
+@dataclass
+class _ContentBlock:
+    block: dict[str, Any] = field(default_factory=dict)
+    text: list[str] = field(default_factory=list)
+    thinking: list[str] = field(default_factory=list)
+    signature: str = ""
+    partial_json: str = ""
+
+    def finish(self) -> dict[str, Any]:
+        block = dict(self.block)
+        kind = str(block.get("type") or "")
+        if kind == "text":
+            block["text"] = str(block.get("text") or "") + "".join(self.text)
+        elif kind in ("thinking", "redacted_thinking"):
+            block["thinking"] = str(block.get("thinking") or "") + "".join(self.thinking)
+            if self.signature:
+                block["signature"] = self.signature
+        elif kind == "tool_use" and self.partial_json:
+            try:
+                parsed = json.loads(self.partial_json)
+            except ValueError:
+                parsed = None
+            block["input"] = parsed if isinstance(parsed, dict) else block.get("input") or {}
+        return block
+
+
+def collect_anthropic_message_stream(
+    lines: Iterable[Any], policy: RunawayOutputPolicy | None = None
+) -> SseStreamCollection:
+    """Merge Anthropic Messages SSE events into one non-streaming message."""
+
+    text_runaway = RunawayOutputDetector(policy)
+    thinking_runaway = RunawayOutputDetector(policy)
+    verdict: RunawayVerdict | None = None
+    message: dict[str, Any] = {
+        "type": "message",
+        "role": "assistant",
+        "content": [],
+        "stop_reason": None,
+    }
+    blocks: dict[int, _ContentBlock] = {}
+    chunks = 0
+    for payload in iter_sse_payloads(lines):
+        chunks += 1
+        event_type = str(payload.get("type") or "")
+        if event_type == "message_start":
+            started = payload.get("message")
+            if isinstance(started, dict):
+                message.update({key: value for key, value in started.items() if key != "content"})
+            continue
+        if event_type == "content_block_start":
+            index = payload.get("index")
+            block = payload.get("content_block")
+            if isinstance(index, int) and isinstance(block, dict):
+                blocks[index] = _ContentBlock(block=dict(block))
+            continue
+        if event_type == "content_block_delta":
+            index = payload.get("index")
+            delta = payload.get("delta") if isinstance(payload.get("delta"), dict) else {}
+            if not isinstance(index, int):
+                continue
+            state = blocks.setdefault(index, _ContentBlock(block={"type": "text", "text": ""}))
+            delta_type = str(delta.get("type") or "")
+            if delta_type == "text_delta":
+                chunk = str(delta.get("text") or "")
+                state.text.append(chunk)
+                verdict = verdict or text_runaway.feed(chunk)
+            elif delta_type == "thinking_delta":
+                chunk = str(delta.get("thinking") or "")
+                state.thinking.append(chunk)
+                verdict = verdict or thinking_runaway.feed(chunk)
+            elif delta_type == "signature_delta":
+                state.signature += str(delta.get("signature") or "")
+            elif delta_type == "input_json_delta":
+                state.partial_json += str(delta.get("partial_json") or "")
+            if verdict is not None:
+                break
+            continue
+        if event_type == "message_delta":
+            delta = payload.get("delta") if isinstance(payload.get("delta"), dict) else {}
+            for key in ("stop_reason", "stop_sequence"):
+                if delta.get(key) is not None:
+                    message[key] = delta[key]
+            usage = payload.get("usage")
+            if isinstance(usage, dict):
+                message["usage"] = {**(message.get("usage") or {}), **usage}
+            continue
+    message["content"] = [state.finish() for _index, state in sorted(blocks.items())]
+    if verdict is not None and not message.get("stop_reason"):
+        message["stop_reason"] = "max_tokens"
+    return SseStreamCollection(response=message, verdict=verdict, chunks=chunks)
+
+
+__all__ = [
+    "SseStreamCollection",
+    "collect_anthropic_message_stream",
+    "collect_openai_chat_stream",
+    "iter_sse_payloads",
+]

package/ciel_runtime_support/statusline_script.py

@@ -25,14 +25,15 @@ def default_config_dir():
 
 
 CONFIG_DIR = default_config_dir()
+STATE_DIR = Path(os.environ.get("CIEL_RUNTIME_STATE_DIR") or CONFIG_DIR)
 CONFIG_PATH = CONFIG_DIR / "config.json"
-STATE_PATH = CONFIG_DIR / "rate-limit-state.json"
-ACTIVITY_PATH = CONFIG_DIR / "router-activity.json"
-COMPACT_ACTIVITY_PATH = CONFIG_DIR / "context-compact-activity.json"
-CONTEXT_PATH = CONFIG_DIR / "context-usage.json"
-CHAT_MESSAGES_PATH = CONFIG_DIR / "chat-messages.jsonl"
-CHANNEL_LLM_CURSOR_PATH = CONFIG_DIR / "channel-llm-cursor.json"
-CHANNEL_LLM_CLEAR_FLOOR_PATH = CONFIG_DIR / "channel-llm-clear-floor.json"
+STATE_PATH = STATE_DIR / "rate-limit-state.json"
+ACTIVITY_PATH = STATE_DIR / "router-activity.json"
+COMPACT_ACTIVITY_PATH = STATE_DIR / "context-compact-activity.json"
+CONTEXT_PATH = STATE_DIR / "context-usage.json"
+CHAT_MESSAGES_PATH = STATE_DIR / "chat-messages.jsonl"
+CHANNEL_LLM_CURSOR_PATH = STATE_DIR / "channel-llm-cursor.json"
+CHANNEL_LLM_CLEAR_FLOOR_PATH = STATE_DIR / "channel-llm-clear-floor.json"
 PALETTE = (203, 209, 215, 221, 229, 187, 151, 116, 111, 147, 183, 219)
 
 
@@ -247,6 +248,42 @@ def session_context_status_text(session):
     return f"ctx {tokens:,} tok"
 
 
+def session_cache_status_text(session):
+    if not isinstance(session, dict):
+        return ""
+    context_window = session.get("context_window")
+    if not isinstance(context_window, dict):
+        return ""
+    usage = context_window.get("current_usage")
+    if not isinstance(usage, dict):
+        return ""
+    details = usage.get("input_tokens_details")
+    details = details if isinstance(details, dict) else {}
+    cache_read = _as_int(
+        usage.get("cache_read_input_tokens"),
+        _as_int(details.get("cached_tokens")),
+    )
+    cache_write = _as_int(
+        usage.get("cache_creation_input_tokens"),
+        _as_int(details.get("cache_write_tokens")),
+    )
+    input_tokens = max(0, _as_int(usage.get("input_tokens")))
+    uncached = (
+        max(0, input_tokens - cache_read - cache_write)
+        if details
+        else input_tokens
+    )
+    total = uncached + cache_read + cache_write
+    if total <= 0 or (cache_read <= 0 and cache_write <= 0):
+        return ""
+    hit_pct = (cache_read / total) * 100.0
+    parts = [f"cache {hit_pct:.1f}%", f"hit {cache_read:,}"]
+    if cache_write > 0:
+        parts.append(f"write {cache_write:,}")
+    parts.append(f"new {uncached:,}")
+    return " ".join(parts)
+
+
 def _status_as_string_list(value):
     if value is None:
         return []
@@ -472,6 +509,9 @@ def main():
     ctx_text = router_ctx_text or session_ctx_text
     if ctx_text:
         status_parts.append(gray(ctx_text))
+    cache_text = session_cache_status_text(session)
+    if cache_text:
+        status_parts.append(color(cache_text))
     channel_pending = channel_pending_status_count()
     if channel_pending > 0:
         status_parts.append(color(f"channel queue {channel_pending}"))
@@ -554,6 +594,16 @@ def main():
                         activity_text += " " + color(f"({chunks} chunks)")
             elif event in ("success", "error"):
                 activity_text = color(f"{event} {age:.0f}s")
+                cache_read = max(0, _as_int(activity.get("cache_read_tokens")))
+                cache_write = max(0, _as_int(activity.get("cache_creation_tokens")))
+                uncached = max(0, _as_int(activity.get("uncached_input_tokens")))
+                cache_total = cache_read + cache_write + uncached
+                if not cache_text and cache_total > 0 and (cache_read > 0 or cache_write > 0):
+                    cache_pct = (cache_read / cache_total) * 100.0
+                    activity_text += " " + color(
+                        f"cache {cache_pct:.1f}% hit {cache_read:,} "
+                        f"write {cache_write:,} new {uncached:,}"
+                    )
     if activity_text:
         status_parts.append(activity_text)
     compact_text = ""
@@ -590,4 +640,3 @@ if __name__ == "__main__":
     main()
 
 '''
-