@oneciel-ai/ciel-runtime 0.2.22 → 0.2.23

package/ciel_runtime.py

@@ -45,7 +45,7 @@ from ciel_runtime_support.agy_installer import AgyInstaller
 from ciel_runtime_support.anthropic_response_writer import AnthropicResponseWriter
 from ciel_runtime_support.anthropic_response_writer import anthropic_text_response as project_anthropic_text_response
 from ciel_runtime_support.anthropic_response_writer import prepend_anthropic_text as project_prepend_anthropic_text
-from ciel_runtime_support.anthropic_tool_turns import AnthropicToolTurnServices, normalize_historical_anthropic_tool_turns
+from ciel_runtime_support.anthropic_tool_turns import AnthropicToolTurnServices, normalize_historical_anthropic_tool_turns, sanitize_invalid_anthropic_tool_history
 from ciel_runtime_support.api_key_cooldown import API_KEY_COOLDOWN_DEFAULT_SECONDS  # noqa: F401 - compatibility export
 from ciel_runtime_support.api_key_cooldown import API_KEY_COOLDOWN_MAX_SECONDS  # noqa: F401 - compatibility export
 from ciel_runtime_support.api_key_cooldown import RATE_LIMIT_RESET_HEADER_NAMES as _RATE_LIMIT_RESET_HEADER_NAMES  # noqa: F401 - compatibility export
@@ -73,8 +73,7 @@ from ciel_runtime_support.channel_message_policy import message_has_external_pro
 from ciel_runtime_support.channel_message_policy import message_is_web_chat_request as _channel_message_is_web_chat_request
 from ciel_runtime_support.channel_message_policy import string_list as _as_string_list
 from ciel_runtime_support.channel_message_policy import superseded_message_ids as _channel_superseded_message_ids
-from ciel_runtime_support.channel_message_prompt import format_llm_batch_prompt as format_channel_llm_batch_prompt
-from ciel_runtime_support.channel_message_prompt import format_llm_delivery_wake_prompt as format_channel_llm_delivery_wake_prompt
+from ciel_runtime_support.channel_message_prompt import format_llm_batch_prompt as format_channel_llm_batch_prompt, format_llm_delivery_wake_prompt as format_channel_llm_delivery_wake_prompt, format_visible_llm_delivery_wake_prompt as format_channel_visible_llm_delivery_wake_prompt
 from ciel_runtime_support.channel_message_prompt import format_wake_batch_prompt as format_channel_wake_batch_prompt
 from ciel_runtime_support.channel_message_prompt import format_wake_prompt as format_channel_wake_prompt  # noqa: F401 - compatibility export
 from ciel_runtime_support.channel_message_prompt import format_web_chat_wake_batch_prompt as format_channel_web_chat_wake_batch_prompt
@@ -103,6 +102,7 @@ from ciel_runtime_support.channel_transcript import queued_age_seconds_from_text
 from ciel_runtime_support.channel_transcript import queued_command_ids_from_text as analyze_channel_queued_ids
 from ciel_runtime_support.channel_transcript import wake_state_evidence_from_text as analyze_channel_wake_evidence
 from ciel_runtime_support.channel_transcript_repository import ChannelTranscriptRepository
+from ciel_runtime_support.transcript_delta_delivery import TranscriptDeliveryPorts, TranscriptDeltaDeliveryService
 from ciel_runtime_support.channel_wake_claim_repository import ChannelWakeClaimRepository
 from ciel_runtime_support.channel_wake_claim_repository import prompt_message_ids as _channel_prompt_message_ids
 from ciel_runtime_support.channel_wake_claim_repository import prompt_references_message_id as analyze_prompt_message_reference
@@ -244,7 +244,7 @@ from ciel_runtime_support.prompt_injection import normalize_anthropic_system_rol
 from ciel_runtime_support.prompt_injection import normalize_anthropic_system_role_messages_by_strategy as project_normalize_anthropic_system_role_messages_by_strategy
 from ciel_runtime_support.remote_instructions import RemoteInstructionResult, RemoteInstructionSynchronizer, SynchronizedLaunch
 from ciel_runtime_support.remote_instructions import panel_rows as project_remote_instruction_panel_rows
-from ciel_runtime_support.remote_memory import RemoteMemoryResult, RemoteMemorySynchronizer, sync_all_memory_pointers as project_sync_all_memory_pointers, sync_instruction_with_memory_pointer as project_sync_instruction_with_memory_pointer, sync_launch_assets as project_sync_launch_assets
+from ciel_runtime_support.remote_memory import RemoteMemoryResult, RemoteMemorySynchronizer, current_memory_prompt as project_current_memory_prompt, inject_current_memory_prompt as project_inject_current_memory_prompt, move_memory_pointer_to_system_end as project_move_memory_pointer_to_system_end, sync_all_memory_pointers as project_sync_all_memory_pointers, sync_instruction_with_memory_pointer as project_sync_instruction_with_memory_pointer, sync_launch_assets as project_sync_launch_assets, without_memory_pointer as project_without_memory_pointer
 from ciel_runtime_support.protocols import PROTOCOL_ADAPTERS
 from ciel_runtime_support.protocols.anthropic_content import content_to_text as anthropic_content_to_text
 from ciel_runtime_support.protocols.anthropic_thinking_policy import AnthropicThinkingPolicy, SuppressedThinkingRepository, ThinkingPolicyPorts
@@ -509,7 +509,8 @@ from ciel_runtime_support.upstream_stream_io import iter_lines_until_disconnect
 from ciel_runtime_support.upstream_stream_io import set_stream_read_timeout as project_set_stream_read_timeout
 from ciel_runtime_support.upstream_stream_io import sleep_until_disconnect as project_sleep_until_disconnect
 from ciel_runtime_support.upstream_stream_io import stream_idle_timeout as project_stream_idle_timeout
