@oneciel-ai/ciel-runtime 0.2.2 → 0.2.4

package/ciel_runtime_support/codex_backend_context.py

@@ -0,0 +1,363 @@
+"""Codex backend and provider-native passthrough bounded context."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from http.server import BaseHTTPRequestHandler
+from typing import Any, Callable
+
+from .codex_router import CodexChannelContextPorts, CodexChannelContextProjector
+from .openai_chat_passthrough import OpenAIChatPassthrough, OpenAIChatPassthroughPorts
+from .provider_responses_passthrough import (
+    ProviderResponsesPassthrough,
+    ProviderResponsesPassthroughPorts,
+)
+from .router_http import (
+    CodexBackendHttpAdapter,
+    CodexBackendRequestPorts,
+    CodexBackendRetryPorts,
+    CodexRoutedHeaderPolicy,
+)
+
+
+@dataclass(frozen=True, slots=True)
+class CodexBackendChannelPorts:
+    responses_to_anthropic: Callable[..., dict[str, Any]]
+    inject_pending: Callable[..., dict[str, Any]]
+    inject_tool_results: Callable[..., dict[str, Any]]
+    content_to_text: Callable[..., str]
+    begin_delivery: Callable[..., Any]
+    mark_delivery_success: Callable[..., Any]
+    commit_delivery: Callable[..., Any]
+
+
+@dataclass(frozen=True, slots=True)
+class CodexBackendTransportPorts:
+    upstream_base: str
+    decorate_headers: Callable[..., dict[str, str]]
+    urlopen: Callable[..., Any]
+    timeout_seconds: Callable[..., float]
+    read_preamble: Callable[..., Any]
+    retry_wait_seconds: Callable[..., float]
+    log: Callable[..., Any]
+    publish_event: Callable[..., Any]
+    sleep: Callable[[float], None]
+    env_get: Callable[..., str | None]
+
+
+@dataclass(frozen=True, slots=True)
+class CodexBackendReplayPorts:
+    """Durable upstream verdicts about replayed turns."""
+
+    rejected_reasoning_contains: Callable[[str], bool] = lambda _sealed: False
+    rejected_reasoning_record: Callable[[str], Any] = lambda _sealed: None
+    estimate_tokens: Callable[[Any], int] = lambda _body: 0
+    compact_responses: Callable[..., dict[str, Any]] = lambda body, _budget, **_kw: body
+
+
+@dataclass(frozen=True, slots=True)
+class ProviderPassthroughProjectionPorts:
+    provider_headers: Callable[..., dict[str, str]]
+    chat_headers: Callable[..., dict[str, str]]
+    responses_headers: Callable[..., dict[str, str]]
+    upstream_model: Callable[..., str]
+    resolve_model: Callable[..., str]
+    apply_request_policy: Callable[..., dict[str, Any]]
+
+
+@dataclass(frozen=True, slots=True)
+class ProviderPassthroughTransportPorts:
+    upstream_base: Callable[..., str]
+    join_url: Callable[[str, str], str]
+    urlopen: Callable[..., Any]
+    timeout_seconds: Callable[..., float]
+    copy_response_headers: Callable[..., None]
+    write_activity: Callable[..., None]
+
+
+@dataclass(frozen=True, slots=True)
+class CodexBackendContext:
+    channel: CodexBackendChannelPorts
+    transport: CodexBackendTransportPorts
+    provider_projection: ProviderPassthroughProjectionPorts
+    provider_transport: ProviderPassthroughTransportPorts
+    replay: CodexBackendReplayPorts = CodexBackendReplayPorts()
+
+    def routed_headers(
+        self,
+        pcfg: dict[str, Any],
+        inbound_headers: Any | None = None,
+    ) -> dict[str, str]:
+        del pcfg
+        return CodexRoutedHeaderPolicy(
+            decorate=self.transport.decorate_headers
+        ).project(inbound_headers)
+
+    @staticmethod
+    def routed_auth_error_message(message: str) -> str:
+        low = str(message or "").lower()
+        markers = (
+            "api.responses.write",
+            "insufficient permissions",
+            "unauthorized",
+        )
+        if not any(marker in low for marker in markers):
+            return message
+        guidance = (
+            " Codex routed is expected to forward Codex CLI native auth to the "
+            "ChatGPT Codex backend. If this mentions api.responses.write, the "
+            "request is still using the OpenAI Platform /v1 endpoint; upgrade "
+            "ciel-runtime and relaunch Codex routed so the local base URL is "
+            "/backend-api/codex."
+        )
+        return f"{message}{guidance}"
+
+    def project_channel_context(
+        self, body: dict[str, Any]
+    ) -> tuple[dict[str, Any], dict[str, Any]]:
+        return CodexChannelContextProjector(
+            CodexChannelContextPorts(
+                self.channel.responses_to_anthropic,
+                self.channel.inject_pending,
+                self.channel.inject_tool_results,
+                self.channel.content_to_text,
+            )
+        ).project(body)
+
+    @staticmethod
+    def responses_input_as_list(value: Any) -> list[Any]:
+        return CodexChannelContextProjector.input_items(value)
+
+    @staticmethod
+    def copy_response_headers(
+        handler: BaseHTTPRequestHandler,
+        headers: Any,
+    ) -> None:
+        CodexBackendHttpAdapter.copy_response_headers(handler, headers)
+
+    def capacity_retry_limit(self) -> int:
+        raw = str(
+            self.transport.env_get("CIEL_RUNTIME_CODEX_CAPACITY_RETRIES") or "3"
+        ).strip()
+        try:
+            return max(0, min(10, int(raw)))
+        except ValueError:
+            return 3
+
+    def backend_adapter(self) -> CodexBackendHttpAdapter:
+        return CodexBackendHttpAdapter(
+            self.transport.upstream_base,
+            CodexBackendRequestPorts(
+                self.project_channel_context,
+                self.channel.begin_delivery,
+                self.routed_headers,
+                self.transport.urlopen,
+                self.transport.timeout_seconds,
+            ),
+            CodexBackendRetryPorts(
+                self.capacity_retry_limit,
+                self.transport.read_preamble,
+                self.transport.retry_wait_seconds,
+                self.transport.log,
+                self.transport.publish_event,
+                self.transport.sleep,
+                rejected_reasoning_contains=self.replay.rejected_reasoning_contains,
+                rejected_reasoning_record=self.replay.rejected_reasoning_record,
+                estimate_tokens=self.replay.estimate_tokens,
+                compact_responses=self.replay.compact_responses,
+            ),
+        )
+
+    def provider_responses_headers(
+        self,
+        provider: str,
+        pcfg: dict[str, Any],
+        inbound_headers: Any | None = None,
+    ) -> dict[str, str]:
+        headers = self.provider_projection.provider_headers(
+            provider,
+            pcfg,
+            inbound_headers,
+            "openai_responses",
+        )
+        if inbound_headers is None:
+            headers = {
+                name: value
+                for name, value in headers.items()
+                if str(name).casefold() != "anthropic-version"
+            }
+        return headers
+
+    def provider_chat_headers(
+        self,
+        provider: str,
+        pcfg: dict[str, Any],
+        inbound_headers: Any | None = None,
+    ) -> dict[str, str]:
+        return self.provider_projection.provider_headers(
+            provider,
+            pcfg,
+            inbound_headers,
+            "openai_chat",
+        )
+
+    def normalize_model(
+        self,
+        provider: str,
+        pcfg: dict[str, Any],
+        model: Any,
+    ) -> str:
+        return self.provider_projection.upstream_model(
+            provider,
+            pcfg,
+            self.provider_projection.resolve_model(provider, pcfg, model),
+        )
+
+    def normalize_request(
+        self,
+        provider: str,
+        pcfg: dict[str, Any],
+        body: dict[str, Any],
+    ) -> dict[str, Any]:
+        return self.provider_projection.apply_request_policy(
+            provider, pcfg, dict(body)
+        )
+
+    def chat_passthrough(self) -> OpenAIChatPassthrough:
+        return OpenAIChatPassthrough(
+            OpenAIChatPassthroughPorts(
+                normalize_model=self.normalize_model,
+                normalize_request=self.normalize_request,
+                upstream_base=self.provider_transport.upstream_base,
+                join_url=self.provider_transport.join_url,
+                headers=self.provider_projection.chat_headers,
+                urlopen=self.provider_transport.urlopen,
+                timeout_seconds=self.provider_transport.timeout_seconds,
+                copy_response_headers=self.provider_transport.copy_response_headers,
+            )
+        )
+
+    def forward_provider_chat(self, *args: Any, **kwargs: Any) -> None:
+        self.chat_passthrough().forward(*args, **kwargs)
+
+    def responses_passthrough(self) -> ProviderResponsesPassthrough:
+        return ProviderResponsesPassthrough(
+            ProviderResponsesPassthroughPorts(
+                project_channel_context=self.project_channel_context,
+                begin_channel_delivery=self.channel.begin_delivery,
+                normalize_model=self.normalize_model,
+                normalize_request=self.normalize_request,
+                upstream_base=self.provider_transport.upstream_base,
+                join_url=self.provider_transport.join_url,
+                headers=self.provider_projection.responses_headers,
+                urlopen=self.provider_transport.urlopen,
+                timeout_seconds=self.provider_transport.timeout_seconds,
+                copy_response_headers=self.provider_transport.copy_response_headers,
+                record_usage=lambda provider, model, usage: self.provider_transport.write_activity(
+                    "success",
+                    provider,
+                    model,
+                    protocol="openai_responses",
+                    **usage,
+                ),
+                log=self.transport.log,
+            )
+        )
+
+    def forward_provider_responses(self, *args: Any, **kwargs: Any) -> Any:
+        return self.responses_passthrough().forward(*args, **kwargs)
+
+    def upstream_url(self, request_path: str, query: str = "") -> str:
+        return self.backend_adapter().upstream_url(request_path, query)
+
+    def forward_json(self, *args: Any, **kwargs: Any) -> Any:
+        return self.backend_adapter().forward_json(*args, **kwargs)
+
+    def forward_get(self, *args: Any, **kwargs: Any) -> None:
+        self.backend_adapter().forward_get(*args, **kwargs)
+
+    def forward_responses(
+        self,
+        handler: BaseHTTPRequestHandler,
+        provider: str,
+        pcfg: dict[str, Any],
+        body: dict[str, Any],
+    ) -> None:
+        delivery_body = self.forward_json(
+            handler,
+            provider,
+            pcfg,
+            body,
+            mutate_responses=True,
+        )
+        if delivery_body is None:
+            return
+        self.channel.mark_delivery_success(handler, "codex_responses_proxy")
+        self.channel.commit_delivery(delivery_body, handler)
+
+
+@dataclass(frozen=True, slots=True)
+class CodexBackendCompatibilityApi:
+    context: Callable[[], CodexBackendContext]
+
+    def routed_headers(self, *args: Any, **kwargs: Any) -> Any:
+        return self.context().routed_headers(*args, **kwargs)
+
+    def routed_auth_error_message(self, message: str) -> str:
+        return self.context().routed_auth_error_message(message)
+
+    def project_channel_context(self, *args: Any, **kwargs: Any) -> Any:
+        return self.context().project_channel_context(*args, **kwargs)
+
+    def responses_input_as_list(self, value: Any) -> list[Any]:
+        return self.context().responses_input_as_list(value)
+
+    def copy_response_headers(self, *args: Any, **kwargs: Any) -> None:
+        self.context().copy_response_headers(*args, **kwargs)
+
+    def backend_adapter(self) -> CodexBackendHttpAdapter:
+        return self.context().backend_adapter()
+
+    def provider_responses_headers(self, *args: Any, **kwargs: Any) -> Any:
+        return self.context().provider_responses_headers(*args, **kwargs)
+
+    def provider_chat_headers(self, *args: Any, **kwargs: Any) -> Any:
+        return self.context().provider_chat_headers(*args, **kwargs)
+
+    def chat_passthrough(self) -> OpenAIChatPassthrough:
+        return self.context().chat_passthrough()
+
+    def forward_provider_chat(self, *args: Any, **kwargs: Any) -> None:
+        self.context().forward_provider_chat(*args, **kwargs)
+
+    def responses_passthrough(self) -> ProviderResponsesPassthrough:
+        return self.context().responses_passthrough()
+
+    def forward_provider_responses(self, *args: Any, **kwargs: Any) -> Any:
+        return self.context().forward_provider_responses(*args, **kwargs)
+
+    def upstream_url(self, *args: Any, **kwargs: Any) -> str:
+        return self.context().upstream_url(*args, **kwargs)
+
+    def forward_json(self, *args: Any, **kwargs: Any) -> Any:
+        return self.context().forward_json(*args, **kwargs)
+
+    def capacity_retry_limit(self) -> int:
+        return self.context().capacity_retry_limit()
+
+    def forward_get(self, *args: Any, **kwargs: Any) -> None:
+        self.context().forward_get(*args, **kwargs)
+
+    def forward_responses(self, *args: Any, **kwargs: Any) -> None:
+        self.context().forward_responses(*args, **kwargs)
+
+
+__all__ = [
+    "CodexBackendChannelPorts",
+    "CodexBackendCompatibilityApi",
+    "CodexBackendContext",
+    "CodexBackendReplayPorts",
+    "CodexBackendTransportPorts",
+    "ProviderPassthroughProjectionPorts",
+    "ProviderPassthroughTransportPorts",
+]

package/ciel_runtime_support/codex_config.py

@@ -146,8 +146,20 @@ def normalize_codex_mcp_server(
     out: dict[str, Any] = {"type": server_type, "url": url}
     if explicit_type:
         out["_ciel_runtime_explicit_type"] = True
+    headers: dict[str, Any] = {}
+    raw_headers = raw_server.get("headers")
+    if isinstance(raw_headers, dict):
+        headers.update(raw_headers)
+    codex_http_headers = raw_server.get("http_headers")
+    if isinstance(codex_http_headers, dict):
+        headers.update(codex_http_headers)
+    if headers:
+        # Codex names literal HTTP headers ``http_headers`` while the shared
+        # MCP discovery/transport contract uses ``headers``.  Normalize the
+        # spelling here so the independently owned notification worker keeps
+        # the same authentication as Codex's native MCP client.
+        out["headers"] = headers
     for key in (
-        "headers",
         "env_http_headers",
         "bearer_token_env_var",
         "token_env_var",

package/ciel_runtime_support/codex_launch_assembly.py

@@ -0,0 +1,213 @@
+"""Assemble Codex CLI and app-server launch services from shared typed ports."""
+
+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 CodexLaunchSharedConfigPorts:
+    apply_endpoint_policy: Callback
+    current_alias: Callback
+    current_launch_cwd_key: Callback
+    ensure_model_cache: Callback
+    get_current_provider: Callback
+    load_config: Callback
+    provider_mode_label: Callback
+    record_launch_state: Callback
+    model_catalog_args: Callback
+
+
+@dataclass(frozen=True, slots=True)
+class CodexLaunchSharedInstallationPorts:
+    find_executable: Callback
+    install_codex: Callback
+    warn_multiple_installs: Callback
+    disable_prompts: Callback
+    has_passthrough_option: Callback
+    install_prompts: Callback
+
+
+@dataclass(frozen=True, slots=True)
+class CodexLaunchSharedDispatchPorts:
+    launch_agy: Callback
+    launch_claude: Callback
+    launch_codex: Callback
+    launch_app_server: Callback
+    materialize_command: Callback
+    run_runtime_update: Callback
+    run_codex_update: Callback
+    run_prelaunch_menu: Callback
+    log_passthrough_mapping: Callback
+
+
+@dataclass(frozen=True, slots=True)
+class CodexLaunchSharedRoutingPorts:
+    cleanup_services: Callback
+    routed_enabled: Callback
+    direct_native_enabled: Callback
+    readiness_errors: Callback
+    native_enabled: Callback
+    launch_enabled: Callback
+    run_with_router_lifetime: Callback
+    start_router: Callback
+
+
+@dataclass(frozen=True, slots=True)
+class CodexLaunchSharedChannelPorts:
+    auto_import_channels: Callback
+    delivery_mode: Callback
+    capable_server_names: Callback
+    native_http_args: Callback
+    split_proxy_enabled: Callback
+    restore_config: Callback
+    start_sse: Callback
+    write_discovery_config: Callback
+    select_resume_session: Callback
+
+
+@dataclass(frozen=True, slots=True)
+class CodexCliLaunchPorts:
+    process: runtime_launch.CodexLaunchProcess
+    policy: runtime_launch.CodexLaunchCliPolicy
+
+
+@dataclass(frozen=True, slots=True)
+class CodexAppServerLaunchPorts:
+    process: runtime_launch.CodexAppServerProcess
+    policy: runtime_launch.CodexAppServerCliPolicy
+
+
+@dataclass(frozen=True, slots=True)
+class CodexLaunchAssembly:
+    config: CodexLaunchSharedConfigPorts
+    installation: CodexLaunchSharedInstallationPorts
+    dispatch: CodexLaunchSharedDispatchPorts
+    routing: CodexLaunchSharedRoutingPorts
+    channel: CodexLaunchSharedChannelPorts
+    cli: CodexCliLaunchPorts
+    app_server: CodexAppServerLaunchPorts
+
+    def cli_services(self) -> runtime_launch.CodexLaunchServices:
+        return runtime_launch.CodexLaunchServices(
+            constants=runtime_launch.build_default_codex_launch_constants(),
+            process=self.cli.process,
+            cli_policy=self.cli.policy,
+            config=runtime_launch.CodexLaunchConfig(
+                apply_launch_endpoint_policy=self.config.apply_endpoint_policy,
+                current_alias=self.config.current_alias,
+                current_launch_cwd_key=self.config.current_launch_cwd_key,
+                ensure_model_cache_for_launch=self.config.ensure_model_cache,
+                get_current_provider=self.config.get_current_provider,
+                load_config=self.config.load_config,
+                provider_mode_label=self.config.provider_mode_label,
+                record_launch_state_for_cwd=self.config.record_launch_state,
+                codex_runtime_model_catalog_args=self.config.model_catalog_args,
+            ),
+            installation=runtime_launch.CodexLaunchInstallation(
+                disable_ciel_runtime_codex_prompts_for_native=self.installation.disable_prompts,
+                find_executable=self.installation.find_executable,
+                has_passthrough_option=self.installation.has_passthrough_option,
+                install_ciel_runtime_codex_prompts=self.installation.install_prompts,
+                install_codex_if_missing=self.installation.install_codex,
+                warn_if_multiple_ciel_runtime_installs=self.installation.warn_multiple_installs,
+            ),
+            dispatch=runtime_launch.CodexLaunchDispatch(
+                launch_agy=self.dispatch.launch_agy,
+                launch_claude=self.dispatch.launch_claude,
+                launch_codex_app_server=self.dispatch.launch_app_server,
+                log_codex_passthrough_mapping=self.dispatch.log_passthrough_mapping,
+                materialize_runtime_command=self.dispatch.materialize_command,
+                run_ciel_runtime_update_check=self.dispatch.run_runtime_update,
+                run_codex_update_check=self.dispatch.run_codex_update,
+                run_prelaunch_menu=self.dispatch.run_prelaunch_menu,
+            ),
+            routing=runtime_launch.CodexLaunchRouting(
+                cleanup_managed_services_for_provider=self.routing.cleanup_services,
+                codex_routed_enabled=self.routing.routed_enabled,
+                direct_native_codex_enabled=self.routing.direct_native_enabled,
+                launch_readiness_errors=self.routing.readiness_errors,
+                native_codex_enabled=self.routing.native_enabled,
+                run_with_router_lifetime=self.routing.run_with_router_lifetime,
+                start_router_if_needed=self.routing.start_router,
+            ),
+            channel=runtime_launch.CodexLaunchChannel(
+                auto_import_passthrough_channels=self.channel.auto_import_channels,
+                channel_delivery_mode=self.channel.delivery_mode,
+                codex_channel_capable_mcp_server_names=self.channel.capable_server_names,
+                codex_mcp_native_http_compat_args=self.channel.native_http_args,
+                codex_mcp_split_proxy_enabled=self.channel.split_proxy_enabled,
+                restore_codex_mcp_config_from_managed=self.channel.restore_config,
+                select_codex_resume_session=self.channel.select_resume_session,
+                start_codex_mcp_channel_sse_for_launch=self.channel.start_sse,
+                write_codex_mcp_config_for_channel_discovery=self.channel.write_discovery_config,
+            ),
+        )
+
+    def app_server_services(self) -> runtime_launch.CodexAppServerLaunchServices:
+        return runtime_launch.CodexAppServerLaunchServices(
+            constants=runtime_launch.build_default_codex_launch_constants(),
+            process=self.app_server.process,
+            config=runtime_launch.CodexAppServerConfig(
+                apply_launch_endpoint_policy=self.config.apply_endpoint_policy,
+                current_alias=self.config.current_alias,
+                current_launch_cwd_key=self.config.current_launch_cwd_key,
+                ensure_model_cache_for_launch=self.config.ensure_model_cache,
+                get_current_provider=self.config.get_current_provider,
+                load_config=self.config.load_config,
+                provider_mode_label=self.config.provider_mode_label,
+                record_launch_state_for_cwd=self.config.record_launch_state,
+            ),
+            cli_policy=self.app_server.policy,
+            installation=runtime_launch.CodexAppServerInstallation(
+                find_executable=self.installation.find_executable,
+                install_codex_if_missing=self.installation.install_codex,
+                warn_if_multiple_ciel_runtime_installs=self.installation.warn_multiple_installs,
+            ),
+            dispatch=runtime_launch.CodexAppServerDispatch(
+                launch_agy=self.dispatch.launch_agy,
+                launch_claude=self.dispatch.launch_claude,
+                launch_codex=self.dispatch.launch_codex,
+                run_ciel_runtime_update_check=self.dispatch.run_runtime_update,
+                run_codex_update_check=self.dispatch.run_codex_update,
+                run_prelaunch_menu=self.dispatch.run_prelaunch_menu,
+            ),
+            routing=runtime_launch.CodexAppServerRouting(
+                cleanup_managed_services_for_provider=self.routing.cleanup_services,
+                codex_launch_enabled_for_provider=self.routing.launch_enabled,
+                codex_routed_enabled=self.routing.routed_enabled,
+                direct_native_codex_enabled=self.routing.direct_native_enabled,
+                launch_readiness_errors=self.routing.readiness_errors,
+                native_codex_enabled=self.routing.native_enabled,
+                run_with_router_lifetime=self.routing.run_with_router_lifetime,
+                start_router_if_needed=self.routing.start_router,
+            ),
+            channel=runtime_launch.CodexAppServerChannel(
+                auto_import_passthrough_channels=self.channel.auto_import_channels,
+                channel_delivery_mode=self.channel.delivery_mode,
+                codex_channel_capable_mcp_server_names=self.channel.capable_server_names,
+                codex_mcp_native_http_compat_args=self.channel.native_http_args,
+                codex_mcp_split_proxy_enabled=self.channel.split_proxy_enabled,
+                restore_codex_mcp_config_from_managed=self.channel.restore_config,
+                start_codex_mcp_channel_sse_for_launch=self.channel.start_sse,
+                write_codex_mcp_config_for_channel_discovery=self.channel.write_discovery_config,
+            ),
+        )
+
+
+__all__ = [
+    "CodexAppServerLaunchPorts",
+    "CodexCliLaunchPorts",
+    "CodexLaunchAssembly",
+    "CodexLaunchSharedChannelPorts",
+    "CodexLaunchSharedConfigPorts",
+    "CodexLaunchSharedDispatchPorts",
+    "CodexLaunchSharedInstallationPorts",
+    "CodexLaunchSharedRoutingPorts",
+]

package/ciel_runtime_support/codex_launch_configuration.py

@@ -178,6 +178,9 @@ class CodexLaunchConfigurationService:
             auto_compact_token_limit = None
         if auto_compact_token_limit is not None and auto_compact_token_limit <= 0:
             auto_compact_token_limit = None
+        metadata = provider_config.get("codex_model_catalog")
+        if not isinstance(metadata, Mapping):
+            metadata = None
         return self.catalog.write(
             codex,
             CodexModelCatalogSpec(
@@ -186,16 +189,42 @@ class CodexLaunchConfigurationService:
                 context_window=context_window,
                 effort=str(provider_config.get("effort_level") or "").strip().lower(),
                 auto_compact_token_limit=auto_compact_token_limit,
+                metadata=metadata,
             ),
             catalog_env,
         )
 
+    def auto_compact_config_args(self, cfg: dict[str, Any]) -> list[str]:
+        """Move Codex's own compaction trigger to the operator's threshold.
+
+        A session that crosses providers carries history built under whatever
+        window was in force at the time. Codex compacts on its own, but only
+        once its configured limit is reached — and by then a history grown
+        under a larger window no longer fits the smaller one, so the compaction
+        request itself is refused and the turn cannot recover.
+
+        Passing the threshold keeps that trigger where the operator wants it
+        rather than claiming a window size of our own: it only decides when
+        Codex compacts, never how much context it believes it has.
+        """
+
+        _provider, provider_config = self.model.current_provider(cfg)
+        try:
+            limit = int(provider_config.get("codex_auto_compact_window"))
+        except (TypeError, ValueError):
+            return []
+        if limit <= 0:
+            return []
+        return ["-c", f"model_auto_compact_token_limit={limit}"]
+
     def runtime_model_catalog_args(
         self, codex: str, cfg: dict[str, Any]
     ) -> list[str]:
         path = self.write_runtime_model_catalog(codex, cfg)
         if path is None:
-            return []
+            # A native provider keeps its own bundled catalog; only the
+            # compaction threshold is ours to set.
+            return self.auto_compact_config_args(cfg)
         value = self.policy.toml_string(str(path.resolve()))
         return ["-c", f"model_catalog_json={value}"]