@oneciel-ai/ciel-runtime 0.2.2 → 0.2.4

package/ciel_runtime_support/channel_mcp_transport.py

@@ -7,6 +7,8 @@ import urllib.error
 from dataclasses import dataclass
 from typing import Any, Callable
 
+from .mcp_transport import negotiated_protocol_version
+
 
 @dataclass(frozen=True, slots=True)
 class ChannelMcpTransportConfig:
@@ -262,9 +264,10 @@ class ChannelMcpTransport:
                     },
                 },
             }
-            _result, session_id = self.http.streamable_post(
+            result, session_id = self.http.streamable_post(
                 endpoint, headers, initialize, timeout, protocol_version
             )
+            protocol_version = negotiated_protocol_version(result, protocol_version)
             if requires_session and not session_id:
                 self.effects.set_state(
                     name,
@@ -291,6 +294,7 @@ class ChannelMcpTransport:
                 mcp_endpoint=endpoint,
                 mcp_initialized=True,
                 mcp_session_id=session_id,
+                mcp_protocol_version=protocol_version,
                 mcp_last_error=None,
                 mcp_rpc_results={},
             )

package/ciel_runtime_support/channel_message_context.py

@@ -0,0 +1,212 @@
+"""Durable channel message queue and launch-dedupe bounded context."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Callable
+
+from .channel_launch_guard_repository import ChannelLaunchGuardRepository
+from .channel_message_dedupe import (
+    ChannelMessageDedupePorts,
+    ChannelMessageDedupeService,
+)
+from .channel_message_repository import (
+    ChannelMessageAppendPorts,
+    ChannelMessageRepository,
+)
+
+
+@dataclass(frozen=True, slots=True)
+class ChannelMessageStoragePorts:
+    path: Callable[[], Path]
+    max_bytes: int
+    condition: Any
+    file_lock: Callable[[Path], Any]
+    log: Callable[[str, str], None]
+
+
+@dataclass(frozen=True, slots=True)
+class ChannelMessageIdentityPorts:
+    stable_key: Callable[[dict[str, Any]], Any]
+    fallback_key: Callable[[dict[str, Any]], Any]
+    timestamp_seconds: Callable[[Any], float]
+    normalize_recipients: Callable[[Any], list[str]]
+
+
+@dataclass(frozen=True, slots=True)
+class ChannelMessageLaunchPorts:
+    guard_path: Callable[[], Path]
+    now: Callable[[], float]
+    recent_scan_limit: int
+    fallback_ttl_seconds: float
+
+
+@dataclass(frozen=True, slots=True)
+class ChannelMessageCachePorts:
+    read_next_id: Callable[[], int | None]
+    write_next_id: Callable[[int], None]
+
+
+@dataclass(frozen=True, slots=True)
+class ChannelMessageContext:
+    storage: ChannelMessageStoragePorts
+    identity: ChannelMessageIdentityPorts
+    launch: ChannelMessageLaunchPorts
+    cache: ChannelMessageCachePorts
+
+    def repository(self) -> ChannelMessageRepository:
+        return ChannelMessageRepository(
+            path=self.storage.path(),
+            log=self.storage.log,
+            max_bytes=self.storage.max_bytes,
+        )
+
+    def max_id(self) -> int:
+        return self.repository().max_id()
+
+    def max_id_before_epoch(self, cutoff_epoch: float) -> int:
+        return self.repository().max_id_before_epoch(cutoff_epoch)
+
+    def file_lock(self) -> Any:
+        return self.storage.file_lock(self.storage.path())
+
+    def read(
+        self,
+        after_id: int = 0,
+        channel: str | None = None,
+        recipient: str | None = None,
+        limit: int = 100,
+    ) -> list[dict[str, Any]]:
+        return self.repository().read(after_id, channel, recipient, limit)
+
+    def read_before(
+        self,
+        before_id: int = 0,
+        channel: str | None = None,
+        recipient: str | None = None,
+        limit: int = 100,
+    ) -> list[dict[str, Any]]:
+        return self.repository().read_before(before_id, channel, recipient, limit)
+
+    def recent_rows(self, limit: int | None = None) -> list[dict[str, Any]]:
+        return self.repository().recent_rows(
+            self.launch.recent_scan_limit if limit is None else limit
+        )
+
+    def launch_guard_repository(self) -> ChannelLaunchGuardRepository:
+        return ChannelLaunchGuardRepository(
+            path=self.launch.guard_path(),
+            now=self.launch.now,
+            log=self.storage.log,
+        )
+
+    def launch_guard(self) -> dict[str, Any] | None:
+        return self.launch_guard_repository().read()
+
+    def write_launch_guard(
+        self, max_existing_id: int, ttl_seconds: float = 180.0
+    ) -> None:
+        self.launch_guard_repository().write(max_existing_id, ttl_seconds)
+
+    def duplicate(self, message: dict[str, Any]) -> dict[str, Any] | None:
+        return ChannelMessageDedupeService(
+            ports=ChannelMessageDedupePorts(
+                stable_key=self.identity.stable_key,
+                fallback_key=self.identity.fallback_key,
+                recent_rows=self.recent_rows,
+                launch_guard=self.launch_guard,
+                timestamp_seconds=self.identity.timestamp_seconds,
+                now=self.launch.now,
+            ),
+            fallback_ttl_seconds=self.launch.fallback_ttl_seconds,
+        ).duplicate(message)
+
+    def initialize_next_id(self) -> int:
+        cached = self.cache.read_next_id()
+        if cached is not None:
+            return cached
+        next_id = self.max_id() + 1
+        self.cache.write_next_id(next_id)
+        return next_id
+
+    def append(self, payload: dict[str, Any]) -> dict[str, Any]:
+        message = self.repository().append(
+            payload,
+            ChannelMessageAppendPorts(
+                self.storage.condition,
+                self.file_lock,
+                self.duplicate,
+                self.identity.normalize_recipients,
+            ),
+        )
+        self.cache.write_next_id(int(message.get("id") or 0) + 1)
+        return message
+
+
+@dataclass(frozen=True, slots=True)
+class ChannelMessageCompatibilityApi:
+    context: Callable[[], ChannelMessageContext]
+
+    def repository(self) -> ChannelMessageRepository:
+        return self.context().repository()
+
+    def max_id(self) -> int:
+        return self.context().max_id()
+
+    def max_id_before_epoch(self, cutoff_epoch: float) -> int:
+        return self.context().max_id_before_epoch(cutoff_epoch)
+
+    def file_lock(self) -> Any:
+        return self.context().file_lock()
+
+    def read(
+        self,
+        after_id: int = 0,
+        channel: str | None = None,
+        recipient: str | None = None,
+        limit: int = 100,
+    ) -> list[dict[str, Any]]:
+        return self.context().read(after_id, channel, recipient, limit)
+
+    def read_before(
+        self,
+        before_id: int = 0,
+        channel: str | None = None,
+        recipient: str | None = None,
+        limit: int = 100,
+    ) -> list[dict[str, Any]]:
+        return self.context().read_before(before_id, channel, recipient, limit)
+
+    def recent_rows(self, limit: int | None = None) -> list[dict[str, Any]]:
+        return self.context().recent_rows(limit)
+
+    def launch_guard_repository(self) -> ChannelLaunchGuardRepository:
+        return self.context().launch_guard_repository()
+
+    def launch_guard(self) -> dict[str, Any] | None:
+        return self.context().launch_guard()
+
+    def write_launch_guard(
+        self, max_existing_id: int, ttl_seconds: float = 180.0
+    ) -> None:
+        self.context().write_launch_guard(max_existing_id, ttl_seconds)
+
+    def duplicate(self, message: dict[str, Any]) -> dict[str, Any] | None:
+        return self.context().duplicate(message)
+
+    def initialize_next_id(self) -> int:
+        return self.context().initialize_next_id()
+
+    def append(self, payload: dict[str, Any]) -> dict[str, Any]:
+        return self.context().append(payload)
+
+
+__all__ = [
+    "ChannelMessageCachePorts",
+    "ChannelMessageCompatibilityApi",
+    "ChannelMessageContext",
+    "ChannelMessageIdentityPorts",
+    "ChannelMessageLaunchPorts",
+    "ChannelMessageStoragePorts",
+]

package/ciel_runtime_support/channel_message_repository.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from contextlib import contextmanager
-from datetime import datetime, timezone
+from datetime import datetime
 import json
 from dataclasses import dataclass
 import os
@@ -65,9 +65,11 @@ class ChannelMessageRepository:
                 if self.path.exists() and self.path.stat().st_size > self.max_bytes:
                     self.path.replace(self.path.with_suffix(".jsonl.1"))
                 next_id = previous_max_id + 1
+                created_at = time.time()
                 message = {
                     "id": next_id,
-                    "time": time.strftime("%Y-%m-%dT%H:%M:%S"),
+                    "time": time.strftime("%Y-%m-%dT%H:%M:%S", time.localtime(created_at)),
+                    "created_at_epoch": created_at,
                     "channel": str(payload.get("channel") or "default"),
                     "sender_id": str(payload.get("sender_id") or payload.get("sender") or "anonymous"),
                     "recipients": ports.normalize_recipients(
@@ -100,6 +102,12 @@ class ChannelMessageRepository:
 
     @staticmethod
     def timestamp_seconds(item: dict[str, Any]) -> float | None:
+        raw_epoch = item.get("created_at_epoch")
+        if raw_epoch is not None:
+            try:
+                return float(raw_epoch)
+            except (TypeError, ValueError):
+                pass
         raw = item.get("time") or item.get("created_at") or item.get("updated_at")
         if not raw:
             return None
@@ -113,7 +121,10 @@ class ChannelMessageRepository:
         except (TypeError, ValueError):
             return None
         if parsed.tzinfo is None:
-            parsed = parsed.replace(tzinfo=timezone.utc)
+            # Historical messages were written with time.strftime(), i.e. in
+            # the machine's local timezone.  Treating those values as UTC can
+            # move the replay boundary by several hours.
+            return parsed.timestamp()
         return parsed.timestamp()
 
     def _jsonl_items(self, operation: str) -> list[dict[str, Any]]:

package/ciel_runtime_support/channel_pending_injection.py

@@ -52,6 +52,7 @@ class ChannelInjectionIO:
 @dataclass(frozen=True, slots=True)
 class ChannelInjectionPolicy:
     wake_batch_limit: Callable[[], int]
+    replay_skip_reason: Callable[[dict[str, Any]], str]
 
 
 @dataclass(frozen=True, slots=True)
@@ -115,6 +116,14 @@ def inject_pending_channel_messages(
             if web_chat_only and not state.message_is_web_chat(message):
                 io.log("INFO", f"channel_stdin_proxy_skipped_noise message_id={message_id} channel={channel} reason=not_web_chat")
                 continue
+            replay_skip_reason = services.policy.replay_skip_reason(message)
+            if replay_skip_reason:
+                io.log(
+                    "WARN",
+                    f"channel_stdin_proxy_skipped_noise message_id={message_id} "
+                    f"channel={channel} reason={replay_skip_reason}",
+                )
+                continue
             skip_reason = state.message_skip_reason(message)
             if skip_reason:
                 io.log("INFO", f"channel_stdin_proxy_skipped_noise message_id={message_id} channel={channel} reason={skip_reason}")

package/ciel_runtime_support/channel_probe_launch_context.py

@@ -0,0 +1,213 @@
+"""Channel probe-cache decisions and runtime launch orchestration."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Callable, Iterable
+
+from .codex_channel_sse_launch import (
+    CodexChannelSseEffects,
+    CodexChannelSseLaunchService,
+    CodexChannelSseQueryPorts,
+)
+
+
+@dataclass(frozen=True, slots=True)
+class ChannelProbeLaunchDiscoveryPorts:
+    discover_servers: Callable[..., dict[str, dict[str, Any]]]
+    cached_external_capable: Callable[[], list[str]]
+    channel_specs: Callable[[dict[str, Any], list[str]], list[str]]
+    server_names: Callable[[Iterable[str]], list[str]]
+    codex_capable_names: Callable[..., list[str]]
+    external_names: Callable[..., list[str]]
+    dedupe: Callable[[Iterable[str]], list[str]]
+
+
+@dataclass(frozen=True, slots=True)
+class ChannelProbeLaunchCachePorts:
+    service: Callable[[], Any]
+    read: Callable[[], dict[str, Any]]
+    records: Callable[[], list[dict[str, Any]]]
+    refresh: Callable[..., dict[str, Any]]
+    bucket: Callable[[dict[str, Any]], str]
+    panel_rows: Callable[[dict[str, Any]], tuple[list[str], list[str]]]
+    log: Callable[[str, str], None]
+
+
+@dataclass(frozen=True, slots=True)
+class ChannelProbeLaunchEffects:
+    delivery_mode: Callable[[dict[str, Any]], str]
+    auto_start: Callable[..., list[dict[str, Any]]]
+
+
+@dataclass(frozen=True, slots=True)
+class ChannelProbeLaunchContext:
+    discovery: ChannelProbeLaunchDiscoveryPorts
+    cache: ChannelProbeLaunchCachePorts
+    effects: ChannelProbeLaunchEffects
+    native_channel_names: frozenset[str]
+
+    def native_auto_capable_names(
+        self, passthrough: list[str] | None = None
+    ) -> list[str]:
+        discovered = set(
+            self.discovery.discover_servers(passthrough or []).keys()
+        )
+        if not discovered:
+            return []
+        return [
+            name
+            for name in self.discovery.cached_external_capable()
+            if name in discovered
+        ]
+
+    def start_codex_sse(
+        self,
+        cfg: dict[str, Any],
+        codex_mcp_config: Path | None,
+        allowed_server_names: Iterable[str] | None = None,
+    ) -> list[dict[str, Any]]:
+        service = CodexChannelSseLaunchService(
+            query=CodexChannelSseQueryPorts(
+                delivery_mode=self.effects.delivery_mode,
+                channel_specs=self.discovery.channel_specs,
+                server_names=self.discovery.server_names,
+                capable_names=self.discovery.codex_capable_names,
+                dedupe=self.discovery.dedupe,
+            ),
+            effects=CodexChannelSseEffects(
+                auto_start=self.effects.auto_start,
+                log=self.cache.log,
+            ),
+            native_channel_names=frozenset(
+                name.casefold() for name in self.native_channel_names
+            ),
+        )
+        return service.start(cfg, codex_mcp_config, allowed_server_names)
+
+    def summary(self, prefix: str, cache: dict[str, Any]) -> str:
+        records = [
+            record
+            for record in cache.get("servers") or []
+            if isinstance(record, dict)
+        ]
+        grouped = {
+            name: [
+                record for record in records if self.cache.bucket(record) == name
+            ]
+            for name in ("capable", "inconclusive", "non_capable")
+        }
+        return (
+            f"{prefix}: {len(grouped['capable'])} channel-capable, "
+            f"{len(grouped['inconclusive'])} inconclusive, "
+            f"{len(grouped['non_capable'])} non-capable server(s)."
+        )
+
+    def panel_rows(
+        self, cfg: dict[str, Any], passthrough: list[str]
+    ) -> tuple[list[str], list[str], list[str]]:
+        messages: list[str] = []
+        if self.needs_refresh(cfg, passthrough):
+            try:
+                self.cache.log(
+                    "INFO",
+                    "channel_probe_menu_refresh "
+                    "reason=missing_cache_or_selected_server",
+                )
+                result = self.cache.refresh(passthrough)
+                messages = [self.summary("Probe complete", result)]
+            except Exception as exc:
+                self.cache.log(
+                    "WARN",
+                    "channel_probe_menu_refresh_failed "
+                    f"error={type(exc).__name__}: {exc}",
+                )
+                messages = [
+                    f"Channel probe failed: {type(exc).__name__}: {exc}"
+                ]
+        rows, values = self.cache.panel_rows(cfg)
+        return rows, values, messages
+
+    def candidate_names(
+        self,
+        cfg: dict[str, Any],
+        passthrough: list[str],
+        extra_config_paths: list[Path | str] | None = None,
+    ) -> list[str]:
+        return self.cache.service().candidate_names(
+            self.discovery.channel_specs(cfg, passthrough),
+            lambda: self.discovery.external_names(
+                passthrough,
+                extra_config_paths=extra_config_paths,
+            ),
+        )
+
+    def needs_refresh(
+        self,
+        cfg: dict[str, Any],
+        passthrough: list[str],
+        extra_config_paths: list[Path | str] | None = None,
+    ) -> bool:
+        candidates = self.candidate_names(
+            cfg, passthrough, extra_config_paths=extra_config_paths
+        )
+        return self.cache.service().needs_refresh(
+            self.cache.read(), self.cache.records(), candidates
+        )
+
+    def ensure_cache(
+        self,
+        cfg: dict[str, Any],
+        passthrough: list[str],
+        extra_config_paths: list[Path | str] | None = None,
+    ) -> bool:
+        needed = self.needs_refresh(
+            cfg, passthrough, extra_config_paths=extra_config_paths
+        )
+        return self.cache.service().ensure_refresh(
+            needed,
+            lambda: self.cache.refresh(
+                passthrough,
+                **(
+                    {"extra_config_paths": extra_config_paths}
+                    if extra_config_paths is not None
+                    else {}
+                ),
+            ),
+        )
+
+
+@dataclass(frozen=True, slots=True)
+class ChannelProbeLaunchCompatibilityApi:
+    context: Callable[[], ChannelProbeLaunchContext]
+
+    def native_auto_capable_names(self, *args: Any, **kwargs: Any) -> list[str]:
+        return self.context().native_auto_capable_names(*args, **kwargs)
+
+    def start_codex_sse(self, *args: Any, **kwargs: Any) -> list[dict[str, Any]]:
+        return self.context().start_codex_sse(*args, **kwargs)
+
+    def summary(self, *args: Any, **kwargs: Any) -> str:
+        return self.context().summary(*args, **kwargs)
+
+    def panel_rows(self, *args: Any, **kwargs: Any) -> tuple[list[str], list[str], list[str]]:
+        return self.context().panel_rows(*args, **kwargs)
+
+    def candidate_names(self, *args: Any, **kwargs: Any) -> list[str]:
+        return self.context().candidate_names(*args, **kwargs)
+
+    def needs_refresh(self, *args: Any, **kwargs: Any) -> bool:
+        return self.context().needs_refresh(*args, **kwargs)
+
+    def ensure_cache(self, *args: Any, **kwargs: Any) -> bool:
+        return self.context().ensure_cache(*args, **kwargs)
+
+
+__all__ = [
+    "ChannelProbeLaunchCachePorts",
+    "ChannelProbeLaunchCompatibilityApi",
+    "ChannelProbeLaunchContext",
+    "ChannelProbeLaunchDiscoveryPorts",
+    "ChannelProbeLaunchEffects",
+]

package/ciel_runtime_support/channel_replay_policy.py

@@ -0,0 +1,38 @@
+"""Safety policy for replaying durable channel messages into an agent terminal."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Callable
+
+
+@dataclass(frozen=True, slots=True)
+class ChannelReplaySafetyPolicy:
+    now: Callable[[], float]
+    replay_ttl_seconds: Callable[[], float]
+    timestamp_seconds: Callable[[dict[str, Any]], float | None]
+    is_web_chat: Callable[[dict[str, Any]], bool]
+
+    def skip_reason(self, message: dict[str, Any]) -> str:
+        """Expire old browser commands independently of startup cursor state.
+
+        Browser messages are durable history, but they are also executable input.
+        A cursor or launch-hook failure must never turn old history back into a
+        command after a process or machine restart.
+        """
+
+        if not self.is_web_chat(message):
+            return ""
+        created_at = self.timestamp_seconds(message)
+        if created_at is None:
+            return ""
+        ttl = max(1.0, float(self.replay_ttl_seconds()))
+        age = self.now() - created_at
+        if age > ttl:
+            return "stale_web_chat_replay"
+        if age < -300.0:
+            return "future_web_chat_timestamp"
+        return ""
+
+
+__all__ = ["ChannelReplaySafetyPolicy"]

package/ciel_runtime_support/channel_runtime_environment.py

@@ -55,6 +55,14 @@ class ChannelRuntimeEnvironmentPolicy:
             maximum=50,
         )
 
+    def web_chat_replay_ttl_seconds(self) -> float:
+        return self._bounded_float(
+            self.environment.get("CIEL_RUNTIME_WEB_CHAT_REPLAY_TTL_SECONDS"),
+            default=600.0,
+            minimum=30.0,
+            maximum=3600.0,
+        )
+
     def wake_claim_ttl_seconds(self) -> float:
         return self._bounded_float(
             self.environment.get(