-from ciel_runtime_support.usage_events import JsonlUsageEventSink
+from ciel_runtime_support.usage_events import CompositeUsageEventSink, JsonlUsageEventSink
+from ciel_runtime_support.usage_service import SqliteUsageLedger, UsageApiKeyRepository, UsageHttpAdapter, UsagePushDeliveryService, UsageRuntimeServices, usage_jsonl_enabled
 from ciel_runtime_support.visible_stream_filters import VISIBLE_THINKING_MARKUP_PREFIXES  # noqa: F401 - compatibility export
 from ciel_runtime_support.visible_stream_filters import VISIBLE_THINKING_MARKUP_TAG_RE  # noqa: F401 - compatibility export
 from ciel_runtime_support.visible_stream_filters import VISIBLE_TOOL_CALL_ARTIFACT_HOLD_CHARS  # noqa: F401 - compatibility export
@@ -586,17 +587,12 @@ _CHANNEL_COMPACT_REQUEST_LOCK = threading.Lock()
 _TOOL_SIDE_EFFECT_DEDUP_TTL_SECONDS = 10 * 60.0
 _TOOL_SIDE_EFFECT_DEDUP_LOCK = threading.Lock()
 _TOOL_SIDE_EFFECT_DEDUP_RECENT: dict[str, float] = {}
-EVENT_BUS = EventBus()
-TUI_OBSERVATION_BUS = TuiObservationBus()
-USAGE_EVENT_SINK = JsonlUsageEventSink(
-    USAGE_EVENTS_PATH,
-    enabled=lambda: str(os.environ.get("CIEL_RUNTIME_USAGE_LOG", "1")).strip().lower()
-    not in {"0", "false", "off", "no", ""},
-)
+EVENT_BUS, TUI_OBSERVATION_BUS = EventBus(), TuiObservationBus()
+USAGE_API_KEYS = UsageApiKeyRepository(USAGE_LEDGER := SqliteUsageLedger(WORKSPACE_STATE_DIR / "usage" / "usage.sqlite3", ROUTER_WORKSPACE_ID), WORKSPACE_STATE_DIR / "usage" / "api-key.pepper", os.environ)
+USAGE_EVENT_SINK = CompositeUsageEventSink(JsonlUsageEventSink(USAGE_EVENTS_PATH, enabled=lambda: usage_jsonl_enabled(load_config(), os.environ)), USAGE_LEDGER)
 # Tools Claude Code injects into every model's tool list that misfire when called
 # by non-Anthropic models. See docs/notes from anthropics/claude-code issues
 # #25720, #29950 and Piebald-AI/claude-code-system-prompts for tool semantics.
-
 def positive_env_int(name: str, default: int) -> int: return runtime_primitives.positive_environment_int(os.environ, name, default)
 SUPPRESSED_THINKING_PASSBACK_MAX = positive_env_int("CIEL_RUNTIME_THINKING_PASSBACK_MAX", 4096)
 SUPPRESSED_THINKING_PASSBACK_CACHE: list[dict[str, Any]] = []
@@ -934,9 +930,9 @@ def select_provider_protocol(provider: str, pcfg: dict[str, Any], operation: Mes
     adapter = configured_provider_adapter(provider, pcfg)
     return adapter.select_protocol(operation, provider_contract_config(provider, pcfg), model)
 
-def apply_provider_adapter_request_policy(provider: str, pcfg: dict[str, Any], body: dict[str, Any]) -> dict[str, Any]:
+def apply_provider_adapter_request_policy(provider: str, pcfg: dict[str, Any], body: dict[str, Any], protocol: MessageProtocol | None = None) -> dict[str, Any]:
     adapter = configured_provider_adapter(provider, pcfg)
-    normalized = adapter.normalize_request_options(provider_contract_config(provider, pcfg), body)
+    normalized = adapter.normalize_request_options_for_protocol(provider_contract_config(provider, pcfg), body, protocol)
     return dict(normalized)
 
 def provider_has_api_key(provider: str, pcfg: dict[str, Any]) -> bool: return bool(provider_config_api_keys(provider, pcfg))
@@ -1727,10 +1723,12 @@ def parse_json_body(raw: bytes) -> dict[str, Any]:
     except Exception:
         return {}
     return value if isinstance(value, dict) else {}
-
 query_int = EventHttpAdapter.query_int
 def event_http_adapter() -> EventHttpAdapter: return EventHttpAdapter(EventHttpPorts(EVENT_BUS.recent, EVENT_BUS.wait_after, render_events_html, write_text_response, write_json, router_log))
 def handle_events_get(handler: BaseHTTPRequestHandler, path: str, query: dict[str, list[str]]) -> bool: return event_http_adapter().handle_get(handler, path, query)
+_USAGE_HTTP_ADAPTER = UsageHttpAdapter(USAGE_LEDGER, USAGE_API_KEYS, write_json, reject_external_router_request, load_config, router_log)
+def handle_usage_post(handler: BaseHTTPRequestHandler, path: str, body: dict[str, Any]) -> bool: return _USAGE_HTTP_ADAPTER.handle_post(handler, path, body)
+def handle_observability_get(handler: BaseHTTPRequestHandler, path: str, query: dict[str, list[str]]) -> bool: return _USAGE_HTTP_ADAPTER.handle_get(handler, path, query) or handle_events_get(handler, path, query)
 def tui_observation_http_adapter() -> TuiObservationHttpAdapter: return TuiObservationHttpAdapter(TuiObservationHttpPorts(TUI_OBSERVATION_BUS, write_json, write_text_response, router_log))
 def handle_tui_observation_get(handler: BaseHTTPRequestHandler, path: str, query: dict[str, list[str]]) -> bool: return tui_observation_http_adapter().handle_get(handler, path, query)
 def observe_tui_runtime_response(handler: BaseHTTPRequestHandler, path: str, provider: str, model: str, body: dict[str, Any]) -> Any: return observe_runtime_response(handler, path, provider, model, body, TUI_OBSERVATION_BUS)
@@ -1946,14 +1944,14 @@ def set_external_event_config(key: str, value: Any) -> list[str]:
         "External events use the private Runtime Input Gateway and are never published to Web Chat.",
     ]
 
