@oneciel-ai/ciel-runtime 0.2.2 → 0.2.3

package/ciel_runtime_support/responses_usage_observer.py

@@ -0,0 +1,83 @@
+"""Incremental cache-usage observation for native Responses passthrough."""
+
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass
+from typing import Any, Mapping
+
+
+@dataclass(slots=True)
+class ResponsesUsageObserver:
+    """Observe final usage without altering or delaying streamed response bytes."""
+
+    _line_buffer: str = ""
+    _raw: str = ""
+    _usage: dict[str, int] | None = None
+
+    def feed(self, chunk: bytes) -> None:
+        text = chunk.decode("utf-8", errors="ignore")
+        if len(self._raw) < 1_048_576:
+            self._raw = (self._raw + text)[-1_048_576:]
+        self._line_buffer += text
+        lines = self._line_buffer.split("\n")
+        self._line_buffer = lines.pop()
+        for line in lines:
+            payload = line.strip()
+            if payload.startswith("data:"):
+                payload = payload[5:].strip()
+            self._observe_json(payload)
+
+    def finish(self) -> dict[str, int]:
+        self._observe_json(self._line_buffer.strip())
+        self._observe_json(self._raw.strip())
+        return dict(self._usage or {})
+
+    def _observe_json(self, text: str) -> None:
+        if not text or text == "[DONE]":
+            return
+        try:
+            payload = json.loads(text)
+        except (TypeError, ValueError):
+            return
+        if not isinstance(payload, Mapping):
+            return
+        usage = payload.get("usage")
+        response = payload.get("response")
+        if not isinstance(usage, Mapping) and isinstance(response, Mapping):
+            usage = response.get("usage")
+        if not isinstance(usage, Mapping):
+            return
+        details = usage.get("input_tokens_details")
+        details = details if isinstance(details, Mapping) else {}
+        input_tokens = _positive_int(usage.get("input_tokens"))
+        output_tokens = _positive_int(usage.get("output_tokens"))
+        cache_read = (
+            _positive_int(details.get("cached_tokens"))
+            or _positive_int(usage.get("cache_read_input_tokens"))
+        )
+        cache_creation = (
+            _positive_int(details.get("cache_write_tokens"))
+            or _positive_int(usage.get("cache_creation_input_tokens"))
+        )
+        if not any((input_tokens, output_tokens, cache_read, cache_creation)):
+            return
+        self._usage = {
+            "input_tokens": input_tokens,
+            "output_tokens": output_tokens,
+            "cache_read_tokens": cache_read,
+            "cache_creation_tokens": cache_creation,
+            "uncached_input_tokens": max(
+                0, input_tokens - cache_read - cache_creation
+            ),
+        }
+
+
+def _positive_int(value: Any) -> int:
+    try:
+        return max(0, int(value or 0))
+    except (TypeError, ValueError):
+        return 0
+
+
+__all__ = ["ResponsesUsageObserver"]

package/ciel_runtime_support/router_client_lifecycle.py

@@ -39,6 +39,7 @@ class RouterClientRegistry:
             "pid": client_pid,
             "started_at": time.strftime("%Y-%m-%dT%H:%M:%S"),
             "router_port": self._router_port,
+            "workspace": str(Path.cwd().resolve(strict=False)),
         }
         path.write_text(json.dumps(payload, ensure_ascii=False), encoding="utf-8")
         try:

package/ciel_runtime_support/router_http.py

@@ -2,9 +2,11 @@
 
 from __future__ import annotations
 
+import io
 import json
 import sys
 import traceback
+import urllib.error
 import urllib.parse
 import urllib.request
 from dataclasses import dataclass
@@ -15,6 +17,36 @@ from ciel_runtime_support.header_forwarding import (
     HOP_BY_HOP_REQUEST_HEADERS,
     project_end_to_end_request_headers,
 )
