@oneciel-ai/ciel-runtime 0.2.37 → 0.2.38

package/ciel_runtime_support/runtime_input_gateway.py

@@ -17,6 +17,42 @@ from typing import Any, Callable
 class RuntimeInputGateway:
     append: Callable[[dict[str, Any]], dict[str, Any]]
     project_attachment: Callable[[dict[str, Any]], dict[str, Any]] | None = None
+    default_input_transport: Callable[[], str] = lambda: "session_socket"
+    status: Any = None
+
+    def _append(self, payload: dict[str, Any]) -> dict[str, Any]:
+        message = self.append(payload)
+        request_id = int(message.get("id") or 0)
+        if (
+            request_id > 0
+            and not message.get("_ciel_runtime_duplicate")
+            and self.status is not None
+        ):
+            self.status.transition(
+                request_id,
+                "queued",
+                data={
+                    "channel": str(message.get("channel") or "default"),
+                    "input_transport": str(
+                        (message.get("meta") or {}).get("input_transport") or ""
+                    ),
+                },
+            )
+        return message
+
+    def _transport(self, value: Any = None) -> str:
+        transport = str(value or self.default_input_transport() or "session_socket").strip().lower().replace("-", "_")
+        aliases = {
+            "socket": "session_socket",
+            "claude_socket": "session_socket",
+            "messaging_socket": "session_socket",
+            "llm": "router",
+            "context": "router",
+            "terminal": "tty",
+            "stdin": "tty",
+        }
+        transport = aliases.get(transport, transport)
+        return transport if transport in {"session_socket", "router", "tty"} else "tty"
 
     def submit_web_chat(
         self,
@@ -30,6 +66,10 @@ class RuntimeInputGateway:
         meta.setdefault("source", "ciel-runtime-web-chat")
         meta.setdefault("source_kind", "web_chat")
         meta.setdefault("injection_mode", "structured")
+        meta.setdefault(
+            "input_transport",
+            self._transport(inbound.get("input_transport") or meta.get("input_transport")),
+        )
         meta.setdefault("response_mode", "web_chat")
         if meta["response_mode"] == "web_chat":
             meta["reply_parent_id"] = public_message.get("id")
@@ -58,7 +98,7 @@ class RuntimeInputGateway:
             "delivery": ["llm"],
             "visibility": "private_runtime",
         }
