@oneciel-ai/ciel-runtime 0.2.47 → 0.2.48

package/ciel_runtime.py

@@ -1346,8 +1346,8 @@ _PROVIDER_REQUEST_ACCESS = ProviderRequestAccessService(
         request_policy=lambda provider, pcfg: provider_request_policy(provider, pcfg),
         select_api_key=lambda provider, pcfg: select_provider_api_key(provider, pcfg),
         meaningful_key=project_meaningful_key_value,
-        adapter_headers=lambda provider, pcfg, key: configured_provider_adapter(provider, pcfg).build_headers(
-            provider_contract_config(provider, pcfg), key),
+        adapter_headers=lambda provider, pcfg, key, router_originated=False: configured_provider_adapter(provider, pcfg).request_headers(
+            provider_contract_config(provider, pcfg), key, router_originated=router_originated),
         inbound_credentials=lambda key, inbound: credential.headers if (credential := resolve_anthropic_credentials(key, inbound)) is not None else None,
     ),
     effects=ProviderRequestAccessEffects(
@@ -2895,7 +2895,7 @@ def body_with_codex_compat_instructions(cfg: dict[str, Any], provider: str, pcfg
     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, prepare_reasoning_budget_retry=lambda provider, pcfg, body: codex_turn_recovery.prepare_provider_reasoning_output_budget_retry(provider, pcfg, body, adapter_for=configured_provider_adapter, contract_for=provider_contract_config, resolve_model=resolve_requested_model, select_protocol=select_provider_protocol))
+    return codex_turn_recovery.CodexTurnRecoveryServices(should_retry=should_retry_preamble_only_turn, collect_message=collect_provider_message_for_responses, log=router_log, is_plan_mode=plan_mode_active, prepare_reasoning_budget_retry=lambda provider, pcfg, body: codex_turn_recovery.prepare_provider_reasoning_output_budget_retry(provider, pcfg, body, adapter_for=configured_provider_adapter, contract_for=provider_contract_config, resolve_model=resolve_requested_model, select_protocol=select_provider_protocol))
 def recover_codex_preamble_only_turn(handler: Any, provider: str, pcfg: dict[str, Any], body: dict[str, Any], message: dict[str, Any]) -> dict[str, Any]:
     return codex_turn_recovery.recover_preamble_only_turn(handler, provider, pcfg, body, message, _codex_turn_recovery_services())
 def forward_anthropic_via_responses(handler: Any, provider: str, pcfg: dict[str, Any], body: dict[str, Any], model: str) -> None: AnthropicResponsesBridge(AnthropicResponsesBridgePorts(AnthropicResponsesProjectionPorts(anthropic_messages_to_openai_responses, openai_response_to_anthropic_message, provider_upstream_model, apply_provider_adapter_request_policy), AnthropicResponsesTransportPorts(provider_endpoint, provider_headers, post_json_with_rate_retry, open_provider_request_with_key_retry, provider_request_timeout_seconds), AnthropicResponsesOutputPorts(write_anthropic_message_response, write_json, ResponsesAnthropicStreamWriter(openai_response_to_anthropic_message).forward))).forward(handler, provider, pcfg, body, model)
@@ -3659,7 +3659,7 @@ def compatibility_test_services() -> CompatibilityTestServices:
                                    provider_native_compat_enabled, upstream_api_model_id, vllm_native_compat_enabled, vllm_tool_parser_hint),
         request=CompatibilityTestRequest(compatibility_endpoint_probe_lines, compatibility_failure_diagnosis, compatibility_http_error_message,
                                          post_json, provider_headers, provider_ip_family_probe_lines, run_compatibility_api_key_probes,
-                                         start_router_if_needed, stop_router_processes),
+                                         start_router_if_needed, stop_router_processes, lambda p, c: configured_provider_adapter(p, c).compatibility_headers(provider_contract_config(p, c))),
         protocol=CompatibilityTestProtocol(compatibility_text_request, compatibility_tool_request, compatibility_tool_result_request,
                                            find_compat_tool_use, known_compatibility_tool_use_blocker, normalize_thinking_for_non_anthropic_provider,
                                            normalize_tool_choice_for_provider, ollama_chat_request, resolve_requested_model, response_text_preview),