-def remote_instruction_synchronizer() -> RemoteInstructionSynchronizer: return RemoteInstructionSynchronizer(load_config=load_config, workspace=Path.cwd, state_dir=WORKSPACE_STATE_DIR, log=router_log)
-
-def remote_memory_synchronizer() -> RemoteMemorySynchronizer: return RemoteMemorySynchronizer(load_config=load_config, workspace=Path.cwd, state_dir=WORKSPACE_STATE_DIR, log=router_log)
+def remote_instruction_synchronizer() -> RemoteInstructionSynchronizer: return RemoteInstructionSynchronizer(load_config=load_config, workspace=lambda: Path(ROUTER_WORKSPACE), state_dir=WORKSPACE_STATE_DIR, log=router_log)
+def remote_memory_synchronizer() -> RemoteMemorySynchronizer: return RemoteMemorySynchronizer(load_config=load_config, workspace=lambda: Path(ROUTER_WORKSPACE), state_dir=WORKSPACE_STATE_DIR, log=router_log)
+def body_with_remote_memory_prompt(body: dict[str, Any], protocol: MessageProtocol) -> dict[str, Any]: return project_inject_current_memory_prompt(body, protocol, WORKSPACE_STATE_DIR, load_config(), Path(ROUTER_WORKSPACE))
+def finalized_anthropic_upstream_body(body: dict[str, Any]) -> dict[str, Any]: return body_without_ciel_runtime_internal_metadata(body_with_remote_memory_prompt(body, "anthropic_messages"))
 def sync_remote_instruction(runtime: str, *, reason: str) -> RemoteInstructionResult: return project_sync_instruction_with_memory_pointer(runtime, reason=reason, instruction_synchronizer=remote_instruction_synchronizer, memory_synchronizer=remote_memory_synchronizer, log=router_log)
 def sync_remote_memory(runtime: str, *, reason: str) -> RemoteMemoryResult: return remote_memory_synchronizer().sync(runtime, reason=reason)
 def sync_remote_launch_assets(runtime: str, *, reason: str) -> RemoteMemoryResult: return project_sync_launch_assets(runtime, reason=reason, instruction_sync=sync_remote_instruction, memory_sync=sync_remote_memory)
 def sync_all_remote_memories() -> list[str]: return project_sync_all_memory_pointers(remote_memory_synchronizer())
-
 def remote_instruction_panel_rows(cfg: dict[str, Any]) -> tuple[list[str], list[str]]:
     return project_remote_instruction_panel_rows(cfg)
 
@@ -2006,7 +2004,7 @@ def _latest_remote_instruction(runtime: str, *, reason: str) -> str:
     if path is None or not path.is_file():
         return ""
     try:
-        return path.read_text(encoding="utf-8").strip()
+        return project_without_memory_pointer(path.read_text(encoding="utf-8"))
     except OSError as exc:
         router_log("WARN", f"remote_instructions_read_failed runtime={runtime} error={type(exc).__name__}: {exc}")
         return ""
@@ -2047,7 +2045,7 @@ def _refresh_anthropic_compact_body(body: dict[str, Any], runtime: str = "claude
         _without_remote_instruction_blocks(body.get("system")),
         [_with_latest_instruction_text("", instruction)],
     )
-    return updated
+    return body_with_remote_memory_prompt(updated, "anthropic_messages")
 
 def _refresh_chat_compact_messages(messages: list[dict[str, Any]], runtime: str = "claude") -> list[dict[str, Any]]:
     instruction = _latest_remote_instruction(runtime, reason="pre-compact")
@@ -2057,15 +2055,17 @@ def _refresh_chat_compact_messages(messages: list[dict[str, Any]], runtime: str
     for message in updated:
         if str(message.get("role") or "") == "system" and isinstance(message.get("content"), str):
             message["content"] = _with_latest_instruction_text(message.get("content"), instruction)
-            return updated
-    return [{"role": "system", "content": _with_latest_instruction_text("", instruction)}, *updated]
+            break
+    else:
+        updated = [{"role": "system", "content": _with_latest_instruction_text("", instruction)}, *updated]
+    return project_move_memory_pointer_to_system_end(updated, project_current_memory_prompt(WORKSPACE_STATE_DIR, load_config(), Path(ROUTER_WORKSPACE)))
 
 def compact_responses_with_remote_instruction(body: dict[str, Any], budget: int, **kwargs: Any) -> dict[str, Any]:
     instruction = _latest_remote_instruction("codex", reason="pre-compact")
     updated = dict(body)
     if instruction:
         updated["instructions"] = _with_latest_instruction_text(body.get("instructions"), instruction)
-    return run_responses_prompt_compaction(updated, budget, services=prompt_compaction_services(), **kwargs)
+    return body_with_remote_memory_prompt(run_responses_prompt_compaction(updated, budget, services=prompt_compaction_services(), **kwargs), "openai_responses")
 
 def _channel_compact_request_ttl_seconds() -> float: return compact_request_ttl(os.environ.get('CIEL_RUNTIME_CHANNEL_COMPACT_REQUEST_TTL_SECONDS'))
 
@@ -2304,7 +2304,7 @@ def normalize_request_for_provider_wire(provider: str, pcfg: dict[str, Any], bod
             normalize_thinking_for_non_anthropic_provider=normalize_thinking_for_non_anthropic_provider,
             normalize_tool_choice_for_provider=normalize_tool_choice_for_provider,
             provider_wire_profile=provider_wire_profile,
-            sanitize_assistant_pseudo_tool_text_history=sanitize_assistant_pseudo_tool_text_history
+            sanitize_assistant_pseudo_tool_text_history=sanitize_assistant_pseudo_tool_text_history, sanitize_invalid_anthropic_tool_history=lambda body: sanitize_invalid_anthropic_tool_history(body, AnthropicToolTurnServices(log=router_log))
         ),
     )
 
@@ -2409,8 +2409,8 @@ def chat_projection_services() -> ChatProjectionServices:
         ),
     )
 