-        return self.append(payload)
+        return self._append(payload)
 
     def submit_tty(
         self,
@@ -94,6 +134,9 @@ class RuntimeInputGateway:
         meta["source"] = "ciel-runtime-api-tty"
         meta["source_kind"] = "tty_input"
         meta["injection_mode"] = "tty"
+        meta["input_transport"] = self._transport(
+            meta.get("input_transport") or body.get("input_transport")
+        )
         meta["response_mode"] = response_mode
 
         content: Any = params.get("content")
@@ -103,7 +146,7 @@ class RuntimeInputGateway:
             content = json.dumps(content, ensure_ascii=False, separators=(",", ":"))
             meta["content_type"] = "application/json"
 
-        return self.append(
+        return self._append(
             {
                 "channel": body.get("channel") or meta.get("channel") or "default",
                 "sender_id": body.get("sender_id") or body.get("sender") or "api-user",
@@ -126,10 +169,14 @@ class RuntimeInputGateway:
         meta = dict(meta_value) if isinstance(meta_value, dict) else {}
         meta.setdefault("source", "ciel-runtime-notify")
         meta.setdefault("source_kind", "notification")
+        meta.setdefault(
+            "input_transport",
+            self._transport(body.get("input_transport") or meta.get("input_transport")),
+        )
         content = params.get("content")
         if content is None:
             content = body.get("content", body.get("message", body.get("text", "")))
-        return self.append(
+        return self._append(
             {
                 "channel": body.get("channel") or meta.get("channel") or "default",
                 "sender_id": body.get("sender_id") or body.get("sender") or body.get("server") or meta.get("source") or "channel",
@@ -144,6 +191,36 @@ class RuntimeInputGateway:
             }
         )
 
+    def submit_stream_input(self, body: dict[str, Any]) -> dict[str, Any]:
+        """Admit an external Streamable HTTP/MCP input into the runtime queue."""
+
+        meta = dict(body.get("meta") or {}) if isinstance(body.get("meta"), dict) else {}
+        meta.setdefault("source", "ciel-runtime-mcp-streamable")
+        meta.setdefault("source_kind", "mcp_streamable_input")
+        meta.setdefault("injection_mode", "structured")
+        meta["input_transport"] = self._transport(
+            body.get("input_transport") or meta.get("input_transport")
+        )
+        meta.setdefault("response_mode", str(body.get("response_mode") or "tty"))
+        content = body.get("message", body.get("content", body.get("text", "")))
+        if isinstance(content, (dict, list)):
+            content = json.dumps(content, ensure_ascii=False, separators=(",", ":"))
+            meta["content_type"] = "application/json"
+        return self._append(
+            {
+                "channel": body.get("channel") or "mcp-streamable",
+                "sender_id": body.get("sender_id") or body.get("sender") or "mcp-client",
+                "recipients": body.get("recipients", "all"),
+                "thread_id": body.get("thread_id"),
+                "parent_id": body.get("parent_id"),
+                "kind": body.get("kind") or "mcp_streamable_input",
+                "message": content if content is not None else "",
+                "meta": meta,
+                "delivery": ["llm"],
+                "visibility": "private_runtime",
+            }
+        )
+
     def submit_external_event(
         self,
         raw_event: str,
@@ -154,10 +231,11 @@ class RuntimeInputGateway:
         event_type: str,
         event_source: str,
         transport_event_id: str = "",
+        input_transport: str = "",
     ) -> dict[str, Any]:
         """Admit exact decoded event text; never normalize or re-serialize it."""
 
-        return self.append(
+        return self._append(
             {
                 "channel": f"external:{receiver_id}",
                 "sender_id": event_source or receiver_id,
@@ -174,6 +252,7 @@ class RuntimeInputGateway:
                     "event_type": event_type,
                     "event_source": event_source,
                     "transport_event_id": transport_event_id,
+                    "input_transport": self._transport(input_transport),
                     "raw_preserved": True,
                 },
                 "delivery": ["llm"],
@@ -216,7 +295,7 @@ class RuntimeInputGateway:
             "to read only the needed range. This is input-only telemetry; no acknowledgement "
             f"or response is required. Stored ranges: {locations}"
         )
-        return self.append(
+        return self._append(
             {
                 "channel": "telemetry",
                 "sender_id": "otlp",
@@ -231,6 +310,7 @@ class RuntimeInputGateway:
                     "ack_required": False,
                     "response_expected": False,
                     "logs_embedded": False,
+                    "input_transport": self._transport(),
                 },
                 "delivery": ["llm"],
                 "visibility": "private_runtime",

package/ciel_runtime_support/runtime_input_status.py

@@ -0,0 +1,150 @@
+"""Durable lifecycle state for private runtime input requests."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from datetime import datetime, timezone
+import json
+from pathlib import Path
+import threading
+import time
+from typing import Any, Callable
+
+
+RUNTIME_INPUT_STATES = frozenset({"queued", "submitted", "replied", "failed"})
+_TERMINAL_STATES = frozenset({"replied", "failed"})
+
+
+@dataclass(slots=True)
+class RuntimeInputStatusRepository:
+    path: Path
+    publish_event: Callable[..., Any]
+    log: Callable[[str, str], None]
+    lock: threading.Lock | threading.RLock
+
+    def transition(
+        self,
+        request_id: int,
+        status: str,
+        *,
+        reason: str = "",
+        data: dict[str, Any] | None = None,
+    ) -> dict[str, Any]:
+        request_id = int(request_id)
+        status = str(status or "").strip().lower()
+        if request_id <= 0:
+            raise ValueError("request_id must be positive")
+        if status not in RUNTIME_INPUT_STATES:
+            raise ValueError(f"invalid runtime input status: {status}")
+        with self.lock:
+            current = self.get(request_id, _locked=True)
+            current_status = str((current or {}).get("status") or "")
+            if current_status in _TERMINAL_STATES or current_status == status:
+                return current or self._record(request_id, status, reason, data)
+            allowed = {
+                "": {"queued"},
+                "queued": {"submitted", "failed"},
+                "submitted": {"replied", "failed"},
+            }
+            if status not in allowed.get(current_status, set()):
+                self.log(
+                    "WARN",
+                    "runtime_input_status_transition_rejected "
+                    f"request_id={request_id} from={current_status or '-'} to={status}",
+                )
+                return current or {}
+            record = self._record(request_id, status, reason, data)
+        self.publish_event(
+            level="error" if status == "failed" else "info",
+            category="runtime_input.status",
+            message=f"runtime input {status}",
+            source="runtime-input",
+            request_id=str(request_id),
+            data=record,
+        )
+        return record
+
+    def _record(
+        self,
+        request_id: int,
+        status: str,
+        reason: str,
+        data: dict[str, Any] | None,
+    ) -> dict[str, Any]:
+        now = time.time()
+        record: dict[str, Any] = {
+            "request_id": request_id,
+            "status": status,
+            "updated_at": datetime.now(timezone.utc).astimezone().isoformat(timespec="seconds"),
+            "updated_at_epoch": now,
+        }
+        if reason:
+            record["reason"] = str(reason)
+        if data:
+            record["data"] = dict(data)
+        self.path.parent.mkdir(parents=True, exist_ok=True)
+        with self.path.open("a", encoding="utf-8") as stream:
+            stream.write(json.dumps(record, ensure_ascii=False, separators=(",", ":")) + "\n")
+            stream.flush()
+        return record
+
+    def get(self, request_id: int, *, _locked: bool = False) -> dict[str, Any] | None:
+        def read() -> dict[str, Any] | None:
+            latest = None
+            for item in self._items():
+                try:
+                    if int(item.get("request_id") or 0) == int(request_id):
+                        latest = item
+                except (TypeError, ValueError):
+                    continue
+            return latest
+
+        if _locked:
+            return read()
+        with self.lock:
+            return read()
+
+    def list_latest(
+        self,
+        *,
+        after_request_id: int = 0,
+        status: str = "",
+        limit: int = 100,
+    ) -> list[dict[str, Any]]:
+        with self.lock:
+            latest: dict[int, dict[str, Any]] = {}
+            for item in self._items():
+                try:
+                    request_id = int(item.get("request_id") or 0)
+                except (TypeError, ValueError):
+                    continue
+                if request_id > after_request_id:
+                    latest[request_id] = item
+        expected = str(status or "").strip().lower()
+        rows = [latest[key] for key in sorted(latest)]
+        if expected:
+            rows = [row for row in rows if row.get("status") == expected]
+        return rows[: max(1, min(500, int(limit)))]
+
+    def _items(self) -> list[dict[str, Any]]:
+        if not self.path.exists():
+            return []
+        items: list[dict[str, Any]] = []
+        try:
+            with self.path.open("r", encoding="utf-8") as stream:
+                for line in stream:
+                    try:
+                        item = json.loads(line)
+                    except (json.JSONDecodeError, TypeError):
+                        continue
+                    if isinstance(item, dict):
+                        items.append(item)
+        except OSError as exc:
+            self.log(
+                "WARN",
+                f"runtime_input_status_read_failed error={type(exc).__name__}: {exc}",
+            )
+        return items
+
+
+__all__ = ["RUNTIME_INPUT_STATES", "RuntimeInputStatusRepository"]

package/ciel_runtime_support/runtime_launch.py

@@ -8,6 +8,7 @@ from typing import Any, Callable
 from dataclasses import dataclass
 
 from ciel_runtime_support.claude_environment import CLAUDE_PROJECTED_ENV_KEYS
+from ciel_runtime_support.managed_tool_injection import should_inject_tool, codex_native_web_tool_overrides
 from ciel_runtime_support.runtime_constants import (
     CLAUDE_SERVER_SIDE_WEB_TOOLS,
     CODEX_RUNTIME_API_KEY_ENV,
@@ -151,6 +152,8 @@ class ClaudeLaunchChannelDelivery:
     channel_wake_submit_delay_seconds: Callable[..., Any]
     channel_wake_submit_retries: Callable[..., Any]
     set_channel_transcript_scope: Callable[..., Any]
+    prepare_session_socket: Callable[..., str]
+    configure_session_socket: Callable[[str | None], None]
 
 
 @dataclass(frozen=True, slots=True)
@@ -245,6 +248,8 @@ def run_claude(
     channel_wake_submit_delay_seconds = services.channel_delivery.channel_wake_submit_delay_seconds
     channel_wake_submit_retries = services.channel_delivery.channel_wake_submit_retries
     set_channel_transcript_scope = services.channel_delivery.set_channel_transcript_scope
+    prepare_session_socket = services.channel_delivery.prepare_session_socket
+    configure_session_socket = services.channel_delivery.configure_session_socket
     start_router_if_needed = services.routing.start_router_if_needed
     subprocess_call_with_channel_wake_proxy = services.process.subprocess_call_with_channel_wake_proxy
     subprocess_call_with_child_pid_record = services.process.subprocess_call_with_child_pid_record
@@ -330,6 +335,11 @@ def run_claude(
     if use_native_anthropic and web_backend_start_requested(cfg):
         llm_channel_delivery = True
         stdin_channel_proxy = not has_noninteractive_claude_args(launch_passthrough)
+    session_socket_target = (
+        prepare_session_socket(cfg, launch_passthrough)
+        if stdin_channel_proxy
+        else ""
+    )
     manage_router_lifetime = False
     if use_router_mode or llm_channel_delivery:
         manage_router_lifetime = bool(start_router_if_needed())
@@ -454,7 +464,7 @@ def run_claude(
     zai_mcp_config = write_zai_mcp_config(provider, pcfg)
     if zai_mcp_config:
         mcp_config_paths.append(str(zai_mcp_config))
-    if should_attach_web_search(provider, cfg, web_search_override):
+    if should_inject_tool(native=provider == "anthropic", mode="non_native") and should_attach_web_search(provider, cfg, web_search_override):
         mcp_config_paths.append(str(write_duckduckgo_mcp_config(cfg)))
     workspace_mcp_launch = (
         workspace_mcp.prepare(
@@ -463,6 +473,7 @@ def run_claude(
                 "transport": "streamable_http", "url": f"{ROUTER_BASE}/ca/mcp",
                 "runtimes": ["claude"],
             }} if llm_channel_delivery and web_backend_start_requested(cfg) else None,
+            native=provider == "anthropic",
         ) if workspace_mcp is not None else None
     )
     if workspace_mcp_launch is not None:
@@ -472,7 +483,15 @@ def run_claude(
         extra_args.extend(["--mcp-config", *mcp_config_paths])
     if should_append_compat_prompt(provider, pcfg, cfg) and not has_passthrough_option(launch_passthrough, "--system-prompt"):
         extra_args.extend(["--append-system-prompt", ROUTED_COMPAT_PROMPT])
-    append_claude_code_runtime_settings_args(extra_args, launch_passthrough, provider, pcfg)
+    if session_socket_target and not has_passthrough_option(
+        launch_passthrough, "--messaging-socket-path"
+    ):
+        extra_args.extend(["--messaging-socket-path", session_socket_target])
+    runtime_settings_config = dict(pcfg)
+    runtime_settings_config["_ciel_session_socket_enabled"] = bool(session_socket_target)
+    append_claude_code_runtime_settings_args(
+        extra_args, launch_passthrough, provider, runtime_settings_config
+    )
     if fork_native_session:
         session_id = str(uuid.uuid4())
         extra_args.extend(["--session-id", session_id])
@@ -538,6 +557,7 @@ def run_claude(
     def run_claude_process() -> int:
         rc = 1
         try:
+            configure_session_socket(session_socket_target or None)
             set_channel_transcript_scope(
                 "claude",
                 cwd=Path.cwd(),
@@ -573,6 +593,7 @@ def run_claude(
                 rc = subprocess.call(cmd, env=env)
             return rc
         finally:
+            configure_session_socket(None)
             if use_router_mode:
                 print_routed_claude_exit_diagnostics(rc, provider, pcfg, log_offset=launch_log_offset)
 
@@ -902,10 +923,11 @@ def run_codex(
         ),
     )
     workspace_mcp_launch = (
-        workspace_mcp.prepare("codex", cfg, env) if workspace_mcp is not None else None
+        workspace_mcp.prepare("codex", cfg, env, native=native_codex_enabled(provider)) if workspace_mcp is not None else None
     )
     if workspace_mcp_launch is not None:
         codex_mcp_compat_args.extend(workspace_mcp_launch.codex_args)
+    codex_mcp_compat_args.extend(codex_native_web_tool_overrides(native=native_codex_enabled(provider)))
     codex_yolo_args = codex_yolo_launch_args(codex_passthrough)
     if not use_native_codex and not use_codex_routed:
         env[CODEX_RUNTIME_API_KEY_ENV] = env.get(CODEX_RUNTIME_API_KEY_ENV) or "ciel-runtime-router-local-key"
@@ -1232,12 +1254,13 @@ def run_codex_app_server(
         ),
     )
     workspace_mcp_launch = (
-        workspace_mcp.prepare("codex-app-server", cfg, env)
+        workspace_mcp.prepare("codex-app-server", cfg, env, native=native_codex_enabled(provider))
         if workspace_mcp is not None else None
     )
     try:
         if workspace_mcp_launch is not None:
             codex_mcp_compat_args.extend(workspace_mcp_launch.codex_args)
+        codex_mcp_compat_args.extend(codex_native_web_tool_overrides(native=native_codex_enabled(provider)))
         config_args = [*config_args, *codex_mcp_compat_args]
         listen_url = codex_app_server_default_listen_url()
         app_server_args = codex_app_server_launch_args(

package/ciel_runtime_support/runtime_paths.py

@@ -167,6 +167,7 @@ CONTEXT_USAGE_PATH = ROUTER_INSTANCE_DIR / "context-usage.json"
 OLLAMA_MODEL_CATALOG_PATH = CONFIG_DIR / "ollama-model-catalog.json"
 CHAT_MESSAGES_PATH = WORKSPACE_STATE_DIR / "chat-messages.jsonl"
 RUNTIME_INPUTS_PATH = WORKSPACE_STATE_DIR / "runtime-inputs.jsonl"
+RUNTIME_INPUT_STATUS_PATH = WORKSPACE_STATE_DIR / "runtime-input-status.jsonl"
 CHAT_FILES_DIR = WORKSPACE_STATE_DIR / "chat-files"
 MENU_KEY_DEBUG_PATH = ROUTER_INSTANCE_DIR / "ca-key-debug.log"
 PLAN_ARTIFACTS_DIR = WORKSPACE_STATE_DIR / "plan-artifacts"

package/ciel_runtime_support/speech_http_controller.py

@@ -151,8 +151,9 @@ class SpeechHttpController:
                 "chat_message_processing": {
                     "input_mode": {"default": "structured", "allowed": ["structured", "tty"]},
                     "input_transport": {
-                        "default": "tty",
-                        "allowed": ["tty", "router"],
+                        "default": "session_socket; tty fallback when the active runtime has no usable session socket",
+                        "allowed": ["session_socket", "tty", "router"],
+                        "session_socket_requires": "an active Claude session launched with its Ciel-owned messaging socket",
                         "router_requires": "an active model session routed through Ciel Router",
                     },
                     "response_mode": {"default": "web_chat", "allowed": ["web_chat", "tty", "mcp"]},

package/ciel_runtime_support/streaming_anthropic.py

@@ -716,6 +716,7 @@ def rebatch_anthropic_sse_text(
             "anthropic_stream_tool_call",
             {
                 "model": model,
+                "tool_id": tool_id,
                 "raw_name": raw_name,
                 "matched_name": matched_name,
                 "raw_arguments": raw_args,
@@ -1656,6 +1657,7 @@ def ollama_stream_to_anthropic_sse(
                     "ollama_stream_tool_call",
                     {
                         "model": model,
+                        "tool_id": tool_id,
                         "raw_name": raw_name,
                         "matched_name": matched_name,
                         "raw_arguments": raw_args,
@@ -2434,6 +2436,7 @@ def forward_openai_chat_to_anthropic_sse(
                 "openai_stream_tool_call",
                 {
                     "model": model,
+                    "tool_id": tool_id,
                     "raw_name": raw_name,
                     "matched_name": matched_name,
                     "raw_arguments": fragment.get("arguments"),

package/ciel_runtime_support/tool_call_events.py

@@ -0,0 +1,98 @@
+"""Normalize tool-call records emitted by supported CLI transcript formats."""
+
+from __future__ import annotations
+
+import json
+from typing import Any
+
+
+_CODEX_CALL_TYPES = {"function_call", "custom_tool_call", "local_shell_call"}
+_CODEX_BEGIN_TYPES = {"mcp_tool_call_begin", "tool_call_begin"}
+_CLAUDE_CALL_TYPES = {"tool_use", "server_tool_use"}
+
+
+def _object(value: Any) -> dict[str, Any]:
+    return value if isinstance(value, dict) else {}
+
+
+def _call_id(value: dict[str, Any]) -> str:
+    for key in ("call_id", "id", "tool_call_id"):
+        text = str(value.get(key) or "").strip()
+        if text:
+            return text
+    return ""
+
+
+def _arguments(value: Any) -> Any:
+    if not isinstance(value, str):
+        return value
+    text = value.strip()
+    if not text:
+        return ""
+    try:
+        return json.loads(text)
+    except (TypeError, ValueError):
+        return value
+
+
+def _project(value: dict[str, Any], *, call_type: str) -> dict[str, Any]:
+    name = str(value.get("name") or value.get("tool_name") or "").strip()
+    arguments = value.get("arguments")
+    if arguments is None:
+        arguments = value.get("input")
+    if arguments is None:
+        arguments = value.get("action")
+    if arguments is None:
+        arguments = value.get("args")
+    return {
+        "call_id": _call_id(value),
+        "name": name or call_type,
+        "call_type": call_type,
+        "arguments": _arguments(arguments),
+    }
+
+
+def project_transcript_tool_calls(
+    record: dict[str, Any], runtime: str
+) -> list[dict[str, Any]]:
+    """Project one Claude/Codex JSONL record into normalized tool-call starts."""
+
+    record_type = str(record.get("type") or "").strip()
+    payload = _object(record.get("payload"))
+    payload_type = str(payload.get("type") or "").strip()
+    calls: list[dict[str, Any]] = []
+    if record_type == "response_item" and payload_type in _CODEX_CALL_TYPES:
+        calls.append(_project(payload, call_type=payload_type))
+    elif record_type == "event_msg" and payload_type in _CODEX_BEGIN_TYPES:
+        invocation = _object(payload.get("invocation")) or _object(payload.get("tool_call"))
+        calls.append(_project({**payload, **invocation}, call_type=payload_type))
+
+    muse_payload_type = str(record.get("payload_type") or "").strip()
+    if str(record.get("record_type") or "").strip() == "event" and muse_payload_type == "runtime.session":
+        muse_event = _object(payload.get("event"))
+        muse_calls = muse_event.get("tool_calls")
+        if isinstance(muse_calls, list):
+            for call in muse_calls:
+                if isinstance(call, dict):
+                    calls.append(_project(call, call_type="muse_tool_call"))
+
+    message = _object(record.get("message"))
+    message_role = str(message.get("role") or "").strip()
+    if record_type == "assistant" or message_role == "assistant":
+        content = message.get("content")
+        blocks = [content] if isinstance(content, dict) else content if isinstance(content, list) else []
+        for block in blocks:
+            block_obj = _object(block)
+            block_type = str(block_obj.get("type") or "").strip()
+            if block_type in _CLAUDE_CALL_TYPES:
+                calls.append(_project(block_obj, call_type=block_type))
+
+    model = str(record.get("model") or message.get("model") or "").strip()
+    for call in calls:
+        call["runtime"] = str(runtime or "runtime")
+        if model:
+            call["model"] = model
+    return calls
+
+
+__all__ = ["project_transcript_tool_calls"]