+from ciel_runtime_support.codex_reasoning_rejects import (
+    drop_reasoning_matching_verdict,
+    drop_rejected_reasoning,
+    parse_missing_item_id,
+    parse_unverifiable_encrypted_content,
+    repair_unstored_items,
+)
+from ciel_runtime_support.responses_input_compatibility import (
+    repair_replayed_response_items,
+)
+from ciel_runtime_support.upstream_dump import dump_upstream_request
+
+# Upper bound on verdict-driven repairs of one replayed turn. The sealed
+# reasoning rule needs one pass per rejected ciphertext and was measured
+# converging in 39; the unknown-item rule needs exactly one.
+MAX_REPLAY_REPAIR_ATTEMPTS = 64
+
+# Each pass hands the compactor a smaller share of the window it was refused
+# at, so a turn converges in a few rounds instead of the client's one-item-per
+# -round-trip retry, which does not converge at all on a large transcript.
+CONTEXT_COMPACTION_BUDGETS = (0.75, 0.5, 0.25)
+
+
+class UpstreamContextExceeded(Exception):
+    """The upstream refused the turn because its input does not fit."""
+
+    def __init__(self, code: str, payload: bytes) -> None:
+        super().__init__(code)
+        self.code = code
+        self.payload = payload
 
 
 @dataclass(frozen=True, slots=True)
@@ -116,6 +148,10 @@ class CodexBackendRetryPorts:
     log: Callable[[str, str], None]
     publish: Callable[..., Any]
     sleep: Callable[[float], None]
+    rejected_reasoning_contains: Callable[[str], bool] = lambda _sealed: False
+    rejected_reasoning_record: Callable[[str], Any] = lambda _sealed: None
+    estimate_tokens: Callable[[Any], int] = lambda _body: 0
+    compact_responses: Callable[..., dict[str, Any]] = lambda body, _budget, **_kw: body
 
 
 class CodexBackendHttpAdapter:
@@ -169,15 +205,210 @@ class CodexBackendHttpAdapter:
         *,
         mutate_responses: bool = False,
     ) -> dict[str, Any] | None:
-        upstream_body = body
+        upstream_body = repair_replayed_response_items(body)
+        upstream_body, prefiltered = drop_rejected_reasoning(
+            upstream_body, self._retry.rejected_reasoning_contains
+        )
+        if prefiltered:
+            self._retry.log(
+                "INFO",
+                f"codex_rejected_reasoning_prefiltered count={prefiltered}",
+            )
         delivery_body: dict[str, Any] | None = None
         if mutate_responses:
-            upstream_body, delivery_body = self._request.body_with_channel_context(body)
+            upstream_body, delivery_body = self._request.body_with_channel_context(upstream_body)
             self._request.begin_channel_delivery(handler, delivery_body)
         parsed = urllib.parse.urlparse(handler.path)
         url = self.upstream_url(parsed.path, parsed.query)
         headers = self._request.upstream_headers(config, handler.headers)
         data = json.dumps(upstream_body).encode("utf-8")