-def anthropic_messages_to_ollama(body: dict[str, Any]) -> list[dict[str, Any]]: return project_anthropic_messages_to_ollama(body, services=chat_projection_services())
-def anthropic_messages_to_openai(body: dict[str, Any], reasoning_passback: bool = False) -> list[dict[str, Any]]: return project_anthropic_messages_to_openai(body, reasoning_passback, services=chat_projection_services())
+def anthropic_messages_to_ollama(body: dict[str, Any]) -> list[dict[str, Any]]: return project_move_memory_pointer_to_system_end(project_anthropic_messages_to_ollama(body, services=chat_projection_services()), project_current_memory_prompt(WORKSPACE_STATE_DIR, load_config(), Path(ROUTER_WORKSPACE)))
+def anthropic_messages_to_openai(body: dict[str, Any], reasoning_passback: bool = False) -> list[dict[str, Any]]: return project_move_memory_pointer_to_system_end(project_anthropic_messages_to_openai(body, reasoning_passback, services=chat_projection_services()), project_current_memory_prompt(WORKSPACE_STATE_DIR, load_config(), Path(ROUTER_WORKSPACE)))
 missing_openai_tool_result_message = project_missing_openai_tool_result_message
 orphan_openai_tool_message_to_user = project_orphan_openai_tool_message_to_user
 def repair_openai_tool_call_adjacency(messages: list[dict[str, Any]]) -> list[dict[str, Any]]: return project_repair_openai_tool_call_adjacency(messages, OpenAiHistoryServices(log=router_log))
@@ -2534,7 +2534,7 @@ def provider_request_builder() -> ProviderRequestBuilder:
             sampling_allowed=lambda provider, config: configured_provider_adapter(provider, config).allows_sampling_overrides(provider_contract_config(provider, config)),
             omit_tool_choice=should_omit_openai_chat_tool_choice, tool_choice=anthropic_tool_choice_to_openai, normalize_request=apply_provider_adapter_request_policy,
         ),
-        ProviderOptionPorts(frozenset(PROVIDER_SAMPLING_OPTION_PROVIDERS), tuple(PROVIDER_SAMPLING_OPTIONS), anthropic_model_runtime_hints, router_log),
+        ProviderOptionPorts(frozenset(PROVIDER_SAMPLING_OPTION_PROVIDERS), tuple(PROVIDER_SAMPLING_OPTIONS), anthropic_model_runtime_hints, router_log, lambda messages: project_move_memory_pointer_to_system_end(messages, project_current_memory_prompt(WORKSPACE_STATE_DIR, load_config(), Path(ROUTER_WORKSPACE)))),
     )
 
 _PROVIDER_REQUEST_API = ProviderRequestCompatibilityApi(provider_request_builder)
@@ -2843,7 +2843,7 @@ def response_collection_context() -> ResponseCollectionContext:
         anthropic=AnthropicCollectionServices(
             request=AnthropicCollectionRequest(normalize_thinking_for_non_anthropic_provider, normalize_anthropic_system_role_messages_for_provider, cap_anthropic_body_for_provider,
                                                apply_provider_request_options, rehydrate_suppressed_thinking_passback, resolve_requested_model, provider_upstream_model,
-                                               resolve_tool_model_references, normalize_anthropic_model_request_options, body_without_ciel_runtime_internal_metadata),
+                                               resolve_tool_model_references, normalize_anthropic_model_request_options, finalized_anthropic_upstream_body),
             transport=AnthropicCollectionTransport(provider_native_compat_enabled, native_anthropic_base_url, provider_upstream_request_base, join_url, upstream_messages_query,
                                                    provider_headers, apply_router_rate_limit, open_provider_request_with_key_retry, provider_request_timeout_seconds),
             projection=AnthropicCollectionProjection(normalize_response_thinking_for_non_anthropic_provider, append_synthetic_tasklist_to_message,
@@ -2881,7 +2881,8 @@ def codex_backend_context() -> CodexBackendContext:
         provider_projection=ProviderPassthroughProjectionPorts(provider_headers, lambda *args, **kwargs: provider_chat_headers(*args, **kwargs),
                                                                 lambda *args, **kwargs: provider_responses_headers(*args, **kwargs),
                                                                 provider_upstream_model, resolve_requested_model, apply_provider_adapter_request_policy,
-                                                                lambda provider, pcfg: configured_provider_adapter(provider, pcfg).responses_request_max_bytes(provider_contract_config(provider, pcfg))),
+                                                                lambda provider, pcfg: configured_provider_adapter(provider, pcfg).responses_request_max_bytes(provider_contract_config(provider, pcfg)),
+                                                                lambda body: body_with_remote_memory_prompt(body, "openai_chat"), lambda body: body_with_remote_memory_prompt(body, "openai_responses")),
         provider_transport=ProviderPassthroughTransportPorts(provider_upstream_request_base, join_url, provider_urlopen,
                                                              provider_request_timeout_seconds,
                                                              lambda *args, **kwargs: _copy_upstream_response_headers(*args, **kwargs), write_router_activity),
@@ -2907,7 +2908,8 @@ forward_codex_backend_get = _CODEX_BACKEND_API.forward_get
 forward_codex_responses = _CODEX_BACKEND_API.forward_responses
 
 def body_with_codex_compat_instructions(cfg: dict[str, Any], provider: str, pcfg: dict[str, Any], body: dict[str, Any]) -> dict[str, Any]:
-    return codex_turn_recovery.body_with_codex_compat_instructions(body, ROUTED_CODEX_COMPAT_PROMPT, is_native_codex=codex_routed_enabled(provider, pcfg), compat_enabled=should_append_compat_prompt(provider, pcfg, cfg))
+    body = codex_turn_recovery.body_with_codex_compat_instructions(body, ROUTED_CODEX_COMPAT_PROMPT, is_native_codex=codex_routed_enabled(provider, pcfg), compat_enabled=should_append_compat_prompt(provider, pcfg, cfg))
+    return body_with_remote_memory_prompt(body, "openai_responses")
 
 def _codex_turn_recovery_services() -> codex_turn_recovery.CodexTurnRecoveryServices:
     return codex_turn_recovery.CodexTurnRecoveryServices(should_retry=should_retry_preamble_only_turn, collect_message=collect_provider_message_for_responses, log=router_log)