package/ciel_runtime_support/architecture.py

@@ -334,6 +334,34 @@ class ProviderAdapter(ABC):
     def build_headers(self, config: ProviderConfig, api_key: str | None) -> Mapping[str, str]:
         """Build upstream HTTP headers for this provider."""
 
+    def compatibility_headers(self, config: ProviderConfig) -> Mapping[str, str]:
+        """Return headers scoped to one provider compatibility-test conversation."""
+
+        del config
+        return {}
+
+    def session_headers(self, config: ProviderConfig) -> Mapping[str, str]:
+        """Return identity headers for requests the router originates itself.
+
+        Client traffic forwards the client's own headers verbatim; advisor,
+        compaction and probe requests have none to forward.
+        """
+
+        del config
+        return {}
+
+    def request_headers(
+        self,
+        config: ProviderConfig,
+        api_key: str | None,
+        *,
+        router_originated: bool = False,
+    ) -> Mapping[str, str]:
+        headers = dict(self.build_headers(config, api_key))
+        if router_originated:
+            headers.update(self.session_headers(config))
+        return headers
+
     def parse_rate_limit(self, response_or_error: Any) -> RateLimitState | None:
         """Return a rate-limit observation when the provider exposes one."""
 

package/ciel_runtime_support/channel_terminal_proxy.py

@@ -411,7 +411,12 @@ def run_windows_channel_terminal_proxy(
                 input_ready=now >= channel_input_ready_at,
             )
             console.sleep(0.05)
-        return proc.wait()
+        returncode = proc.wait()
+        policy.log("INFO", f"channel_windows_console_child_exit pid={proc.pid} returncode={returncode}")
+        return returncode
+    except BaseException as exc:
+        policy.log("ERROR", f"channel_windows_console_proxy_exception type={type(exc).__name__}")
+        raise
     finally:
         cleanup_resources()
 

package/ciel_runtime_support/codex_completion_gate.py

@@ -134,16 +134,29 @@ class ResponsesCompletionObservation:
         )
 
 
+def request_allows_completion_check(body: dict[str, Any]) -> bool:
+    """Return whether the client let the model act in this request at all."""
+
+    return bool(body.get("tools")) and body.get("tool_choice") != "none"
+
+
 def request_requires_completion_check(
     body: dict[str, Any], observation: ResponsesCompletionObservation
 ) -> bool:
