alysis-code 0.13.6__tar.gz → 0.13.6.2__tar.gz

{alysis_code-0.13.6 → alysis_code-0.13.6.2}/PKG-INFO

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

@@ -408,6 +408,33 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
   Workspace-target extraction also keeps extensionless dotfiles such as `.npmrc` available to
   verification selection.
 
+## [0.13.6.2] - 2026-09-08
+
+### Fixed
+
+- **Alysis Code account setup and configuration use subscription controls.**
+  Setup identifies the Alysis Code endpoint without the retired MiMo label.
+  Hosted profiles show Alysis Code subscription access and account sign-in,
+  reconnect, and disconnect controls instead of an API-key editor.
+- **Hosted model changes no longer ask for a base URL.** The managed endpoint
+  stays in place through model selection and back navigation. Custom and BYOK
+  providers keep their endpoint settings.
+- **Switching to an Alysis Code account keeps the correct connection.** Signing
+  in refreshes the full active profile before configuration is saved, preventing
+  the previous provider's URL from overwriting the hosted endpoint. Login also
+  switches back to the native agent from a selected delegated runtime. Account
+  status reflects the Alysis login, including after logout when an unrelated
+  provider key is still saved.
+
+## [0.13.6.1] - 2026-09-08
+
+### Fixed
+
+- **V4.1 Flash beta on Alysis Code Pro.** The Pro model picker now includes
+  `deepseek-v4.1-flash-expires-on-0910` and `deepseek-v4-flash-vision-exp`
+  with descriptions. Newly discovered models are captioned "available on your
+  Alysis Code Pro plan" instead of the retired MiMo "trial" wording.
+
 ## [0.13.6] - 2026-09-08
 
 ### Added

{alysis_code-0.13.6 → alysis_code-0.13.6.2}/pyproject.toml

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

{alysis_code-0.13.6 → alysis_code-0.13.6.2}/src/alysis_code/__init__.py

@@ -1,3 +1,3 @@
 __all__ = ["__version__"]
 
-__version__ = "0.13.6"
+__version__ = "0.13.6.2"

{alysis_code-0.13.6 → alysis_code-0.13.6.2}/src/alysis_code/account_login.py

@@ -479,6 +479,10 @@ def _activate_alysis_profile(cfg: AppConfig, *, email: str | None) -> LoginResul
 
     add_profile(cfg, profile)
     set_active_profile(cfg, profile.name)