+        dump_upstream_request(url, data, self._retry.log)
+        # Every pass costs a full upstream round trip while the client sees
+        # nothing, so the loop is capped: the unknown-item rule repairs the
+        # whole request at once and needs one pass, and the sealed-reasoning
+        # rule removes one ciphertext per pass and was measured converging in
+        # 39. Past the cap the upstream's own error reaches the client instead
+        # of the router retrying in silence.
+        compaction_rounds = 0
+        for attempt in range(MAX_REPLAY_REPAIR_ATTEMPTS + 1):
+            try:
+                self._send_codex_request(
+                    handler, provider, config, url, headers, data, upstream_body,
+                    mutate_responses=mutate_responses,
+                )
+                return delivery_body
+            except UpstreamContextExceeded as exc:
+                compacted = self._compacted_for_context(
+                    upstream_body, compaction_rounds, provider, exc.code
+                )
+                if compacted is None:
+                    self._write_preamble_failure(handler, exc.payload)
+                    return delivery_body
+                compaction_rounds += 1
+                upstream_body = compacted
+                data = json.dumps(upstream_body).encode("utf-8")
+                dump_upstream_request(url, data, self._retry.log)
+            except urllib.error.HTTPError as exc:
+                if exc.code not in (400, 404):
+                    raise
+                raw = exc.read()
+                exhausted = attempt >= MAX_REPLAY_REPAIR_ATTEMPTS
+                repaired = (
+                    None
+                    if exhausted
+                    else self._repaired_after_rejection(
+                        exc.code,
+                        raw.decode("utf-8", errors="replace"),
+                        upstream_body,
+                        provider,
+                    )
+                )
+                if repaired is None:
+                    if exhausted:
+                        self._retry.log(
+                            "WARN",
+                            "codex_replay_repair_exhausted "
+                            f"attempts={attempt} code={exc.code} relaying upstream error",
+                        )
+                    raise urllib.error.HTTPError(
+                        exc.url, exc.code, exc.msg, exc.hdrs, io.BytesIO(raw)
+                    ) from None
+                upstream_body = repaired
+                data = json.dumps(upstream_body).encode("utf-8")
+                dump_upstream_request(url, data, self._retry.log)
+        return delivery_body
+
+    def _compacted_for_context(
+        self,
+        upstream_body: dict[str, Any],
+        round_number: int,
+        provider: str,
+        code: str,
+    ) -> dict[str, Any] | None:
+        """Shrink the refused turn, keeping the newest history verbatim.
+
+        The upstream, not a catalogued window size, decides that compaction is
+        needed, so a wrong context number in our own metadata cannot discard
+        history that would have fit.
+        """
+
+        if round_number >= len(CONTEXT_COMPACTION_BUDGETS):
+            return None
+        estimated = self._retry.estimate_tokens(upstream_body)
+        budget = int(estimated * CONTEXT_COMPACTION_BUDGETS[round_number])
+        compacted = self._retry.compact_responses(
+            upstream_body, budget, provider=provider,
+            model=str(upstream_body.get("model") or ""),
+        )
+        if compacted is upstream_body or compacted.get("input") == upstream_body.get("input"):
+            return None
+        self._retry.log(
+            "ERROR",
+            f"codex_context_compacted provider={provider} code={code} round={round_number + 1} "
+            f"items={len(upstream_body.get('input') or [])}->{len(compacted.get('input') or [])} "
+            f"tokens={estimated}->{self._retry.estimate_tokens(compacted)} budget={budget}",
+        )
+        self._retry.publish(
+            level="warn",
+            category="router.context",
+            message="Compacted an oversized turn the upstream refused",
+            provider=provider,
+            model=str(upstream_body.get("model") or ""),
+            data={"code": code, "round": round_number + 1, "budget": budget},
+        )
+        return compacted
+
+    def _write_preamble_failure(
+        self, handler: BaseHTTPRequestHandler, payload: bytes
+    ) -> None:
+        """Relay the upstream's own refusal once compaction cannot help."""
+
+        handler.send_response(200)
+        handler.send_header("content-type", "text/event-stream")
+        handler.send_header("connection", "close")
+        handler.end_headers()
+        handler.wfile.write(payload)
+        handler.wfile.flush()
+
+    def _repaired_after_rejection(
+        self,
+        status: int,
+        error_text: str,
+        upstream_body: dict[str, Any],
+        provider: str,
+    ) -> dict[str, Any] | None:
+        """Rebuild the request around the item the upstream just named."""
+
+        if status == 400:
+            return self._without_unverifiable_reasoning(error_text, upstream_body, provider)
+        return self._without_unknown_item(error_text, upstream_body, provider)
+
+    def _without_unverifiable_reasoning(
+        self,
+        error_text: str,
+        upstream_body: dict[str, Any],
+        provider: str,
+    ) -> dict[str, Any] | None:
+        verdict = parse_unverifiable_encrypted_content(error_text)
+        if verdict is None:
+            return None
+        repaired, sealed = drop_reasoning_matching_verdict(upstream_body, *verdict)
+        if sealed is None:
+            return None
+        self._retry.rejected_reasoning_record(sealed)
+        self._retry.log(
+            "WARN",
+            "codex_unverifiable_reasoning_dropped "
+            f"head={verdict[0]} tail={verdict[1]} retrying",
+        )
+        self._retry.publish(
+            level="warn",
+            category="router.retry",
+            message="Dropped reasoning the upstream could not verify",
+            provider=provider,
+            model=str(repaired.get("model") or ""),
+            data={"head": verdict[0], "tail": verdict[1]},
+        )
+        return repaired
+
+    def _without_unknown_item(
+        self,
+        error_text: str,
+        upstream_body: dict[str, Any],
+        provider: str,
+    ) -> dict[str, Any] | None:
+        item_id = parse_missing_item_id(error_text)
+        if item_id is None:
+            return None
+        repaired, count = repair_unstored_items(upstream_body)
+        if not count:
+            return None
+        self._retry.log(
+            "WARN",
+            f"codex_unstored_items_repaired named={item_id} items={count} retrying",
+        )
+        self._retry.publish(
+            level="warn",
+            category="router.retry",
+            message="Replayed items the upstream never stored",
+            provider=provider,
+            model=str(repaired.get("model") or ""),
+            data={"item_id": item_id, "items": count},
+        )
+        return repaired
+
+    def _send_codex_request(
+        self,
+        handler: BaseHTTPRequestHandler,
+        provider: str,
+        config: dict[str, Any],
+        url: str,
+        headers: dict[str, str],
+        data: bytes,
+        upstream_body: dict[str, Any],
+        *,
+        mutate_responses: bool,
+    ) -> None:
         max_retries = self._retry.retry_limit() if mutate_responses else 0
         for attempt in range(max_retries + 1):
             request = urllib.request.Request(url, data=data, headers=headers, method="POST")
