alysis-code 0.14.1__tar.gz → 0.14.3__tar.gz

{alysis_code-0.14.1 → alysis_code-0.14.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alysis-code
-Version: 0.14.1
+Version: 0.14.3
 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.1 → alysis_code-0.14.3}/docs/CHANGELOG.md

@@ -6,6 +6,44 @@ Notable user-facing changes to Alysis Code are recorded here. This project follo
 
 ## [Unreleased]
 
+## [0.14.3] - 2026-09-29
+
+### Added
+
+- Add Claude Sonnet 5.5 to the Alysis account model picker, using native Messages
+  transport, streaming, signed reasoning and tool continuation, and the shared
+  hosted credit allowance.
+
+### Changed
+
+- Default hosted accounts to automatic prompt caching. Migrate legacy Manual
+  settings only when their other cache settings match the old defaults; preserve
+  Off, customized settings, and subsequent explicit choices.
+- Use five-minute cache controls for hosted Sonnet and provider-managed caching
+  for hosted DeepSeek, GLM, and Luna. See the
+  [caching guide](hosted-prompt-caching.md) for migration details and controls.
+
+### Fixed
+
+- Resolve cache previews and diagnostics using each model's actual protocol,
+  preserve hosted credit-limit error details, and report Sonnet reasoning usage
+  without counting it twice.
+- Honor the configured HTTP MCP startup timeout for initialization acknowledgements.
+  Report MCP startup errors once and exit cleanly without retrying through classic chat.
+
+## [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

{alysis_code-0.14.1 → alysis_code-0.14.3}/pyproject.toml

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

{alysis_code-0.14.1 → alysis_code-0.14.3}/src/alysis_code/__init__.py

@@ -1,3 +1,3 @@
 __all__ = ["__version__"]
 
-__version__ = "0.14.1"
+__version__ = "0.14.3"

{alysis_code-0.14.1 → alysis_code-0.14.3}/src/alysis_code/cli_impl/chat/loop.py

@@ -18,6 +18,7 @@ from ...cancellation import InteractiveCancellationToken
 from ...compaction.conversation_compactor import CompactionState
 from ...error_text import sanitize_error_text_for_output
 from ...failure_category import exit_code_for_failure