+    # Hosted account access uses the native agent loop. Keep configured
+    # delegated runtimes available, but stop routing this session through one.
+    cfg.execution.backend = "native"
+    cfg.execution.runtime = None
     save_config(cfg)
 
     return LoginResult(

{alysis_code-0.13.6 → alysis_code-0.13.6.2}/src/alysis_code/cli_impl/config_menu.py

@@ -227,6 +227,7 @@ class ConfigMenuState:
     _provider_models_cache_identity: tuple[str, str, str] | None = field(default=None, repr=False)
     _provider_models_cache: tuple[ProviderModelOption, ...] = field(default=(), repr=False)
     _provider_model_catalog_warning: str = field(default="", repr=False)
+    _account_changed: bool = field(default=False, repr=False)
     _original: dict[str, Any] = field(default_factory=dict, repr=False)
 
     @classmethod
@@ -1115,7 +1116,9 @@ class ConfigMenuState:
         return ConfigMenuResult(
             saved=True,
             changes=changes,
-            api_key_changed=bool(self.new_api_key.strip() or self.clear_stored_key_confirmed),
+            api_key_changed=bool(
+                self.new_api_key.strip() or self.clear_stored_key_confirmed or self._account_changed
+            ),
         )
 
     def validate(self) -> str | None:
@@ -1309,7 +1312,9 @@ def run_config_menu(
             if result.saved or result.error is None:
                 return result
         elif action == "cancel" and _confirm_cancel_when_dirty(state, console):
-            return ConfigMenuResult(saved=False, changes={}, api_key_changed=False)
+            return ConfigMenuResult(
+                saved=state._account_changed, changes={}, api_key_changed=state._account_changed
+            )
 
 
 def _resolve_console() -> Console:
@@ -1317,6 +1322,8 @@ def _resolve_console() -> Console:
 
 
 def _execution_summary_text(state: ConfigMenuState) -> str:
+    if _active_alysis_profile(state) is not None:
+        return "Alysis Code subscription"
     if state.execution_backend == "native":
         return "API key · Alysis Code agent"
     runtime = str(state.execution_runtime or "").strip()
@@ -1326,6 +1333,25 @@ def _execution_summary_text(state: ConfigMenuState) -> str:
     return f"AI subscription · {labels.get(runtime, runtime)}"
 
 
+def _active_alysis_profile(state: ConfigMenuState) -> ProfileSpec | None:
+    """Recognize hosted account access by its effective endpoint, not its model or key."""
+    from .. import alysis_cloud
+
+    if state.execution_backend != "native" or state.active_profile not in state.profiles:
+        return None
+    profile = ProfileSpec.from_dict(state.active_profile, state.profiles[state.active_profile])
+    if profile.auth_provider or profile.protocol != OPENAI_COMPAT_PROTOCOL:
+        return None
+    effective_url = str(state.fields.get("base_url") or profile.base_url).strip().rstrip("/")
+    preset = next(p for p in PROFILE_PRESETS if p.key == alysis_cloud.PROFILE_KEY)
+    hosted_urls = {preset.base_url.strip().rstrip("/")}
+    try:
+        hosted_urls.add(alysis_cloud.gateway_base_url().strip().rstrip("/"))
+    except alysis_cloud.AlysisCloudConfigError:
+        pass
+    return profile if effective_url in hosted_urls else None
+
+
 def _inactive_native_summary(summary: str) -> str:
     if summary == _MISSING_REQUIRED:
         base = "not configured"
@@ -1615,9 +1641,12 @@ def _top_level_menu_rows(state: ConfigMenuState) -> list[tuple[str, str, str]]:
         api_key_summary = "not used · managed by AI subscription"
     native_suffix = " (inactive)" if delegated else ""
     api_key_suffix = " (not used)" if direct_subscription else native_suffix
+    hosted_account = _active_alysis_profile(state) is not None
+    if hosted_account:
+        api_key_summary = "Manage your Alysis Code subscription connection"
     return [
         ("profile", f"Provider Profile{native_suffix}", profile_summary),
-        ("api_key", f"API Key{api_key_suffix}", api_key_summary),
+        ("api_key", "Account" if hosted_account else f"API Key{api_key_suffix}", api_key_summary),
         ("default", f"Default Model{native_suffix}", model_summary),
         ("web_search", "Web Search", _web_search_summary_text(state)),
         ("cache", "Context & Cache", _cache_summary_text(state)),
@@ -1634,7 +1663,10 @@ def _top_level_menu_rows(state: ConfigMenuState) -> list[tuple[str, str, str]]:
 
 
 def _run_execution_section(state: ConfigMenuState, console: Console) -> None:
+    from ..alysis_cloud import PROFILE_KEY
+
     while True:
+        hosted_account = _active_alysis_profile(state) is not None
         selected_backend = _run_config_picker(
             console=console,
             title="Model Access",
@@ -1651,23 +1683,28 @@ def _run_execution_section(state: ConfigMenuState, console: Console) -> None:
                     "Sign in through a supported provider connection; API-key settings stay saved.",
                 ),
             ],
-            current_value=state.execution_backend,
+            current_value="delegated" if hosted_account else state.execution_backend,
         )
         if selected_backend is None:
             _print_section_cancelled(console, "Model Access")
             return
         if selected_backend == "native":
             state.set_execution_backend("native")
+            if hosted_account:
+                _run_provider_section(state, console)
+                return
             console.print("[green]Model access:[/green] API key. Save to apply.")
             return
 
-        rows = _runtime_setup_rows()
-        if not rows:
-            console.print(
-                "[yellow]No AI subscription connections are available in this build.[/yellow]"
-            )
-            return
-        current_runtime = state.execution_runtime
+        rows = [
+            (
+                PROFILE_KEY,
+                "Alysis Code account",
+                "Connect your Alysis Code subscription in the browser.",
+            ),
+            *_runtime_setup_rows(),
+        ]
+        current_runtime = PROFILE_KEY if hosted_account else state.execution_runtime
         if current_runtime not in {value for value, _label, _description in rows}:
             current_runtime = rows[0][0]
         selected_runtime = _run_config_picker(
@@ -1682,6 +1719,9 @@ def _run_execution_section(state: ConfigMenuState, console: Console) -> None:
         )
         if selected_runtime is None:
             continue
+        if selected_runtime == PROFILE_KEY:
+            _run_alysis_account_section(state, console)
+            return
         state.set_execution_backend("delegated", runtime=selected_runtime)
         runtime_label = next(
             (label for value, label, _description in rows if value == selected_runtime),
@@ -1695,6 +1735,59 @@ def _run_execution_section(state: ConfigMenuState, console: Console) -> None:
         return
 
 
+def _run_alysis_account_section(state: ConfigMenuState, console: Console) -> None:
+    from .. import account_login
+    from ..alysis_cloud import PROFILE_KEY
+    from ..profiles import get_profile
+
+    while True:
+        cfg = load_config()
+        status = account_login.login_status(cfg)
+        rows = [
+            (
+                "connect",
+                "Reconnect / switch account" if status.logged_in else "Connect account",
+                "Open Alysis Code sign-in in your browser.",
+            )
+        ]
+        if status.logged_in:
+            rows.append(
+                ("disconnect", "Disconnect account", "Remove your saved account connection.")
+            )
+        rows.append(("back", "Back", "Return to configuration."))
+        action = _run_config_picker(
+            console=console,
+            title="Alysis Code Account",
+            subtitle="Account: connected" if status.logged_in else "Account: not connected",
+            rows=rows,
+            current_value="back",
+        )
+        if action in {None, "back"}:
+            return
+        try:
+            if action == "disconnect":
+                if not _prompt_yes_no("Disconnect your Alysis Code account? [y/N]"):
+                    continue
+                account_login.logout(cfg)
+                state._account_changed = True
+                state.refresh_api_key_status()
+                console.print("[yellow]Alysis Code account disconnected.[/yellow]")
+                continue
+            account_login.login(
+                cfg,
+                output_write=lambda message: console.print(message, highlight=False),
+            )
+            profile = get_profile(cfg, PROFILE_KEY)
+            if profile is not None:
+                state.profiles[PROFILE_KEY] = profile.to_dict()
+                state.set_active_profile_name(PROFILE_KEY)
+                state.set_execution_backend("native")
+            state._account_changed = True
+            console.print("[green]Alysis Code account connected.[/green]")
+        except (account_login.AlysisLoginError, ConfigError) as exc:
+            console.print(f"[red]Alysis Code account action failed:[/red] {escape(str(exc))}")
+
+
 def _run_subscription_account_section(provider_id: str, console: Console) -> None:
     from ..provider_auth import ProviderAuthError, create_provider_auth
 
@@ -2647,7 +2740,7 @@ def _run_profile_edit_current(state: ConfigMenuState, console: Console) -> None:
         )
         return
     profile = ProfileSpec.from_dict(state.active_profile, state.profiles[state.active_profile])
-    if profile.auth_provider:
+    if profile.auth_provider or _active_alysis_profile(state) is not None:
         console.print(
             "[yellow]This subscription connection is provider-managed. Use Default Model "
             "to choose its model and reasoning effort.[/yellow]"
@@ -2770,6 +2863,9 @@ def _run_profile_remove(state: ConfigMenuState, console: Console) -> None:
 
 
 def _run_api_key_section(state: ConfigMenuState, console: Console) -> None:
+    if _active_alysis_profile(state) is not None:
+        _run_alysis_account_section(state, console)
+        return
     console.print()
     console.rule("[bold]API Key[/bold]")
     if state.execution_backend == "delegated":
@@ -2808,6 +2904,7 @@ def _run_default_section(state: ConfigMenuState, console: Console) -> None:
     console.print()
     console.rule("[bold]Default Model[/bold]")
     direct_subscription = _active_subscription_profile(state) is not None
+    hosted_account = _active_alysis_profile(state) is not None
     if state.execution_backend == "delegated" and not direct_subscription:
         console.print(
             "[yellow]This API-key model is preserved but inactive while an AI subscription is selected.[/yellow]"
@@ -2820,7 +2917,7 @@ def _run_default_section(state: ConfigMenuState, console: Console) -> None:
         model = _prompt_default_model(console, state)
         base_url = (
             state.fields["base_url"]
-            if direct_subscription
+            if direct_subscription or hosted_account
             else _prompt_text("Base URL", state.fields["base_url"])
         )
         state.set_field("base_url", base_url)
@@ -3104,8 +3201,9 @@ def _preset_model_option_rows(
 
     NVIDIA's API catalog contains both NVIDIA and third-party models, so its live
     ``/v1/models`` inventory is merged with a small curated recommendation set.
-    The hosted MiMo trial similarly appends its live proxy allowlist. Discovery is
-    best-effort and offline-safe: on failure the static rows still render.
+    The hosted Alysis Code Pro gateway similarly appends its live ``/v1/models``
+    allowlist. Discovery is best-effort and offline-safe: on failure the static
+    rows still render.
     """
     rows = list(model_options_for_preset(preset))
 
@@ -3155,7 +3253,10 @@ def _preset_model_option_rows(
         if any(_same_model(model_id, existing) for existing in known):
             continue
         known.append(model_id)
-        rows.append((model_id, model_id, "available on your Alysis Code trial"))
+        # A model the gateway serves but the client predates: the preset may
+        # still describe it; otherwise say where it comes from.
+        description = str(preset.suggested_model_descriptions.get(model_id) or "").strip()
+        rows.append((model_id, model_id, description or "available on your Alysis Code Pro plan"))
     return rows
 
 

{alysis_code-0.13.6 → alysis_code-0.13.6.2}/src/alysis_code/cli_impl/setup_wizard.py

@@ -333,7 +333,7 @@ def run_setup_wizard() -> bool:
 def _maybe_offer_alysis_login(
     console: Console, *, profile_result: _ProfileStepResult, cfg: AppConfig
 ) -> None:
-    """If the user chose the hosted MiMo (login-based) preset, offer to connect now.
+    """If the user chose the hosted Alysis Code preset, offer to connect now.
 
     That preset authenticates via `alysis login` instead of an API key.
     Running the handshake here saves a separate step; declining is harmless (the

{alysis_code-0.13.6 → alysis_code-0.13.6.2}/src/alysis_code/cli_impl/tui/config_flow.py

@@ -73,6 +73,7 @@ from ..config_menu import (
     ROLE_ORDER,
     ConfigMenuResult,
     ConfigMenuState,
+    _active_alysis_profile,
     _active_preset,
     _active_subscription_profile,
     _advanced_profile_presets_for_setup,
@@ -178,7 +179,7 @@ def _pretty_key_source(source: str | None) -> str:
 
 def _short_preset_description(preset: Any) -> str:
     if preset.key == "alysis":
-        return "hosted MiMo — Alysis Code account"
+        return "Alysis Code endpoint — account sign-in"
     short = _NATIVE_PROTOCOL_SHORT.get(preset.protocol)
     if short:
         return short
@@ -608,6 +609,7 @@ class ConfigFlow:
         direct_sub = st.execution_backend == "delegated" and _is_direct_subscription_id(
             st.execution_runtime
         )
+        hosted_account = _active_alysis_profile(st) is not None
         native_suffix = " (inactive)" if delegated else ""
         profile_desc, profile_tone = self._short_profile(delegated)
         model_desc, model_tone = self._short_model(delegated)
@@ -637,7 +639,7 @@ class ConfigFlow:
             # The status ("not used" / "inactive") lives in the description —
             # repeating it as a label suffix read twice on one row.
             Row(
-                label="API Key",
+                label="Account" if hosted_account else "API Key",
                 description=key_desc,
                 value="api_key",
                 tone=key_tone,
@@ -691,6 +693,8 @@ class ConfigFlow:
 
     def _short_execution(self) -> tuple[str, str]:
         st = self.state
+        if _active_alysis_profile(st) is not None:
+            return "Alysis Code subscription", ""
         if st.execution_backend == "native":
             return "API key", ""
         runtime = str(st.execution_runtime or "").strip()
@@ -718,6 +722,12 @@ class ConfigFlow:
             return "not used", ""
         if delegated:
             return "inactive", ""
+        if _active_alysis_profile(self.state) is not None:
+            from ... import account_login
+
+            if account_login.login_status(self.cfg).logged_in:
+                return "connected", ""
+            return "not connected — sign in", "warn"
         raw = _api_key_summary_text(self.state)
         if raw == _MISSING_REQUIRED:
             return "missing — required", "warn"
@@ -742,6 +752,7 @@ class ConfigFlow:
         return f"subagents {sub} · forge {forge}"
 
     def _screen_execution_backend(self) -> Screen:
+        hosted_account = _active_alysis_profile(self.state) is not None
         return Screen(
             stage="execution_backend",
             mode="list",
@@ -752,7 +763,7 @@ class ConfigFlow:
                     label="Use an API key",
                     description="Connect directly to a supported model provider.",
                     value="native",
-                    current=self.state.execution_backend == "native",
+                    current=self.state.execution_backend == "native" and not hosted_account,
                 ),
                 Row(
                     label="Use an AI subscription",
@@ -760,7 +771,7 @@ class ConfigFlow:
                         "Sign in through a supported provider connection; API-key settings stay saved."
                     ),
                     value="delegated",
-                    current=self.state.execution_backend == "delegated",
+                    current=self.state.execution_backend == "delegated" or hosted_account,
                 ),
             ],
             hint="",
@@ -775,10 +786,7 @@ class ConfigFlow:
                 label="Alysis Code account",
                 description="Free daily DeepSeek included — browser sign-in, no API key.",
                 value=_ALYSIS_CONNECTION_ID,
-                current=(
-                    self.state.execution_backend == "native"
-                    and self.state.active_profile == _ALYSIS_CONNECTION_ID
-                ),
+                current=_active_alysis_profile(self.state) is not None,
             )
         ]
         rows.extend(
@@ -1845,6 +1853,12 @@ class ConfigFlow:
         if self.stage == "cancel_confirm":
             self._goto(self._resume_stage or "menu")
             return
+        if self.stage == "model_thinking" and (
+            _active_subscription_profile(self.state) is not None
+            or _active_alysis_profile(self.state) is not None
+        ):
+            self._goto("model", index=self._model_index())
+            return
         prev = _PREV.get(self.stage)
         if prev is not None:
             self._goto(prev)
@@ -1886,7 +1900,10 @@ class ConfigFlow:
         elif value == "profile":
             self._goto("provider")
         elif value == "api_key":
-            self._goto("api_key")
+            if _active_alysis_profile(self.state) is not None:
+                self._choose_execution_runtime(_ALYSIS_CONNECTION_ID)
+            else:
+                self._goto("api_key")
         elif value == "default":
             self.open_default_model()
         elif value == "web_search":
@@ -1903,10 +1920,17 @@ class ConfigFlow:
             self._goto("personas", index=self._persona_index())
 
     def _execution_backend_index(self) -> int:
-        return 1 if self.state.execution_backend == "delegated" else 0
+        return int(
+            self.state.execution_backend == "delegated"
+            or _active_alysis_profile(self.state) is not None
+        )
 
     def _choose_execution_backend(self, value: str) -> None:
         if value == "native":
+            if _active_alysis_profile(self.state) is not None:
+                self._goto("provider")
+                self._set_status("Choose or add an API-key provider profile.", "dim")
+                return
             self.state.set_execution_backend("native")
             self._goto("menu")
             self._set_status("API-key model access selected. Save to apply.", "ok")
@@ -1915,10 +1939,9 @@ class ConfigFlow:
             self._set_status(f"Unknown model access method: {value}", "err")
             return
         rows = _runtime_setup_rows()
-        if not rows:
-            self._set_status("No AI subscription connections are available in this build.", "warn")
-            return
-        runtime_ids = [runtime_id for runtime_id, _label, _description in rows]
+        runtime_ids = [_ALYSIS_CONNECTION_ID] + [
+            runtime_id for runtime_id, _label, _description in rows
+        ]
         index = (
             runtime_ids.index(self.state.execution_runtime)
             if self.state.execution_runtime in runtime_ids
@@ -2089,7 +2112,10 @@ class ConfigFlow:
         self.state.set_field("model", value)
         if self._finish_preset_chain_if_active(model=value):
             return
-        if _active_subscription_profile(self.state) is not None:
+        if (
+            _active_subscription_profile(self.state) is not None
+            or _active_alysis_profile(self.state) is not None
+        ):
             labels = _thinking_labels_for_state(self.state, model=value)
             if self.state.thinking_label not in labels:
                 self.state.set_thinking_label("auto")
@@ -2105,7 +2131,13 @@ class ConfigFlow:
         self.state.set_field("model", model)
         if self._finish_preset_chain_if_active(model=model):
             return
-        self._goto("model_base_url")
+        if (
+            _active_subscription_profile(self.state) is not None
+            or _active_alysis_profile(self.state) is not None
+        ):
+            self._goto("model_thinking", index=self._thinking_index())
+        else:
+            self._goto("model_base_url")
 
     def _submit_model_base_url(self, text: str) -> None:
         value = text.strip() or str(self.state.fields.get("base_url", ""))
@@ -2505,7 +2537,7 @@ class ConfigFlow:
         profile = ProfileSpec.from_dict(
             self.state.active_profile, self.state.profiles[self.state.active_profile]
         )
-        if profile.auth_provider:
+        if profile.auth_provider or _active_alysis_profile(self.state) is not None:
             self._set_status(
                 "This subscription connection is provider-managed. Use Default model for "
                 "model and reasoning choices.",
@@ -2731,24 +2763,21 @@ class ConfigFlow:
         if kind == "connected":
             # login() already activated + saved the alysis profile in cfg;
             # mirror it into the TUI state so a later Save is consistent.
-            result = getattr(self, "_alysis_login_result", None)
             self._alysis_login_result = None
             from ...profiles import get_profile
 
             profile = get_profile(self.cfg, _ALYSIS_CONNECTION_ID)
             if profile is not None:
                 self.state.profiles[_ALYSIS_CONNECTION_ID] = profile.to_dict()
-            self.state.active_profile = _ALYSIS_CONNECTION_ID
+                self.state.set_active_profile_name(_ALYSIS_CONNECTION_ID)
             self.state.set_execution_backend("native")
-            model = str(getattr(result, "model", "") or "").strip()
-            if model:
-                self.state.fields["model"] = model
             self._goto("subscription_account")
             self._set_status(
-                "Alysis Code connected — hosted DeepSeek active. Esc to exit config.",
+                "Alysis Code subscription connected. Esc to exit config.",
                 "ok",
             )
         else:
+            self.state.refresh_api_key_status()
             self._goto("subscription_account")
             self._set_status(
                 "Logged out. Hosted requests will be refused until you sign in again.",

{alysis_code-0.13.6 → alysis_code-0.13.6.2}/src/alysis_code/cli_impl/tui/setup_flow.py

@@ -256,7 +256,7 @@ class SetupFlow:
             else "thread"
         )
 
-    def _hosted_mimo(self) -> bool:
+    def _hosted_alysis(self) -> bool:
         preset = self.profile_result.preset if self.profile_result else None
         if preset is None:
             return False
@@ -636,7 +636,7 @@ class SetupFlow:
             stage="login_confirm",
             mode="confirm",
             title="Alysis Code account",
-            subtitle="Your provider is the Alysis Code-hosted MiMo endpoint.",
+            subtitle="Your provider is the Alysis Code endpoint.",
             lines=[("Connect your Alysis Code account now?", "plain")],
             hint="Y connect · N later · Esc skip",
             confirm_default=True,
@@ -1073,7 +1073,7 @@ class SetupFlow:
             self._model_catalog_warning = ""
         self.profile_result = new
         warning = (preset.setup_warning or "").strip()
-        if self._hosted_mimo():
+        if self._hosted_alysis():
             # The Alysis Code account needs no API key and login picks the
             # hosted default model — skip both steps and head straight to the
             # workspace; the post-commit login_confirm step connects the
@@ -1582,7 +1582,7 @@ class SetupFlow:
         self._after_sandbox()
 
     def _after_sandbox(self) -> None:
-        if self._hosted_mimo():
+        if self._hosted_alysis():
             self._goto("login_confirm")
         else:
             self._goto("complete")

{alysis_code-0.13.6 → alysis_code-0.13.6.2}/src/alysis_code/profile_presets.py

@@ -1698,10 +1698,22 @@ PROFILE_PRESETS: tuple[ProfilePreset, ...] = (
         # The models the subscription offers. Live availability is discovered
         # from the gateway's /v1/models at runtime; this static list is the
         # offline fallback and the menu shown before a model is chosen.
-        suggested_models=("deepseek-v4-flash", "deepseek-v4-pro"),
+        suggested_models=(
+            "deepseek-v4-flash",
+            "deepseek-v4-pro",
+            "deepseek-v4-flash-vision-exp",
+            "deepseek-v4.1-flash-expires-on-0910",
+        ),
         suggested_model_descriptions={
             "deepseek-v4-flash": "default - fast high-volume coding (1M context, free daily allowance)",
             "deepseek-v4-pro": "flagship - deeper reasoning (1M context, requires Alysis Code Pro)",
+            "deepseek-v4-flash-vision-exp": (
+                "vision preview - image understanding at the v4-flash rate (experimental)"
+            ),
+            "deepseek-v4.1-flash-expires-on-0910": (
+                "V4.1 Flash beta - new architecture, native multimodal, v4-flash rate; "
+                "DeepSeek retires this id on 2026-09-10"
+            ),
         },
         validation_model="deepseek-v4-flash",
         # Migrate ids from the retired Xiaomi MiMo trial to the Pro default so