@oneciel-ai/ciel-runtime 0.2.2 → 0.2.4

package/ciel_runtime_support/claude_launch_assembly.py

@@ -0,0 +1,249 @@
+"""Assemble Claude Code launch services from bounded, typed dependency groups."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Callable
+
+from . import runtime_launch
+
+
+Callback = Callable[..., Any]
+
+
+@dataclass(frozen=True, slots=True)
+class ClaudeLaunchProcessPorts:
+    log_command: Callback
+    call_capturing_stderr: Callback
+    env_bool: Callback
+    env_vars: Callback
+    file_size: Callback
+    runtime_path: Callback
+    print_exit_diagnostics: Callback
+    call_with_channel_wake: Callback
+
+
+@dataclass(frozen=True, slots=True)
+class ClaudeLaunchInstallationPorts:
+    find_executable: Callback
+    install_commands: Callback
+    install_statusline: Callback
+    install_claude: Callback
+    install_tool_guard: Callback
+    disable_commands: Callback
+    readiness_errors: Callback
+    warn_multiple_installs: Callback
+
+
+@dataclass(frozen=True, slots=True)
+class ClaudeLaunchDispatchPorts:
+    launch_agy: Callback
+    launch_codex: Callback
+    launch_codex_app_server: Callback
+    materialize_command: Callback
+    run_runtime_update: Callback
+    run_claude_update: Callback
+    run_prelaunch_menu: Callback
+    launch_enabled: Callback
+
+
+@dataclass(frozen=True, slots=True)
+class ClaudeLaunchConfigPorts:
+    load_config: Callback
+    save_config: Callback
+    current_provider: Callback
+    ensure_current_model: Callback
+    ensure_model_cache: Callback
+    apply_endpoint_policy: Callback
+    provider_menu_label: Callback
+    launch_mode_name: Callback
+    current_launch_cwd_key: Callback
+
+
+@dataclass(frozen=True, slots=True)
+class ClaudeLaunchRoutingPorts:
+    routed_enabled: Callback
+    direct_native_enabled: Callback
+    cleanup_services: Callback
+    ensure_router_running: Callback
+    reset_zai_mcp: Callback
+    health_summary: Callback
+    log: Callback
+    start_router: Callback
+    run_with_router_lifetime: Callback
+    record_launch_state: Callback
+
+
+@dataclass(frozen=True, slots=True)
+class ClaudeLaunchPolicyPorts:
+    append_runtime_settings: Callback
+    supports_permission_mode: Callback
+    has_noninteractive_args: Callback
+    has_passthrough_option: Callback
+    should_append_compat_prompt: Callback
+    should_attach_web_search: Callback
+    should_disallow_server_web_tools: Callback
+    should_fork_native_session: Callback
+    should_insert_option_boundary: Callback
+    strip_mcp_config: Callback
+
+
+@dataclass(frozen=True, slots=True)
+class ClaudeLaunchDiscoveryPorts:
+    auto_import_channels: Callback
+    cached_capable_names: Callback
+    cached_source_paths: Callback
+    candidate_names: Callback
+    channel_specs: Callback
+    channels_requested: Callback
+    auth_available: Callback
+    ensure_probe_cache: Callback
+    external_server_names: Callback
+    read_probe_cache: Callback
+
+
+@dataclass(frozen=True, slots=True)
+class ClaudeLaunchDeliveryPorts:
+    auto_start_sse: Callback
+    channel_args: Callback
+    native_passthrough_requested: Callback
+    normalize_passthrough: Callback
+    should_start_sse: Callback
+    should_use_llm_delivery: Callback
+    should_use_stdin_proxy: Callback
+    should_use_native_bridge: Callback
+    write_channel_config: Callback
+
+
+@dataclass(frozen=True, slots=True)
+class ClaudeLaunchMcpConfigPorts:
+    write_duckduckgo: Callback
+    write_proxy: Callback
+    write_native_discovery: Callback
+    write_zai: Callback
+
+
+@dataclass(frozen=True, slots=True)
+class ClaudeLaunchAssembly:
+    process: ClaudeLaunchProcessPorts
+    installation: ClaudeLaunchInstallationPorts
+    dispatch: ClaudeLaunchDispatchPorts
+    config: ClaudeLaunchConfigPorts
+    routing: ClaudeLaunchRoutingPorts
+    policy: ClaudeLaunchPolicyPorts
+    discovery: ClaudeLaunchDiscoveryPorts
+    delivery: ClaudeLaunchDeliveryPorts
+    mcp_config: ClaudeLaunchMcpConfigPorts
+
+    def services(self) -> runtime_launch.ClaudeLaunchServices:
+        return runtime_launch.ClaudeLaunchServices(
+            constants=runtime_launch.build_default_claude_launch_constants(),
+            process=runtime_launch.ClaudeLaunchProcess(
+                _log_claude_command_for_diagnostics=self.process.log_command,
+                _subprocess_call_capturing_stderr=self.process.call_capturing_stderr,
+                env_bool=self.process.env_bool,
+                env_vars=self.process.env_vars,
+                file_size_or_zero=self.process.file_size,
+                path_with_ciel_runtime_user_dirs=self.process.runtime_path,
+                print_routed_claude_exit_diagnostics=self.process.print_exit_diagnostics,
+                subprocess_call_with_channel_wake_proxy=self.process.call_with_channel_wake,
+            ),
+            installation=runtime_launch.ClaudeLaunchInstallation(
+                find_executable=self.installation.find_executable,
+                install_ciel_runtime_slash_commands=self.installation.install_commands,
+                install_ciel_runtime_statusline=self.installation.install_statusline,
+                install_claude_code_if_missing=self.installation.install_claude,
+                install_tool_guard_hooks=self.installation.install_tool_guard,
+                disable_ciel_runtime_slash_commands_for_native=self.installation.disable_commands,
+                launch_readiness_errors=self.installation.readiness_errors,
+                warn_if_multiple_ciel_runtime_installs=self.installation.warn_multiple_installs,
+            ),
+            dispatch=runtime_launch.ClaudeLaunchDispatch(
+                launch_agy=self.dispatch.launch_agy,
+                launch_codex=self.dispatch.launch_codex,
+                launch_codex_app_server=self.dispatch.launch_codex_app_server,
+                materialize_runtime_command=self.dispatch.materialize_command,
+                run_ciel_runtime_update_check=self.dispatch.run_runtime_update,
+                run_claude_update_check=self.dispatch.run_claude_update,
+                run_prelaunch_menu=self.dispatch.run_prelaunch_menu,
+                claude_launch_enabled_for_provider=self.dispatch.launch_enabled,
+            ),
+            config=runtime_launch.ClaudeLaunchConfig(
+                load_config=self.config.load_config,
+                save_config=self.config.save_config,
+                get_current_provider=self.config.current_provider,
+                ensure_current_model_from_provider_list=self.config.ensure_current_model,
+                ensure_model_cache_for_launch=self.config.ensure_model_cache,
+                apply_launch_endpoint_policy=self.config.apply_endpoint_policy,
+                provider_menu_label=self.config.provider_menu_label,
+                launch_mode_name=self.config.launch_mode_name,
+                current_launch_cwd_key=self.config.current_launch_cwd_key,
+            ),
+            routing=runtime_launch.ClaudeLaunchRouting(
+                anthropic_routed_enabled=self.routing.routed_enabled,
+                direct_native_anthropic_enabled=self.routing.direct_native_enabled,
+                cleanup_managed_services_for_provider=self.routing.cleanup_services,
+                ensure_managed_router_running_for_client=self.routing.ensure_router_running,
+                reset_zai_mcp_config_if_inactive=self.routing.reset_zai_mcp,
+                router_health_summary=self.routing.health_summary,
+                router_log=self.routing.log,
+                start_router_if_needed=self.routing.start_router,
+                run_with_router_lifetime=self.routing.run_with_router_lifetime,
+                record_launch_state_for_cwd=self.routing.record_launch_state,
+            ),
+            policy=runtime_launch.ClaudeLaunchPolicy(
+                append_claude_code_runtime_settings_args=self.policy.append_runtime_settings,
+                claude_supports_permission_mode_arg=self.policy.supports_permission_mode,
+                has_noninteractive_claude_args=self.policy.has_noninteractive_args,
+                has_passthrough_option=self.policy.has_passthrough_option,
+                should_append_compat_prompt=self.policy.should_append_compat_prompt,
+                should_attach_web_search=self.policy.should_attach_web_search,
+                should_disallow_claude_server_side_web_tools=self.policy.should_disallow_server_web_tools,
+                should_fork_native_session_after_mode_switch=self.policy.should_fork_native_session,
+                should_insert_passthrough_option_boundary=self.policy.should_insert_option_boundary,
+                strip_mcp_config_passthrough=self.policy.strip_mcp_config,
+            ),
+            channel_discovery=runtime_launch.ClaudeLaunchChannelDiscovery(
+                auto_import_passthrough_channels=self.discovery.auto_import_channels,
+                cached_channel_capable_server_names=self.discovery.cached_capable_names,
+                cached_channel_source_paths_for_specs=self.discovery.cached_source_paths,
+                channel_candidate_server_names_for_launch=self.discovery.candidate_names,
+                channel_specs_for_launch=self.discovery.channel_specs,
+                claude_channels_requested=self.discovery.channels_requested,
+                claude_code_channels_auth_available=self.discovery.auth_available,
+                ensure_channel_probe_cache_for_launch=self.discovery.ensure_probe_cache,
+                external_mcp_channel_server_names_from_configs=self.discovery.external_server_names,
+                read_channel_probe_cache=self.discovery.read_probe_cache,
+            ),
+            channel_delivery=runtime_launch.ClaudeLaunchChannelDelivery(
+                auto_start_sse_channels_from_mcp_configs=self.delivery.auto_start_sse,
+                claude_channel_args=self.delivery.channel_args,
+                native_channel_passthrough_requested=self.delivery.native_passthrough_requested,
+                normalize_channel_passthrough=self.delivery.normalize_passthrough,
+                should_launch_process_start_channel_sse=self.delivery.should_start_sse,
+                should_use_channel_llm_delivery=self.delivery.should_use_llm_delivery,
+                should_use_channel_stdin_proxy=self.delivery.should_use_stdin_proxy,
+                should_use_native_channel_bridge=self.delivery.should_use_native_bridge,
+                write_channel_mcp_config=self.delivery.write_channel_config,
+            ),
+            mcp_config=runtime_launch.ClaudeLaunchMcpConfig(
+                write_duckduckgo_mcp_config=self.mcp_config.write_duckduckgo,
+                write_mcp_proxy_config=self.mcp_config.write_proxy,
+                write_native_mcp_config_from_discovery=self.mcp_config.write_native_discovery,
+                write_zai_mcp_config=self.mcp_config.write_zai,
+            ),
+        )
+
+
+__all__ = [
+    "ClaudeLaunchAssembly",
+    "ClaudeLaunchConfigPorts",
+    "ClaudeLaunchDeliveryPorts",
+    "ClaudeLaunchDiscoveryPorts",
+    "ClaudeLaunchDispatchPorts",
+    "ClaudeLaunchInstallationPorts",
+    "ClaudeLaunchMcpConfigPorts",
+    "ClaudeLaunchPolicyPorts",
+    "ClaudeLaunchProcessPorts",
+    "ClaudeLaunchRoutingPorts",
+]

package/ciel_runtime_support/claude_router.py

@@ -115,6 +115,11 @@ class ClaudeRouterResponse:
     key_from_headers: Callable[..., Any]
 
 
+@dataclass(frozen=True, slots=True)
+class ClaudeRouterContextRecovery:
+    recover_output_budget: Callable[..., Any]
+
+
 @dataclass(frozen=True, slots=True)
 class ClaudeRouterServices:
     core: ClaudeRouterCore
@@ -126,6 +131,7 @@ class ClaudeRouterServices:
     normalization: ClaudeRouterNativeNormalization
     transport: ClaudeRouterTransport
     response: ClaudeRouterResponse
+    context_recovery: ClaudeRouterContextRecovery
 
 
 def handle_claude_count_tokens_post(
@@ -158,6 +164,7 @@ def handle_claude_messages_post(
     normalization = services.normalization
     transport = services.transport
     response = services.response
+    context_recovery = services.context_recovery
     _rebatch_anthropic_sse_text = response.rebatch_sse
     _update_tool_schema_registry = pipeline.update_tool_schema_registry
     append_synthetic_tasklist_to_message = response.append_tasklist
@@ -313,7 +320,7 @@ def handle_claude_messages_post(
             )
             return
         body = normalize_thinking_for_non_anthropic_provider(provider, pcfg, body)
-        body = normalize_anthropic_system_role_messages(body)
+        body = normalize_anthropic_system_role_messages(provider, pcfg, body)
         body = cap_anthropic_body_for_provider(provider, pcfg, body)
         body = apply_provider_request_options(provider, pcfg, body)
         body = rehydrate_suppressed_thinking_passback(provider, pcfg, body)
@@ -339,16 +346,56 @@ def handle_claude_messages_post(
         waited, rpm_used, rpm_limit = apply_router_rate_limit(provider, pcfg, upstream_model)
         try:
             event_bus.publish(level="info", category="upstream.request", message="forwarding to Anthropic-compatible provider", request_id=request_id, provider=provider, model=upstream_model, data={"url": url, "stream": bool(body.get("stream", stream_enabled))})
-            resp = open_provider_request_with_key_retry(
-                url,
-                upstream_body,
-                headers,
-                provider_request_timeout_seconds(pcfg),
-                provider,
-                pcfg,
-                upstream_model,
-                stream=bool(body.get("stream", stream_enabled)),
-            )
+            try:
+                resp = open_provider_request_with_key_retry(
+                    url,
+                    upstream_body,
+                    headers,
+                    provider_request_timeout_seconds(pcfg),
+                    provider,
+                    pcfg,
+                    upstream_model,
+                    stream=bool(body.get("stream", stream_enabled)),
+                )
+            except urllib.error.HTTPError as initial_error:
+                raw_error = initial_error.read()
+                recovered_body = (
+                    context_recovery.recover_output_budget(
+                        upstream_body, raw_error, pcfg
+                    )
+                    if initial_error.code == 400
+                    else None
+                )
+                if recovered_body is None:
+                    initial_error.ciel_runtime_body = raw_error
+                    raise
+                previous_output = upstream_body.get("max_tokens")
+                upstream_body = recovered_body
+                body["max_tokens"] = recovered_body["max_tokens"]
+                router_log(
+                    "WARN",
+                    "native_context_output_retry "
+                    f"provider={provider} model={upstream_model} "
+                    f"max_tokens={previous_output}->{recovered_body['max_tokens']}",
+                )
+                write_router_activity(
+                    "retry",
+                    provider,
+                    upstream_model,
+                    code=400,
+                    reason="context_output_budget",
+                    max_tokens=recovered_body["max_tokens"],
+                )
+                resp = open_provider_request_with_key_retry(
+                    url,
+                    upstream_body,
+                    headers,
+                    provider_request_timeout_seconds(pcfg),
+                    provider,
+                    pcfg,
+                    upstream_model,
+                    stream=bool(body.get("stream", stream_enabled)),
+                )
             if bool(body.get("stream", stream_enabled)):
                 set_upstream_stream_read_timeout(resp, provider_stream_idle_timeout_seconds(pcfg))
             status = getattr(resp, "status", 200)
@@ -395,7 +442,9 @@ def handle_claude_messages_post(
                 mark_pending_channel_delivery_success(self, "anthropic_json")
             commit_pending_channel_delivery_cursors(body, self)
         except urllib.error.HTTPError as e:
-            err = e.read()
+            err = getattr(e, "ciel_runtime_body", None)
+            if err is None:
+                err = e.read()
             if e.code == 429:
                 register_api_key_cooldown(provider, pcfg, key_from_request_headers(headers), e.headers)
             event_bus.publish(level="error", category="upstream.error", message=f"upstream HTTP {e.code}", request_id=request_id, provider=provider, model=upstream_model, data={"status": e.code})
@@ -518,6 +567,7 @@ assert all(any(capability.name == required for capability in ClaudeRouter.capabi
 
 __all__ = [
     "ClaudeRouter",
+    "ClaudeRouterContextRecovery",
     "ClaudeRouterCore",
     "ClaudeRouterCountTokens",
     "ClaudeRouterDelivery",

package/ciel_runtime_support/cli_application_context.py

@@ -0,0 +1,132 @@
+"""CLI dispatch, parser construction, and process entrypoint context."""
+
+from __future__ import annotations
+
+import argparse
+from dataclasses import dataclass
+from typing import Any, Callable, Sequence
+
+
+@dataclass(frozen=True, slots=True)
+class CliApplicationDispatchPorts:
+    dispatch: Callable[..., int]
+    services: Callable[[], Any]
+    mcp_proxy: Callable[[list[str]], int]
+    launch_claude: Callable[[list[str]], int]
+    launch_codex: Callable[[list[str]], int]
+    launch_codex_app_server: Callable[[list[str]], int]
+    launch_agy: Callable[[list[str]], int]
+    launch_kimi: Callable[[list[str]], int]
+    kimi_login: Callable[[], int]
+
+
+@dataclass(frozen=True, slots=True)
+class CliApplicationPresentationPorts:
+    parser_builder: Callable[[Any], argparse.ArgumentParser]
+    parser_services: Callable[[], Any]
+    version: str
+    output: Callable[[str], None]
+    arguments: Callable[[], Sequence[str]]
+
+
+@dataclass(frozen=True, slots=True)
+class CliApplicationContext:
+    dispatch: CliApplicationDispatchPorts
+    presentation: CliApplicationPresentationPorts
+
+    def run_cli(self, argv: list[str]) -> int:
+        return self.dispatch.dispatch(argv, self.dispatch.services())
+
+    def build_parser(self) -> argparse.ArgumentParser:
+        return self.presentation.parser_builder(
+            self.presentation.parser_services()
+        )
+
+    def cmd_cli(self, args: argparse.Namespace) -> None:
+        raise SystemExit(self.run_cli(args.argv))
+
+    def cmd_launch(self, args: argparse.Namespace) -> None:
+        raise SystemExit(self.dispatch.launch_claude(args.argv))
+
+    def cmd_launch_codex(self, args: argparse.Namespace) -> None:
+        raise SystemExit(self.dispatch.launch_codex(args.argv))
+
+    def cmd_launch_codex_app_server(self, args: argparse.Namespace) -> None:
+        raise SystemExit(self.dispatch.launch_codex_app_server(args.argv))
+
+    def cmd_launch_agy(self, args: argparse.Namespace) -> None:
+        raise SystemExit(self.dispatch.launch_agy(args.argv))
+
+    def cmd_version(self, _: argparse.Namespace) -> None:
+        self.presentation.output(f"ciel-runtime {self.presentation.version}")
+
+    def main(self) -> None:
+        arguments = list(self.presentation.arguments())
+        if len(arguments) >= 2 and arguments[1] == "mcp-proxy":
+            raise SystemExit(self.dispatch.mcp_proxy(arguments[2:]))
+        if len(arguments) >= 2 and arguments[1] == "cli":
+            raise SystemExit(self.run_cli(arguments[2:]))
+        routes = {
+            "launch": self.dispatch.launch_claude,
+            "codex": self.dispatch.launch_codex,
+            "launch-codex": self.dispatch.launch_codex,
+            "codex-app": self.dispatch.launch_codex_app_server,
+            "codex-app-server": self.dispatch.launch_codex_app_server,
+            "codex-appserver": self.dispatch.launch_codex_app_server,
+            "launch-codex-app-server": self.dispatch.launch_codex_app_server,
+            "agy": self.dispatch.launch_agy,
+            "launch-agy": self.dispatch.launch_agy,
+            "antigravity": self.dispatch.launch_agy,
+            "kimi": self.dispatch.launch_kimi,
+            "kimi-code": self.dispatch.launch_kimi,
+            "launch-kimi": self.dispatch.launch_kimi,
+        }
+        if len(arguments) >= 2 and arguments[1] in routes:
+            raise SystemExit(routes[arguments[1]](arguments[2:]))
+        if len(arguments) >= 2 and arguments[1] in (
+            "kimi-login",
+            "kimi-oauth-login",
+        ):
+            raise SystemExit(self.dispatch.kimi_login())
+        args = self.build_parser().parse_args(arguments[1:])
+        args.func(args)
+
+
+@dataclass(frozen=True, slots=True)
+class CliApplicationCompatibilityApi:
+    context: Callable[[], CliApplicationContext]
+
+    def run_cli(self, argv: list[str]) -> int:
+        return self.context().run_cli(argv)
+
+    def build_parser(self) -> argparse.ArgumentParser:
+        return self.context().build_parser()
+
+    def cmd_cli(self, args: argparse.Namespace) -> None:
+        self.context().cmd_cli(args)
+
+    def cmd_launch(self, args: argparse.Namespace) -> None:
+        self.context().cmd_launch(args)
+
+    def cmd_launch_codex(self, args: argparse.Namespace) -> None:
+        self.context().cmd_launch_codex(args)
+
+    def cmd_launch_codex_app_server(self, args: argparse.Namespace) -> None:
+        self.context().cmd_launch_codex_app_server(args)
+
+    def cmd_launch_agy(self, args: argparse.Namespace) -> None:
+        self.context().cmd_launch_agy(args)
+
+    def cmd_version(self, args: argparse.Namespace) -> None:
+        self.context().cmd_version(args)
+
+    def main(self) -> None:
+        self.context().main()
+
+
+__all__ = [
+    "CliApplicationCompatibilityApi",
+    "CliApplicationContext",
+    "CliApplicationDispatchPorts",
+    "CliApplicationPresentationPorts",
+]

package/ciel_runtime_support/cli_assembly.py

@@ -0,0 +1,50 @@
+"""Compose CLI dispatch and parser services from their bounded port groups."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from . import cli_dispatch, cli_parser
+
+
+@dataclass(frozen=True, slots=True)
+class CliServiceAssembly:
+    core: cli_dispatch.CliCore
+    runtime: cli_dispatch.CliRuntime
+    provider_commands: cli_dispatch.CliProviderCommands
+    channel_commands: cli_dispatch.CliChannelCommands
+    special_commands: cli_dispatch.CliSpecialCommands
+    operations: cli_dispatch.CliOperations
+    configuration: cli_dispatch.CliConfiguration
+
+    def services(self) -> cli_dispatch.CliServices:
+        return cli_dispatch.CliServices(
+            core=self.core,
+            runtime=self.runtime,
+            provider_commands=self.provider_commands,
+            channel_commands=self.channel_commands,
+            special_commands=self.special_commands,
+            operations=self.operations,
+            configuration=self.configuration,
+        )
+
+
+@dataclass(frozen=True, slots=True)
+class CliParserAssembly:
+    launch: cli_parser.CliParserLaunch
+    runtime: cli_parser.CliParserRuntime
+    settings: cli_parser.CliParserSettings
+    provider: cli_parser.CliParserProvider
+    models: cli_parser.CliParserModels
+
+    def services(self) -> cli_parser.CliParserServices:
+        return cli_parser.CliParserServices(
+            launch=self.launch,
+            runtime=self.runtime,
+            settings=self.settings,
+            provider=self.provider,
+            models=self.models,
+        )
+
+
+__all__ = ["CliParserAssembly", "CliServiceAssembly"]