-    """Use response structure only; never classify natural-language wording."""
+    """Use response structure only; never classify natural-language wording.
+
+    Any text-only final is ambiguous while tools are available: observed turns
+    ended on a progress announcement after a tool result, straight after the
+    user's message, and after Codex's mid-turn compaction, with and without a
+    reasoning item, across unrelated providers and models. What came before
+    the reply therefore decides nothing; the model confirms through the
+    private tool or does the work.
+    """
 
     return bool(
-        body.get("tools")
+        request_allows_completion_check(body)
         and observation.parseable
         and observation.status == "completed"
-        and observation.has_reasoning
         and not observation.has_action
         and observation.visible_text.strip()
         and observation.output
@@ -194,5 +207,6 @@ def completion_check_body(
 __all__ = [
     "ResponsesCompletionObservation",
     "completion_check_body",
+    "request_allows_completion_check",
     "request_requires_completion_check",
 ]

package/ciel_runtime_support/codex_turn_recovery.py

@@ -324,24 +324,58 @@ def message_confirms_completion(message: dict[str, Any]) -> bool:
 def message_requires_completion_check(
     body: dict[str, Any], message: dict[str, Any]
 ) -> bool:
-    """Gate a no-tool reasoning response without inspecting natural language."""
+    """Check a text-only final turn without inspecting natural language.
+
+    While tools are available a visible no-tool reply is ambiguous: it may be
+    the completed answer or merely a progress update. Observed turns ended on
+    such updates after tool results, straight after the user's message, and
+    after compaction, with and without reasoning blocks, on unrelated
+    providers. Let the model confirm through the private tool.
+    """
+
+    tool_choice = body.get("tool_choice")
+    tools_forbidden = (
+        tool_choice.get("type") if isinstance(tool_choice, dict) else tool_choice
+    ) == "none"
+    return bool(
+        body.get("tools")
+        and not tools_forbidden
+        and not message_has_tool_use(message)
+        and message_text(message).strip()
+    )
+
+
+def _retry_still_unfinished(body: dict[str, Any], message: dict[str, Any]) -> bool:
+    """Bound Kimi's loop by structure: reasoning or a trailing tool result."""
+
+    latest_user = next(
+        (
+            item
+            for item in reversed(body.get("messages") or [])
+            if isinstance(item, dict) and item.get("role") == "user"
+        ),
+        {},
+    )
+    latest_content = latest_user.get("content") or []
+    follows_tool_result = isinstance(latest_content, list) and any(
+        isinstance(block, dict) and block.get("type") == "tool_result"
+        for block in latest_content
+    )
 
     return bool(
         body.get("tools")
-        and message_has_reasoning(message)
+        and (message_has_reasoning(message) or follows_tool_result)
         and not message_has_tool_use(message)
         and message_text(message).strip()
     )
 
 
 def _is_kimi_turn(provider: str, body: dict[str, Any]) -> bool:
-    """Identify Kimi across its native and Ollama Cloud provider routes."""
+    """Identify Kimi by model identity across provider transports."""
 
     provider_name = str(provider or "").strip().casefold()
     if provider_name == "kimi":
         return True
-    if provider_name not in {"ollama", "ollama-cloud"}:
-        return False
     model = str(body.get("model") or "").strip().casefold()
     return "kimi-k3" in model
 
@@ -484,6 +518,7 @@ class CodexTurnRecoveryServices:
     should_retry: Callable[[dict[str, Any], str, list[Any]], bool]
     collect_message: Callable[..., dict[str, Any]]
     log: Callable[[str, str], Any]
+    is_plan_mode: Callable[[dict[str, Any]], bool] | None = None
     prepare_reasoning_budget_retry: Callable[
         [str, dict[str, Any], dict[str, Any]],
         tuple[dict[str, Any], dict[str, Any], str],
@@ -523,6 +558,7 @@ def recover_preamble_only_turn(
         not empty_end_turn
         and not repeated_tool_guard
         and not reasoning_only
+        and not (services.is_plan_mode and services.is_plan_mode(body))
         and message_requires_completion_check(body, message)
     )
     if (
@@ -671,7 +707,7 @@ def recover_preamble_only_turn(
 
         retried_text = message_text(retried)
         retryable = services.should_retry(retry_body, retried_text, []) or (
-            kimi_turn and message_requires_completion_check(retry_body, retried)
+            kimi_turn and _retry_still_unfinished(retry_body, retried)
         )
         services.log(
             "WARN" if retryable else "INFO",

package/ciel_runtime_support/compatibility_test.py

@@ -5,7 +5,7 @@ from __future__ import annotations
 import argparse
 from dataclasses import dataclass
 import sys
-from typing import Any, Callable
+from typing import Any, Callable, Mapping
 import urllib.error
 
 
@@ -57,6 +57,7 @@ class CompatibilityTestRequest:
     run_api_key_probes: Callable[..., Any]
     start_router: Callable[..., Any]
     stop_router: Callable[..., Any]
+    compatibility_headers: Callable[[str, dict[str, Any]], Mapping[str, str]]
 
 
 @dataclass(frozen=True, slots=True)
@@ -190,6 +191,7 @@ def run_compatibility_test(
     url = join_url(base, "/v1/messages")
     headers = provider_headers(provider, pcfg)
     headers[COMPATIBILITY_TEST_HEADER] = "1"
+    headers.update(request.compatibility_headers(provider, pcfg))
     if ollama_native:
         headers = {
             "content-type": "application/json",
@@ -367,4 +369,3 @@ def run_compatibility_test(
 
     set_compatibility_cache(cfg, provider, model, True, 200, "text/tool_use/tool_result OK", "")
     print("Compatibility: OK")
-

package/ciel_runtime_support/config_migrations.py

@@ -38,6 +38,50 @@ def apply_config_migrations(cfg: dict[str, Any], *, policy: ConfigMigrationPolic
         migrations = {}
         cfg["migrations"] = migrations
 
+    marker = "openrouter_union_alpha_catalog_20260917"
+    if not migrations.get(marker):
+        providers = cfg.get("providers") if isinstance(cfg.get("providers"), dict) else {}
+        pcfg = providers.get("openrouter")
+        if isinstance(pcfg, dict):
+            custom = pcfg.get("custom_models")
+            if not isinstance(custom, list):
+                custom = []
+                pcfg["custom_models"] = custom
+            known = {
+                normalize_model_id("openrouter", str(model))
+                for model in custom
+                if str(model).strip()
+            }
+            if normalize_model_id("openrouter", "stealth/union-alpha") not in known:
+                custom.append("stealth/union-alpha")
+        migrations[marker] = True
+
+    marker = "openrouter_pareto_catalog_20260917"
+    if not migrations.get(marker):
+        providers = cfg.get("providers") if isinstance(cfg.get("providers"), dict) else {}
+        pcfg = providers.get("openrouter")
+        if isinstance(pcfg, dict):
+            custom = pcfg.get("custom_models")
+            if not isinstance(custom, list):
+                custom = []
+                pcfg["custom_models"] = custom
+            # stealth/union-alpha ended its testing period (404 with a pointer
+            # to unbiased/pareto); replace it in existing catalogs.
+            custom[:] = [
+                model
+                for model in custom
+                if normalize_model_id("openrouter", str(model))
+                != normalize_model_id("openrouter", "stealth/union-alpha")
+            ]
+            known = {
+                normalize_model_id("openrouter", str(model))
+                for model in custom
+                if str(model).strip()
+            }
+            if normalize_model_id("openrouter", "unbiased/pareto") not in known:
+                custom.append("unbiased/pareto")
+        migrations[marker] = True
+
     marker = "meta_muse_spark_13_catalog_20260902"
     if not migrations.get(marker):
         providers = cfg.get("providers") if isinstance(cfg.get("providers"), dict) else {}

package/ciel_runtime_support/provider_request_access.py

@@ -33,9 +33,8 @@ class ProviderRequestAccessPorts:
     ]
     select_api_key: Callable[[str, dict[str, Any]], str | None]
     meaningful_key: Callable[[str], bool]
-    adapter_headers: Callable[
-        [str, dict[str, Any], str | None], Mapping[str, str]
-    ]
+    # Called as (provider, config, key, router_originated=<bool>).
+    adapter_headers: Callable[..., Mapping[str, str]]
     inbound_credentials: Callable[
         [str, Any | None], Mapping[str, str] | None
     ]
@@ -174,7 +173,7 @@ class ProviderRequestAccessService:
         else:
             headers.update(
                 self.ports.adapter_headers(
-                    provider, config, meaningful
+                    provider, config, meaningful, router_originated=not passthrough
                 )
             )
         configured_protocol_headers = self._configured_protocol_headers(

package/ciel_runtime_support/provider_responses_passthrough.py

@@ -11,6 +11,13 @@ from dataclasses import dataclass
 from http.client import IncompleteRead
 from typing import Any, Callable, Mapping
 
+from .codex_completion_gate import (
+    ResponsesCompletionObservation,
+    completion_check_body,
+    request_allows_completion_check,
+    request_requires_completion_check,
+)
+from .codex_turn_recovery import CODEX_COMPLETION_TOOL_NAME
 from .responses_usage_observer import ResponsesUsageObserver
 from .responses_cache_diagnostics import (
     cache_trace,
@@ -59,6 +66,13 @@ class ProviderResponsesPassthroughPorts:
     endpoint: Callable[[str, dict[str, Any], str], str] | None = None
 
 
+@dataclass(frozen=True, slots=True)
+class _BufferedResponsesStream:
+    status: int
+    headers: Any
+    stream: Any
+
+
 class ProviderResponsesPassthrough:
     """Forward Responses without collapsing typed items into another protocol."""
 
@@ -286,8 +300,14 @@ class ProviderResponsesPassthrough:
         upstream_body: dict[str, Any],
         response_tools: Mapping[str, Mapping[str, Any]],
         cache_profile: Mapping[str, Any],
+        *,
+        completion_gate_headers: Mapping[str, str] | None = None,
     ) -> None:
-        """Validate a native Responses stream before exposing it downstream."""
+        """Validate a native Responses stream before exposing it downstream.
+
+        ``completion_gate_headers`` enables the completion check and carries the
+        request headers as built, not as urllib amended them while sending.
+        """
 
         retries = self._stream_truncation_retries(config)
         max_attempts = retries + 1
@@ -300,22 +320,26 @@ class ProviderResponsesPassthrough:
                 pcfg=config,
             ) as response, tempfile.SpooledTemporaryFile(max_size=4 * 1024 * 1024) as spool:
                 usage = ResponsesUsageObserver()
+                completion = ResponsesCompletionObservation()
                 received_bytes = 0
                 read_error: BaseException | None = None
                 try:
                     while chunk := response.read(65_536):
                         received_bytes += len(chunk)
                         usage.feed(chunk)
+                        completion.feed(chunk)
                         spool.write(chunk)
                 except (IncompleteRead, OSError) as exc:
                     partial = bytes(getattr(exc, "partial", b"") or b"")
                     if partial:
                         received_bytes += len(partial)
                         usage.feed(partial)
+                        completion.feed(partial)
                         spool.write(partial)
                     read_error = exc
 
                 observed = usage.finish()
+                completion.finish()
                 stream_expected = bool(upstream_body.get("stream", True))
                 terminal_missing = stream_expected and usage.terminal_event is None
                 if read_error is not None and not terminal_missing:
@@ -354,36 +378,143 @@ class ProviderResponsesPassthrough:
                         received_bytes=received_bytes,
                     ) from failure
 
-                handler.send_response(getattr(response, "status", 200))
-                self._ports.copy_response_headers(
-                    handler,
-                    self._response_headers(
-                        response.headers, transformed=bool(response_tools)
-                    ),
-                )
-                handler.end_headers()
-                spool.seek(0)
-                projector = (
-                    ResponsesCustomToolStreamProjector(response_tools)
-                    if response_tools
-                    else None
-                )
-                while chunk := spool.read(65_536):
-                    output = projector.feed(chunk) if projector is not None else chunk
-                    if output:
-                        handler.wfile.write(output)
-                        handler.wfile.flush()
-                if projector is not None:
-                    tail = projector.finish()
-                    if tail:
-                        handler.wfile.write(tail)
-                        handler.wfile.flush()
                 if observed:
                     observation = usage_with_cache_profile(observed, cache_profile)
                     self._ports.record_usage(provider, model, observation)
                     self._ports.log(*cache_trace(provider, model, observation))
+                continuation = (
+                    self._completion_continuation(
+                        request.full_url,
+                        completion_gate_headers,
+                        provider,
+                        config,
+                        upstream_body,
+                        completion,
+                    )
+                    if completion_gate_headers is not None
+                    else None
+                )
+                try:
+                    chosen = continuation or _BufferedResponsesStream(
+                        int(getattr(response, "status", 200)), response.headers, spool
+                    )
+                    handler.send_response(chosen.status)
+                    self._ports.copy_response_headers(
+                        handler,
+                        self._response_headers(
+                            chosen.headers, transformed=bool(response_tools)
+                        ),
+                    )
+                    handler.end_headers()
+                    chosen.stream.seek(0)
+                    projector = (
+                        ResponsesCustomToolStreamProjector(response_tools)
+                        if response_tools
+                        else None
+                    )
+                    while chunk := chosen.stream.read(65_536):
+                        output = (
+                            projector.feed(chunk) if projector is not None else chunk
+                        )
+                        if output:
+                            handler.wfile.write(output)
+                            handler.wfile.flush()
+                    if projector is not None:
+                        tail = projector.finish()
+                        if tail:
+                            handler.wfile.write(tail)
+                            handler.wfile.flush()
+                finally:
+                    if continuation is not None:
+                        continuation.stream.close()
                 return
 
+    def _completion_continuation(
+        self,
+        url: str,
+        request_headers: Mapping[str, str],
+        provider: str,
+        config: dict[str, Any],
+        upstream_body: dict[str, Any],
+        completion: ResponsesCompletionObservation,
+    ) -> _BufferedResponsesStream | None:
+        """Return the model's next action when a text-only final was unconfirmed.
+
+        The candidate response stays authoritative unless the follow-up is a
+        completed response that performs real work; every failure keeps it.
+        """
+
+        if not request_requires_completion_check(upstream_body, completion):
+            return None
+        model = str(upstream_body.get("model") or "")
+        # The candidate's output items are replayed as input, exactly as Codex
+        # would replay them on its next request, so they need the same repair,
+        # and the forced tool choice must pass the provider's own request rules.
+        data = self._encode(
+            dict(
+                self._ports.normalize_request(
+                    provider,
+                    config,
+                    repair_replayed_response_items(
+                        completion_check_body(upstream_body, completion)
+                    ),
+                )
+            )
+        )
+        headers = dict(request_headers)
+        dump_upstream_request(url, data, self._ports.log, headers=headers)
+        follow_up = urllib.request.Request(
+            url, data=data, headers=headers, method="POST"
+        )
+        stream = tempfile.SpooledTemporaryFile(max_size=4 * 1024 * 1024)
+        try:
+            with self._ports.urlopen(
+                follow_up,
+                timeout=self._ports.timeout_seconds(config),
+                provider=provider,
+                pcfg=config,
+            ) as response:
+                usage = ResponsesUsageObserver()
+                validated = ResponsesCompletionObservation()
+                while chunk := response.read(65_536):
+                    usage.feed(chunk)
+                    validated.feed(chunk)
+                    stream.write(chunk)
+                observed = usage.finish()
+                validated.finish()
+                if observed:
+                    self._ports.record_usage(provider, model, observed)
+                status = int(getattr(response, "status", 200))
+                response_headers = response.headers
+        except Exception as exc:  # noqa: BLE001 - the candidate response must survive
+            stream.close()
+            self._ports.log(
+                "WARN",
+                "provider_responses_completion_gate_failed "
+                f"provider={provider} model={model} error={type(exc).__name__}: {exc}",
+            )
+            return None
+        # A follow-up that names the private tool can never reach the client:
+        # Codex does not know it and would answer with an unknown-tool error.
+        calls_private_tool = any(
+            item.get("name") == CODEX_COMPLETION_TOOL_NAME for item in validated.output
+        )
+        if validated.status == "completed" and validated.has_action and not calls_private_tool:
+            self._ports.log(
+                "WARN",
+                "provider_responses_completion_gate_continued "
+                f"provider={provider} model={model}",
+            )
+            return _BufferedResponsesStream(status, response_headers, stream)
+        stream.close()
+        self._ports.log(
+            "INFO",
+            "provider_responses_completion_gate_kept "
+            f"provider={provider} model={model} "
+            f"confirmed={validated.completion_confirmed} status={validated.status or '-'}",
+        )
+        return None
+
     def forward(
         self,
         handler: Any,
@@ -435,7 +566,16 @@ class ProviderResponsesPassthrough:
             headers=request_headers,
             method="POST",
         )
-        if not remote_bridge and self._stream_truncation_retries(config):
+        # A response that may still need the completion check is held back, as
+        # on the Codex backend route; requests without usable tools keep streaming.
+        completion_gate = (
+            not remote_bridge
+            and bool(upstream_body.get("stream", True))
+            and request_allows_completion_check(upstream_body)
+        )
+        if not remote_bridge and (
+            completion_gate or self._stream_truncation_retries(config)
+        ):
             self._forward_buffered_stream(
                 handler,
                 request,
@@ -444,6 +584,7 @@ class ProviderResponsesPassthrough:
                 upstream_body,
                 response_tools,
                 cache_profile,
+                completion_gate_headers=request_headers if completion_gate else None,
             )
             return delivery_body
         with self._ports.urlopen(

package/ciel_runtime_support/providers/meta.py

@@ -295,6 +295,11 @@ class MetaModelProviderAdapter(HttpBearerProviderAdapter):
         tools = request.get("tools")
         if isinstance(tools, list):
             request["tools"] = [cls._normalize_responses_tool(tool) for tool in tools]
+        # Meta Responses answers 400 "only "auto" is supported for tool_choice"
+        # to "required" and to named function choices; keep the tools usable.
+        tool_choice = request.get("tool_choice")
+        if tool_choice == "required" or isinstance(tool_choice, Mapping):
+            request["tool_choice"] = "auto"
         raw_input = request.get("input")
         if isinstance(raw_input, list):
             request["input"] = [cls._normalize_responses_input(item) for item in raw_input]