+from ...mcp.errors import McpError
 from ...personas import (
     DEFAULT_PERSONA,
     get_persona,
@@ -3738,6 +3739,10 @@ def chat(
                             )
                         except Exception:
                             pass
+                    if isinstance(_tui_exc, McpError):
+                        # Rebuilding the same MCP session in classic chat cannot
+                        # repair a server startup failure. Report it once below.
+                        raise
                     console.print(
                         f"[yellow]TUI unavailable ({_tui_exc}); using classic chat.[/yellow]"
                     )
@@ -3865,6 +3870,9 @@ def chat(
     except ConfigError as e:
         console.print(f"[red]Config error:[/red] {e}")
         raise typer.Exit(code=2) from e
+    except McpError as e:
+        console.print(f"MCP error: {sanitize_error_text_for_output(e)}", style="red", markup=False)
+        raise typer.Exit(code=1) from e
     except WorkspaceBindingError as e:
         console.print(f"[red]Workspace error:[/red] {e}")
         raise typer.Exit(code=1) from e

{alysis_code-0.14.1 → alysis_code-0.14.3}/src/alysis_code/cli_impl/config_menu.py

@@ -63,6 +63,7 @@ from ..profile_presets import (
 from ..profiles import (
     SUBSCRIPTION_SELECTION_REQUIRED_KEY,
     ProfileSpec,
+    apply_hosted_prompt_cache_defaults,
     get_active_profile,
     list_profiles,
     set_active_profile,
@@ -226,6 +227,10 @@ class ConfigMenuState:
     subscription_selection_required: bool = False
     default_workspace_path: str = ""
     thinking_label_explicitly_set: bool = field(default=False, repr=False)
+    hosted_prompt_cache_defaults_applied: bool = False
+    prompt_cache_mode_explicitly_set: bool = field(default=False, repr=False)
+    cache_prompt_key_enabled: bool = True
+    cache_keepalive_enabled: bool = False
     _subscription_models_cache: tuple[Any, ...] = field(default=(), repr=False)
     _subscription_models_loaded: bool = field(default=False, repr=False)
     _provider_models_cache_identity: tuple[str, ...] | None = field(default=None, repr=False)
@@ -236,6 +241,7 @@ class ConfigMenuState:
 
     @classmethod
     def from_cfg(cls, cfg: AppConfig) -> ConfigMenuState:
+        apply_hosted_prompt_cache_defaults(cfg, get_active_profile(cfg))
         warnings: list[str] = []
         try:
             resolved_key = resolve_api_key(cfg)
@@ -363,6 +369,9 @@ class ConfigMenuState:
             default_workspace_path=default_workspace_path,
         )
         state._normalize_provider_thinking_label()
+        state.hosted_prompt_cache_defaults_applied = cfg.hosted_prompt_cache_defaults_applied
+        state.cache_prompt_key_enabled = cfg.cache.prompt_cache_key_enabled
+        state.cache_keepalive_enabled = cfg.cache.keepalive_enabled
         state._original = state.snapshot()
         return state
 
@@ -394,6 +403,8 @@ class ConfigMenuState:
             "clear_stored_key_confirmed": self.clear_stored_key_confirmed,
             "clear_stored_key_profile": self.clear_stored_key_profile,
             "thinking_label_explicitly_set": self.thinking_label_explicitly_set,
+            "hosted_prompt_cache_defaults_applied": self.hosted_prompt_cache_defaults_applied,
+            "prompt_cache_mode_explicitly_set": self.prompt_cache_mode_explicitly_set,
             "subscription_selection_required": self.subscription_selection_required,
         }
 
@@ -439,6 +450,12 @@ class ConfigMenuState:
         self.thinking_label_explicitly_set = bool(
             self._original.get("thinking_label_explicitly_set", False)
         )
+        self.hosted_prompt_cache_defaults_applied = bool(
+            self._original.get("hosted_prompt_cache_defaults_applied", False)
+        )
+        self.prompt_cache_mode_explicitly_set = bool(
+            self._original.get("prompt_cache_mode_explicitly_set", False)
+        )
         self.refresh_api_key_status()
 
     def set_field(self, name: str, value: str) -> None:
@@ -473,6 +490,16 @@ class ConfigMenuState:
         }:
             raise KeyError(f"Unknown config menu field: {name}")
         self.fields[key] = str(value)
+        if key in {
+            "prompt_cache_mode",
+            "prompt_cache_key",
+            "prompt_cache_retention",
+            "anthropic_prompt_cache_enabled",
+            "anthropic_prompt_cache_ttl",
+        }:
+            self.hosted_prompt_cache_defaults_applied = True
+        if key == "prompt_cache_mode":
+            self.prompt_cache_mode_explicitly_set = True
         if key == "model":
             profile = _active_subscription_profile(self)
             if profile is not None and str(value).strip() != profile.default_model:
@@ -492,7 +519,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,
@@ -646,6 +673,10 @@ class ConfigMenuState:
         self._provider_models_cache = ()
         self._provider_model_catalog_warning = ""
         profile = ProfileSpec.from_dict(profile_name, self.profiles[profile_name])
+        cache_cfg = self._resolution_cfg()
+        if apply_hosted_prompt_cache_defaults(cache_cfg, profile):
+            self.fields["prompt_cache_mode"] = cache_cfg.prompt_cache_mode
+            self.hosted_prompt_cache_defaults_applied = True
         if profile.base_url:
             self.fields["base_url"] = profile.base_url
         if profile.auth_provider:
@@ -763,6 +794,11 @@ class ConfigMenuState:
             prompt_cache_mode=_normalize_prompt_cache_mode(
                 self.fields.get("prompt_cache_mode", "manual")
             ),
+            hosted_prompt_cache_defaults_applied=self.hosted_prompt_cache_defaults_applied,
+            cache={
+                "prompt_cache_key_enabled": self.cache_prompt_key_enabled,
+                "keepalive_enabled": self.cache_keepalive_enabled,
+            },
             prompt_cache_key=str(self.fields.get("prompt_cache_key", "") or ""),
             prompt_cache_retention=str(self.fields.get("prompt_cache_retention", "") or ""),
             anthropic_prompt_cache_enabled=_normalize_bool_text(
@@ -813,6 +849,7 @@ class ConfigMenuState:
             )
 
         changes: dict[str, Any] = {}
+        cfg.hosted_prompt_cache_defaults_applied = self.hosted_prompt_cache_defaults_applied
 
         execution = getattr(cfg, "execution", None)
         if execution is None:
@@ -930,7 +967,10 @@ class ConfigMenuState:
         desired_cache_mode = _normalize_prompt_cache_mode(
             self.fields.get("prompt_cache_mode", "manual")
         )
-        if str(getattr(cfg, "prompt_cache_mode", "") or "manual") != desired_cache_mode:
+        if (
+            str(getattr(cfg, "prompt_cache_mode", "") or "manual") != desired_cache_mode
+            or self.prompt_cache_mode_explicitly_set
+        ):
             set_config_value(cfg, "prompt_cache_mode", desired_cache_mode)
             changes["prompt_cache_mode"] = desired_cache_mode
 
@@ -1415,8 +1455,12 @@ def _cache_summary_text(state: ConfigMenuState) -> str:
     if mode == "off":
         return f"cache off · {policy_summary} · {compaction}"
     if mode == "auto":
-        ttl = _normalize_anthropic_prompt_cache_ttl(
-            state.fields.get("anthropic_prompt_cache_ttl", "5m")
+        ttl = (
+            policy.anthropic_cache_control_ttl
+            if policy is not None
+            else _normalize_anthropic_prompt_cache_ttl(
+                state.fields.get("anthropic_prompt_cache_ttl", "5m")
+            )
         )
         return f"auto · {policy_summary} · Anthropic TTL {ttl} · {compaction}"
 
@@ -1474,7 +1518,13 @@ def _effective_cache_capability_for_state(
             )
             or preview_profile.name
         )
-        protocol = str(preview_profile.protocol or OPENAI_COMPAT_PROTOCOL).strip()
+        from ..llm.factory import resolve_model_protocol
+
+        protocol = resolve_model_protocol(
+            provider_key=provider_key,
+            model=model,
+            protocol=str(preview_profile.protocol or OPENAI_COMPAT_PROTOCOL).strip(),
+        )
         capabilities = get_provider_protocol_capabilities(
             provider_key=provider_key,
             protocol=protocol,
@@ -1532,7 +1582,13 @@ def _resolved_cache_policy_with_error_for_state(
             )
             or profile.name
         )
-        protocol = str(profile.protocol or OPENAI_COMPAT_PROTOCOL).strip()
+        from ..llm.factory import resolve_model_protocol
+
+        protocol = resolve_model_protocol(
+            provider_key=provider_key,
+            model=model,
+            protocol=str(profile.protocol or OPENAI_COMPAT_PROTOCOL).strip(),
+        )
         capabilities = get_provider_protocol_capabilities(
             provider_key=provider_key,
             protocol=protocol,
@@ -3674,7 +3730,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.1 → alysis_code-0.14.3}/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.1 → alysis_code-0.14.3}/src/alysis_code/cli_impl/tui/config_flow.py

