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

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

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

@@ -6,6 +6,31 @@ 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

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

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

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

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

{alysis_code-0.14.2 → 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.2 → 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:
@@ -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,

{alysis_code-0.14.2 → 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.2 → 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.2 → 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.2 → 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.2 → 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.2 → 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,

{alysis_code-0.14.2 → alysis_code-0.14.3}/src/alysis_code/mcp/client.py

@@ -48,9 +48,9 @@ _SUPPORTED_PROTOCOL_VERSIONS_BY_TRANSPORT = {
     "stdio": (MCP_STDIO_PROTOCOL_VERSION,),
     "http": MCP_HTTP_SUPPORTED_PROTOCOL_VERSIONS,
 }
-# `notifications/initialized` needs a real follow-up window for immediate
-# server activity without turning every quiet startup into a full startup-timeout wait.
-_INITIALIZED_NOTIFICATION_COMPLETION_TIMEOUT_S = 0.5
+# Stdio observes immediate server activity after `notifications/initialized`
+# without making a quiet startup wait for the full configured timeout.
+_STDIO_INITIALIZED_NOTIFICATION_COMPLETION_TIMEOUT_S = 0.5
 _ReadOnlyRequestResult = TypeVar("_ReadOnlyRequestResult")
 
 
@@ -430,13 +430,17 @@ class _BaseMcpClient:
         self._supports_resources = "resources" in capabilities
         self._supports_prompts = "prompts" in capabilities
         self._apply_negotiated_protocol_version(protocol_version)
+        notification_timeout_s = self.server.startup_timeout_s
+        if self.server.transport == "stdio":
+            notification_timeout_s = min(
+                notification_timeout_s, _STDIO_INITIALIZED_NOTIFICATION_COMPLETION_TIMEOUT_S
+            )
+        # HTTP must wait for the server's acknowledgement of the notification;
+        # a short stdio observation window is not a network request timeout.
         self.transport.send_notification(
             method="notifications/initialized",
             params={},
-            completion_timeout_s=min(
-                self.server.startup_timeout_s,
-                _INITIALIZED_NOTIFICATION_COMPLETION_TIMEOUT_S,
-            ),
+            completion_timeout_s=notification_timeout_s,
         )
         self._initialized = True
         self._drain_notifications()

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

@@ -1593,6 +1593,23 @@ _OFFICIAL_PROVIDER_MODEL_METADATA["alysis"]["gpt-6-luna"] = {
     "output_cost_per_token": 0.0000005,
 }
 
+# Anthropic's launch specifications and standard five-minute cache pricing.
+_PROVIDER_CANONICAL_MODEL_IDS["alysis"]["claude-sonnet-5-5"] = "claude-sonnet-5-5"
+_OFFICIAL_PROVIDER_MODEL_SOURCES["alysis"]["claude-sonnet-5-5"] = (
+    "https://platform.claude.com/docs/en/models/sonnet-5-5/overview",
+)
+_OFFICIAL_PROVIDER_MODEL_METADATA["alysis"]["claude-sonnet-5-5"] = {
+    "context_window_tokens": 1_000_000,
+    "max_output_tokens": 128_000,
+    # The hosted route initially meters text/tools; image accounting is separate.
+    "supports_vision": False,
+    "supports_reasoning": True,
+    "input_cost_per_token": 0.000002,
+    "cache_read_input_cost_per_token": 0.0000002,
+    "cache_creation_input_cost_per_token": 0.0000025,
+    "output_cost_per_token": 0.00001,
+}
+
 _BUILT_IN_MODEL_METADATA: dict[str, dict[str, Any]] = {
     "deepseek-chat": {
         "context_window_tokens": 1_000_000,

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

@@ -1768,8 +1768,10 @@ PROFILE_PRESETS: tuple[ProfilePreset, ...] = (
             ReviewedModel("deepseek-flash", "deepseek-expanded"),
             ReviewedModel("glm-5.3-flash", "glm-normal"),
             ReviewedModel("gpt-6-luna", "gpt-expanded"),
+            ReviewedModel("claude-sonnet-5-5", "claude-normal"),
         ),
         suggested_model_descriptions={
+            "claude-sonnet-5-5": "Claude Sonnet 5.5 - coding and reasoning, included with free credits",
             "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"
@@ -1787,7 +1789,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, GLM 5.3 Flash, and GPT-6 Luna with free credits. Authenticate with `alysis login`.",
+        notes="DeepSeek V4.1 Flash, GLM 5.3 Flash, GPT-6 Luna, and Claude Sonnet 5.5 with free credits. Authenticate with `alysis login`.",
     ),
     ProfilePreset(
         key="ollama",
@@ -1842,6 +1844,7 @@ def model_display_name(model: str) -> str:
         "deepseek-flash": "DeepSeek V4.1 Flash",
         "glm-5.3-flash": "GLM 5.3 Flash",
         "gpt-6-luna": "GPT-6 Luna",
+        "claude-sonnet-5-5": "Claude Sonnet 5.5",
         "grok-4.7": "Grok 4.7",
     }.get(model.casefold(), model)