@@ -2939,7 +2941,7 @@ def _router_request_context() -> RouterRequestContext:
         assembly.ClaudeRouterRoutingPorts(forward_ollama_api_chat, forward_openai_compatible_chat, select_provider_protocol, provider_request_policy, resolve_requested_model, PROVIDER_LABELS, write_json),
         assembly.ClaudeRouterNormalizationPorts(normalize_request_for_provider_wire, normalize_thinking_for_non_anthropic_provider, normalize_anthropic_system_role_messages_for_provider,
                                                 cap_anthropic_body_for_provider, apply_provider_request_options, rehydrate_suppressed_thinking_passback, ncp_model_id_for_nvidia_hosted,
-                                                resolve_tool_model_references, normalize_anthropic_model_request_options, body_without_ciel_runtime_internal_metadata),
+                                                resolve_tool_model_references, normalize_anthropic_model_request_options, finalized_anthropic_upstream_body),
         assembly.ClaudeRouterTransportPorts(native_anthropic_base_url, provider_native_compat_enabled, provider_upstream_request_base, join_url, upstream_messages_query,
                                             provider_headers, apply_router_rate_limit, open_provider_request_with_key_retry, provider_request_timeout_seconds, provider_stream_idle_timeout_seconds),
         assembly.ClaudeRouterResponsePorts(_rebatch_anthropic_sse_text, preserves_anthropic_thinking_contract, should_normalize_anthropic_stream_tool_use,
@@ -2962,9 +2964,7 @@ runtime_router_capability_matrix = _ROUTER_REQUEST_API.capability_matrix
 runtime_router_capability_gaps = _ROUTER_REQUEST_API.capability_gaps
 route_runtime_get = _ROUTER_REQUEST_API.route_get
 route_runtime_post = _ROUTER_REQUEST_API.route_post
-
 _ROUTER_REQUEST_BODY_POLICY: RouterRequestBodyPolicy | None = None
-
 def router_request_body_policy() -> RouterRequestBodyPolicy:
     global _ROUTER_REQUEST_BODY_POLICY
     if _ROUTER_REQUEST_BODY_POLICY is None:
@@ -2975,17 +2975,21 @@ def router_request_body_policy() -> RouterRequestBodyPolicy:
         for warning in _ROUTER_REQUEST_BODY_POLICY.configuration_warnings:
             router_log("WARN", f"router_request_limit_configuration {warning}")
     return _ROUTER_REQUEST_BODY_POLICY
-
 def _router_server_context() -> RouterServerContext:
+    usage_services = UsageRuntimeServices(USAGE_LEDGER, USAGE_API_KEYS, UsagePushDeliveryService(USAGE_LEDGER, load_config, os.environ, router_log), CONFIG_DIR, WORKSPACE_STATE_DIR, ROUTER_WORKSPACE_ID, USAGE_EVENTS_PATH, router_log)
+    def start_router_services() -> None:
+        external_event_receiver_service().start()
+        usage_services.start()
+    def stop_router_services() -> None:
+        usage_services.stop()
+        external_event_receiver_service().stop()
     http_services = RouterHttpServices(
         core=RouterHttpCore(load_config, reject_external_router_request, get_current_provider, parse_json_body, is_client_disconnect_error, router_log, observe_tui_runtime_response, router_request_body_policy()),
-        # Channel MCP delivery was retired in favor of the TTY/PTY bridge.  Do
-        # not expose the legacy endpoint or register it with Claude.
-        get=RouterHttpGetEndpoints(handle_tui_observation_get, handle_events_get, handle_llm_config_get, lambda _handler, _path: False, handle_web_get,
+        get=RouterHttpGetEndpoints(handle_tui_observation_get, handle_observability_get, handle_llm_config_get, lambda _handler, _path: False, handle_web_get,
                                    lambda handler, path: speech_http_controller().get(handler, path), handle_chat_get, handle_plan_get, route_runtime_get,
                                    handle_external_event_get),
-        post=RouterHttpPostEndpoints(lambda handler, path, raw, content_type: speech_http_controller().post(handler, path, raw, content_type), handle_llm_config_post, lambda _handler, _path, _body: False, handle_chat_post,
-                                     handle_plan_post, route_runtime_post, handle_external_event_raw_post, handle_external_event_config_post),
+        post=RouterHttpPostEndpoints(lambda handler, path, raw, content_type: speech_http_controller().post(handler, path, raw, content_type), handle_llm_config_post, handle_channel_mcp_post, handle_chat_post,
+                                     handle_plan_post, route_runtime_post, handle_external_event_raw_post, handle_external_event_config_post, handle_usage_post),
         presentation=RouterHttpPresentation(render_router_home_html, router_health_payload, write_text_response, write_json, list_model_objects_for_request,
                                             resolve_requested_model, model_object),
         errors=RouterHttpErrors(write_openai_responses_error, try_write_json),
@@ -2997,8 +3001,8 @@ def _router_server_context() -> RouterServerContext:
         router_server_runtime.RouterServerEffects(os.chmod, sys.stderr, ThreadingHTTPServer, start_managed_router_lifetime_watchdog,
                                                   lambda bind_host: configure_requested_web_endpoints(ROUTER_PORT, ROUTER_HOST, bind_host,
                                                                                                        config=load_config()),
-                                                  external_event_receiver_service().start,
-                                                  external_event_receiver_service().stop),
+                                                   start_router_services,
+                                                   stop_router_services),
     )
     return RouterServerContext(
         health=RouterHealthPresentationPorts(VERSION, SOURCE_FINGERPRINT, RouterHealthRuntimePorts(os.getpid, active_router_client_pids), getpass.getuser, HOME, ROUTER_INSTANCE_DIR, ROUTER_WORKSPACE, ROUTER_PORT, ROUTER_INSTANCE_ID, current_alias),
@@ -4412,7 +4416,7 @@ def channel_wake_context() -> ChannelWakeContext:
         pending_state=ChannelPendingStatePorts(_channel_stdin_active_tool_call, _channel_stdin_active_turn, _channel_stdin_recover_cursor_from_queued_only, _channel_pending_scan_limit,
                                                _channel_superseded_message_ids, _channel_message_is_web_chat_request, _channel_llm_message_skip_reason, _channel_message_event_identity_key,
                                                _channel_stdin_wake_state_for_message, _channel_stdin_wake_queued_is_stale_for_message),
-        pending_delivery=ChannelPendingDeliveryPorts(format_channel_llm_delivery_wake_prompt, format_channel_web_chat_wake_batch_prompt, format_channel_wake_batch_prompt, _channel_enter_label,
+        pending_delivery=ChannelPendingDeliveryPorts(format_channel_llm_delivery_wake_prompt, format_channel_visible_llm_delivery_wake_prompt, format_channel_web_chat_wake_batch_prompt, format_channel_wake_batch_prompt, _channel_enter_label,
                                                      _channel_wake_store_release_stale, _CHANNEL_WAKE_DELIVERY_REPOSITORY.mark_delivered, _channel_wake_store_record_prompts,
                                                      _channel_wake_store_rollback, _commit_channel_llm_cursor_if_newer),
         pending_io=ChannelPendingIoPorts(_CHANNEL_STDIN_INJECT_LOCK, read_runtime_inputs, _write_channel_wake_prompt, _read_channel_compact_request, _clear_channel_compact_request, _runtime_input_storage_path(), router_log),
@@ -4429,7 +4433,7 @@ def _channel_prompt_references_message_id(text: str, message_id: int, prompt_tex
 def _channel_message_ids_already_in_request(body: dict[str, Any]) -> set[int]: return channel_wake_context().message_ids_already_in_request(body)
 def _channel_llm_commit_cursor_locked(last_id: int) -> None: channel_wake_context().commit_cursor(last_id)
 def _channel_llm_stdin_skip_reason(message_id: int) -> str: return channel_wake_context().stdin_skip_reason(message_id)
-def body_with_pending_channel_messages(body: dict[str, Any]) -> dict[str, Any]: return channel_wake_context().body_with_pending_messages(body)
+def body_with_pending_channel_messages(body: dict[str, Any]) -> dict[str, Any]: return channel_wake_context().body_with_pending_messages(body_with_remote_memory_prompt(body, "anthropic_messages"))
 def _write_fd_all(fd: int, data: bytes) -> None: ChannelWakeContext.write_all(fd, data)
 def _channel_wake_enter_bytes(value: str | bytes | None = None) -> bytes: return channel_wake_context().enter_bytes(value)
 def _channel_wake_input_bytes(prompt: str, enter_bytes: bytes | None = None) -> bytes: return channel_wake_context().input_bytes(prompt, enter_bytes)
@@ -4444,8 +4448,8 @@ def _windows_channel_startup_grace_seconds() -> float:
 def _windows_channel_wake_max_attempts() -> int:
     return channel_runtime_environment_policy().windows_wake_max_attempts()
 
-def _write_channel_wake_prompt( master_fd: int, prompt: str, enter_bytes: bytes | None = None, *, submit_retry_count: int = 1, confirm_submit: bool = False, bracketed_paste: bool = False, submit_delay_seconds: float | None = None, ) -> None:
-    channel_wake_context().write_prompt(
+def _write_channel_wake_prompt( master_fd: int, prompt: str, enter_bytes: bytes | None = None, *, submit_retry_count: int = 1, confirm_submit: bool = False, bracketed_paste: bool = False, submit_delay_seconds: float | None = None, ) -> bool:
+    return channel_wake_context().write_prompt(
         master_fd, prompt, enter_bytes, submit_retry_count=submit_retry_count,
         confirm_submit=confirm_submit, bracketed_paste=bracketed_paste,
         submit_delay_seconds=submit_delay_seconds, write_all=_write_fd_all,
@@ -4458,11 +4462,9 @@ _CHANNEL_TRANSCRIPT_SCOPE: dict[str, Any] = {
     'session_id': '', 'bound_path': None,
 }
 _CHANNEL_STDIN_RECOVERY_CACHE: dict[str, Any] = {'checked_at': 0.0, 'last_id': None, 'marker': None, 'recovered_last_id': None}
+_TRANSCRIPT_DELIVERY_SERVICE = TranscriptDeltaDeliveryService(WORKSPACE_STATE_DIR / "transcript-event-cursors.json", ROUTER_WORKSPACE_ID, TranscriptDeliveryPorts(load_config, lambda: _latest_claude_transcript_path(ttl_seconds=0.5), lambda: dict(_CHANNEL_TRANSCRIPT_SCOPE), router_log))
 def channel_transcript_repository() -> ChannelTranscriptRepository: return channel_wake_context().transcript_repository()
-
-def _set_channel_transcript_scope(runtime: str, *, started_at: float | None = None, codex_home: Path | None = None, cwd: Path | None = None, session_id: str | None = None) -> None:
-    channel_wake_context().set_transcript_scope(runtime, started_at=started_at, codex_home=codex_home, cwd=cwd, session_id=session_id)
-
+def _set_channel_transcript_scope(runtime: str, *, started_at: float | None = None, codex_home: Path | None = None, cwd: Path | None = None, session_id: str | None = None) -> None: return (channel_wake_context().set_transcript_scope(runtime, started_at=started_at, codex_home=codex_home, cwd=cwd, session_id=session_id), _TRANSCRIPT_DELIVERY_SERVICE.start())[1]
 def _channel_transcript_roots() -> tuple[tuple[Path, str], ...]: return channel_wake_context().transcript_roots()
 def _latest_claude_transcript_path(ttl_seconds: float = 2.0) -> Path | None: return channel_wake_context().latest_transcript_path(ttl_seconds)
 _read_file_tail_text = ChannelTranscriptRepository.read_tail_text
@@ -4507,7 +4509,7 @@ def _inject_pending_channel_messages(
     enter_bytes: bytes | None = None,
     *,
     web_chat_only: bool = False,
-    wake_for_llm_delivery: bool = False,
+    wake_for_llm_delivery: bool = False, display_llm_delivery_body: bool = False,
     commit_cursor: bool = True,
     injected_message_ids: list[int] | None = None,
     submit_retry_count: int = 1,
@@ -4522,6 +4524,7 @@ def _inject_pending_channel_messages(
         enter_bytes,
         web_chat_only=web_chat_only,
         wake_for_llm_delivery=wake_for_llm_delivery,
+        display_llm_delivery_body=display_llm_delivery_body,
         commit_cursor=commit_cursor,
         injected_message_ids=injected_message_ids,
         submit_retry_count=submit_retry_count,
@@ -4948,7 +4951,7 @@ def cli_parser_services() -> cli_parser.CliParserServices:
     return cli_assembly.CliParserAssembly(
             launch=cli_parser.CliParserLaunch(cmd_cli, cmd_launch, cmd_launch_codex, cmd_launch_codex_app_server, cmd_launch_agy, serve, cmd_launch_grok),
             runtime=cli_parser.CliParserRuntime(cmd_version, cmd_status, cmd_env, cmd_stop, cmd_test),
-            settings=cli_parser.CliParserSettings(cmd_language, cmd_web_search, cmd_web_fetch, cmd_log_level, *event_settings_cli.handlers(event_settings_cli.EventSettingsCliPorts(load_config, save_config, external_event_receiver_service, lambda: set_remote_instruction_config('sync', ''), sync_all_remote_memories, print))),
+            settings=cli_parser.CliParserSettings(cmd_language, cmd_web_search, cmd_web_fetch, cmd_log_level, *event_settings_cli.handlers(event_settings_cli.EventSettingsCliPorts(load_config, save_config, external_event_receiver_service, lambda: set_remote_instruction_config('sync', ''), sync_all_remote_memories, print, lambda: USAGE_API_KEYS))),
             provider=cli_parser.CliParserProvider(cmd_ollama_native, cmd_ollama_options, cmd_provider_options, cmd_ollama_catalog, cmd_provider,
                                                   cmd_api_key, cmd_set_api_key, cmd_set_api_keys, cmd_base_url, cmd_copilot_oauth),
             models=cli_parser.CliParserModels(cmd_model, cmd_advisor_model, cmd_models),

package/ciel_runtime_support/anthropic_tool_turns.py

@@ -12,6 +12,80 @@ class AnthropicToolTurnServices:
     log: Callable[[str, str], Any]
 
 
+def sanitize_invalid_anthropic_tool_history(
+    body: dict[str, Any],
+    services: AnthropicToolTurnServices,
+) -> dict[str, Any]:
+    """Remove schema-invalid tool uses and only their paired results.
+
+    Provider-native compaction validates retained messages again.  A historical
+    assistant tool block with an empty name therefore makes every later
+    compaction fail, even when the current runtime no longer emits that block.
+    Preserve valid and unmatched history; remove only invalid tool blocks and
+    results that explicitly reference their IDs.
+    """
+    messages = body.get("messages")
+    if not isinstance(messages, list):
+        return body
+
+    invalid_ids = {
+        str(block.get("id") or "")
+        for message in messages
+        if isinstance(message, dict)
+        and str(message.get("role") or "") == "assistant"
+        for block in _content_blocks(message)
+        if isinstance(block, dict)
+        and block.get("type") == "tool_use"
+        and not str(block.get("name") or "").strip()
+        and str(block.get("id") or "")
+    }
+    invalid_uses = 0
+    invalid_results = 0
+    normalized_messages: list[Any] = []
+    for message in messages:
+        if not isinstance(message, dict) or not isinstance(message.get("content"), list):
+            normalized_messages.append(message)
+            continue
+        role = str(message.get("role") or "")
+        next_content: list[Any] = []
+        content_changed = False
+        for block in message["content"]:
+            if (
+                role == "assistant"
+                and isinstance(block, dict)
+                and block.get("type") == "tool_use"
+                and not str(block.get("name") or "").strip()
+            ):
+                invalid_uses += 1
+                content_changed = True
+                continue
+            if (
+                role == "user"
+                and isinstance(block, dict)
+                and block.get("type") == "tool_result"
+                and str(block.get("tool_use_id") or "") in invalid_ids
+            ):
+                invalid_results += 1
+                content_changed = True
+                continue
+            next_content.append(block)
+        if not content_changed:
+            normalized_messages.append(message)
+        elif next_content:
+            normalized_messages.append(_with_content(message, next_content))
+
+    if not invalid_uses and not invalid_results:
+        return body
+    out = dict(body)
+    out["messages"] = normalized_messages
+    services.log(
+        "WARN",
+        "discarded schema-invalid historical Anthropic tool blocks "
+        f"tool_uses={invalid_uses} tool_results={invalid_results}",
+    )
+    return out
+
+
 def normalize_historical_anthropic_tool_turns(
     provider: str,
     body: dict[str, Any],
@@ -133,3 +207,10 @@ def _with_content(message: dict[str, Any], content: list[Any]) -> dict[str, Any]
     updated = dict(message)
     updated["content"] = content
     return updated
+
+
+__all__ = [
+    "AnthropicToolTurnServices",
+    "normalize_historical_anthropic_tool_turns",
+    "sanitize_invalid_anthropic_tool_history",
+]

package/ciel_runtime_support/architecture.py

@@ -699,6 +699,23 @@ class ProviderAdapter(ABC):
         del config
         return request
 
+    def normalize_request_options_for_protocol(
+        self,
+        config: ProviderConfig,
+        request: Mapping[str, Any],
+        protocol: MessageProtocol | None,
+    ) -> Mapping[str, Any]:
+        """Normalize request options for the selected upstream wire protocol.
+
+        Existing adapters remain protocol-neutral by default. Providers that
+        expose more than one wire surface can override this hook without
+        inferring the protocol from overlapping request fields such as
+        ``messages`` and ``max_tokens``.
+        """
+
+        del protocol
+        return self.normalize_request_options(config, request)
+
     def anthropic_system_role_strategy(
         self, config: ProviderConfig
     ) -> Literal["inline_user", "hoist_top_level"]:

package/ciel_runtime_support/channel_injection.py

@@ -23,6 +23,16 @@ class InputTransport(Protocol):
 
     def input_snapshot(self) -> str | None: ...
 
+    def prompt_readiness_checkpoint(self) -> object: ...
+
+    def wait_until_prompt_ready(
+        self,
+        previous_snapshot: object,
+        timeout_seconds: float = 2.0,
+        *,
+        expected_prompt: str | None = None,
+    ) -> bool | None: ...
+
 
 @dataclass(frozen=True)
 class RuntimeInjectionPolicy:
@@ -36,6 +46,7 @@ class RuntimeInjectionPolicy:
     confirm_submission: bool = False
     bracketed_paste: bool = False
     input_drain_timeout_seconds: float = 2.0
+    prompt_render_timeout_seconds: float = 30.0
 
     def __post_init__(self) -> None:
         if not self.runtime.strip():
@@ -46,6 +57,8 @@ class RuntimeInjectionPolicy:
             raise ValueError("submit_delay_seconds cannot be negative")
         if not 1 <= self.submit_attempts <= 8:
             raise ValueError("submit_attempts must be between 1 and 8")
+        if self.prompt_render_timeout_seconds < 0:
+            raise ValueError("prompt_render_timeout_seconds cannot be negative")
 
 
 @dataclass(frozen=True)
@@ -70,8 +83,18 @@ class ChannelPromptInjector:
         self._snapshot = snapshot
         self._log = log
 
-    def inject(self, transport: InputTransport, request: PromptInjection) -> None:
+    def inject(self, transport: InputTransport, request: PromptInjection) -> bool:
         policy = request.policy
+        prompt_ready_wait = bool(
+            getattr(transport, "supports_prompt_ready_wait", False)
+        )
+        before_prompt = (
+            self._prompt_readiness_checkpoint(transport)
+            if prompt_ready_wait
+            and policy.confirm_submission
+            and policy.submit_attempts > 1
+            else None
+        )
         normalize = getattr(transport, "normalize_prompt", None)
         prompt_text = (
             str(normalize(request.prompt)) if callable(normalize) else request.prompt
@@ -101,10 +124,28 @@ class ChannelPromptInjector:
             ):
                 self._log("WARN", "channel_input_drain_timeout")
 
+        if prompt_ready_wait:
+            prompt_ready = self._wait_until_prompt_ready(
+                transport,
+                before_prompt,
+                prompt_text,
+                policy,
+            )
+            if prompt_ready is False:
+                self._log(
+                    "WARN",
+                    "channel_input_submit_deferred reason=prompt_render_timeout",
+                )
+                return False
+
         if policy.submit_delay_seconds:
             self._sleep(policy.submit_delay_seconds)
 
-        before = self._snapshot() if policy.confirm_submission and policy.submit_attempts > 1 else None
+        before = (
+            self._submission_snapshot(transport)
+            if policy.confirm_submission and policy.submit_attempts > 1
+            else None
+        )
         for attempt in range(policy.submit_attempts):
             if bool(getattr(transport, "separate_input_stages", False)):
                 self._write_stage(
@@ -120,10 +161,52 @@ class ChannelPromptInjector:
             retry_delay = self._retry_delay_seconds()
             if retry_delay:
                 self._sleep(retry_delay)
-            after = self._snapshot()
+            after = self._submission_snapshot(transport)
             if after and after != before:
                 self._log("INFO", f"channel_stdin_proxy_submit_confirmed attempt={attempt + 1}")
                 break
+        return True
+
+    def _submission_snapshot(self, transport: InputTransport) -> str | None:
+        """Use the host snapshot when available, then the transport's own view."""
+
+        captured = self._snapshot()
+        if captured is not None:
+            return captured
+        snapshot = getattr(transport, "input_snapshot", None)
+        return snapshot() if callable(snapshot) else None
+
+    def _prompt_readiness_checkpoint(self, transport: InputTransport) -> object:
+        """Capture the transport's own output position before prompt input."""
+
+        checkpoint = getattr(transport, "prompt_readiness_checkpoint", None)
+        if callable(checkpoint):
+            return checkpoint()
+        return self._submission_snapshot(transport)
+
+    def _wait_until_prompt_ready(
+        self,
+        transport: InputTransport,
+        previous_snapshot: object,
+        prompt: str,
+        policy: RuntimeInjectionPolicy,
+    ) -> bool | None:
+        if not policy.confirm_submission or policy.submit_attempts <= 1:
+            return None
+        wait = getattr(transport, "wait_until_prompt_ready", None)
+        if not callable(wait):
+            return None
+        ready = wait(
+            previous_snapshot,
+            policy.prompt_render_timeout_seconds,
+            expected_prompt=prompt,
+        )
+        if ready is not None:
+            self._log(
+                "INFO" if ready else "WARN",
+                f"channel_input_prompt_ready result={'observed' if ready else 'timeout'}",
+            )
+        return ready
 
     def _write_stage(
         self,
@@ -188,6 +271,9 @@ class CallableInputTransport:
         self.supports_input_snapshot = callable(
             getattr(target, "input_snapshot", None)
         )
+        self.supports_prompt_ready_wait = callable(
+            getattr(target, "wait_until_prompt_ready", None)
+        )
 
     def write(self, data: bytes) -> None:
         self._write(self._target, data)
@@ -213,6 +299,30 @@ class CallableInputTransport:
         snapshot = getattr(self._target, "input_snapshot", None)
         return snapshot() if callable(snapshot) else None
 
+    def prompt_readiness_checkpoint(self) -> object:
+        checkpoint = getattr(self._target, "prompt_readiness_checkpoint", None)
+        if callable(checkpoint):
+            return checkpoint()
+        return self.input_snapshot()
+
+    def wait_until_prompt_ready(
+        self,
+        previous_snapshot: object,
+        timeout_seconds: float = 2.0,
+        *,
+        expected_prompt: str | None = None,
+    ) -> bool | None:
+        wait = getattr(self._target, "wait_until_prompt_ready", None)
+        if not callable(wait):
+            return None
+        return bool(
+            wait(
+                previous_snapshot,
+                timeout_seconds,
+                expected_prompt=expected_prompt,
+            )
+        )
+
 
 __all__ = [
     "CallableInputTransport",