alysis-code 0.14.0__tar.gz → 0.14.2__tar.gz

{alysis_code-0.14.0 → alysis_code-0.14.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alysis-code
-Version: 0.14.0
+Version: 0.14.2
 Summary: Local CLI coding agent powered by any API.
 Project-URL: Changelog, https://github.com/AlysisAi/alysis-code/blob/main/docs/CHANGELOG.md
 Project-URL: Documentation, https://github.com/AlysisAi/alysis-code/tree/main/docs

{alysis_code-0.14.0 → alysis_code-0.14.2}/docs/CHANGELOG.md

@@ -6,7 +6,34 @@ Notable user-facing changes to Alysis Code are recorded here. This project follo
 
 ## [Unreleased]
 
-No user-facing changes yet.
+## [0.14.2] - 2026-09-28
+
+### Fixed
+
+- Show only supported reasoning efforts for hosted Luna and clear incompatible
+  settings inherited from another model. Map saved or environment-provided
+  `minimal` and `ultra` settings to `low` and `max`, preventing invalid-effort
+  errors during the free-credit campaign.
+- Preserve the hosted gateway's capacity retry guidance and account request-limit
+  messages so users can distinguish temporary capacity from exhausted credits.
+- Cancel working-tip link clicks when a fast mouse drag arrives before the next
+  screen repaint.
+
+## [0.14.1] - 2026-09-25
+
+### Added
+
+- Add GPT-6 Luna to the Alysis Code account model picker, with hosted Responses
+  routing, configurable reasoning, and stateless function-tool continuation.
+  Luna uses the account's shared credit allowance alongside the Flash models.
+
+### Fixed
+
+- Rebuild the correct chat and compactor transports when switching between hosted
+  Luna and Flash models during a conversation, while preserving the session on a
+  failed switch.
+- Keep hosted web search as a function tool and show the gateway's capacity,
+  request, and credit-limit reasons instead of a generic rate-limit message.
 
 ## [0.14.0] - 2026-09-24
 
@@ -342,7 +369,8 @@ Public launch and repository-layout refresh.
 Release notes for versions before 0.9.8 remain available in the
 [GitHub Releases archive](https://github.com/AlysisAi/alysis-code/releases).
 
-[Unreleased]: https://github.com/AlysisAi/alysis-code/compare/v0.14.0...HEAD
+[Unreleased]: https://github.com/AlysisAi/alysis-code/compare/v0.14.1...HEAD
+[0.14.1]: https://github.com/AlysisAi/alysis-code/compare/v0.14.0...v0.14.1
 [0.14.0]: https://github.com/AlysisAi/alysis-code/compare/v0.13.8...v0.14.0
 [0.13.8]: https://github.com/AlysisAi/alysis-code/compare/v0.13.7...v0.13.8
 [0.13.7]: https://github.com/AlysisAi/alysis-code/compare/v0.13.6.2...v0.13.7

{alysis_code-0.14.0 → alysis_code-0.14.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "alysis-code"
-version = "0.14.0"
+version = "0.14.2"
 description = "Local CLI coding agent powered by any API."
 readme = "README.md"
 requires-python = ">=3.11"

{alysis_code-0.14.0 → alysis_code-0.14.2}/src/alysis_code/__init__.py

@@ -1,3 +1,3 @@
 __all__ = ["__version__"]
 
-__version__ = "0.14.0"
+__version__ = "0.14.2"

{alysis_code-0.14.0 → alysis_code-0.14.2}/src/alysis_code/cli_impl/chat/loop.py

@@ -947,6 +947,8 @@ def _reset_route_local_client_capabilities(client: Any, *, route_changed: bool)
 
 _RELOAD_SESSION_FIELDS = (
     "cfg",
+    "client",
+    "conversation_compactor",
     "routing_mode",
     "max_steps",
     "api_key",
@@ -1093,7 +1095,7 @@ def _apply_config_menu_changes_to_session_mutating(*, session: Any, cfg: AppConf
     )
     from ...llm.cache_capabilities import resolve_effective_cache_capability
     from ...llm.cache_policy import build_prompt_cache_namespace, resolve_prompt_cache_policy
-    from ...llm.factory import _session_routing_headers
+    from ...llm.factory import _session_routing_headers, make_llm_client, resolve_model_protocol
     from ...llm.metadata import (
         build_provider_route_identity,
         credential_scope_fingerprint,
@@ -1125,7 +1127,7 @@ def _apply_config_menu_changes_to_session_mutating(*, session: Any, cfg: AppConf
     )
     active_profile = get_active_profile(session.cfg)
     effective_base_url = resolve_effective_base_url(cfg=session.cfg, profile=active_profile)
-    protocol = str(active_profile.protocol or OPENAI_COMPAT_PROTOCOL).strip()
+    profile_protocol = str(active_profile.protocol or OPENAI_COMPAT_PROTOCOL).strip()
     resolved_key = resolve_api_key(session.cfg)
     session.api_key = str(resolved_key.key or "")
     session.api_key_source = (
@@ -1166,8 +1168,41 @@ def _apply_config_menu_changes_to_session_mutating(*, session: Any, cfg: AppConf
         model: str,
         role: str,
         temperature: float | None = None,
-    ) -> None:
+    ) -> Any:
         existing_route_identity = getattr(client, "route_identity", None)
+        preset = find_preset_for_profile(active_profile)
+        provider_key = str(preset.provider_key or "").strip() if preset is not None else ""
+        if not provider_key:
+            provider_key = resolve_model_provider_key(
+                cfg=session.cfg,
+                model_name=model,
+                base_url=effective_base_url,
+                profile_name=active_profile.name,
+            )
+        protocol = resolve_model_protocol(
+            provider_key=provider_key, model=model, protocol=profile_protocol
+        )
+        existing_protocol = str(getattr(existing_route_identity, "protocol", "") or "")
+        if existing_protocol and existing_protocol != protocol:
+            return make_llm_client(
+                cfg=session.cfg,
+                api_key=session.api_key,
+                model=model,
+                timeout_s=timeout_s,
+                temperature=temperature if temperature is not None else client.temperature,
+                prompt_cache_key=prompt_cache_key,
+                prompt_cache_retention=prompt_cache_retention,
+                prompt_cache_namespace=build_prompt_cache_namespace(
+                    workspace_root=getattr(session, "root", None),
+                    role=role,
+                    profile_name=active_profile.name,
+                ),
+                enable_thinking=enable_thinking,
+                reasoning_effort=reasoning_effort,
+                transport=getattr(client, "_transport", None),
+                profile=active_profile,
+                session_id=provider_session_id,
+            )
         client.base_url = effective_base_url
         if hasattr(client, "provider_auth"):
             client.provider_auth = provider_auth
@@ -1178,17 +1213,10 @@ def _apply_config_menu_changes_to_session_mutating(*, session: Any, cfg: AppConf
         client.timeout_s = timeout_s
         if temperature is not None:
             client.temperature = temperature
-        provider_key = resolve_model_provider_key(
-            cfg=session.cfg,
-            model_name=model,
-            base_url=effective_base_url,
-            profile_name=active_profile.name,
-        )
         capabilities = get_provider_protocol_capabilities(
             provider_key=provider_key,
             protocol=protocol,
         )
-        preset = find_preset_for_profile(active_profile)
         cache_capability = resolve_effective_cache_capability(
             provider_key=provider_key,
             protocol=protocol,
@@ -1331,10 +1359,11 @@ def _apply_config_menu_changes_to_session_mutating(*, session: Any, cfg: AppConf
             client.provider_concurrency_caps = dict(session.cfg.provider_concurrency_caps)
         if hasattr(client, "provider_retry_settings"):
             client.provider_retry_settings = provider_retry_settings
+        return client
 
     client = getattr(session, "client", None)
     if client is not None:
-        _apply_client_config(
+        session.client = _apply_client_config(
             client,
             model=str(session.cfg.model or ""),
             role=ROLE_CODING,
@@ -1353,12 +1382,15 @@ def _apply_config_menu_changes_to_session_mutating(*, session: Any, cfg: AppConf
             )
         except ConfigError:
             compactor_model = str(session.cfg.model or "")
-        _apply_client_config(
+        refreshed_compactor_client = _apply_client_config(
             compactor_client,
             model=compactor_model,
             role=ROLE_COMPACTOR,
             temperature=resolve_role_temperature(session.cfg, role=ROLE_COMPACTOR),
         )
+        if refreshed_compactor_client is not compactor_client:
+            session.conversation_compactor = copy.copy(compactor)
+            session.conversation_compactor.compactor_client = refreshed_compactor_client
 
     _rebuild_session_tools_for_mode(
         session=session,

{alysis_code-0.14.0 → alysis_code-0.14.2}/src/alysis_code/cli_impl/config_menu.py

@@ -492,7 +492,7 @@ class ConfigMenuState:
         """Drop a stale effort inherited from another provider/model surface."""
 
         preset = _active_preset(self)
-        if preset is None or preset.key not in {"nvidia", "zai-coding-plan"}:
+        if preset is None or preset.key not in {"alysis", "nvidia", "zai-coding-plan"}:
             return
         allowed = _thinking_labels_for_state(
             self,
@@ -3674,7 +3674,7 @@ def _thinking_labels_for_state(
         if preset_key == "nvidia" and contract is UNKNOWN_CONTRACT:
             return ("auto",)
         current = _normalize_thinking_label(state.thinking_label)
-        if preset_key in {"nvidia", "zai-coding-plan"}:
+        if preset_key in {"alysis", "nvidia", "zai-coding-plan"}:
             # A global effort may have been saved for the previously active
             # provider. Do not preserve an invalid value merely because it is
             # current; these controls are exact per hosted model and surface.

{alysis_code-0.14.0 → alysis_code-0.14.2}/src/alysis_code/cli_impl/tui/app.py

@@ -59,6 +59,7 @@ from prompt_toolkit.layout.controls import FormattedTextControl, UIContent, UICo
 from prompt_toolkit.layout.dimension import D
 from prompt_toolkit.layout.margins import ScrollbarMargin
 from prompt_toolkit.layout.menus import CompletionsMenu
+from prompt_toolkit.layout.mouse_handlers import MouseHandlers
 from prompt_toolkit.layout.processors import Processor, Transformation
 from prompt_toolkit.layout.utils import explode_text_fragments
 from prompt_toolkit.mouse_events import MouseButton, MouseEvent, MouseEventType
@@ -2646,6 +2647,7 @@ def run_tui(
         "step": None,
         "generation": 0,
         "worker_generation": None,
+        "early_mouse_handlers": None,
     }
 
     def _safe_invalidate() -> None:
@@ -2660,11 +2662,30 @@ def run_tui(
             tip_link_press = None
         drag_capture["generation"] += 1
         drag_capture.update({"target": target, "direction": 0, "step": step})
+        if target == "tip_link":
+            # A whole press/drag/release can arrive in one input batch, before
+            # the capture float repaints. Capture those events immediately too.
+            application = get_app()
+            renderer = application.renderer
+            previous = renderer.mouse_handlers
+            captured = MouseHandlers()
+            size = application.output.get_size()
+            captured.set_mouse_handler_for_range(
+                0, size.columns, 0, size.rows, _tip_link_mouse_event
+            )
+            renderer.mouse_handlers = captured
+            drag_capture["early_mouse_handlers"] = (renderer, previous, captured)
         _safe_invalidate()
 
     def _stop_drag_capture() -> None:
         nonlocal tip_link_press
         tip_link_press = None
+        early_handlers = drag_capture.pop("early_mouse_handlers", None)
+        if early_handlers is not None:
+            renderer, previous, captured = early_handlers
+            # A repaint installs its own capture map; never restore over it.
+            if renderer.mouse_handlers is captured:
+                renderer.mouse_handlers = previous
         if drag_capture["target"] is None:
             return
         drag_capture["generation"] += 1

{alysis_code-0.14.0 → alysis_code-0.14.2}/src/alysis_code/llm/factory.py

@@ -126,6 +126,7 @@ def make_llm_client(
             base_url=base_url,
             profile_name=resolved_profile.name,
         )
+    protocol = resolve_model_protocol(provider_key=provider_key, model=model, protocol=protocol)
     capabilities = get_provider_protocol_capabilities(
         provider_key=provider_key,
         protocol=protocol,
@@ -376,6 +377,13 @@ def make_llm_client(
     )
 
 
+def resolve_model_protocol(*, provider_key: str | None, model: str, protocol: str) -> str:
+    """Resolve model-specific transports for initial connections and live switches."""
+    if provider_key == "alysis" and model == "gpt-6-luna":
+        return OPENAI_RESPONSES_PROTOCOL
+    return protocol
+
+
 def _attach_reasoning_trace_capability(client: ChatClient, capability: object) -> ChatClient:
     """Expose the resolved trace dialect without widening every client constructor."""
 

{alysis_code-0.14.0 → alysis_code-0.14.2}/src/alysis_code/llm/openai_compat.py

@@ -1329,8 +1329,9 @@ _ALYSIS_PROXY_ERROR_MESSAGES: dict[str, str] = {
         "You're sending requests too quickly. Please wait a moment and try again."
     ),
     "hosted_capacity_exceeded": (
-        "Hosted model capacity is full. Please retry in a few seconds. "
-        "No generation was started and your reserved credits were released."
+        "The Alysis hosted model is unavailable or at capacity. "
+        "If this persists, its server route needs checking. "
+        "No generation was started and no credits were charged."
     ),
     "hosted_routing_unavailable": (
         "Hosted model routing is temporarily unavailable. Please retry shortly. "
@@ -1361,6 +1362,12 @@ def alysis_trial_error_message(err: LLMError) -> str | None:
     # and reservation budget in its message, while retaining the OpenAI error code.
     # Preserve that explanation instead of mislabeling every limit as excess RPM.
     message = error.get("message")
+    if (
+        code == "hosted_capacity_exceeded"
+        and isinstance(message, str)
+        and message.startswith("Hosted model capacity is busy. Retry in ")
+    ):
+        return message[:2048]
     if (
         code == "rate_limit_exceeded"
         and isinstance(message, str)
@@ -1369,7 +1376,10 @@ def alysis_trial_error_message(err: LLMError) -> str | None:
                 "5-hour fair-use limit reached (",
                 "Weekly fair-use limit reached (",
                 "Four hosted requests are already running for your account.",
+                "Your account has reached its hosted request limit.",
+                "Your account has reached the 20 requests per minute limit.",
                 "Available credits cannot cover this request while other usage or reservations apply.",
+                "Your available credit allowance is exhausted.",
             )
         )
     ):

{alysis_code-0.14.0 → alysis_code-0.14.2}/src/alysis_code/llm/openai_responses.py

@@ -35,6 +35,7 @@ from .metadata import (
     merge_canonical_headers,
     stamp_response_for_route,
 )
+from .protocols import OPENAI_RESPONSES_PROTOCOL, get_provider_protocol_capabilities
 from .provider_limits import (
     DEFAULT_PROVIDER_CONCURRENCY_CAPS,
     ProviderRetrySettings,
@@ -867,6 +868,7 @@ def _responses_tools(
     *,
     mode: str,
     adapter: str,
+    provider_key: str | None = None,
 ) -> _ResponsesToolMapping:
     normalized_mode = str(mode or "off").strip().lower()
     normalized_adapter = (
@@ -874,8 +876,26 @@ def _responses_tools(
     )
     raw_tools = [tool for tool in tools or [] if isinstance(tool, dict)]
     alysis_web_search_present = any(_is_alysis_web_search_function(tool) for tool in raw_tools)
+    capabilities = get_provider_protocol_capabilities(
+        provider_key=provider_key or "", protocol=OPENAI_RESPONSES_PROTOCOL
+    )
+    builtin_web_search_allowed = (
+        capabilities is None or capabilities.supports_provider_hosted_web_search_adapter
+    )
+    hosted_web_search_present = any(
+        _is_responses_hosted_web_search_tool(tool) for tool in raw_tools
+    )
+    if not builtin_web_search_allowed and (
+        (normalized_mode == "native" and alysis_web_search_present)
+        or (normalized_mode in {"auto", "native"} and hosted_web_search_present)
+    ):
+        raise LLMError(
+            f"Provider {provider_key!r} does not support built-in web search. "
+            "Use web_search_mode='auto' or 'external' with the Alysis web_search function."
+        )
     use_openai_builtin_web_search = (
-        alysis_web_search_present
+        builtin_web_search_allowed
+        and alysis_web_search_present
         and _openai_builtin_web_search_allowed(
             mode=normalized_mode,
             adapter=normalized_adapter,
@@ -1004,9 +1024,15 @@ def _responses_reasoning(
     enable_thinking: bool | None,
     reasoning_effort: str | None,
     request_summary: bool = False,
+    provider_key: str | None = None,
+    model: str | None = None,
 ) -> dict[str, Any] | None:
     reasoning: dict[str, Any] = {}
     effort = str(reasoning_effort or "").strip().lower()
+    if provider_key == "alysis" and model == "gpt-6-luna":
+        # Older hosted pickers exposed the generic Responses efforts. Preserve
+        # saved configs and environment overrides at Luna's supported bounds.
+        effort = {"minimal": "low", "ultra": "max"}.get(effort, effort)
     if effort:
         if effort not in _RESPONSES_REASONING_EFFORTS:
             raise LLMError(f"OpenAI Responses reasoning_effort is not supported: {effort}")
@@ -1916,12 +1942,16 @@ class OpenAIResponsesClient:
             )
         error_message = _extract_error_message(data)
         if error_message:
-            return LLMError(
+            err = LLMError(
                 sanitize_error_text_for_output(f"LLM error {response.status_code}: {error_message}")
             )
-        return LLMError(
-            sanitize_error_text_for_output(f"LLM error {response.status_code}: {data!r}")
-        )
+        else:
+            err = LLMError(
+                sanitize_error_text_for_output(f"LLM error {response.status_code}: {data!r}")
+            )
+        err.provider_status_code = response.status_code
+        err.provider_error_body = sanitize_error_text_for_output(json.dumps(data))
+        return err
 
     def count_input_tokens(
         self,
@@ -1940,6 +1970,7 @@ class OpenAIResponsesClient:
             tools,
             mode=self.web_search_mode,
             adapter=self.web_search_adapter,
+            provider_key=self.provider_key,
         )
         payload: dict[str, Any] = {
             "model": self.model,
@@ -2080,6 +2111,7 @@ class OpenAIResponsesClient:
             tools,
             mode=self.web_search_mode,
             adapter=self.web_search_adapter,
+            provider_key=self.provider_key,
         )
         mapped_tools = tool_mapping.tools
         temp_omit_key = _responses_temperature_omit_key(self.base_url, self.model)
@@ -2089,6 +2121,8 @@ class OpenAIResponsesClient:
             enable_thinking=self.enable_thinking,
             reasoning_effort=self.reasoning_effort,
             request_summary=self._should_request_reasoning_summary(),
+            provider_key=self.provider_key,
+            model=self.model,
         )
         documented_temperature_reason = documented_temperature_omit_reason(
             self.model,
@@ -2106,6 +2140,10 @@ class OpenAIResponsesClient:
         supports_previous_response_id = self.provider_auth is None or bool(
             getattr(self.provider_auth, "supports_previous_response_id", True)
         )
+        if self.provider_key == "alysis":
+            # Hosted credits meter the complete request. Shared upstream storage
+            # must never be addressable by another Alysis account.
+            supports_previous_response_id = False
         if continuation is not None and supports_previous_response_id:
             # With previous_response_id the API appends the sent input items to the
             # stored thread; system/developer messages from turn 1 are already
@@ -2175,6 +2213,10 @@ class OpenAIResponsesClient:
                 payload["stream"] = True
             if self.provider_auth is not None:
                 payload = self.provider_auth.adapt_responses_payload(payload)
+            if self.provider_key == "alysis":
+                payload["store"] = False
+                payload["include"] = ["reasoning.encrypted_content"]
+                payload.pop("temperature", None)
             if self._reasoning_summary_support_by_model.get(reasoning_summary_support_key) is False:
                 _without_responses_reasoning_summary(payload)
             return payload

{alysis_code-0.14.0 → alysis_code-0.14.2}/src/alysis_code/llm/protocols.py

@@ -383,6 +383,30 @@ PROVIDER_PROTOCOL_CAPABILITIES: tuple[ProviderProtocolCapabilities, ...] = (
         reports_cache_write_tokens=True,
         quirks=("Native OpenAI Responses chat supports buffered and SSE streaming responses.",),
     ),
+    ProviderProtocolCapabilities(
+        provider_key="alysis",
+        protocol=OPENAI_RESPONSES_PROTOCOL,
+        reasoning_trace=ReasoningTraceCapability(
+            adapter="openai_responses_summary",
+            output_kind=ReasoningOutputKind.SUMMARY,
+            supports_streaming=True,
+            supports_buffered=True,
+            requestable=True,
+            continuation_state="opaque",
+        ),
+        usage_contract=UsageContract(
+            response_usage_confidence=UsageConfidence.AUTHORITATIVE,
+            input_token_count_strategy="none",
+        ),
+        supports_streaming=True,
+        supports_tool_calling=True,
+        supports_structured_outputs=True,
+        supports_provider_hosted_web_search_adapter=False,
+        default_web_search_adapter="none",
+        reports_cache_read_tokens=True,
+        reports_cache_write_tokens=True,
+        quirks=("Hosted Luna supports stateless text and function tools with shared credits.",),
+    ),
     ProviderProtocolCapabilities(
         provider_key="anthropic",
         protocol=OPENAI_COMPAT_PROTOCOL,

{alysis_code-0.14.0 → alysis_code-0.14.2}/src/alysis_code/model_registry.py

@@ -1577,6 +1577,22 @@ _OFFICIAL_PROVIDER_MODEL_METADATA["alysis"]["glm-5.3-flash"] = {
     "output_cost_per_token": 0.0000005,
 }
 
+_PROVIDER_CANONICAL_MODEL_IDS["alysis"]["gpt-6-luna"] = "gpt-6-luna"
+_OFFICIAL_PROVIDER_MODEL_SOURCES["alysis"]["gpt-6-luna"] = (
+    "https://developers.openai.com/api/docs/models/gpt-6-luna",
+    "https://developers.openai.com/api/docs/pricing",
+)
+_OFFICIAL_PROVIDER_MODEL_METADATA["alysis"]["gpt-6-luna"] = {
+    "context_window_tokens": 1_050_000,
+    "max_output_tokens": 128_000,
+    "supports_vision": False,
+    "supports_reasoning": True,
+    "input_cost_per_token": 0.0000001,
+    "cache_read_input_cost_per_token": 0.00000001,
+    "cache_creation_input_cost_per_token": 0.000000125,
+    "output_cost_per_token": 0.0000005,
+}
+
 _BUILT_IN_MODEL_METADATA: dict[str, dict[str, Any]] = {
     "deepseek-chat": {
         "context_window_tokens": 1_000_000,

{alysis_code-0.14.0 → alysis_code-0.14.2}/src/alysis_code/profile_presets.py

@@ -1767,8 +1767,10 @@ PROFILE_PRESETS: tuple[ProfilePreset, ...] = (
         model_choices=(
             ReviewedModel("deepseek-flash", "deepseek-expanded"),
             ReviewedModel("glm-5.3-flash", "glm-normal"),
+            ReviewedModel("gpt-6-luna", "gpt-expanded"),
         ),
         suggested_model_descriptions={
+            "gpt-6-luna": "GPT-6 Luna - efficient coding and reasoning, included with free credits",
             "deepseek-flash": (
                 "DeepSeek V4.1 Flash - vision and reasoning, 1M context, included with free credits"
             ),
@@ -1785,7 +1787,7 @@ PROFILE_PRESETS: tuple[ProfilePreset, ...] = (
             "deepseek-v4.1-flash-expires-on-0910": "deepseek-flash",
         },
         setup_warning="Run `alysis login` to connect your Alysis account and use free credits.",
-        notes="DeepSeek V4.1 Flash and GLM 5.3 Flash with free credits. Authenticate with `alysis login`.",
+        notes="DeepSeek V4.1 Flash, GLM 5.3 Flash, and GPT-6 Luna with free credits. Authenticate with `alysis login`.",
     ),
     ProfilePreset(
         key="ollama",

{alysis_code-0.14.0 → alysis_code-0.14.2}/src/alysis_code/reasoning_contracts.py

@@ -88,6 +88,7 @@ def reasoning_labels_allowed_by_contract(
         return list(labels)
     effort_wires = {
         WIRE_REASONING_EFFORT,
+        WIRE_REASONING_OBJECT,
         WIRE_THINKING_LEVEL,
         WIRE_THINKING_ADAPTIVE,
     }
@@ -355,6 +356,17 @@ _CONTRACTS: dict[str, tuple[tuple[str, ReasoningContract], ...]] = {
     ),
     # Hosted models retain their upstream reasoning and replay contracts.
     "alysis": (
+        (
+            "gpt-6-luna",
+            _C(
+                mode=OPTIONAL,
+                wire=WIRE_REASONING_OBJECT,
+                values=("none", "low", "medium", "high", "xhigh", "max"),
+                default="medium",
+                off=OFF_EXPLICIT,
+                notes="hosted Responses with full stateless reasoning and function-tool replay",
+            ),
+        ),
         (
             "deepseek-",
             _C(