@@ -406,9 +406,9 @@ _THINKING_DESCRIPTIONS = {
     "auto": "let the provider decide",
 }
 _CACHE_MODE_DESCRIPTIONS = {
-    "auto": "derive provider-aware cache settings when supported",
+    "auto": "use supported provider caching; default for Alysis hosted models",
     "manual": "use the manual key/retention below when supported",
-    "off": "disable prompt caching",
+    "off": "disable optional client cache controls",
 }
 _CACHE_TTL_DESCRIPTIONS = {
     "5m": "lower lifetime; safest default",

{alysis_code-0.14.1 → alysis_code-0.14.3}/src/alysis_code/config.py

@@ -699,6 +699,9 @@ class AppConfig(BaseModel):
     session_log_dir: str | None = None
     crash_diagnostic_log_path: str | None = None
     prompt_cache_mode: str = "manual"
+    # Hosted defaults are applied once when an Alysis profile is selected/loaded.
+    # Explicit cache choices also set this marker, including reselecting Manual.
+    hosted_prompt_cache_defaults_applied: bool = False
     prompt_cache_key: str | None = None
     prompt_cache_retention: str | None = None
     anthropic_prompt_cache_enabled: bool = False
@@ -3624,22 +3627,27 @@ def set_config_value(
 
     if key == "prompt_cache_mode":
         cfg.prompt_cache_mode = _normalize_prompt_cache_mode(value, key=key)
+        cfg.hosted_prompt_cache_defaults_applied = True
         return cfg
 
     if key == "prompt_cache_key":
         cfg.prompt_cache_key = value.strip() or None
+        cfg.hosted_prompt_cache_defaults_applied = True
         return cfg
 
     if key == "prompt_cache_retention":
         cfg.prompt_cache_retention = value.strip() or None
+        cfg.hosted_prompt_cache_defaults_applied = True
         return cfg
 
     if key == "anthropic_prompt_cache_enabled":
         cfg.anthropic_prompt_cache_enabled = _coerce_bool(value, key=key)
+        cfg.hosted_prompt_cache_defaults_applied = True
         return cfg
 
     if key == "anthropic_prompt_cache_ttl":
         cfg.anthropic_prompt_cache_ttl = _normalize_anthropic_prompt_cache_ttl(value, key=key)
+        cfg.hosted_prompt_cache_defaults_applied = True
         return cfg
 
     if key == "verify_commands":

{alysis_code-0.14.1 → alysis_code-0.14.3}/src/alysis_code/llm/anthropic_messages.py

@@ -237,6 +237,12 @@ def _anthropic_thinking_plan(
         raise LLMError(f"Anthropic Messages reasoning_effort is not supported: {effort}")
 
     if enable_thinking is False or effort == "none":
+        if _claude_model_version(model) == _ClaudeModelVersion("sonnet", 5, 5):
+            # Sonnet 5.5 replaces disabled with between_tools. This mode still
+            # produces signed progress blocks and never accepts forced tools.
+            return _AnthropicThinkingPlan(
+                config={"type": "between_tools"}, output_effort="high", active=True
+            )
         if not _supports_disabled_thinking(model):
             raise LLMError(f"Anthropic model {model!r} does not support disabling thinking")
         # output_effort stays None on purpose: Opus 5 accepts disabled thinking
@@ -494,12 +500,22 @@ def _anthropic_tools(
     *,
     mode: str,
     adapter: str,
+    provider_key: str | None = None,
 ) -> _AnthropicToolMapping:
     normalized_mode = str(mode or "off").strip().lower()
     normalized_adapter = (
         str(adapter or AUTO_WEB_SEARCH_ADAPTER).strip().lower() or AUTO_WEB_SEARCH_ADAPTER
     )
     raw_tools = [tool for tool in tools or [] if isinstance(tool, dict)]
+    if provider_key == "alysis":
+        if normalized_mode == "native" or any(
+            _is_anthropic_hosted_web_search_tool(tool) for tool in raw_tools
+        ):
+            raise LLMError(
+                "Hosted Sonnet does not support built-in web search; use external search"
+            )
+        if normalized_mode == "auto":
+            normalized_mode = "external"
     alysis_web_search_present = any(_is_alysis_web_search_function(tool) for tool in raw_tools)
     use_builtin_web_search = alysis_web_search_present and _anthropic_builtin_web_search_allowed(
         mode=normalized_mode,
@@ -970,6 +986,12 @@ def _parse_usage(raw: Any) -> LLMUsage | None:
 
     input_tokens = _as_non_negative_int(raw.get("input_tokens"))
     output_tokens = _as_non_negative_int(raw.get("output_tokens"))
+    output_details = raw.get("output_tokens_details")
+    reasoning_tokens = (
+        _as_non_negative_int(output_details.get("thinking_tokens"))
+        if isinstance(output_details, dict)
+        else None
+    )
     cache_read_input_tokens = _as_non_negative_int(raw.get("cache_read_input_tokens"))
     cache_creation = raw.get("cache_creation")
     cache_creation_5m_input_tokens: int | None = None
@@ -1013,6 +1035,8 @@ def _parse_usage(raw: Any) -> LLMUsage | None:
         cache_creation_input_tokens=cache_creation_input_tokens,
         cache_creation_5m_input_tokens=cache_creation_5m_input_tokens,
         cache_creation_1h_input_tokens=cache_creation_1h_input_tokens,
+        # Anthropic output_tokens already includes thinking; this is a subset.
+        reasoning_tokens=reasoning_tokens,
         raw_provider_usage=copy.deepcopy(raw),
     )
 
@@ -1472,6 +1496,9 @@ class AnthropicMessagesClient:
         self.base_url = base_url.rstrip("/")
         self.api_key = api_key
         self.model = model
+        self.supports_forced_tool_choice = _claude_model_version(model) != _ClaudeModelVersion(
+            "sonnet", 5, 5
+        )
         self.timeout_s = timeout_s
         self.temperature = temperature
         self.prompt_cache_key = str(prompt_cache_key or "").strip() or None
@@ -1523,7 +1550,11 @@ class AnthropicMessagesClient:
     def _headers(self) -> dict[str, str]:
         headers = merge_canonical_headers(
             {
-                "x-api-key": self.api_key,
+                **(
+                    {"Authorization": "Bearer " + self.api_key}
+                    if self.provider_key == "alysis"
+                    else {"x-api-key": self.api_key}
+                ),
                 "anthropic-version": _DEFAULT_ANTHROPIC_VERSION,
                 "Content-Type": "application/json",
                 "User-Agent": "alysis-code/0.1.0",
@@ -1534,23 +1565,29 @@ class AnthropicMessagesClient:
 
     @staticmethod
     def _llm_error_from_response(response: httpx.Response) -> LLMError:
+        # Keep the structured envelope for shared error presentation. Extracting
+        # only the message loses hosted credit/RPM codes and mislabels all 429s
+        # as provider throttling. Preserve the existing readable exception text.
+        safe_body = sanitize_error_text_for_output(response.text)
         try:
             data = response.json()
         except Exception:
-            body = response.text
+            body = safe_body
             if len(body) > 1000:
                 body = body[:1000] + "...(truncated)"
-            return LLMError(
-                sanitize_error_text_for_output(f"LLM error {response.status_code}: {body}")
-            )
-        error_message = _extract_error_message(data)
-        if error_message:
-            return 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:
+            body = _extract_error_message(data) or repr(data)
+            raw_error = data.get("error") if isinstance(data, dict) else None
+            if isinstance(raw_error, dict) and isinstance(raw_error.get("code"), str):
+                # Surfaces and persisted errors can receive only str(error).
+                # Retain coded envelopes there as well as on the exception.
+                body = safe_body
+        error = LLMError(
+            sanitize_error_text_for_output(f"LLM error {response.status_code}: {body}")
         )
+        error.provider_status_code = response.status_code
+        error.provider_error_body = safe_body
+        return error
 
     def count_input_tokens(
         self,
@@ -1567,6 +1604,7 @@ class AnthropicMessagesClient:
             tools,
             mode=self.web_search_mode,
             adapter=self.web_search_adapter,
+            provider_key=self.provider_key,
         )
         payload: dict[str, Any] = {
             "model": self.model,
@@ -1703,6 +1741,7 @@ class AnthropicMessagesClient:
             tools,
             mode=self.web_search_mode,
             adapter=self.web_search_adapter,
+            provider_key=self.provider_key,
         )
         effective_max_tokens = (
             int(max_tokens) if max_tokens is not None else self.default_max_tokens

{alysis_code-0.14.1 → alysis_code-0.14.3}/src/alysis_code/llm/cache_policy.py

@@ -155,6 +155,10 @@ def resolve_prompt_cache_policy(
 ) -> ResolvedPromptCachePolicy:
     mode = resolve_prompt_cache_mode(cfg)
     ttl = resolve_anthropic_prompt_cache_ttl(cfg)
+    hosted_ttl_warning: tuple[str, ...] = ()
+    if provider_key == "alysis" and protocol == "anthropic_messages" and ttl != "5m":
+        ttl = "5m"
+        hosted_ttl_warning = ("Hosted Sonnet supports only five-minute prompt caching.",)
     effective_capability = cache_capability or resolve_effective_cache_capability(
         provider_key=provider_key,
         protocol=protocol,
@@ -172,7 +176,7 @@ def resolve_prompt_cache_policy(
             trusted_usage_fields=effective_capability.trusted_usage_fields,
             usage_schema=effective_capability.usage_schema,
             min_cacheable_tokens=effective_capability.min_cacheable_tokens,
-            warnings=effective_capability.warnings,
+            warnings=(*effective_capability.warnings, *hosted_ttl_warning),
         )
 
     strategy = effective_capability.strategy
@@ -207,7 +211,7 @@ def resolve_prompt_cache_policy(
     gemini_explicit_enabled = (
         effective_capability.supports_explicit_cached_content and mode == "auto"
     )
-    warnings = effective_capability.warnings
+    warnings = (*effective_capability.warnings, *hosted_ttl_warning)
     gemini_ttl: str | None = None
     if gemini_explicit_enabled:
         gemini_ttl, gemini_ttl_fallback = _google_duration_from_retention(explicit_retention)

{alysis_code-0.14.1 → alysis_code-0.14.3}/src/alysis_code/llm/factory.py

@@ -381,6 +381,8 @@ def resolve_model_protocol(*, provider_key: str | None, model: str, protocol: st
     """Resolve model-specific transports for initial connections and live switches."""
     if provider_key == "alysis" and model == "gpt-6-luna":
         return OPENAI_RESPONSES_PROTOCOL
+    if provider_key == "alysis" and model == "claude-sonnet-5-5":
+        return ANTHROPIC_MESSAGES_PROTOCOL
     return protocol
 
 

{alysis_code-0.14.1 → alysis_code-0.14.3}/src/alysis_code/llm/openai_compat.py

@@ -1362,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)
@@ -1371,6 +1377,7 @@ def alysis_trial_error_message(err: LLMError) -> str | None:
                 "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.1 → alysis_code-0.14.3}/src/alysis_code/llm/openai_responses.py

@@ -1024,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}")
@@ -2115,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,

{alysis_code-0.14.1 → alysis_code-0.14.3}/src/alysis_code/llm/protocols.py

@@ -356,6 +356,27 @@ PROVIDER_PROTOCOL_CAPABILITIES: tuple[ProviderProtocolCapabilities, ...] = (
         reports_cache_write_tokens=True,
         quirks=("Alysis Code's current chat runtime uses Chat Completions-compatible requests.",),
     ),
+    ProviderProtocolCapabilities(
+        provider_key="alysis",
+        protocol=OPENAI_COMPAT_PROTOCOL,
+        reasoning_trace=ReasoningTraceCapability(
+            adapter="openrouter_reasoning",
+            supports_streaming=True,
+            supports_buffered=True,
+        ),
+        # Declaring cache support must retain the existing local payload
+        # estimator and conservative response-usage confidence for this route.
+        usage_contract=default_usage_contract_for_protocol(OPENAI_COMPAT_PROTOCOL),
+        supports_streaming=True,
+        supports_tool_calling=True,
+        supports_structured_outputs=True,
+        supports_provider_hosted_web_search_adapter=False,
+        default_web_search_adapter="none",
+        # The gateway does not forward OpenAI affinity/retention fields.
+        cache_strategy="implicit_provider",
+        reports_cache_read_tokens=True,
+        quirks=("Hosted DeepSeek and GLM use provider-managed prompt caching.",),
+    ),
     ProviderProtocolCapabilities(
         provider_key="openai",
         protocol=OPENAI_RESPONSES_PROTOCOL,
@@ -403,10 +424,38 @@ PROVIDER_PROTOCOL_CAPABILITIES: tuple[ProviderProtocolCapabilities, ...] = (
         supports_structured_outputs=True,
         supports_provider_hosted_web_search_adapter=False,
         default_web_search_adapter="none",
+        cache_strategy="implicit_provider",
         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="alysis",
+        protocol=ANTHROPIC_MESSAGES_PROTOCOL,
+        reasoning_trace=ReasoningTraceCapability(
+            adapter="anthropic_messages_summary",
+            output_kind=ReasoningOutputKind.SUMMARY,
+            supports_streaming=True,
+            supports_buffered=True,
+            requestable=True,
+            continuation_state="sensitive",
+        ),
+        usage_contract=UsageContract(
+            response_usage_confidence=UsageConfidence.AUTHORITATIVE,
+            input_token_count_strategy="none",
+        ),
+        supports_streaming=True,
+        supports_tool_calling=True,
+        supports_structured_outputs=False,
+        supports_forced_tool_choice=False,
+        supports_provider_hosted_web_search_adapter=False,
+        default_web_search_adapter="none",
+        cache_strategy="anthropic_cache_control",
+        supports_cache_control=True,
+        reports_cache_read_tokens=True,
+        reports_cache_write_tokens=True,
+        quirks=("Hosted Sonnet supports text, function tools, and five-minute prompt caching.",),
+    ),
     ProviderProtocolCapabilities(
         provider_key="anthropic",
         protocol=OPENAI_COMPAT_PROTOCOL,