@@ -188,6 +419,12 @@ class CodexBackendHttpAdapter:
                 pcfg=config,
             ) as response:
                 preamble = self._retry.read_preamble(response) if mutate_responses else None
+                if preamble is not None and getattr(preamble, "context_error_code", None):
+                    # Nothing has been written to the client yet, so the turn can
+                    # still be made to fit instead of failing.
+                    raise UpstreamContextExceeded(
+                        preamble.context_error_code, preamble.payload
+                    )
                 if preamble is not None and preamble.capacity_error_code and attempt < max_retries:
                     retry_number = attempt + 1
                     wait = self._retry.retry_wait(retry_number)
@@ -214,7 +451,6 @@ class CodexBackendHttpAdapter:
                     continue
                 self._write_response(handler, response, preamble)
                 break
-        return delivery_body
 
     def forward_get(
         self,

package/ciel_runtime_support/router_observability_context.py

@@ -0,0 +1,251 @@
+"""Router request, response, and SSE observability bounded context."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Callable, Mapping
+
+from .request_trace import (
+    RequestTracePolicy,
+    RequestTraceProjection,
+    RequestTraceServices,
+    ResponseTraceController,
+    RouterMessagePreviewPolicy,
+    dump_request_for_trace,
+    summarize_messages_for_trace,
+)
+from .sse_trace import (
+    SseTraceConfig,
+    SseTracePorts,
+    SseTraceRepository,
+    summarize_payload,
+)
+
+
+@dataclass(frozen=True, slots=True)
+class RouterPreviewPorts:
+    environment: Mapping[str, str]
+    load_config: Callable[[], dict[str, Any]]
+    positive_int: Callable[..., int]
+    latest_user_text: Callable[..., str]
+    redact_sensitive_text: Callable[[str], str]
+
+
+@dataclass(frozen=True, slots=True)
+class RequestTraceConfiguration:
+    request_path: Path
+    response_path: Path
+    request_max_bytes: int
+    response_max_bytes: int
+    response_text_limit: int
+    trace_level: int
+
+
+@dataclass(frozen=True, slots=True)
+class RequestTracePorts:
+    current_log_level: Callable[[], int]
+    content_to_text: Callable[..., str]
+    thinking_block_count: Callable[..., int]
+    tool_continuation_block_count: Callable[..., int]
+    log: Callable[[str, str], None]
+    usage_record: Callable[..., Any]
+    event_publish: Callable[..., Any]
+
+
+@dataclass(frozen=True, slots=True)
+class SseTraceConfiguration:
+    config_dir: Path
+    last_path: Path
+    trace_path: Path
+    tool_call_path: Path
+    event_limit: int
+    payload_limit: int
+    max_bytes: int
+    trace_level: int
+
+
+@dataclass(frozen=True, slots=True)
+class SseObservabilityPorts:
+    environment: Mapping[str, str]
+    current_log_level: Callable[[], int]
+    truncate: Callable[[str, int], str]
+    log: Callable[[str, str], None]
+
+
+@dataclass(frozen=True, slots=True)
+class RouterObservabilityContext:
+    preview: RouterPreviewPorts
+    request_config: RequestTraceConfiguration
+    request: RequestTracePorts
+    sse_config: SseTraceConfiguration
+    sse: SseObservabilityPorts
+
+    def message_preview_policy(self) -> RouterMessagePreviewPolicy:
+        return RouterMessagePreviewPolicy(
+            self.preview.environment,
+            self.preview.load_config,
+            self.preview.positive_int,
+            self.preview.latest_user_text,
+            self.preview.redact_sensitive_text,
+        )
+
+    def preview_chars(self, cfg: dict[str, Any] | None = None) -> int:
+        return self.message_preview_policy().configured_chars(cfg)
+
+    def event_preview(
+        self, body: dict[str, Any], cfg: dict[str, Any] | None = None
+    ) -> dict[str, Any]:
+        return self.message_preview_policy().project(body, cfg)
+
+    def request_projection(self) -> RequestTraceProjection:
+        return RequestTraceProjection(
+            content_to_text=self.request.content_to_text,
+            thinking_block_count=self.request.thinking_block_count,
+            tool_continuation_block_count=(
+                self.request.tool_continuation_block_count
+            ),
+        )
+
+    def request_services(self) -> RequestTraceServices:
+        return RequestTraceServices(
+            policy=RequestTracePolicy(
+                enabled=lambda: self.request.current_log_level()
+                >= self.request_config.trace_level,
+                request_path=self.request_config.request_path,
+                response_path=self.request_config.response_path,
+                request_max_bytes=self.request_config.request_max_bytes,
+                response_max_bytes=self.request_config.response_max_bytes,
+                response_text_limit=self.request_config.response_text_limit,
+            ),
+            projection=self.request_projection(),
+            log=self.request.log,
+        )
+
+    def summarize_messages(
+        self, messages: Any, max_messages: int = 30
+    ) -> list[dict[str, Any]]:
+        return summarize_messages_for_trace(
+            messages,
+            self.request_projection(),
+            max_messages=max_messages,
+        )
+
+    def dump_request(
+        self, provider: str, path: str, body: dict[str, Any]
+    ) -> None:
+        dump_request_for_trace(
+            provider, path, body, self.request_services()
+        )
+
+    def response_controller(self) -> ResponseTraceController:
+        return ResponseTraceController(
+            self.request.usage_record,
+            self.request.event_publish,
+            self.request_services,
+            self.request.log,
+        )
+
+    def dump_response(self, *args: Any, **kwargs: Any) -> None:
+        self.response_controller().write(*args, **kwargs)
+
+    def sse_enabled(self) -> bool:
+        value = str(
+            self.sse.environment.get("CIEL_RUNTIME_SSE_TRACE", "")
+        ).strip().lower()
+        if value in {"1", "true", "yes", "on", "trace"}:
+            return True
+        return self.sse.current_log_level() >= self.sse_config.trace_level
+
+    def sse_repository(self) -> SseTraceRepository:
+        return SseTraceRepository(
+            SseTraceConfig(
+                self.sse_config.config_dir,
+                self.sse_config.last_path,
+                self.sse_config.trace_path,
+                self.sse_config.tool_call_path,
+                self.sse_config.event_limit,
+                self.sse_config.payload_limit,
+                self.sse_config.max_bytes,
+            ),
+            SseTracePorts(self.sse_enabled, self.sse.truncate, self.sse.log),
+        )
+
+    def summarize_sse_payload(self, payload: dict[str, Any]) -> dict[str, Any]:
+        return summarize_payload(payload, self.sse.truncate)
+
+    def begin_sse(self, *args: Any, **kwargs: Any) -> dict[str, Any]:
+        return self.sse_repository().begin(*args, **kwargs)
+
+    def record_sse(self, *args: Any, **kwargs: Any) -> None:
+        self.sse_repository().record(*args, **kwargs)
+
+    def finish_sse(self, *args: Any, **kwargs: Any) -> None:
+        self.sse_repository().finish_stream(*args, **kwargs)
+
+    def append_tool_call(self, *args: Any, **kwargs: Any) -> None:
+        self.sse_repository().append_tool_call(*args, **kwargs)
+
+
+@dataclass(frozen=True, slots=True)
+class RouterObservabilityCompatibilityApi:
+    context: Callable[[], RouterObservabilityContext]
+
+    def message_preview_policy(self) -> RouterMessagePreviewPolicy:
+        return self.context().message_preview_policy()
+
+    def preview_chars(self, *args: Any, **kwargs: Any) -> int:
+        return self.context().preview_chars(*args, **kwargs)
+
+    def event_preview(self, *args: Any, **kwargs: Any) -> dict[str, Any]:
+        return self.context().event_preview(*args, **kwargs)
+
+    def request_projection(self) -> RequestTraceProjection:
+        return self.context().request_projection()
+
+    def request_services(self) -> RequestTraceServices:
+        return self.context().request_services()
+
+    def summarize_messages(self, *args: Any, **kwargs: Any) -> list[dict[str, Any]]:
+        return self.context().summarize_messages(*args, **kwargs)
+
+    def dump_request(self, *args: Any, **kwargs: Any) -> None:
+        self.context().dump_request(*args, **kwargs)
+
+    def response_controller(self) -> ResponseTraceController:
+        return self.context().response_controller()
+
+    def dump_response(self, *args: Any, **kwargs: Any) -> None:
+        self.context().dump_response(*args, **kwargs)
+
+    def sse_enabled(self) -> bool:
+        return self.context().sse_enabled()
+
+    def sse_repository(self) -> SseTraceRepository:
+        return self.context().sse_repository()
+
+    def summarize_sse_payload(self, payload: dict[str, Any]) -> dict[str, Any]:
+        return self.context().summarize_sse_payload(payload)
+
+    def begin_sse(self, *args: Any, **kwargs: Any) -> dict[str, Any]:
+        return self.context().begin_sse(*args, **kwargs)
+
+    def record_sse(self, *args: Any, **kwargs: Any) -> None:
+        self.context().record_sse(*args, **kwargs)
+
+    def finish_sse(self, *args: Any, **kwargs: Any) -> None:
+        self.context().finish_sse(*args, **kwargs)
+
+    def append_tool_call(self, *args: Any, **kwargs: Any) -> None:
+        self.context().append_tool_call(*args, **kwargs)
+
+
+__all__ = [
+    "RequestTraceConfiguration",
+    "RequestTracePorts",
+    "RouterObservabilityCompatibilityApi",
+    "RouterObservabilityContext",
+    "RouterPreviewPorts",
+    "SseObservabilityPorts",
+    "SseTraceConfiguration",
+]