fix(agent): rebuild provider on preset switch

.agent/design.md

@@ -24,14 +24,6 @@ Fix bugs by changing only what is necessary. Do not bundle unrelated refactors o
 
 A bugfix should make the protected invariant clear, change the smallest surface that enforces it, and add only the closest regression test. If a diff starts changing ownership boundaries or mixing behavior changes with clean-up, split it before it becomes hard to review.
 
-## Type dynamic boundaries at the edge
-
-Wire payloads, persisted records, and third-party SDK objects are untrusted dynamic boundaries. Prefer a parser or small normalizer at the owning edge, and use `TypedDict` for stable dictionary shapes, so validation happens once and internal code receives a concrete type. Do not spread raw dynamic dictionaries or SDK objects through the core.
-
-Stable first-party dependencies must be typed where they are stored or passed. Do not declare an internal service, context field, or callback result as `Any` and then recover its real type with consumer-side casts. Use the concrete type or a narrow `Protocol`; reserve `Any` for genuinely dynamic boundaries.
-
-`typing.cast` performs no runtime validation. Every new cast must be supported by a runtime check on the same path or by an explicit invariant that is clear from construction and control flow (and documented locally when it is not obvious). If input can violate the claimed type, handle that invalid case before casting; never use `cast` only to silence BasedPyright.
-
 ## Explicit over magical
 
 Configuration must be declared explicitly in `config/schema.py` Pydantic models. Error handling should raise clear exceptions rather than silently correcting bad input. Provider auto-detection exists, but every resolution path must be traceable from the factory to the concrete provider class.

.github/workflows/ci.yml

@@ -5,28 +5,10 @@ on:
     branches: [main]
     paths-ignore:
       - docs/**
-      - .agent/**
-      - .github/ISSUE_TEMPLATE/**
-      - AGENTS.md
-      - CLAUDE.md
-      - COMMUNICATION.md
-      - CONTRIBUTING.md
-      - README.md
-      - SECURITY.md
-      - webui/README.md
   pull_request:
     branches: [main]
     paths-ignore:
       - docs/**
-      - .agent/**
-      - .github/ISSUE_TEMPLATE/**
-      - AGENTS.md
-      - CLAUDE.md
-      - COMMUNICATION.md
-      - CONTRIBUTING.md
-      - README.md
-      - SECURITY.md
-      - webui/README.md
 
 concurrency:
   group: ${{ github.workflow }}-${{ github.ref }}
@@ -86,18 +68,14 @@ jobs:
             os: ubuntu-latest
             python-version: "3.11"
             coverage: false
-            pytest_args: ""
           - name: latest, 3.14 + coverage
             os: ubuntu-latest
             python-version: "3.14"
             coverage: true
-            pytest_args: ""
           - name: Windows, 3.14
             os: windows-latest
             python-version: "3.14"
             coverage: false
-            # Keep each test file in one worker while using both hosted-runner cores.
-            pytest_args: "-n 2 --dist loadfile"
 
     steps:
       - uses: actions/checkout@v4
@@ -120,19 +98,12 @@ jobs:
       - name: Install channel dependencies
         run: uv run --no-sync python -m scripts.install_channel_dependencies --all-channels
 
-      - name: Verify dependency consistency
-        run: uv pip check
-
       # Channel requirements live in manifests rather than uv.lock. Avoid a
       # later uv run sync pruning the packages installed by the previous step.
       - name: Lint with ruff
         if: matrix.coverage
         run: uv run --no-sync ruff check nanobot tests conftest.py
 
-      - name: Type check with BasedPyright (strict)
-        if: matrix.coverage
-        run: uv run --no-sync basedpyright
-
       - name: Run tests with coverage
         if: matrix.coverage
         run: >-
@@ -144,7 +115,6 @@ jobs:
         if: ${{ !matrix.coverage }}
         run: >-
           uv run --no-sync python -m pytest
-          ${{ matrix.pytest_args }}
           --durations=25 --durations-min=1.0
 
   webui:

AGENTS.md

@@ -11,11 +11,6 @@ nanobot is a lightweight, open-source AI agent framework written in Python with
 pytest tests/test_openai_api.py::test_function -v
 ruff check nanobot/
 
-# Strict type checking (matches CI)
-uv sync --all-extras --dev
-uv run --no-sync python -m scripts.install_channel_dependencies --all-channels
-uv run --no-sync basedpyright
-
 # WebUI: dev server (proxies API/WS to gateway :8765), build, test
 # Build outputs to ../nanobot/web/dist (bundled into the Python wheel)
 cd webui && bun run dev      # or NANOBOT_API_URL=... bun run dev

CONTRIBUTING.md

@@ -78,20 +78,6 @@ ruff check nanobot/
 ruff format <files-you-changed>
 ```
 
-### Strict Type Checking
-
-Strict type checking covers optional providers and channels. Reproduce the CI environment
-with the same dependency sources and commands:
-
-```bash
-uv sync --all-extras --dev
-uv run --no-sync python -m scripts.install_channel_dependencies --all-channels
-uv run --no-sync basedpyright
-```
-
-Keep `--no-sync` on the final commands: channel dependencies come from their package
-manifests and are installed explicitly by the setup step.
-
 ## Contribution License
 
 By submitting a contribution, you confirm that you have the right to submit it

conftest.py

@@ -9,17 +9,6 @@ from collections.abc import Iterator
 
 import certifi
 import pytest
-from loguru import logger
-
-
-@pytest.fixture(autouse=True)
-def _isolate_nanobot_log_activation() -> Iterator[None]:
-    """Keep CLI log settings from leaking into later tests in the same process."""
-    logger.enable("nanobot")
-    try:
-        yield
-    finally:
-        logger.enable("nanobot")
 
 
 @pytest.fixture(scope="session", autouse=True)

docs/architecture.md

@@ -59,7 +59,7 @@ Provider metadata is centralized in `nanobot/providers/registry.py`. Configurati
 
 Provider selection uses:
 
-- explicit `agents.defaults.provider` or preset provider;
+- the active model preset's explicit provider;
 - provider registry keywords;
 - API key prefixes and API base URL hints;
 - local provider fallback when `apiBase` is configured;

docs/chat-commands.md

@@ -57,7 +57,7 @@ To switch presets for future turns:
 /model default
 ```
 
-Preset names come from the top-level `modelPresets` config. Switching affects only the current session and persists the selection in that session, so later turns keep using it across process restarts. It does not rewrite `config.json`, does not change other sessions, and does not alter an in-progress turn's captured model. Sessions without a saved selection follow `agents.defaults.modelPreset` (or the implicit `default` preset when it is omitted). See [Configuration: Model presets](./configuration.md#model-presets) for setup details.
+Preset names come from the top-level `modelPresets` config. Switching affects only the current session and persists the selection in that session, so later turns keep using it across process restarts. It does not rewrite `config.json`, does not change other sessions, and does not alter an in-progress turn's captured model. Sessions without a saved selection follow `agents.defaults.modelPreset`, or the concrete `modelPresets.default` entry when it is omitted. See [Configuration: Model presets](./configuration.md#model-presets) for setup details.
 
 ## Local triggers
 

docs/concepts.md

@@ -87,9 +87,9 @@ The WebUI launcher is the normal browser entry point. Underneath, the gateway ke
 
 ## Provider and Model Selection
 
-The active model should normally come from a named `modelPresets` entry selected by `agents.defaults.modelPreset`. Direct `agents.defaults.provider` and `agents.defaults.model` still form the implicit `default` preset for older or minimal configs. The active provider is resolved in this order:
+The active model comes from the named `modelPresets` entry selected by `agents.defaults.modelPreset`, or from the concrete `modelPresets.default` entry when that selector is omitted. The active provider is resolved in this order:
 
-1. If the active preset provider or implicit default provider is not `"auto"`, nanobot uses that provider.
+1. If the active preset provider is not `"auto"`, nanobot uses that provider.
 2. If provider is `"auto"`, nanobot tries to infer the provider from the model name, configured API keys, local provider base URLs, or gateway providers.
 3. OAuth providers such as OpenAI Codex and GitHub Copilot require explicit login and explicit provider/model selection inside the active preset.
 

docs/configuration.md

@@ -259,7 +259,7 @@ Tracing covers the providers that go through nanobot's OpenAI-compatible client
 > - **ModelScope**: If you're using ModelScope's OpenAI-compatible endpoint, set `"apiBase": "https://api-inference.modelscope.cn/v1"` in your modelscope provider config.
 > - **StepFun Step Plan**: If you're on StepFun's Step Plan subscription, set `"apiBase": "https://api.stepfun.ai/step_plan/v1"` in your stepfun provider config. Supported models include `step-3.5-flash`, `step-3.5-flash-2603`, and `step-router-v1`.
 > - **Step Fun (Mainland China)**: If your API key is from Step Fun's mainland China platform (stepfun.com), set `"apiBase": "https://api.stepfun.com/v1"` in your stepfun provider config.
-> - **Xiaomi MiMo thinking mode**: MiMo models (e.g. `mimo-v2.5-pro`) default to enabled thinking. Use `agents.defaults.reasoningEffort: "none"` to disable it, or `"low"` / `"medium"` / `"high"` to keep it on. Omitting the field preserves the provider's per-model default.
+> - **Xiaomi MiMo thinking mode**: MiMo models (e.g. `mimo-v2.5-pro`) default to enabled thinking. Set `reasoningEffort: "none"` on the active model preset to disable it, or `"low"` / `"medium"` / `"high"` to keep it on. Omitting the field preserves the provider's per-model default.
 > - **Xiaomi MiMo Token Plan**: If you're on MiMo's token plan, set `"apiBase": "https://token-plan-sgp.xiaomimimo.com/v1"` in your xiaomi_mimo provider config.
 > - **Custom OpenAI-compatible providers**: Besides the built-in `custom` provider, any extra key under `providers` can define its own OpenAI-compatible endpoint. For example, `providers.companyProxy.apiBase` plus `modelPresets.primary.provider: "companyProxy"` creates a separate custom provider. Set `apiBase`; set `apiKey` only when the endpoint requires it. This named-custom path uses the OpenAI-compatible request format only. For Anthropic-compatible proxies, use `providers.anthropic.apiBase` with `provider: "anthropic"`.
 > - **Provider-scoped proxy**: `providers.<name>.proxy` routes only that provider through an HTTP proxy. It is supported for OpenAI-compatible providers, `openai_codex`, and `xai_grok`. Native provider backends such as `anthropic`, `bedrock`, `azure_openai`, and `github_copilot` reject `proxy`.
@@ -348,19 +348,6 @@ Valid `apiType` values are exactly `auto`, `chat_completions`, and `responses`.
 
 </details>
 
-<a id="responses-state-and-compaction"></a>
-
-### Responses conversation state and compaction
-
-Providers that use the Responses API can keep reasoning context across a
-conversation, which helps with multi-step tasks. Supported providers can also
-compact long conversations automatically.
-
-nanobot preserves Responses conversation state automatically for OpenAI Responses, OpenAI Codex, Azure OpenAI, DeepSeek V4 Flash, and compatible GitHub Copilot models.
-Native compaction is also automatic when the provider supports it. The
-threshold is derived from the active model's context window and reserved output
-headroom; no provider configuration is required.
-
 <details>
 <summary><b>Azure OpenAI</b></summary>
 
@@ -1359,20 +1346,12 @@ Contributor notes for adding new providers live in [`development.md`](./developm
 
 ## Model Presets
 
-Model presets let you name a complete model configuration and select one per session with `/model <preset>`. They are the recommended way to configure models because the same names can be reused for new-session defaults, chat-command switching, and fallback chains.
+Model presets let you name a complete model configuration and select one per session with `/model <preset>`. Configure all model, provider, generation, context-window, and image-input settings under top-level `modelPresets`; `agents.defaults` only selects preset names.
 
-Existing configs do not need to change. Direct `agents.defaults.model`, `provider`, `maxTokens`, `contextWindowTokens`, `temperature`, and `reasoningEffort` fields still define the implicit `default` preset. For new configs, prefer top-level `modelPresets` plus `agents.defaults.modelPreset`.
+On first load, nanobot migrates legacy model fields from `agents.defaults` and inline fallback objects in `config.json` into named presets, then atomically rewrites the file and logs a warning. If a concrete `modelPresets.default` and legacy direct fields both exist, the concrete preset wins and the warning explains that the conflicting legacy fields were removed. Legacy model fields supplied through nested `NANOBOT_AGENTS` environment settings are not supported and produce a warning with instructions to move them into `modelPresets`.
 
 ```json
 {
-  "modelPresets": {
-    "fast": {
-      "provider": "openrouter",
-      "model": "anthropic/claude-sonnet-4.5",
-      "maxTokens": 4096,
-      "contextWindowTokens": 65536
-    }
-  },
   "agents": {
     "defaults": {
       "modelPreset": "fast",
@@ -1380,6 +1359,14 @@ Existing configs do not need to change. Direct `agents.defaults.model`, `provide
     }
   },
   "modelPresets": {
+    "default": {
+      "label": "Default",
+      "model": "claude-opus-4-5",
+      "provider": "anthropic",
+      "maxTokens": 8192,
+      "contextWindowTokens": 200000,
+      "supportsImageInput": true
+    },
     "fast": {
       "label": "Fast",
       "model": "gpt-4.1-mini",
@@ -1387,7 +1374,8 @@ Existing configs do not need to change. Direct `agents.defaults.model`, `provide
       "maxTokens": 4096,
       "contextWindowTokens": 128000,
       "temperature": 0.2,
-      "reasoningEffort": "low"
+      "reasoningEffort": "low",
+      "supportsImageInput": true
     },
     "deep": {
       "label": "Deep",
@@ -1409,7 +1397,7 @@ Existing configs do not need to change. Direct `agents.defaults.model`, `provide
 }
 ```
 
-`modelPresets` is a top-level object. The keys under it (`fast`, `deep`, `coding`, etc.) are user-defined preset names. Each preset supports:
+`modelPresets` is a top-level object. `default` is required; its other keys (`fast`, `deep`, `coding`, etc.) are user-defined preset names. Each preset supports:
 
 | Field | Description |
 |-------|-------------|
@@ -1420,25 +1408,30 @@ Existing configs do not need to change. Direct `agents.defaults.model`, `provide
 | `contextWindowTokens` | Context window size used by prompt building and consolidation decisions. |
 | `temperature` | Sampling temperature. |
 | `reasoningEffort` | Optional reasoning/thinking setting. Provider support varies. |
+| `supportsImageInput` | `true` always sends images, `false` strips them before the first request, and `null`/omitted uses automatic retry-on-unsupported behavior. |
 
-`default` is reserved and always means the implicit preset built from direct `agents.defaults.*` fields; do not define `modelPresets.default`. Use `/model default` to switch back to those direct fields in an existing config.
+Every config has a concrete `modelPresets.default` entry. Use `/model default` to switch a session back to it. Configure the default model by editing that preset, not by adding model fields under `agents.defaults`.
 
-Set `agents.defaults.modelPreset` to choose the preset followed by sessions that have no saved model selection. When `modelPreset` is `null` or omitted, such sessions follow the implicit `default` preset from direct `agents.defaults.*` fields. `/model <preset>` saves an override in the current session, so its future turns keep that preset across process restarts while other sessions remain unchanged. The command does not write the selection back to `config.json`.
+Set `agents.defaults.modelPreset` to choose the preset followed by sessions that have no saved model selection. When it is omitted, such sessions use `modelPresets.default`. `/model <preset>` saves an override in the current session, so its future turns keep that preset across process restarts while other sessions remain unchanged. The command does not write the selection back to `config.json`.
 
 ### Model Fallbacks
 
-`agents.defaults.fallbackModels` defines an ordered failover chain for the active model configuration. The primary model is still selected by `agents.defaults.modelPreset` or, in older configs, by the implicit `default` preset from direct `agents.defaults.*` fields.
+`agents.defaults.fallbackModels` defines an ordered failover chain for the active model configuration. The primary model is selected by `agents.defaults.modelPreset`, or by `modelPresets.default` when that selector is omitted.
 
-Each fallback candidate can be either:
-
-- A preset name from `modelPresets`, such as `"deep"`. This is the recommended form. The preset's full model, provider, generation, and context-window config is used.
-- An inline fallback object with at least `provider` and `model`. Optional `maxTokens`, `contextWindowTokens`, and `temperature` fields inherit from the active primary config when omitted. `reasoningEffort` does not inherit; omit it to leave reasoning off for that fallback, or set it explicitly for models that support reasoning.
+Each fallback candidate is a preset name from `modelPresets`, such as `"deep"`. The preset's complete model, provider, generation, context-window, and image-input configuration is used.
 
 Preset fallback chain:
 
 ```json
 {
   "modelPresets": {
+    "default": {
+      "model": "gpt-4.1-mini",
+      "provider": "openai",
+      "maxTokens": 4096,
+      "contextWindowTokens": 128000,
+      "temperature": 0.2
+    },
     "fast": {
       "model": "gpt-4.1-mini",
       "provider": "openai",
@@ -1469,37 +1462,7 @@ Preset fallback chain:
 }
 ```
 
-String entries are preset names, not raw model names. In the example above, `"deep"` means `modelPresets.deep`; nanobot will not interpret it as a provider model ID. Changing a preset updates both `/model <preset>` switching and any fallback chain that references it.
-
-Inline fallback object:
-
-```json
-{
-  "modelPresets": {
-    "fast": {
-      "provider": "openrouter",
-      "model": "anthropic/claude-sonnet-4.5",
-      "maxTokens": 4096,
-      "contextWindowTokens": 65536
-    }
-  },
-  "agents": {
-    "defaults": {
-      "modelPreset": "fast",
-      "fallbackModels": [
-        {
-          "provider": "deepseek",
-          "model": "deepseek-v4-pro",
-          "maxTokens": 4096,
-          "contextWindowTokens": 262144
-        }
-      ]
-    }
-  }
-}
-```
-
-Use inline objects only when a fallback is not worth naming as a reusable preset. `fallbackModels` belongs under `agents.defaults`, not inside individual `modelPresets` entries.
+String entries are preset names, not raw model names. In the example above, `"deep"` means `modelPresets.deep`; nanobot will not interpret it as a provider model ID. Changing a preset updates both `/model <preset>` switching and any fallback chain that references it. `fallbackModels` belongs under `agents.defaults`, not inside individual `modelPresets` entries.
 
 Failover normally runs when the primary provider returns a fallbackable model/provider error before any answer text has been streamed. Stream-stall timeouts are the recovery exception: if the provider already emitted partial answer text and then stalls, nanobot closes the current stream segment and retries/fails over in a new segment. Typical fallback cases include timeouts, connection errors, 5xx server errors, 429 rate limits, overloads, authentication/permission failures such as invalid or expired credentials, and quota/balance exhaustion. It does not run for malformed requests, content filtering/refusals, or context-length/message-format errors.
 

docs/provider-cookbook.md

@@ -34,7 +34,7 @@ Match the recipe to the credential or endpoint you already have:
 5. Run `nanobot agent -m "Hello!"`.
 6. If the CLI works, then connect WebUI, gateway, or chat apps.
 
-The active model should normally come from `agents.defaults.modelPreset`, and that name should point to an entry in `modelPresets`. Direct `agents.defaults.provider` and `agents.defaults.model` still work for older configs, but presets are easier to switch and easier to reuse as fallbacks.
+The active model comes from `agents.defaults.modelPreset`, and that name must point to an entry in `modelPresets`. Configure model/provider settings in presets so they can be switched and reused as fallbacks.
 
 ## Secret Setup
 

docs/providers.md

@@ -10,7 +10,7 @@ For every setup, answer three questions:
 2. What model name does that provider expect?
 3. Does the provider need `apiKey`, `apiBase`, OAuth login, cloud credentials, or only a local server URL?
 
-Prefer a named `modelPresets` entry for the model/provider pair, then select it with `agents.defaults.modelPreset`. Direct `agents.defaults.provider` and `agents.defaults.model` still work for existing configs, but presets make runtime `/model` switching and fallback chains clearer. Pin `provider` inside the preset while setting up; you can switch back to `"auto"` later.
+Define the model/provider pair as a named `modelPresets` entry, then select it with `agents.defaults.modelPreset`. Pin `provider` inside the preset while setting up; you can switch back to `"auto"` later.
 
 ## Choose a Provider Without Guessing
 
@@ -229,9 +229,7 @@ Arbitrary custom provider names are OpenAI-compatible only; they do not use the
 }
 ```
 
-`providers.openai.apiType` may be set when you need to force a specific OpenAI API surface. Other providers reject `apiType`; leave it unset outside `providers.openai`. Replace the model with a model ID available to your OpenAI account. Direct OpenAI Responses, OpenAI Codex, Azure OpenAI Responses, and eligible GitHub Copilot models share [opaque Responses state retention](./configuration.md#responses-state-and-compaction); native compaction is enabled only where the backend supports it.
-
-DeepSeek is the model-level exception in the OpenAI-compatible provider: `deepseek-v4-flash` automatically uses DeepSeek's native Responses API, while `deepseek-v4-pro` remains on Chat Completions.
+`providers.openai.apiType` may be set when you need to force a specific OpenAI API surface. Other providers reject `apiType`; leave it unset outside `providers.openai`. Replace the model with a model ID available to your OpenAI account.
 
 ### Custom OpenAI-Compatible Endpoint
 
@@ -460,18 +458,18 @@ For GitHub Copilot:
 nanobot provider login github-copilot --set-main
 ```
 
-Each command authenticates the selected provider and makes its current default model active. OpenAI Codex and eligible GitHub Copilot models participate in [Responses state retention](./configuration.md#responses-state-and-compaction), while native compaction remains provider-capability-specific. OAuth providers are not valid automatic fallbacks. See [`troubleshooting.md`](./troubleshooting.md#provider-and-model-problems) for proxy, headless-login, model-name, and config-key errors.
+Each command authenticates the selected provider and makes its current default model active. OAuth providers are not valid automatic fallbacks. See [`troubleshooting.md`](./troubleshooting.md#provider-and-model-problems) for proxy, headless-login, model-name, and config-key errors.
 
 ## Provider Resolution
 
-The recommended path is a named preset selected by `agents.defaults.modelPreset`. The effective model parameters come from:
+The effective model parameters come from:
 
 1. the named `modelPresets` entry referenced by `agents.defaults.modelPreset`;
-2. otherwise the implicit `default` preset built from `agents.defaults.model`, `provider`, `maxTokens`, `contextWindowTokens`, `temperature`, and related fields.
+2. otherwise the concrete `modelPresets.default` entry.
 
 Provider selection follows this practical rule:
 
-- Explicit `provider` in the active preset or implicit default config wins.
+- Explicit `provider` in the active preset wins.
 - `provider: "auto"` tries model-name keywords, configured keys, local base URLs, and gateway providers.
 - Gateway providers such as OpenRouter and AiHubMix can route many model families, so the model name must be valid for that gateway.
 - Local providers should normally be explicit because generic local model names such as `llama3.2` do not always contain provider keywords.
@@ -493,6 +491,14 @@ Model presets are the recommended model configuration surface. Use them when you
 ```json
 {
   "modelPresets": {
+    "default": {
+      "label": "Default",
+      "provider": "anthropic",
+      "model": "claude-opus-4-5",
+      "maxTokens": 8192,
+      "contextWindowTokens": 200000,
+      "temperature": 0.1
+    },
     "fast": {
       "label": "Fast",
       "provider": "openrouter",
@@ -518,7 +524,7 @@ Model presets are the recommended model configuration surface. Use them when you
 }
 ```
 
-The preset name `default` is reserved for the implicit `agents.defaults` settings. Do not define `modelPresets.default`; use `/model default` to return to the direct `agents.defaults.*` fields in older configs.
+Every config has a concrete `modelPresets.default` entry. Use `/model default` to return to it. Legacy direct model fields in `agents.defaults` are migrated from `config.json` on first load; configure presets only after migration.
 
 ## Fallback Models
 
@@ -527,6 +533,14 @@ Fallbacks are useful for transient provider failures, rate limits, or model avai
 ```json
 {
   "modelPresets": {
+    "default": {
+      "label": "Default",
+      "provider": "openrouter",
+      "model": "anthropic/claude-sonnet-4.5",
+      "maxTokens": 4096,
+      "contextWindowTokens": 65536,
+      "temperature": 0.1
+    },
     "fast": {
       "label": "Fast",
       "provider": "openrouter",
@@ -561,35 +575,7 @@ Fallbacks are useful for transient provider failures, rate limits, or model avai
 }
 ```
 
-String entries in `fallbackModels` are preset names, not raw model names. nanobot tries them in order after the active preset. Each fallback preset uses its own `provider`, `model`, `maxTokens`, `contextWindowTokens`, `temperature`, and optional `reasoningEffort`.
-
-Use inline fallback objects only when a model is not worth naming as a preset:
-
-```json
-{
-  "modelPresets": {
-    "fast": {
-      "provider": "openrouter",
-      "model": "anthropic/claude-sonnet-4.5",
-      "maxTokens": 4096,
-      "contextWindowTokens": 65536
-    }
-  },
-  "agents": {
-    "defaults": {
-      "modelPreset": "fast",
-      "fallbackModels": [
-        {
-          "provider": "deepseek",
-          "model": "deepseek-v4-pro",
-          "maxTokens": 4096,
-          "contextWindowTokens": 262144
-        }
-      ]
-    }
-  }
-}
-```
+String entries in `fallbackModels` are preset names, not raw model names. nanobot tries them in order after the active preset. Each fallback preset uses its own `provider`, `model`, `maxTokens`, `contextWindowTokens`, `temperature`, optional `reasoningEffort`, and `supportsImageInput` policy.
 
 `fallbackModels` belongs under `agents.defaults`, not inside each preset. If fallback candidates use smaller context windows, nanobot builds context using the smallest window in the active chain so every candidate can receive the same prompt. See [`configuration.md#model-fallbacks`](./configuration.md#model-fallbacks) for failure conditions.
 

docs/python-sdk.md

@@ -266,21 +266,10 @@ The config controls what nanobot may use. The workspace is where nanobot keeps
 state for that instance. See [multiple-instances.md](multiple-instances.md) for
 multi-instance CLI and gateway examples.
 
-### Choose a default or per-run model
+### Choose a default or per-run model preset
 
-Set the SDK instance default model when you create the bot:
-
-```python
-bot = Nanobot.from_config(model="openai/gpt-4.1")
-```
-
-Override the model for one run without changing the instance default:
-
-```python
-result = await bot.run("Summarize this file", model="openai/gpt-4.1-mini")
-```
-
-Model presets from `config.json` work the same way:
+Define complete model choices under `modelPresets` in `config.json`, then select
+them by name for the SDK instance or for one run:
 
 ```python
 bot = Nanobot.from_config(model_preset="fast")
@@ -288,7 +277,8 @@ bot = Nanobot.from_config(model_preset="fast")
 result = await bot.run("Think deeply about this bug", model_preset="reasoning")
 ```
 
-`model` and `model_preset` are mutually exclusive.
+The public SDK accepts preset names rather than raw model IDs. This keeps provider,
+generation, context-window, fallback, and image-input settings together.
 
 For first setup, prefer named presets in `config.json`. Mixing an API key from
 one provider with a model ID from another is the most common first-run failure.
@@ -463,7 +453,7 @@ configuration docs remain the source of truth for the runtime around it:
 
 ## API Reference
 
-### `Nanobot.from_config(config_path=None, *, workspace=None, model=None, model_preset=None)`
+### `Nanobot.from_config(config_path=None, *, workspace=None, model_preset=None)`
 
 Create a `Nanobot` instance from a config file.
 
@@ -471,11 +461,9 @@ Create a `Nanobot` instance from a config file.
 |-------|------|---------|-------------|
 | `config_path` | `str \| Path \| None` | `None` | Path to `config.json`. Defaults to `~/.nanobot/config.json`. |
 | `workspace` | `str \| Path \| None` | `None` | Override the workspace directory from config. |
-| `model` | `str \| None` | `None` | Override the instance default model. |
 | `model_preset` | `str \| None` | `None` | Override the instance default model preset from `config.json`. |
 
 Raises `FileNotFoundError` if an explicit config path does not exist.
-Raises `ValueError` if both `model` and `model_preset` are provided.
 
 ### `await bot.run(...)`
 
@@ -492,13 +480,12 @@ Run the agent once and return a `RunResult`.
 | `ephemeral` | `bool` | `False` | Run without persisting the turn or compacting session history. |
 | `attributes` | `Mapping[str, Any] \| None` | `None` | Caller-owned request data for host integrations. It is available to context providers and turn-hook factories, but is not added to trusted message metadata or persisted in session messages. |
 | `hooks` | `list[AgentHook] \| None` | `None` | Lifecycle hooks for this run only. |
-| `model` | `str \| None` | `None` | Override the model for this run only. |
 | `model_preset` | `str \| None` | `None` | Override the model preset for this run only. |
 
 Without an override, a run uses the preset saved in its session, or the configured
-default when that session has no saved selection. `model` and `model_preset` are
-mutually exclusive per-run overrides; they do not change the saved session selection
-or `bot.runtime.model` after the run completes.
+default when that session has no saved selection. A per-run `model_preset` override
+does not change the saved session selection or `bot.runtime.model` after the run
+completes.
 
 ### `await bot.run_streamed(...)`
 
@@ -535,7 +522,7 @@ async for event in bot.stream("Generate a long answer"):
 | `await aclose()` | Close the stream; equivalent cleanup primitive for `async with` / manual lifecycle code. |
 
 SDK runs with different session keys may overlap, including runs with per-run
-`model` or `model_preset` overrides. Each run receives an immutable runtime without
+`model_preset` overrides. Each run receives an immutable runtime without
 mutating the instance default. Runs sharing one session key remain serialized.
 
 ### `StreamEvent`

docs/troubleshooting.md

@@ -145,12 +145,12 @@ If you need a known-good snippet instead of diagnosis, use [`provider-cookbook.m
 |---|---|
 | 401, unauthorized, invalid API key | Key is missing, expired, pasted with whitespace, or under the wrong provider key. |
 | Model not found | The model ID belongs to a different provider or gateway. |
-| Provider cannot be inferred | Pin `modelPresets.<name>.provider` in the active preset instead of using `"auto"`. For legacy direct configs, pin `agents.defaults.provider`. |
+| Provider cannot be inferred | Pin `modelPresets.<name>.provider` in the active preset instead of using `"auto"`. |
 | Local model connection refused | Ollama, vLLM, LM Studio, or another local server is not running, or `apiBase` points to the wrong port. |
 | Bedrock validation error | Check AWS region, credentials, model access, model ID, and whether the model supports Converse. |
 | OAuth provider fails | Run the matching login command: `openai-codex`, `xai-grok`, or `github-copilot`, normally with `--set-main`. |
 | Codex OAuth needs a proxy | Set `providers.openaiCodex.proxy` before running the login command. The proxy applies to login, token refresh, and Codex API requests. |
-| Codex login runs on a remote/headless machine | In the WebUI, open ChatGPT in your local browser; when the localhost callback page cannot load, copy the full `http://localhost:1455/auth/callback?...` URL from the address bar and paste it into the WebUI dialog. From the CLI, open the printed URL locally and paste the same callback URL back into the terminal. |
+| Codex login runs on a remote/headless machine | Open the printed URL in a local browser, then paste the final `http://localhost:1455/auth/callback?...` URL back into the terminal. |
 | Codex login runs in Docker | Start the container with `docker run -it` so the OAuth flow has an interactive terminal. |
 | Codex says a model is not supported with a ChatGPT account | Use provider `openai_codex` with a Codex model such as `openai-codex/gpt-5.6-sol`. Do not use the direct-API `openai/...` prefix with Codex OAuth. |
 | Config says `providers.openai_codex` conflicts with the built-in provider | Under `providers`, keep only the canonical `openaiCodex` settings key and remove a duplicate `openai_codex` key. A model preset's `provider` value remains `openai_codex`. |

nanobot/__init__.py

@@ -6,32 +6,6 @@ import tomllib
 from importlib.metadata import PackageNotFoundError
 from importlib.metadata import version as _pkg_version
 from pathlib import Path
-from typing import TYPE_CHECKING, Any
-
-if TYPE_CHECKING:
-    from .agent.tools.context import RequestContext
-    from .bus.runtime_events import SessionTurnPersisted
-    from .nanobot import (
-        STREAM_EVENT_REASONING_COMPLETED,
-        STREAM_EVENT_REASONING_DELTA,
-        STREAM_EVENT_RUN_COMPLETED,
-        STREAM_EVENT_RUN_FAILED,
-        STREAM_EVENT_RUN_STARTED,
-        STREAM_EVENT_TEXT_COMPLETED,
-        STREAM_EVENT_TEXT_DELTA,
-        STREAM_EVENT_TOOL_COMPLETED,
-        STREAM_EVENT_TOOL_FAILED,
-        STREAM_EVENT_TOOL_STARTED,
-        STREAM_EVENT_TYPES,
-        Nanobot,
-        RunResult,
-        RunStream,
-        SessionInfo,
-        SessionSnapshot,
-        StreamEvent,
-        StreamEventType,
-    )
-    from .runtime_context import RuntimeContextBlock, RuntimeContextProvider
 
 
 def _read_pyproject_version() -> str | None:
@@ -80,7 +54,7 @@ _LAZY_EXPORTS = {
 }
 
 
-def __getattr__(name: str) -> Any:
+def __getattr__(name: str):
     module_path = _LAZY_EXPORTS.get(name)
     if module_path is None:
         raise AttributeError(f"module {__name__!r} has no attribute {name!r}")

nanobot/agent/autocompact.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 
 from collections.abc import Collection
 from datetime import datetime
-from typing import TYPE_CHECKING, Any, Callable, Coroutine, cast
+from typing import TYPE_CHECKING, Callable, Coroutine
 
 from loguru import logger
 
@@ -31,19 +31,9 @@ class AutoCompact:
                     now: datetime | None = None) -> bool:
         if self._ttl <= 0 or not ts:
             return False
-        try:
-            if isinstance(ts, str):
-                ts = datetime.fromisoformat(ts)
-            current = now or datetime.now()
-            if getattr(ts, "tzinfo", None) is not None or current.tzinfo is not None:
-                idle_seconds = current.timestamp() - ts.timestamp()
-            else:
-                idle_seconds = (current - ts).total_seconds()
-        except (OSError, OverflowError, TypeError, ValueError):
-            # list_sessions() forwards raw persisted metadata; an unusable value
-            # must not escape the idle scan and stop the agent loop.
-            return False
-        return idle_seconds >= self._ttl * 60
+        if isinstance(ts, str):
+            ts = datetime.fromisoformat(ts)
+        return ((now or datetime.now()) - ts).total_seconds() >= self._ttl * 60
 
     def _has_compactable_idle_tail(self, key: str) -> bool:
         session = self.sessions.get_or_create(key)
@@ -75,7 +65,7 @@ class AutoCompact:
 
     def check_expired(
         self,
-        schedule_background: Callable[[Coroutine[Any, Any, None]], None],
+        schedule_background: Callable[[Coroutine], None],
         resolve_runtime: Callable[[Session], LLMRuntime],
         active_session_keys: Collection[str] = (),
     ) -> None:
@@ -113,8 +103,8 @@ class AutoCompact:
                 meta = session.metadata.get("_last_summary")
                 if isinstance(meta, dict):
                     self._summaries[key] = (
-                        cast(str, meta["text"]),
-                        datetime.fromisoformat(cast(str, meta["last_active"])),
+                        meta["text"],
+                        datetime.fromisoformat(meta["last_active"]),
                     )
         except Exception:
             logger.exception("Auto-compact: failed for {}", key)
@@ -134,21 +124,7 @@ class AutoCompact:
         if entry:
             return session, self._format_summary(entry[0], entry[1])
         # Cold path: summary persisted in session metadata (process restarted).
-        # Persisted metadata may outlive schema changes; a malformed summary must
-        # not abort turn preparation.
         meta = session.metadata.get("_last_summary")
         if isinstance(meta, dict):
-            summary_meta = cast(dict[str, object], meta)
-            text = summary_meta.get("text")
-            if isinstance(text, str) and text:
-                raw_last_active = summary_meta.get("last_active")
-                try:
-                    last_active = (
-                        datetime.fromisoformat(raw_last_active)
-                        if isinstance(raw_last_active, str)
-                        else session.updated_at
-                    )
-                except ValueError:
-                    last_active = session.updated_at
-                return session, self._format_summary(text, last_active)
+            return session, self._format_summary(meta["text"], datetime.fromisoformat(meta["last_active"]))
         return session, None

nanobot/agent/context.py

@@ -4,7 +4,7 @@ import base64
 import mimetypes
 import platform
 from pathlib import Path
-from typing import Any, Mapping, Sequence, cast
+from typing import Any, Mapping, Sequence
 
 from nanobot.agent.memory import MemoryStore
 from nanobot.agent.skills import SkillsLoader
@@ -15,10 +15,13 @@ from nanobot.apps.cli import utils as cli_app_utils
 from nanobot.bus.events import InboundMessage
 from nanobot.runtime_context import (
     RUNTIME_CONTEXT_END,
+    RUNTIME_CONTEXT_HISTORY_META,
     RUNTIME_CONTEXT_MESSAGE_META,
     RUNTIME_CONTEXT_TAG,
     RuntimeContextBlock,
     append_runtime_context,
+    detach_runtime_context,
+    reattach_runtime_context,
 )
 from nanobot.utils.helpers import (
     detect_image_mime,
@@ -60,6 +63,9 @@ class ContextBuilder:
     _MAX_RECENT_HISTORY = 50
     _MAX_HISTORY_TOKENS = 8_000  # hard cap on recent history section size (tokens)
     _RUNTIME_CONTEXT_END = RUNTIME_CONTEXT_END
+    _MISSING_IMAGE_TEXT = (
+        "[Image attachment unavailable — do not describe or reference it]"
+    )
 
     def __init__(self, workspace: Path, timezone: str | None = None, disabled_skills: list[str] | None = None):
         self.workspace = workspace
@@ -70,7 +76,6 @@ class ContextBuilder:
     def build_system_prompt(
         self,
         *,
-        active_skill_names: Sequence[str] | None = None,
         channel: str | None = None,
         session_summary: str | None = None,
         workspace: Path | None = None,
@@ -92,18 +97,13 @@ class ContextBuilder:
         if memory and not self._is_template_content(memory, "memory/MEMORY.md"):
             parts.append(f"# Memory\n\n## Long-term Memory\n{memory}")
 
-        active_skills = self.skills.get_always_skills()
-        active_skills.extend(
-            name
-            for name in (active_skill_names or ())
-            if name not in active_skills
-        )
-        if active_skills:
-            active_content = self.skills.load_skills_for_context(active_skills)
-            if active_content:
-                parts.append(f"# Active Skills\n\n{active_content}")
+        always_skills = self.skills.get_always_skills()
+        if always_skills:
+            always_content = self.skills.load_skills_for_context(always_skills)
+            if always_content:
+                parts.append(f"# Active Skills\n\n{always_content}")
 
-        skills_summary = self.skills.build_skills_summary(exclude=set(active_skills))
+        skills_summary = self.skills.build_skills_summary(exclude=set(always_skills))
         if skills_summary:
             parts.append(render_template("agent/skills_section.md", skills_summary=skills_summary))
 
@@ -154,12 +154,7 @@ class ContextBuilder:
 
         def _to_blocks(value: Any) -> list[dict[str, Any]]:
             if isinstance(value, list):
-                return [
-                    cast(dict[str, Any], item)
-                    if isinstance(item, dict)
-                    else {"type": "text", "text": str(item)}
-                    for item in cast(list[Any], value)
-                ]
+                return [item if isinstance(item, dict) else {"type": "text", "text": str(item)} for item in value]
             if value is None:
                 return []
             return [{"type": "text", "text": str(value)}]
@@ -168,7 +163,7 @@ class ContextBuilder:
 
     def _load_bootstrap_files(self, workspace: Path | None = None) -> str:
         """Load project instructions plus the agent's global profile files."""
-        parts: list[str] = []
+        parts = []
         project_root = workspace or self.workspace
         sources = [
             ("AGENTS.md", project_root),
@@ -217,21 +212,16 @@ class ContextBuilder:
         include_memory_recent_history: bool = True,
         session_key: str | None = None,
         unified_session: bool = False,
-        conversation_only: bool = False,
     ) -> list[dict[str, Any]]:
         """Build the complete message list for an LLM call."""
-        messages = list(history)
-        if not conversation_only:
-            root = workspace or self.workspace
-            active_skill_names = (
-                self.skills.get_explicitly_invoked_skills(current_message)
-                if current_role == "user"
-                else []
-            )
-            messages.insert(0, {
+        root = workspace or self.workspace
+        user_content = self.build_user_content(current_message, image_paths=media)
+        blocks = list(runtime_context_blocks or ()) if current_role == "user" else []
+        merged, runtime_context_meta = append_runtime_context(user_content, blocks)
+        messages = [
+            {
                 "role": "system",
                 "content": self.build_system_prompt(
-                    active_skill_names=active_skill_names,
                     channel=channel,
                     session_summary=session_summary,
                     workspace=root,
@@ -239,48 +229,24 @@ class ContextBuilder:
                     session_key=session_key,
                     unified_session=unified_session,
                 ),
-            })
-        current = self.build_current_message(
-            current_message,
-            media=media,
-            current_role=current_role,
-            runtime_context_blocks=runtime_context_blocks,
-        )
-        if messages and messages[-1].get("role") == current_role:
+            },
+            *self._hydrate_history_media(history),
+        ]
+        if messages[-1].get("role") == current_role:
             last = dict(messages[-1])
-            last["content"] = self._merge_message_content(
-                last.get("content"),
-                current.get("content"),
-            )
-            current_meta = current.get("_meta")
-            if current_role == "user" and isinstance(current_meta, dict):
+            last["content"] = self._merge_message_content(last.get("content"), merged)
+            if current_role == "user" and runtime_context_meta is not None:
                 internal_meta = dict(last.get("_meta") or {})
-                internal_meta.update(cast(dict[str, Any], current_meta))
+                internal_meta[RUNTIME_CONTEXT_MESSAGE_META] = runtime_context_meta
                 last["_meta"] = internal_meta
             messages[-1] = last
             return messages
+        current = {"role": current_role, "content": merged}
+        if current_role == "user" and runtime_context_meta is not None:
+            current["_meta"] = {RUNTIME_CONTEXT_MESSAGE_META: runtime_context_meta}
         messages.append(current)
         return messages
 
-    def build_current_message(
-        self,
-        current_message: str,
-        *,
-        media: list[str] | None = None,
-        current_role: str = "user",
-        runtime_context_blocks: Sequence[RuntimeContextBlock] | None = None,
-    ) -> dict[str, Any]:
-        """Build only the fresh turn message without merging it into history."""
-        content = self.build_user_content(current_message, image_paths=media)
-        blocks = list(runtime_context_blocks or ()) if current_role == "user" else []
-        merged, runtime_context_meta = append_runtime_context(content, blocks)
-        current: dict[str, Any] = {"role": current_role, "content": merged}
-        if current_role == "user" and runtime_context_meta is not None:
-            current["_meta"] = {
-                RUNTIME_CONTEXT_MESSAGE_META: runtime_context_meta,
-            }
-        return current
-
     def build_user_content(
         self,
         text: str,
@@ -290,10 +256,13 @@ class ContextBuilder:
         if not image_paths:
             return text
 
-        image_blocks: list[dict[str, Any]] = []
+        image_blocks = []
         for path in image_paths:
             p = Path(path)
             if not p.is_file():
+                image_blocks.append(
+                    {"type": "text", "text": self._MISSING_IMAGE_TEXT}
+                )
                 continue
             raw = p.read_bytes()
             # Re-detect from the bytes used for the request: the file may have
@@ -311,3 +280,45 @@ class ContextBuilder:
         if not image_blocks:
             return text
         return image_blocks + [{"type": "text", "text": text}]
+
+    def _hydrate_history_media(
+        self,
+        history: list[dict[str, Any]],
+    ) -> list[dict[str, Any]]:
+        """Rebuild persisted user media into the same blocks used on first send."""
+        hydrated: list[dict[str, Any]] = []
+        for message in history:
+            clean = dict(message)
+            media_paths = clean.pop("_media_paths", None)
+            runtime_context = clean.pop(RUNTIME_CONTEXT_HISTORY_META, None)
+            if (
+                clean.get("role") == "user"
+                and isinstance(clean.get("content"), str)
+                and isinstance(media_paths, list)
+                and media_paths
+            ):
+                visible_content = clean["content"]
+                detached = (
+                    detach_runtime_context(visible_content, runtime_context)
+                    if isinstance(runtime_context, Mapping)
+                    else None
+                )
+                if detached is not None:
+                    visible_content, sources, context_blocks = detached
+                hydrated_content = self.build_user_content(
+                    visible_content,
+                    image_paths=[
+                        path
+                        for path in media_paths
+                        if isinstance(path, str) and path
+                    ],
+                )
+                if detached is not None:
+                    hydrated_content, _ = reattach_runtime_context(
+                        hydrated_content,
+                        sources,
+                        context_blocks,
+                    )
+                clean["content"] = hydrated_content
+            hydrated.append(clean)
+        return hydrated

nanobot/agent/context_governance.py

@@ -9,7 +9,7 @@ from __future__ import annotations
 
 from dataclasses import dataclass
 from pathlib import Path
-from typing import TYPE_CHECKING, Any, cast
+from typing import TYPE_CHECKING, Any
 
 from loguru import logger
 
@@ -23,7 +23,6 @@ from nanobot.utils.helpers import (
 from nanobot.utils.runtime import ensure_nonempty_tool_result
 
 if TYPE_CHECKING:
-    from nanobot.agent.tools.registry import ToolRegistry
     from nanobot.providers.base import LLMProvider
 
 SNIP_SAFETY_BUFFER = 1024
@@ -50,9 +49,8 @@ def _tool_call_name_is_valid(tool_call: Any) -> bool:
     """
     if not isinstance(tool_call, dict):
         return False
-    tool_call_data = cast(dict[str, Any], tool_call)
-    fn = tool_call_data.get("function")
-    name = cast(dict[str, Any], fn).get("name") if isinstance(fn, dict) else tool_call_data.get("name")
+    fn = tool_call.get("function")
+    name = fn.get("name") if isinstance(fn, dict) else tool_call.get("name")
     return isinstance(name, str) and bool(name)
 
 
@@ -60,7 +58,7 @@ def _tool_call_name_is_valid(tool_call: Any) -> bool:
 class ContextGovernanceConfig:
     provider: LLMProvider
     model: str
-    tools: ToolRegistry
+    tools: Any
     workspace: Path | None
     session_key: str | None
     max_tool_result_chars: int
@@ -201,7 +199,7 @@ class ContextGovernor:
                 if updated is not None:
                     updated.append(msg)
                 continue
-            kept = [tc for tc in cast(list[Any], calls) if _tool_call_name_is_valid(tc)]
+            kept = [tc for tc in calls if _tool_call_name_is_valid(tc)]
             if len(kept) == len(calls):
                 if updated is not None:
                     updated.append(msg)
@@ -240,11 +238,9 @@ class ContextGovernor:
         for idx, msg in enumerate(messages):
             role = msg.get("role")
             if role == "assistant":
-                for tc in cast(list[Any], msg.get("tool_calls") or []):
-                    if isinstance(tc, dict):
-                        tool_call = cast(dict[str, Any], tc)
-                        if tool_call.get("id"):
-                            declared.add(str(tool_call["id"]))
+                for tc in msg.get("tool_calls") or []:
+                    if isinstance(tc, dict) and tc.get("id"):
+                        declared.add(str(tc["id"]))
             if role == "tool":
                 tid = msg.get("tool_call_id")
                 tid_str = str(tid) if tid else ""
@@ -270,17 +266,13 @@ class ContextGovernor:
         for idx, msg in enumerate(messages):
             role = msg.get("role")
             if role == "assistant":
-                for tc in cast(list[Any], msg.get("tool_calls") or []):
-                    if isinstance(tc, dict):
+                for tc in msg.get("tool_calls") or []:
+                    if isinstance(tc, dict) and tc.get("id"):
                         name = ""
-                        tool_call = cast(dict[str, Any], tc)
-                        if tool_call.get("id"):
-                            func = tool_call.get("function")
-                            if isinstance(func, dict):
-                                func_data = cast(dict[str, Any], func)
-                                raw_name = func_data.get("name", "")
-                                name = raw_name if isinstance(raw_name, str) else str(raw_name)
-                            declared.append((idx, str(tool_call["id"]), name))
+                        func = tc.get("function")
+                        if isinstance(func, dict):
+                            name = func.get("name", "")
+                        declared.append((idx, str(tc["id"]), name))
             elif role == "tool":
                 tid = msg.get("tool_call_id")
                 if tid:

nanobot/agent/hooks/file_edit_activity.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 
 from collections.abc import Awaitable, Callable
 from pathlib import Path
-from typing import Any, cast
+from typing import Any
 
 from nanobot.agent.hook import (
     AgentHook,
@@ -56,21 +56,17 @@ class FileEditActivityHook(AgentHook):
     ) -> None:
         if self._on_progress is None or not isinstance(params, dict):
             return
-        typed_params = cast(dict[str, Any], params)
         trackers = prepare_file_edit_trackers(
             call_id=tool_call.id,
             tool_name=tool_call.name,
             tool=tool,
             workspace=self._workspace,
-            params=typed_params,
+            params=params,
         )
         if not trackers:
             return
         self._trackers_by_call[self._tool_call_key(tool_call)] = trackers
-        await self._emit([
-            build_file_edit_start_event(tracker, typed_params)
-            for tracker in trackers
-        ])
+        await self._emit([build_file_edit_start_event(tracker, params) for tracker in trackers])
 
     async def after_execute_tool(
         self,

nanobot/agent/loop.py

@@ -1,7 +1,5 @@
 """Agent loop: the core processing engine."""
 
-# pyright: reportPrivateUsage=false
-
 from __future__ import annotations
 
 import asyncio
@@ -9,14 +7,13 @@ import dataclasses
 import inspect
 import os
 import time
-import weakref
-from collections.abc import Coroutine, Iterable, Mapping
+from collections.abc import Mapping
 from contextlib import AbstractContextManager, ExitStack, nullcontext, suppress
 from dataclasses import dataclass, field
 from enum import Enum, auto
 from functools import partial
 from pathlib import Path
-from typing import TYPE_CHECKING, Any, Awaitable, Callable, TypeVar, cast
+from typing import TYPE_CHECKING, Any, Awaitable, Callable, TypeVar
 
 from loguru import logger
 
@@ -49,7 +46,7 @@ from nanobot.bus.queue import MessageBus
 from nanobot.bus.runtime_events import RuntimeEventBus
 from nanobot.command import CommandContext, CommandRouter, register_builtin_commands
 from nanobot.config.schema import AgentDefaults, ModelPresetConfig
-from nanobot.providers.base import LLMProvider, ProviderConversationState
+from nanobot.providers.base import LLMProvider
 from nanobot.providers.factory import ProviderSnapshot
 from nanobot.runtime_context import (
     RUNTIME_CONTEXT_HISTORY_META,
@@ -97,16 +94,12 @@ if TYPE_CHECKING:
     from nanobot.agent.tools.mcp import MCPConnection
     from nanobot.config.schema import (
         ChannelsConfig,
-        Config,
-        MCPServerConfig,
         ProviderConfig,
         ToolsConfig,
     )
     from nanobot.cron.service import CronService
-    from nanobot.triggers.local_store import LocalTriggerStore
 
 _T = TypeVar("_T")
-_SUBAGENT_PROVIDER_TASK_META = "subagent_provider_task_id"
 
 
 class TurnKind(Enum):
@@ -127,7 +120,6 @@ class TurnContext:
 
     history: list[dict[str, Any]] = field(default_factory=list)
     initial_messages: list[dict[str, Any]] = field(default_factory=list)
-    provider_state: ProviderConversationState | None = field(default=None, repr=False)
     request_context: RequestContext | None = None
     runtime_context_blocks: list[RuntimeContextBlock] = field(default_factory=list)
     attributes: dict[str, Any] = field(default_factory=dict)
@@ -150,7 +142,7 @@ class TurnContext:
     on_runtime_admitted: Callable[[LLMRuntime], Awaitable[None]] | None = None
     on_retry_wait: Callable[[str], Awaitable[None]] | None = None
 
-    pending_queue: asyncio.Queue[InboundMessage] | None = None
+    pending_queue: asyncio.Queue | None = None
     pending_summary: str | None = None
 
     ephemeral: bool = False
@@ -164,18 +156,6 @@ class TurnContext:
     visible_run_started_at: float | None = None
     turn_latency_ms: int | None = None
 
-    def require_runtime(self) -> LLMRuntime:
-        """Return the runtime established by the BUILD stage."""
-        if self.runtime is None:
-            raise RuntimeError("turn runtime is not initialized; BUILD must run before this stage")
-        return self.runtime
-
-    def require_session(self) -> Session:
-        """Return the session established by the RESTORE stage."""
-        if self.session is None:
-            raise RuntimeError("turn session is not initialized; RESTORE must run before this stage")
-        return self.session
-
 
 class AgentLoop:
     """
@@ -245,8 +225,6 @@ class AgentLoop:
 
     _RUNTIME_CHECKPOINT_KEY = "runtime_checkpoint"
     _PENDING_USER_TURN_KEY = "pending_user_turn"
-    _PROVIDER_STATE_CHECKPOINT_VERSION_KEY = "provider_state_checkpoint_version"
-    _PROVIDER_STATE_CHECKPOINT_VERSION = "v1"
 
     def __init__(
         self,
@@ -265,7 +243,7 @@ class AgentLoop:
         cron_service: CronService | None = None,
         restrict_to_workspace: bool = False,
         session_manager: SessionManager | None = None,
-        mcp_servers: dict[str, MCPServerConfig] | None = None,
+        mcp_servers: dict | None = None,
         channels_config: ChannelsConfig | None = None,
         timezone: str | None = None,
         session_ttl_minutes: int = 0,
@@ -288,7 +266,7 @@ class AgentLoop:
         turn_delivery_factory: TurnDeliveryFactory | None = None,
         runtime_model_publisher: Callable[[str, str | None], None] | None = None,
         restart_mode: str = "auto",
-        local_trigger_store: LocalTriggerStore | None = None,
+        local_trigger_store: Any | None = None,
         idle_compact_check_interval_seconds: int = 0,
     ):
         from nanobot.config.schema import ToolsConfig
@@ -321,7 +299,7 @@ class AgentLoop:
         initial_context_window = (
             context_window_tokens
             if context_window_tokens is not None
-            else defaults.context_window_tokens
+            else ModelPresetConfig(model=initial_model).context_window_tokens
         )
         configured_presets = model_presets or {}
         self.runtime_resolver = ModelRuntimeResolver(
@@ -399,13 +377,11 @@ class AgentLoop:
         self._runtime_context_providers: list[RuntimeContextProvider] = []
         self._active_tasks: dict[str, set[asyncio.Task[Any]]] = {}
         self._background_tasks: set[asyncio.Task[Any]] = set()
-        self._session_locks: weakref.WeakValueDictionary[str, asyncio.Lock] = (
-            weakref.WeakValueDictionary()
-        )
+        self._session_locks: dict[str, asyncio.Lock] = {}
         # Per-session pending queues for mid-turn message injection.
         # When a session has an active task, new messages for that session
         # are routed here instead of creating a new task.
-        self._pending_queues: dict[str, asyncio.Queue[InboundMessage]] = {}
+        self._pending_queues: dict[str, asyncio.Queue] = {}
         self._deferred_automation_turns: dict[str, list[InboundMessage]] = {}
         self._cron_turns = CronTurnCoordinator(
             publish_inbound=self.bus.publish_inbound,
@@ -454,7 +430,7 @@ class AgentLoop:
     @classmethod
     def from_config(
         cls,
-        config: Config,
+        config: Any,
         bus: MessageBus | None = None,
         **extra: Any,
     ) -> AgentLoop:
@@ -469,15 +445,20 @@ class AgentLoop:
         if bus is None:
             bus = MessageBus()
         defaults = config.agents.defaults
-        provider = extra.pop("provider", None) or make_provider(config)
+        explicit_provider = extra.pop("provider", None)
+        provider = explicit_provider or make_provider(config)
         resolved = config.resolve_preset()
         model = extra.pop("model", None) or resolved.model
         context_window_tokens = extra.pop("context_window_tokens", None) or resolved.context_window_tokens
         provider_snapshot_loader = extra.pop("provider_snapshot_loader", None)
-        preset_snapshot_loader = extra.pop("preset_snapshot_loader", None) or preset_helpers.make_preset_snapshot_loader(
-            config,
-            provider_snapshot_loader,
-        )
+        preset_snapshot_loader = extra.pop("preset_snapshot_loader", None)
+        if preset_snapshot_loader is None and (
+            explicit_provider is None or provider_snapshot_loader is not None
+        ):
+            preset_snapshot_loader = preset_helpers.make_preset_snapshot_loader(
+                config,
+                provider_snapshot_loader,
+            )
         return cls(
             bus=bus,
             provider=provider,
@@ -681,17 +662,12 @@ class AgentLoop:
         """
         if not turn_continuation.should_persist_user_message(msg.metadata):
             return False
-        media_paths = [
-            path
-            for path in (msg.media or [])
-            if isinstance(cast(object, path), str) and path
-        ]
-        content_value = cast(object, msg.content)
-        has_text = isinstance(content_value, str) and content_value.strip()
+        media_paths = [p for p in (msg.media or []) if isinstance(p, str) and p]
+        has_text = isinstance(msg.content, str) and msg.content.strip()
         if has_text or media_paths or runtime_context_blocks:
             extra: dict[str, Any] = ({"media": list(media_paths)} if media_paths else {}) | agent_context.session_extra(msg.metadata)
             extra.update(kwargs)
-            text = content_value if isinstance(content_value, str) else ""
+            text = msg.content if isinstance(msg.content, str) else ""
             text_override, automation_extra = automation_history_overrides(msg.metadata)
             if text_override is not None:
                 text = text_override
@@ -723,7 +699,6 @@ class AgentLoop:
             include_memory_recent_history=not ctx.ephemeral,
             session_key=ctx.session.key,
             unified_session=self._unified_session,
-            conversation_only=ctx.session.transient is True,
         )
 
     def _request_context_for_turn(self, ctx: TurnContext) -> RequestContext:
@@ -751,12 +726,10 @@ class AgentLoop:
         self,
         ctx: TurnContext,
     ) -> list[RuntimeContextBlock]:
-        if ctx.require_session().transient is True:
-            return []
         assert ctx.request_context is not None
         return await self._resolve_runtime_context_for_request(
             ctx.request_context,
-            ctx.tools if ctx.tools is not None else self.tools,
+            ctx.tools or self.tools,
         )
 
     async def _resolve_runtime_context_for_request(
@@ -787,24 +760,18 @@ class AgentLoop:
         else:
             logger.warning("Command '{}' matched but dispatch returned None", raw)
 
-    async def cancel_active_turn(self, key: str) -> int:
-        """Cancel active work and discard queued follow-ups for *key*.
+    async def _cancel_active_tasks(self, key: str) -> int:
+        """Cancel and await all active tasks and subagents for *key*.
 
         Returns the total number of cancelled tasks + subagents.
         """
-        pending = self._pending_queues.pop(key, None)
-        queued = 0
-        if pending is not None:
-            while not pending.empty():
-                pending.get_nowait()
-                queued += 1
         tasks = tuple(self._active_tasks.pop(key, set()))
         cancelled = sum(1 for t in tasks if not t.done() and t.cancel())
         for t in tasks:
             with suppress(asyncio.CancelledError, Exception):
                 await t
         sub_cancelled = await self.subagents.cancel_by_session(key)
-        return queued + cancelled + sub_cancelled
+        return cancelled + sub_cancelled
 
     def _effective_session_key(self, msg: InboundMessage) -> str:
         """Return the session key used for task routing and mid-turn injections."""
@@ -848,7 +815,7 @@ class AgentLoop:
 
     async def _run_agent_loop(
         self,
-        initial_messages: list[dict[str, Any]],
+        initial_messages: list[dict],
         on_progress: Callable[..., Awaitable[None]] | None = None,
         on_stream: Callable[[str], Awaitable[None]] | None = None,
         on_stream_end: Callable[..., Awaitable[None]] | None = None,
@@ -862,7 +829,7 @@ class AgentLoop:
         metadata: dict[str, Any] | None = None,
         session_key: str | None = None,
         original_user_text: str | None = None,
-        pending_queue: asyncio.Queue[InboundMessage] | None = None,
+        pending_queue: asyncio.Queue | None = None,
         ephemeral: bool = False,
         run_extra_hooks_for_ephemeral: bool = False,
         hooks: list[AgentHook] | None = None,
@@ -870,8 +837,7 @@ class AgentLoop:
         turn_scopes: list[AbstractContextManager[Any]] | None = None,
         tools: ToolRegistry | None = None,
         request_context: RequestContext | None = None,
-        provider_state: ProviderConversationState | None = None,
-    ) -> tuple[str | None, list[str], list[dict[str, Any]], str, bool]:
+    ) -> tuple[str | None, list[str], list[dict], str, bool]:
         """Run the agent iteration loop.
 
         *on_stream*: called with each content delta during streaming.
@@ -886,18 +852,7 @@ class AgentLoop:
         async def _checkpoint(payload: dict[str, Any]) -> None:
             if session is None:
                 return
-            public_payload = dict(payload)
-            private_state = public_payload.pop("provider_state", None)
-            public_payload.pop(self._PROVIDER_STATE_CHECKPOINT_VERSION_KEY, None)
-            if "provider_state" in payload and (
-                private_state is None
-                or isinstance(private_state, ProviderConversationState)
-            ):
-                session.provider_state = private_state
-                public_payload[self._PROVIDER_STATE_CHECKPOINT_VERSION_KEY] = (
-                    self._PROVIDER_STATE_CHECKPOINT_VERSION
-                )
-            self._set_runtime_checkpoint(session, public_payload)
+            self._set_runtime_checkpoint(session, payload)
 
         async def _drain_pending(*, limit: int = _MAX_INJECTIONS_PER_TURN) -> list[dict[str, Any]]:
             """Drain follow-up messages from the pending queue.
@@ -925,16 +880,8 @@ class AgentLoop:
                     image_paths=image_paths,
                 )
                 row: dict[str, Any] = {"role": "user", "content": user_content}
-                metadata_value = cast(object, pending_msg.metadata)
-                metadata = (
-                    pending_msg.metadata
-                    if isinstance(metadata_value, dict)
-                    else {}
-                )
-                if (
-                    pending_msg.channel != "system"
-                    and not (session is not None and session.transient is True)
-                ):
+                metadata = pending_msg.metadata if isinstance(pending_msg.metadata, dict) else {}
+                if pending_msg.channel != "system":
                     scope = self.workspace_scopes.for_turn(
                         channel=pending_msg.channel,
                         message_metadata=metadata,
@@ -957,24 +904,19 @@ class AgentLoop:
                         pending_request,
                         effective_tools,
                     )
-                    row["content"], runtime_marker = append_runtime_context(
-                        user_content,
-                        blocks,
-                    )
-                    if runtime_marker is not None:
-                        row["_meta"] = {
-                            RUNTIME_CONTEXT_MESSAGE_META: runtime_marker,
-                        }
+                    row["content"], marker = append_runtime_context(user_content, blocks)
+                    if marker is not None:
+                        row["_meta"] = {RUNTIME_CONTEXT_MESSAGE_META: marker}
                 if (
                     pending_msg.sender_id == "subagent"
                     and metadata.get("injected_event") == "subagent_result"
                 ):
-                    subagent_marker: dict[str, Any] = {"kind": "subagent_result"}
+                    marker: dict[str, Any] = {"kind": "subagent_result"}
                     task_id = metadata.get("subagent_task_id")
                     if isinstance(task_id, str) and task_id:
-                        subagent_marker["subagent_task_id"] = task_id
+                        marker["subagent_task_id"] = task_id
                         row["subagent_task_id"] = task_id
-                    row[HIDDEN_HISTORY_META] = subagent_marker
+                    row[HIDDEN_HISTORY_META] = marker
                     row["injected_event"] = "subagent_result"
                 return row
 
@@ -1014,7 +956,7 @@ class AgentLoop:
             message_metadata=metadata,
             session_metadata=session.metadata if session is not None else None,
         )
-        effective_tools = tools if tools is not None else self.tools
+        effective_tools = tools or self.tools
         request_ctx = request_context or RequestContext(
             channel=channel,
             chat_id=chat_id,
@@ -1098,7 +1040,6 @@ class AgentLoop:
                     session_metadata=session_metadata,
                     message_metadata=metadata,
                 ),
-                provider_state=provider_state,
             ))
         finally:
             turn_scope_stack.close()
@@ -1106,8 +1047,6 @@ class AgentLoop:
             reset_request_context(request_token)
             reset_file_states(file_state_token)
         self._last_usage = result.usage
-        if session is not None and not ephemeral:
-            session.provider_state = result.provider_state
         if result.stop_reason == "max_iterations":
             logger.warning("Max iterations ({}) reached", self.max_iterations)
             should_stream = turn_continuation.should_stream_budget_response(
@@ -1137,7 +1076,7 @@ class AgentLoop:
             return
         self._next_idle_compact_check_at = now + self._idle_compact_check_interval_s
         self.auto_compact.check_expired(
-            self.schedule_background,
+            self._schedule_background,
             self.runtime_for_session,
             active_session_keys=self._pending_queues.keys(),
         )
@@ -1172,11 +1111,6 @@ class AgentLoop:
                 effective_key = self._effective_session_key(msg)
                 if await agent_context.handle_runtime_control(self, msg, self.tools):
                     continue
-                if (
-                    msg.transient_session
-                    and not self.sessions.is_transient_active(effective_key)
-                ):
-                    continue
                 if self.commands.is_priority(raw):
                     await self._dispatch_command_inline(
                         msg, effective_key, raw,
@@ -1245,11 +1179,11 @@ class AgentLoop:
         session_key = self._effective_session_key(msg)
         if session_key != msg.session_key:
             msg = dataclasses.replace(msg, session_key_override=session_key)
-        lock = self._get_session_lock(session_key)
+        lock = self._session_locks.setdefault(session_key, asyncio.Lock())
         gate = self._concurrency_gate or nullcontext()
 
         delivery = self.turn_delivery_factory.unrouted(msg, session_key)
-        pending: asyncio.Queue[InboundMessage] | None = None
+        pending: asyncio.Queue | None = None
         try:
             async with lock, gate:
                 # Only the task that owns the session lock may publish the
@@ -1288,8 +1222,6 @@ class AgentLoop:
                             session_key,
                             exc_info=True,
                         )
-                    if msg.transient_session:
-                        raise
                     # Preserve partial context from the interrupted turn so
                     # the user does not lose tool results and assistant
                     # messages accumulated before /stop.  The checkpoint was
@@ -1377,7 +1309,7 @@ class AgentLoop:
         if errors:
             raise BaseExceptionGroup("failed to close agent resources", errors)
 
-    def schedule_background(self, coro: Coroutine[Any, Any, Any]) -> None:
+    def _schedule_background(self, coro) -> None:
         """Schedule a coroutine as a tracked background task (drained on shutdown)."""
         task = asyncio.create_task(coro)
         self._background_tasks.add(task)
@@ -1395,7 +1327,7 @@ class AgentLoop:
         on_progress: Callable[..., Awaitable[None]] | None = None,
         on_stream: Callable[[str], Awaitable[None]] | None = None,
         on_stream_end: Callable[..., Awaitable[None]] | None = None,
-        pending_queue: asyncio.Queue[InboundMessage] | None = None,
+        pending_queue: asyncio.Queue | None = None,
         ephemeral: bool = False,
         run_extra_hooks_for_ephemeral: bool = False,
         hooks: list[AgentHook] | None = None,
@@ -1591,38 +1523,27 @@ class AgentLoop:
         # ensure it exists in case this handler is invoked independently.
         if ctx.session is None:
             ctx.session = self.sessions.get_or_create(ctx.session_key)
-        session = ctx.session
-        if session.transient is True:
-            ctx.ephemeral = True
-            ctx.tools = ToolRegistry()
         self._remember_unified_session_route(
-            session,
+            ctx.session,
             msg,
             is_user_turn=ctx.original_user_text is not None,
         )
         await ctx.delivery.started()
-        if ctx.kind is TurnKind.USER and not session.transient:
-            self.workspace_scopes.persist_message_scope(session, msg)
+        if ctx.kind is TurnKind.USER:
+            self.workspace_scopes.persist_message_scope(ctx.session, msg)
 
-        if self._restore_runtime_checkpoint(session):
-            self.sessions.save(session)
-        if self._restore_pending_user_turn(session):
-            self.sessions.save(session)
+        if self._restore_runtime_checkpoint(ctx.session):
+            self.sessions.save(ctx.session)
+        if self._restore_pending_user_turn(ctx.session):
+            self.sessions.save(ctx.session)
 
     async def _compact_session(self, ctx: TurnContext) -> None:
-        session = ctx.require_session()
-        if session.transient is True:
-            return
-        ctx.session, pending = self.auto_compact.prepare_session(
-            session,
-            ctx.session_key,
-        )
+        ctx.session, pending = self.auto_compact.prepare_session(ctx.session, ctx.session_key)
         ctx.pending_summary = pending
 
     async def _dispatch_command(self, ctx: TurnContext) -> bool:
         if ctx.kind is TurnKind.SYSTEM:
             return False
-        session = ctx.require_session()
         raw = ctx.msg.content.strip()
         _, automation_metadata = automation_history_overrides(ctx.msg.metadata)
         is_user_turn = (
@@ -1633,7 +1554,7 @@ class AgentLoop:
         )
         cmd_ctx = CommandContext(
             msg=ctx.msg,
-            session=session,
+            session=ctx.session,
             key=ctx.session_key,
             raw=raw,
             loop=self,
@@ -1651,13 +1572,13 @@ class AgentLoop:
             # intentionally clears the session.
             if cmd_ctx.raw.lower() != "/new":
                 ctx.input_persisted_early = self._persist_user_message_early(
-                    ctx.msg, session, _command=True
+                    ctx.msg, ctx.session, _command=True
                 )
-                session.add_message(
+                ctx.session.add_message(
                     "assistant", result.content, _command=True
                 )
-                self._clear_pending_user_turn(session)
-                self.sessions.save(session)
+                self._clear_pending_user_turn(ctx.session)
+                self.sessions.save(ctx.session)
                 if not ctx.ephemeral:
                     await self.runtime_event_publisher.session_turn_persisted(
                         ctx.msg,
@@ -1669,10 +1590,9 @@ class AgentLoop:
         return False
 
     async def _build_turn(self, ctx: TurnContext) -> None:
-        session = ctx.require_session()
         runtime = ctx.runtime
         if runtime is None:
-            runtime = self.runtime_for_session(session)
+            runtime = self.runtime_for_session(ctx.session)
             ctx.runtime = runtime
         if ctx.session_key.startswith("dream:"):
             logger.info(
@@ -1687,7 +1607,7 @@ class AgentLoop:
         )
         if not ctx.ephemeral:
             await self.consolidator.maybe_consolidate_by_tokens(
-                session,
+                ctx.session,
                 runtime=runtime,
                 replay_max_messages=replay_max_messages,
             )
@@ -1701,92 +1621,31 @@ class AgentLoop:
             "max_messages": replay_max_messages,
             "max_tokens": self._replay_token_budget(runtime),
             "extend_to_user": is_subagent,
+            "include_media": True,
         }
-        ctx.history = session.get_history(**_hist_kwargs)
-        stored_state = session.provider_state
-        subagent_followup_persisted = False
+        ctx.history = ctx.session.get_history(**_hist_kwargs)
         if is_subagent:
             # Keep the durable internal delivery as an assistant record, but
             # present this completion to the model as fresh follow-up input.
             # Providers without assistant-prefill support drop trailing
             # assistant messages, so using the persisted record as the current
             # prompt would hide an independently dispatched subagent result.
-            subagent_followup_persisted = self._persist_subagent_followup(
-                session,
-                ctx.msg,
-            )
-            if subagent_followup_persisted:
+            if self._persist_subagent_followup(ctx.session, ctx.msg):
                 logger.debug("Subagent result persisted for session {}", ctx.session_key)
-                # Establish a durable, replay-safe baseline before any fallible
-                # provider compatibility or prompt assembly work. A compatible
-                # staged state replaces this in a second atomic save below.
-                session.provider_state = None
-                self.sessions.save(session)
+                self.sessions.save(ctx.session)
             ctx.input_persisted_early = True
-        ctx.delivery.record_runtime(runtime)
+        ctx.delivery.record_runtime(ctx.runtime)
 
         ctx.request_context = self._request_context_for_turn(ctx)
         if ctx.kind is TurnKind.USER:
             ctx.runtime_context_blocks = await self._resolve_runtime_context_for_turn(ctx)
-        staged_provider_state = False
-        if stored_state is not None and runtime.provider.can_resume_conversation_state(
-            stored_state,
-            runtime.model,
-        ):
-            current_provider_message = self.context.build_current_message(
-                ctx.msg.content,
-                media=ctx.msg.media if ctx.kind is TurnKind.USER and ctx.msg.media else None,
-                runtime_context_blocks=ctx.runtime_context_blocks,
-            )
-            task_id = ctx.msg.metadata.get("subagent_task_id") if is_subagent else None
-            already_staged = False
-            if isinstance(task_id, str) and task_id:
-                internal_meta = current_provider_message.get("_meta")
-                current_provider_message["_meta"] = {
-                    **(
-                        cast(dict[str, Any], internal_meta)
-                        if isinstance(internal_meta, dict)
-                        else {}
-                    ),
-                    _SUBAGENT_PROVIDER_TASK_META: task_id,
-                }
-                already_staged = any(
-                    isinstance(message.get("_meta"), dict)
-                    and cast(dict[str, Any], message["_meta"]).get(
-                        _SUBAGENT_PROVIDER_TASK_META
-                    )
-                    == task_id
-                    for message in stored_state.pending_messages
-                )
-            ctx.provider_state = (
-                stored_state
-                if already_staged
-                else stored_state.with_pending_messages([
-                    *stored_state.pending_messages,
-                    current_provider_message,
-                ])
-            )
-            if (
-                not ctx.ephemeral
-                and (ctx.kind is TurnKind.USER or subagent_followup_persisted)
-            ):
-                session.provider_state = ctx.provider_state
-                staged_provider_state = True
-        elif stored_state is not None:
-            session.provider_state = None
+        ctx.initial_messages = self._build_initial_messages(ctx)
         if ctx.kind is TurnKind.USER:
             ctx.input_persisted_early = self._persist_user_message_early(
                 ctx.msg,
-                session,
+                ctx.session,
                 runtime_context_blocks=ctx.runtime_context_blocks,
             )
-            if staged_provider_state and not ctx.input_persisted_early:
-                session.provider_state = stored_state
-        elif subagent_followup_persisted and staged_provider_state:
-            # Upgrade the replay-safe baseline to the resumable state before
-            # prompt assembly and the first model checkpoint.
-            self.sessions.save(session)
-        ctx.initial_messages = self._build_initial_messages(ctx)
 
         if ctx.on_progress is None:
             ctx.on_progress = ctx.delivery.progress_callback()
@@ -1794,13 +1653,12 @@ class AgentLoop:
             ctx.on_retry_wait = ctx.delivery.retry_wait_callback()
 
     async def _run_turn(self, ctx: TurnContext) -> None:
-        runtime = ctx.require_runtime()
         if ctx.visible_run_started_at is None:
             ctx.visible_run_started_at = time.time()
         await ctx.delivery.running(started_at=ctx.visible_run_started_at)
         result = await self._run_agent_loop(
             ctx.initial_messages,
-            runtime=runtime,
+            runtime=ctx.runtime,
             on_progress=ctx.on_progress,
             on_stream=ctx.on_stream,
             on_stream_end=ctx.on_stream_end,
@@ -1820,7 +1678,6 @@ class AgentLoop:
             turn_scopes=ctx.turn_scopes,
             tools=ctx.tools,
             request_context=ctx.request_context,
-            provider_state=ctx.provider_state,
         )
         final_content, _, all_msgs, stop_reason, had_injections = result
         ctx.final_content = final_content
@@ -1831,8 +1688,6 @@ class AgentLoop:
             await turn_continuation.maybe_continue_turn(ctx)
 
     async def _persist_turn(self, ctx: TurnContext) -> None:
-        runtime = ctx.require_runtime()
-        session = ctx.require_session()
         turn_continuation.prepare_save_boundary(ctx)
 
         if (
@@ -1853,26 +1708,26 @@ class AgentLoop:
         )
         ctx.turn_latency_ms = max(0, int((time.time() - latency_started_at) * 1000))
         self._save_turn(
-            session, ctx.all_messages, ctx.save_skip,
+            ctx.session, ctx.all_messages, ctx.save_skip,
             turn_latency_ms=ctx.turn_latency_ms,
         )
         ctx.delivery.record_latency(ctx.turn_latency_ms)
         if not ctx.ephemeral:
-            session.enforce_file_cap(
+            ctx.session.enforce_file_cap(
                 on_archive=partial(self.context.memory.raw_archive, session_key=ctx.session_key)
             )
-            self.schedule_background(
+            self._schedule_background(
                 self.consolidator.maybe_consolidate_by_tokens(
-                    session,
-                    runtime=runtime,
+                    ctx.session,
+                    runtime=ctx.runtime,
                     replay_max_messages=replay_max_messages_for_context(
-                        runtime.context_window_tokens
+                        ctx.runtime.context_window_tokens
                     ),
                 )
             )
-        self._clear_pending_user_turn(session)
-        self._clear_runtime_checkpoint(session)
-        self.sessions.save(session)
+        self._clear_pending_user_turn(ctx.session)
+        self._clear_runtime_checkpoint(ctx.session)
+        self.sessions.save(ctx.session)
         if not ctx.ephemeral:
             await self.runtime_event_publisher.session_turn_persisted(
                 ctx.msg,
@@ -1895,7 +1750,7 @@ class AgentLoop:
             return
         ctx.outbound = self._assemble_outbound(
             ctx.msg,
-            cast(str, ctx.final_content),
+            ctx.final_content,
             ctx.stop_reason,
             ctx.had_injections,
             ctx.streamed_content,
@@ -1906,47 +1761,39 @@ class AgentLoop:
 
     def _sanitize_persisted_blocks(
         self,
-        content: list[object],
+        content: list[dict[str, Any]],
         *,
         should_truncate_text: bool = False,
-    ) -> list[object]:
+    ) -> list[dict[str, Any]]:
         """Strip volatile multimodal payloads before writing session history."""
-        filtered: list[object] = []
+        filtered: list[dict[str, Any]] = []
         for block in content:
             if not isinstance(block, dict):
                 filtered.append(block)
                 continue
 
-            block_data = cast(dict[str, Any], block)
-            image_url = cast(dict[str, Any], block_data.get("image_url", {}))
-            if block_data.get("type") == "image_url" and str(
-                image_url.get("url", "")
+            if block.get("type") == "image_url" and block.get("image_url", {}).get(
+                "url", ""
             ).startswith("data:image/"):
-                internal_meta = cast(dict[str, Any], block_data.get("_meta") or {})
-                path = cast(str, internal_meta.get("path", ""))
-                filtered.append(
-                    {"type": "text", "text": image_placeholder_text(path)}
-                )
+                path = (block.get("_meta") or {}).get("path", "")
+                filtered.append({"type": "text", "text": image_placeholder_text(path)})
                 continue
 
-            if block_data.get("type") == "text" and isinstance(
-                block_data.get("text"),
-                str,
-            ):
-                text = cast(str, block_data["text"])
+            if block.get("type") == "text" and isinstance(block.get("text"), str):
+                text = block["text"]
                 if should_truncate_text and len(text) > self.max_tool_result_chars:
                     text = truncate_text_fn(text, self.max_tool_result_chars)
-                filtered.append({**block_data, "text": text})
+                filtered.append({**block, "text": text})
                 continue
 
-            filtered.append(block_data)
+            filtered.append(block)
 
         return filtered
 
     def _save_turn(
         self,
         session: Session,
-        messages: list[dict[str, Any]],
+        messages: list[dict],
         skip: int,
         *,
         turn_latency_ms: int | None = None,
@@ -1958,10 +1805,8 @@ class AgentLoop:
             str(tc["id"])
             for m in session.messages
             if m.get("role") == "assistant"
-            for tc_value in cast(Iterable[object], m.get("tool_calls") or [])
-            if isinstance(tc_value, dict)
-            for tc in (cast(dict[str, Any], tc_value),)
-            if tc.get("id")
+            for tc in m.get("tool_calls") or []
+            if isinstance(tc, dict) and tc.get("id")
         }
         fulfilled_tool_call_ids = {
             str(m["tool_call_id"])
@@ -1971,11 +1816,9 @@ class AgentLoop:
         last_assistant_idx: int | None = None
         for m in messages[skip:]:
             entry = dict(m)
-            internal_meta = cast(object, entry.pop("_meta", None))
+            internal_meta = entry.pop("_meta", None)
             runtime_context_meta = (
-                cast(dict[str, Any], internal_meta).get(
-                    RUNTIME_CONTEXT_MESSAGE_META
-                )
+                internal_meta.get(RUNTIME_CONTEXT_MESSAGE_META)
                 if isinstance(internal_meta, dict)
                 else None
             )
@@ -2001,10 +1844,7 @@ class AgentLoop:
                 if isinstance(content, str) and len(content) > self.max_tool_result_chars:
                     entry["content"] = truncate_text_fn(content, self.max_tool_result_chars)
                 elif isinstance(content, list):
-                    filtered = self._sanitize_persisted_blocks(
-                        cast(list[object], content),
-                        should_truncate_text=True,
-                    )
+                    filtered = self._sanitize_persisted_blocks(content, should_truncate_text=True)
                     if not filtered:
                         # Preserve the tool_call/result pair after block filtering.
                         filtered = [
@@ -2013,9 +1853,7 @@ class AgentLoop:
                     entry["content"] = filtered
             elif role == "user":
                 if isinstance(content, list):
-                    filtered = self._sanitize_persisted_blocks(
-                        cast(list[object], content),
-                    )
+                    filtered = self._sanitize_persisted_blocks(content)
                     if not filtered:
                         continue
                     entry["content"] = filtered
@@ -2027,13 +1865,8 @@ class AgentLoop:
                 last_assistant_idx = len(session.messages) - 1
                 declared_tool_call_ids.update(
                     str(tc["id"])
-                    for tc_value in cast(
-                        Iterable[object],
-                        entry.get("tool_calls") or [],
-                    )
-                    if isinstance(tc_value, dict)
-                    for tc in (cast(dict[str, Any], tc_value),)
-                    if tc.get("id")
+                    for tc in entry.get("tool_calls") or []
+                    if isinstance(tc, dict) and tc.get("id")
                 )
         if turn_latency_ms is not None and last_assistant_idx is not None:
             session.messages[last_assistant_idx]["latency_ms"] = int(turn_latency_ms)
@@ -2048,12 +1881,7 @@ class AgentLoop:
         """
         if not msg.content:
             return False
-        metadata_value = cast(object, msg.metadata)
-        task_id = (
-            msg.metadata.get("subagent_task_id")
-            if isinstance(metadata_value, dict)
-            else None
-        )
+        task_id = msg.metadata.get("subagent_task_id") if isinstance(msg.metadata, dict) else None
         if task_id and any(
             m.get("injected_event") == "subagent_result" and m.get("subagent_task_id") == task_id
             for m in session.messages
@@ -2099,44 +1927,29 @@ class AgentLoop:
         """Materialize an unfinished turn into session history before a new request."""
         from datetime import datetime
 
-        checkpoint = cast(
-            object,
-            session.metadata.get(self._RUNTIME_CHECKPOINT_KEY),
-        )
+        checkpoint = session.metadata.get(self._RUNTIME_CHECKPOINT_KEY)
         if not isinstance(checkpoint, dict):
             return False
-        checkpoint_data = cast(dict[str, Any], checkpoint)
 
-        assistant_message = cast(object, checkpoint_data.get("assistant_message"))
-        completed_tool_results = cast(
-            Iterable[object],
-            checkpoint_data.get("completed_tool_results") or [],
-        )
-        pending_tool_calls = cast(
-            Iterable[object],
-            checkpoint_data.get("pending_tool_calls") or [],
-        )
+        assistant_message = checkpoint.get("assistant_message")
+        completed_tool_results = checkpoint.get("completed_tool_results") or []
+        pending_tool_calls = checkpoint.get("pending_tool_calls") or []
 
         restored_messages: list[dict[str, Any]] = []
         if isinstance(assistant_message, dict):
-            restored = dict(cast(dict[str, Any], assistant_message))
+            restored = dict(assistant_message)
             restored.setdefault("timestamp", datetime.now().isoformat())
             restored_messages.append(restored)
         for message in completed_tool_results:
             if isinstance(message, dict):
-                restored = dict(cast(dict[str, Any], message))
+                restored = dict(message)
                 restored.setdefault("timestamp", datetime.now().isoformat())
                 restored_messages.append(restored)
         for tool_call in pending_tool_calls:
             if not isinstance(tool_call, dict):
                 continue
-            tool_call_data = cast(dict[str, Any], tool_call)
-            tool_id = tool_call_data.get("id")
-            function_data = cast(
-                dict[str, Any],
-                tool_call_data.get("function") or {},
-            )
-            name = function_data.get("name") or "tool"
+            tool_id = tool_call.get("id")
+            name = ((tool_call.get("function") or {}).get("name")) or "tool"
             restored_messages.append(
                 {
                     "role": "tool",
@@ -2158,36 +1971,7 @@ class AgentLoop:
             ):
                 overlap = size
                 break
-        appended_messages = restored_messages[overlap:]
-        session.messages.extend(appended_messages)
-        assistant_message_data = (
-            cast(dict[str, Any], assistant_message)
-            if isinstance(assistant_message, dict)
-            else None
-        )
-        provider_state_is_synchronized = (
-            checkpoint_data.get(self._PROVIDER_STATE_CHECKPOINT_VERSION_KEY)
-            == self._PROVIDER_STATE_CHECKPOINT_VERSION
-        )
-        phase = checkpoint_data.get("phase")
-        exact_final_response = (
-            phase == "final_response"
-            and assistant_message_data is not None
-            and assistant_message_data.get("role") == "assistant"
-            and not bool(checkpoint_data.get("completed_tool_results"))
-            and not bool(checkpoint_data.get("pending_tool_calls"))
-        )
-        exact_completed_tools = (
-            phase == "tools_completed"
-            and assistant_message_data is not None
-            and assistant_message_data.get("role") == "assistant"
-            and not bool(checkpoint_data.get("pending_tool_calls"))
-        )
-        if not (
-            provider_state_is_synchronized
-            and (exact_final_response or exact_completed_tools)
-        ):
-            session.provider_state = None
+        session.messages.extend(restored_messages[overlap:])
 
         self._clear_pending_user_turn(session)
         self._clear_runtime_checkpoint(session)
@@ -2208,7 +1992,6 @@ class AgentLoop:
                     "timestamp": datetime.now().isoformat(),
                 }
             )
-            session.provider_state = None
             session.updated_at = datetime.now()
 
         self._clear_pending_user_turn(session)
@@ -2247,7 +2030,7 @@ class AgentLoop:
             content=content, media=media or [], metadata=metadata,
         )
         # Share the dispatch lock so direct calls serialize with bus turns.
-        lock = self._get_session_lock(session_key)
+        lock = self._session_locks.setdefault(session_key, asyncio.Lock())
         try:
             async with lock:
                 kwargs: dict[str, Any] = {
@@ -2278,11 +2061,3 @@ class AgentLoop:
         finally:
             await self.runtime_event_publisher.run_status_changed(msg, session_key, "idle")
             self.runtime_event_publisher.clear_turn(session_key)
-
-    def _get_session_lock(self, session_key: str) -> asyncio.Lock:
-        """Return the shared lock while allowing idle session entries to expire."""
-        lock = self._session_locks.get(session_key)
-        if lock is None:
-            lock = asyncio.Lock()
-            self._session_locks[session_key] = lock
-        return lock

nanobot/agent/memory.py

@@ -1,10 +1,5 @@
 """Memory system: pure file I/O store and lightweight Consolidator."""
 
-# Tool schemas are installed by the ``@tool_parameters`` class decorator at
-# runtime; static analyzers cannot observe that it clears ``parameters`` from
-# ``__abstractmethods__`` before these classes are instantiated.
-# pyright: reportAbstractUsage=false, reportPrivateUsage=false
-
 from __future__ import annotations
 
 import asyncio
@@ -16,7 +11,7 @@ import weakref
 from contextlib import suppress
 from datetime import datetime
 from pathlib import Path
-from typing import TYPE_CHECKING, Any, Callable, Iterator, cast
+from typing import TYPE_CHECKING, Any, Callable, Iterator
 
 from loguru import logger
 
@@ -29,6 +24,7 @@ from nanobot.utils.helpers import (
     estimate_message_tokens,
     estimate_prompt_tokens_chain,
     find_legal_message_start,
+    image_placeholder_text,
     recent_message_start_index,
     strip_think,
     truncate_text,
@@ -43,7 +39,6 @@ from nanobot.utils.workspace_prompts import (
 )
 
 if TYPE_CHECKING:
-    from nanobot.agent.tools.registry import ToolRegistry
     from nanobot.utils.llm_runtime import LLMRuntime
 
 # ---------------------------------------------------------------------------
@@ -64,7 +59,7 @@ class DreamRunProgress:
         **_kwargs: Any,
     ) -> None:
         if any(
-            isinstance(cast(object, event), dict) and event.get("phase") == "error"
+            isinstance(event, dict) and event.get("phase") == "error"
             for event in tool_events or ()
         ):
             self.had_tool_errors = True
@@ -480,11 +475,11 @@ class MemoryStore:
                     line = line.strip()
                     if line:
                         try:
-                            parsed: object = json.loads(line)
+                            parsed = json.loads(line)
                         except json.JSONDecodeError:
                             continue
                         if isinstance(parsed, dict):
-                            entries.append(cast(dict[str, Any], parsed))
+                            entries.append(parsed)
 
         return entries
 
@@ -502,8 +497,8 @@ class MemoryStore:
                 lines = [line for line in data.split("\n") if line.strip()]
                 if not lines:
                     return None
-                parsed: object = json.loads(lines[-1])
-                return cast(dict[str, Any], parsed) if isinstance(parsed, dict) else None
+                parsed = json.loads(lines[-1])
+                return parsed if isinstance(parsed, dict) else None
         except (FileNotFoundError, json.JSONDecodeError, UnicodeDecodeError):
             return None
 
@@ -618,7 +613,7 @@ class MemoryStore:
             ("USER.md", self.user_file),
             ("memory/MEMORY.md", self.memory_file),
         ]
-        blocks: list[str] = []
+        blocks = []
         for label, path in files:
             try:
                 content = path.read_text(encoding="utf-8") if path.exists() else ""
@@ -639,7 +634,7 @@ class MemoryStore:
             return ""
         return self._git.summarize_working_tree(list(self._DREAM_CONTENT_PATHS))
 
-    def build_dream_tools(self) -> ToolRegistry:
+    def build_dream_tools(self):
         """Build the restricted tool registry used by Dream runs."""
         from nanobot.agent.skills import BUILTIN_SKILLS_DIR
         from nanobot.agent.tools.apply_patch import ApplyPatchTool
@@ -690,48 +685,84 @@ class MemoryStore:
     ) -> bool:
         """Return True only when a Dream turn completed without tool failures."""
         metadata = getattr(resp, "metadata", None)
-        if had_tool_errors or not isinstance(metadata, dict):
-            return False
-        return cast(dict[str, Any], metadata).get("_stop_reason") == "completed"
+        return (
+            not had_tool_errors
+            and isinstance(metadata, dict)
+            and metadata.get("_stop_reason") == "completed"
+        )
 
     # -- message formatting utility ------------------------------------------
 
     @staticmethod
-    def _format_messages(messages: list[dict[str, Any]]) -> str:
-        lines: list[str] = []
+    def _format_messages(messages: list[dict]) -> str:
+        lines = []
         for message in messages:
+            content = message.get("content") or ""
+            media = message.get("media")
+            media_paths = (
+                [
+                    path.replace("\r", " ").replace("\n", " ")
+                    for path in media[:16]
+                    if isinstance(path, str) and path
+                ]
+                if isinstance(media, list)
+                else []
+            )
             content = content_with_media_breadcrumbs(
                 message.get("role"),
-                message.get("content", ""),
-                message.get("media"),
+                content,
+                media_paths,
             )
             if not content:
                 continue
-            tools_used = message.get("tools_used")
-            tools = (
-                f" [tools: {', '.join(cast(list[str], tools_used))}]"
-                if tools_used
-                else ""
+            tools = f" [tools: {', '.join(message['tools_used'])}]" if message.get("tools_used") else ""
+            lines.append(
+                f"[{message.get('timestamp', '?')[:16]}] "
+                f"{message['role'].upper()}{tools}: {content}"
             )
-            raw_timestamp = message.get("timestamp")
-            timestamp = str(raw_timestamp) if raw_timestamp is not None else "?"
-            role = str(message.get("role") or "unknown")
-            lines.append(f"[{timestamp[:16]}] {role.upper()}{tools}: {content}")
         return "\n".join(lines)
 
+    @staticmethod
+    def _media_manifest(messages: list[dict]) -> str:
+        paths: list[str] = []
+        seen: set[str] = set()
+        for message in messages:
+            media = message.get("media")
+            if not isinstance(media, list):
+                continue
+            for raw_path in media:
+                if not isinstance(raw_path, str) or not raw_path:
+                    continue
+                path = raw_path.replace("\r", " ").replace("\n", " ")
+                if path in seen:
+                    continue
+                seen.add(path)
+                paths.append(path)
+                if len(paths) >= 64:
+                    break
+            if len(paths) >= 64:
+                break
+        if not paths:
+            return ""
+        return "Archived attachments:\n" + "\n".join(
+            f"- {image_placeholder_text(path)}"
+            for path in paths
+        )
+
     def raw_archive(
         self,
-        messages: list[dict[str, Any]],
+        messages: list[dict],
         *,
         max_chars: int | None = None,
         session_key: str | None = None,
     ) -> None:
         """Fallback: dump raw messages to history.jsonl without LLM summarization."""
         limit = max_chars if max_chars is not None else _RAW_ARCHIVE_MAX_CHARS
-        formatted = truncate_text(
-            self._format_messages(public_history_messages(messages)),
-            limit,
-        )
+        formatted = self._format_messages(public_history_messages(messages))
+        manifest = self._media_manifest(messages)
+        if manifest:
+            formatted = f"{manifest}\n\n{formatted}"
+        formatted = truncate_text(formatted, limit)
         self.append_history(
             f"[RAW] {len(messages)} messages\n"
             f"{formatted}",
@@ -775,9 +806,9 @@ class MemoryStore:
         Only current base64url-encoded Dream session keys are considered.
         Non-dream session files are never touched.
         """
-        dream_files: list[Path] = []
+        dream_files = []
         for path in sessions_dir.glob("*.jsonl"):
-            decoded_key = SessionManager.decode_storage_key(path.stem)
+            decoded_key = SessionManager._decode_storage_key(path.stem)
             if decoded_key is not None and decoded_key.startswith("dream:"):
                 dream_files.append(path)
         dream_files.sort(key=lambda p: p.stat().st_mtime)
@@ -806,7 +837,7 @@ _HISTORY_ENTRY_HARD_CAP = 64_000      # emergency cap in append_history
 
 
 class Consolidator:
-    """Summarize compacted messages into history.jsonl."""
+    """Lightweight consolidation: summarizes evicted messages into history.jsonl."""
 
     _MAX_CONSOLIDATION_ROUNDS = 5
 
@@ -930,7 +961,6 @@ class Consolidator:
             session_key=session.key,
         )
         session.last_consolidated = end_idx
-        session.provider_state = None
         self.sessions.save(session)
         return summary
 
@@ -953,13 +983,7 @@ class Consolidator:
         channel = session.key.split(":", 1)[0] if ":" in session.key else None
         # Include archived summary in estimation so the budget accounts for it.
         meta = session.metadata.get("_last_summary")
-        summary = (
-            cast(dict[str, Any], meta).get("text")
-            if isinstance(meta, dict)
-            else meta
-            if isinstance(meta, str)
-            else None
-        )
+        summary = meta.get("text") if isinstance(meta, dict) else (meta if isinstance(meta, str) else None)
         probe_messages = self._build_messages(
             history=history,
             current_message="[token-probe]",
@@ -992,15 +1016,20 @@ class Consolidator:
 
     async def archive(
         self,
-        messages: list[dict[str, Any]],
+        messages: list[dict],
         *,
         runtime: LLMRuntime,
         session_key: str | None = None,
-        summary_messages: list[dict[str, Any]] | None = None,
+        summary_messages: list[dict] | None = None,
     ) -> str | None:
-        """Summarize messages and append the result to history.jsonl.
+        """Summarize messages via LLM and append to history.jsonl.
 
-        ``summary_messages`` adds context but is excluded from raw fallback.
+        ``messages`` are the messages being archived (removed from the live
+        session); they are what gets raw-dumped if the LLM call fails.
+        ``summary_messages``, when given, lets callers include retained
+        messages in the summary without archiving them.
+
+        Returns the summary text on success, None if nothing to archive.
         """
         if not messages:
             return None
@@ -1038,6 +1067,11 @@ class Consolidator:
             self.store.raw_archive(messages, session_key=session_key)
             return None
         summary = response.content or "[no summary]"
+        manifest = MemoryStore._media_manifest(messages)
+        if manifest:
+            # Keep the deterministic manifest before generated prose so normal
+            # archive truncation preserves attachment references first.
+            summary = f"{manifest}\n\n{summary}"
         self.store.append_history(
             summary,
             max_chars=_ARCHIVE_SUMMARY_MAX_CHARS,
@@ -1136,7 +1170,6 @@ class Consolidator:
                 if summary:
                     last_summary = summary
                 session.last_consolidated = end_idx
-                session.provider_state = None
                 self.sessions.save(session)
                 if not summary:
                     # LLM is degraded — stop hammering it this call;
@@ -1162,7 +1195,13 @@ class Consolidator:
         runtime: LLMRuntime,
         max_suffix: int = 8,
     ) -> str | None:
-        """Archive an idle prefix and hide it from replay without deleting it."""
+        """Hard-truncate an idle session under the consolidation lock.
+
+        Used by AutoCompact so all session mutation goes through a single
+        lock-protected path.  Returns the summary text on success, ``None``
+        if the LLM failed (raw_archive fallback), or ``""`` if there was
+        nothing to archive.
+        """
         lock = self.get_lock(session_key)
         async with lock:
             self.sessions.invalidate(session_key)
@@ -1182,21 +1221,24 @@ class Consolidator:
                 last_consolidated=0,
             )
             result = probe.retain_recent_legal_suffix(max_suffix, extend_to_user=True)
-            visible_suffix = probe.messages
-            messages_to_remove = result.dropped
+            messages_to_keep = probe.messages
+            messages_to_remove = result.dropped[result.already_consolidated_count:]
 
-            if not messages_to_remove:
+            if not messages_to_remove and not messages_to_keep:
                 self.sessions.save(session)
                 return ""
 
             last_active = session.updated_at
-            # The visible suffix informs the summary but stays out of raw fallback.
-            summary = await self.archive(
-                messages_to_remove,
-                runtime=runtime,
-                session_key=session_key,
-                summary_messages=messages_to_summarize,
-            )
+            summary: str | None = ""
+            if messages_to_remove:
+                # Summarize the retained suffix too, but only remove/raw-dump
+                # the messages that are no longer kept in the live session.
+                summary = await self.archive(
+                    messages_to_remove,
+                    runtime=runtime,
+                    session_key=session_key,
+                    summary_messages=messages_to_summarize,
+                )
 
             if summary and summary != "(nothing)":
                 session.metadata["_last_summary"] = {
@@ -1204,18 +1246,17 @@ class Consolidator:
                     "last_active": last_active.isoformat(),
                 }
 
-            # Preserve history and advance only the replay boundary.
-            session.last_consolidated = len(session.messages) - len(visible_suffix)
-            session.provider_state = None
+            session.messages = messages_to_keep
+            session.last_consolidated = 0
             self.sessions.save(session)
 
-            logger.info(
-                "Idle-session compact for {}: archived={}, visible={}, retained={}, summary={}",
-                session_key,
-                len(messages_to_remove),
-                len(visible_suffix),
-                len(session.messages),
-                bool(summary),
-            )
+            if messages_to_remove:
+                logger.info(
+                    "Idle-session compact for {}: archived={}, kept={}, summary={}",
+                    session_key,
+                    len(messages_to_remove),
+                    len(messages_to_keep),
+                    bool(summary),
+                )
 
             return summary

nanobot/agent/model_presets.py

@@ -5,8 +5,9 @@ from __future__ import annotations
 from collections.abc import Callable, Mapping
 from dataclasses import replace
 from pathlib import Path
+from typing import Any
 
-from nanobot.config.schema import Config, ModelPresetConfig
+from nanobot.config.schema import ModelPresetConfig
 from nanobot.providers.base import LLMProvider
 from nanobot.providers.factory import ProviderSnapshot, build_provider_snapshot
 
@@ -21,8 +22,8 @@ def default_selection_signature(
     return (model_preset, *signature[:2]) if signature else None
 
 
-def configured_model_presets(config: Config) -> dict[str, ModelPresetConfig]:
-    return {**config.model_presets, "default": config.resolve_default_preset()}
+def configured_model_presets(config: Any) -> dict[str, ModelPresetConfig]:
+    return dict(config.model_presets)
 
 
 def load_model_preset_catalog(
@@ -40,7 +41,7 @@ def load_model_preset_catalog(
 
 
 def make_preset_snapshot_loader(
-    config: Config,
+    config: Any,
     provider_snapshot_loader: Callable[..., ProviderSnapshot] | None,
 ) -> PresetSnapshotLoader:
     if provider_snapshot_loader is not None:
@@ -60,6 +61,7 @@ def build_static_preset_snapshot(
         signature=("model_preset", name, preset.model_dump_json()),
         generation=preset.to_generation_settings(),
         model_preset=name,
+        supports_image_input=preset.supports_image_input,
     )
 
 

nanobot/agent/model_runtime.py

@@ -5,7 +5,6 @@ from __future__ import annotations
 from collections.abc import Callable, Mapping
 from dataclasses import replace
 from types import MappingProxyType
-from typing import cast
 
 from nanobot.agent import model_presets as preset_helpers
 from nanobot.config.schema import Config, ModelPresetConfig
@@ -140,7 +139,7 @@ class ModelRuntimeResolver:
 
     def select_model(self, model: str) -> LLMRuntime:
         """Change the default model without reconstructing downstream consumers."""
-        if not isinstance(cast(object, model), str) or not model.strip():
+        if not isinstance(model, str) or not model.strip():
             raise ValueError("model must be a non-empty string")
         self._runtime = replace(
             self._runtime,
@@ -151,9 +150,8 @@ class ModelRuntimeResolver:
 
     def select_context_window(self, context_window_tokens: int) -> LLMRuntime:
         """Change the default context limit for future admissions."""
-        raw_context_window = cast(object, context_window_tokens)
-        if not isinstance(raw_context_window, int) or isinstance(
-            raw_context_window,
+        if not isinstance(context_window_tokens, int) or isinstance(
+            context_window_tokens,
             bool,
         ):
             raise TypeError("context_window_tokens must be an integer")

nanobot/agent/progress_hook.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 
 import inspect
 import json
-from typing import Any, Awaitable, Callable, cast
+from typing import Any, Awaitable, Callable
 
 from loguru import logger
 
@@ -124,7 +124,7 @@ class AgentProgressHook(AgentHook):
         arguments = event.get("arguments")
         if not isinstance(arguments, dict):
             arguments = {}
-        payload: dict[str, Any] = {
+        payload = {
             "version": 1,
             "phase": phase,
             "call_id": str(call_id),
@@ -169,7 +169,7 @@ class AgentProgressHook(AgentHook):
             tool_events = [build_tool_event_start_payload(tc) for tc in context.tool_calls]
             await invoke_on_progress(
                 self._on_progress,
-                cast(str, tool_hint),
+                tool_hint,
                 tool_hint=True,
                 tool_events=tool_events,
             )

nanobot/agent/runner.py

@@ -5,11 +5,10 @@ from __future__ import annotations
 import asyncio
 import inspect
 import os
-from collections.abc import Awaitable, Callable, Iterable
 from copy import deepcopy
 from dataclasses import dataclass, field
 from pathlib import Path
-from typing import Any, cast
+from typing import Any, Callable
 
 from loguru import logger
 
@@ -19,17 +18,7 @@ from nanobot.agent.context_governance import (
 )
 from nanobot.agent.hook import AgentHook, AgentHookContext, AgentRunHookContext
 from nanobot.agent.tools.registry import ToolRegistry, is_tool_error_result
-from nanobot.providers.base import (
-    LLMProvider,
-    LLMResponse,
-    ProviderCallContext,
-    ProviderConversationState,
-    ToolCallRequest,
-)
-from nanobot.providers.conversation_state import (
-    ProviderConversationStateController,
-    allows_conversation_message_merge,
-)
+from nanobot.providers.base import LLMProvider, LLMResponse, ToolCallRequest
 from nanobot.runtime_context import (
     RUNTIME_CONTEXT_MESSAGE_META,
     detach_runtime_context,
@@ -59,10 +48,6 @@ from nanobot.utils.runtime import (
 )
 
 GoalContinueMessage = str | Callable[[], str | None]
-ProgressCallback = Callable[[str], Awaitable[None]]
-RetryWaitCallback = Callable[[str], Awaitable[None]]
-CheckpointCallback = Callable[[dict[str, Any]], Awaitable[None]]
-InjectionCallback = Callable[..., Awaitable[Iterable[Any] | None]]
 
 _DEFAULT_ERROR_MESSAGE = "Sorry, I encountered an error calling the AI model."
 _ARREARAGE_ERROR_MESSAGE = (
@@ -105,16 +90,15 @@ class AgentRunSpec:
     session_key: str | None = None
     context_block_limit: int | None = None
     provider_retry_mode: str = "standard"
-    progress_callback: ProgressCallback | None = None
+    progress_callback: Any | None = None
     stream_progress_deltas: bool = True
-    retry_wait_callback: RetryWaitCallback | None = None
-    checkpoint_callback: CheckpointCallback | None = None
-    injection_callback: InjectionCallback | None = None
+    retry_wait_callback: Any | None = None
+    checkpoint_callback: Any | None = None
+    injection_callback: Any | None = None
     llm_timeout_s: float | None = None
     goal_active_predicate: Callable[[], bool] | None = None
     goal_continue_message: GoalContinueMessage | None = None
     finalize_on_max_iterations: bool = True
-    provider_state: ProviderConversationState | None = None
 
 
 @dataclass(slots=True)
@@ -131,7 +115,6 @@ class AgentRunResult:
     had_injections: bool = False
     # Terminal tail to emit when the preceding final-content prefix was already streamed.
     pending_stream_content: str | None = None
-    provider_state: ProviderConversationState | None = field(default=None, repr=False)
 
 
 class AgentRunner:
@@ -148,10 +131,8 @@ class AgentRunner:
         def _to_blocks(value: Any) -> list[dict[str, Any]]:
             if isinstance(value, list):
                 return [
-                    cast(dict[str, Any], item)
-                    if isinstance(item, dict)
-                    else {"type": "text", "text": str(item)}
-                    for item in cast(list[Any], value)
+                    item if isinstance(item, dict) else {"type": "text", "text": str(item)}
+                    for item in value
                 ]
             if value is None:
                 return []
@@ -173,42 +154,29 @@ class AgentRunner:
                 and messages[-1].get("role") == "user"
                 and not is_hidden_history_message(injection)
                 and not is_hidden_history_message(messages[-1])
-                and allows_conversation_message_merge(messages[-1])
             ):
                 merged = dict(messages[-1])
                 left_meta = merged.get("_meta")
                 right_meta = injection.get("_meta")
-                left_meta_dict = cast(dict[str, Any], left_meta) if isinstance(left_meta, dict) else None
-                right_meta_dict = (
-                    cast(dict[str, Any], right_meta) if isinstance(right_meta, dict) else None
-                )
                 left_marker = (
-                    left_meta_dict.get(RUNTIME_CONTEXT_MESSAGE_META)
-                    if left_meta_dict is not None
+                    left_meta.get(RUNTIME_CONTEXT_MESSAGE_META)
+                    if isinstance(left_meta, dict)
                     else None
                 )
                 right_marker = (
-                    right_meta_dict.get(RUNTIME_CONTEXT_MESSAGE_META)
-                    if right_meta_dict is not None
+                    right_meta.get(RUNTIME_CONTEXT_MESSAGE_META)
+                    if isinstance(right_meta, dict)
                     else None
                 )
-                left_marker_dict = (
-                    cast(dict[str, Any], left_marker) if isinstance(left_marker, dict) else None
-                )
-                right_marker_dict = (
-                    cast(dict[str, Any], right_marker) if isinstance(right_marker, dict) else None
-                )
-                empty_sources: list[str] = []
-                empty_blocks: list[dict[str, Any]] = []
                 detached_left = (
-                    detach_runtime_context(merged.get("content"), left_marker_dict)
-                    if left_marker_dict is not None
-                    else (merged.get("content"), empty_sources, empty_blocks)
+                    detach_runtime_context(merged.get("content"), left_marker)
+                    if isinstance(left_marker, dict)
+                    else (merged.get("content"), [], [])
                 )
                 detached_right = (
-                    detach_runtime_context(injection.get("content"), right_marker_dict)
-                    if right_marker_dict is not None
-                    else (injection.get("content"), empty_sources, empty_blocks)
+                    detach_runtime_context(injection.get("content"), right_marker)
+                    if isinstance(right_marker, dict)
+                    else (injection.get("content"), [], [])
                 )
                 if detached_left is not None and detached_right is not None:
                     left_content, left_sources, left_blocks = detached_left
@@ -221,9 +189,9 @@ class AgentRunner:
                             [*left_sources, *right_sources],
                             context_blocks,
                         )
-                        internal_meta = dict(left_meta_dict) if left_meta_dict is not None else {}
-                        if right_meta_dict is not None:
-                            for key, value in right_meta_dict.items():
+                        internal_meta = dict(left_meta) if isinstance(left_meta, dict) else {}
+                        if isinstance(right_meta, dict):
+                            for key, value in right_meta.items():
                                 internal_meta.setdefault(key, value)
                         internal_meta[RUNTIME_CONTEXT_MESSAGE_META] = marker
                         merged["_meta"] = internal_meta
@@ -244,7 +212,6 @@ class AgentRunner:
         assistant_message: dict[str, Any] | None,
         injection_cycles: int,
         *,
-        conversation_state: ProviderConversationStateController | None = None,
         phase: str = "after error",
         iteration: int | None = None,
         allow_goal_continue: bool = False,
@@ -272,21 +239,16 @@ class AgentRunner:
         if assistant_message is not None:
             messages.append(assistant_message)
             if iteration is not None:
-                checkpoint: dict[str, Any] = {
-                    "phase": "final_response",
-                    "iteration": iteration,
-                    "model": spec.runtime.model,
-                    "assistant_message": assistant_message,
-                    "completed_tool_results": [],
-                    "pending_tool_calls": [],
-                }
-                if conversation_state is not None:
-                    checkpoint["provider_state"] = conversation_state.checkpoint(
-                        messages
-                    )
                 await self._emit_checkpoint(
                     spec,
-                    checkpoint,
+                    {
+                        "phase": "final_response",
+                        "iteration": iteration,
+                        "model": spec.runtime.model,
+                        "assistant_message": assistant_message,
+                        "completed_tool_results": [],
+                        "pending_tool_calls": [],
+                    },
                 )
         self._append_injected_messages(messages, injections)
         if real_injection:
@@ -340,11 +302,11 @@ class AgentRunner:
         for item in items:
             if item is None:
                 continue
+            if isinstance(item, dict) and item.get("role") == "user" and "content" in item:
+                if self._has_injection_content(item.get("content")):
+                    injected_messages.append(item)
+                continue
             if isinstance(item, dict):
-                message_item = cast(dict[str, Any], item)
-                if message_item.get("role") == "user" and "content" in message_item:
-                    if self._has_injection_content(message_item.get("content")):
-                        injected_messages.append(message_item)
                 continue
             content = getattr(item, "content") if hasattr(item, "content") else str(item)
             if self._has_injection_content(content):
@@ -365,7 +327,7 @@ class AgentRunner:
         if isinstance(content, str):
             return bool(content.strip())
         if isinstance(content, list):
-            return bool(cast(list[Any], content))
+            return bool(content)
         return True
 
     async def run(self, spec: AgentRunSpec) -> AgentRunResult:
@@ -439,12 +401,6 @@ class AgentRunner:
         injection_cycles = 0
         compacted_tool_call_ids: set[str] = set()
         pending_stream_content: str | None = None
-        conversation_state = ProviderConversationStateController(
-            provider=spec.runtime.provider,
-            model=spec.runtime.model,
-            messages=messages,
-            state=spec.provider_state,
-        )
         governance_config = ContextGovernanceConfig(
             provider=spec.runtime.provider,
             model=spec.runtime.model,
@@ -475,20 +431,7 @@ class AgentRunner:
                 session_key=spec.session_key,
             )
             await hook.before_iteration(context)
-            provider_context = conversation_state.prepare_request(
-                messages,
-                context_window_tokens=spec.runtime.context_window_tokens,
-                model_messages=messages_for_model,
-            )
-            response = await self._request_model(
-                spec,
-                messages_for_model,
-                hook,
-                context,
-                conversation_state=conversation_state,
-                provider_context=provider_context,
-            )
-            conversation_state.observe_response(response, messages)
+            response = await self._request_model(spec, messages_for_model, hook, context)
             context.response = response
             context.tool_calls = list(response.tool_calls)
 
@@ -518,10 +461,6 @@ class AgentRunner:
                     reasoning_content=response.reasoning_content,
                     thinking_blocks=response.thinking_blocks,
                 )
-                assistant_message = conversation_state.project_response_message(
-                    assistant_message,
-                    response,
-                )
                 messages.append(assistant_message)
                 await self._emit_checkpoint(
                     spec,
@@ -586,15 +525,6 @@ class AgentRunner:
                         length_recovery_parts.clear()
                         continue
                     break
-                checkpoint_model_messages = (
-                    self.context_governor.prepare_for_model(
-                        governance_config,
-                        messages,
-                        compacted_tool_call_ids,
-                    )
-                    if response.provider_state is not None
-                    else None
-                )
                 await self._emit_checkpoint(
                     spec,
                     {
@@ -604,10 +534,6 @@ class AgentRunner:
                         "assistant_message": assistant_message,
                         "completed_tool_results": completed_tool_results,
                         "pending_tool_calls": [],
-                        "provider_state": conversation_state.checkpoint(
-                            messages,
-                            model_messages=checkpoint_model_messages,
-                        ),
                     },
                 )
                 empty_content_retries = 0
@@ -630,11 +556,7 @@ class AgentRunner:
                 )
 
             clean = hook.finalize_content(context, response.content)
-            if (
-                response.finish_reason
-                not in {"error", "length", "refusal", "content_filter"}
-                and is_blank_text(clean)
-            ):
+            if response.finish_reason != "error" and is_blank_text(clean):
                 empty_content_retries += 1
                 if empty_content_retries < _MAX_EMPTY_RETRIES:
                     logger.warning(
@@ -657,12 +579,7 @@ class AgentRunner:
                 if hook.wants_streaming():
                     await hook.on_stream_end(context, resuming=False)
                 retry_messages = self._finalization_retry_messages(messages_for_model)
-                response = await self._request_finalization_retry(
-                    spec,
-                    messages_for_model,
-                    transcript=messages,
-                    conversation_state=conversation_state,
-                )
+                response = await self._request_finalization_retry(spec, messages_for_model)
                 retry_usage = self._usage_or_estimate(spec, retry_messages, response)
                 self._accumulate_usage(usage, retry_usage)
                 raw_usage = self._merge_usage(raw_usage, retry_usage)
@@ -672,10 +589,10 @@ class AgentRunner:
                 original_content = response.content
                 clean = hook.finalize_content(context, response.content)
 
-            if response.finish_reason == "length":
+            if response.finish_reason == "length" and not is_blank_text(clean):
                 if len(length_recovery_parts) < _MAX_LENGTH_RECOVERIES:
                     length_recovery_parts.append(
-                        _restore_outer_whitespace(clean or "", original_content)
+                        _restore_outer_whitespace(clean, original_content)
                     )
                     logger.info(
                         "Output truncated on turn {} for {} ({}/{}); continuing",
@@ -687,15 +604,12 @@ class AgentRunner:
                     if hook.wants_streaming():
                         context.stream_continues_current_message = True
                         await hook.on_stream_end(context, resuming=True)
-                    messages.append(conversation_state.project_response_message(
-                        build_assistant_message(
-                            clean,
-                            reasoning_content=response.reasoning_content,
-                            thinking_blocks=response.thinking_blocks,
-                        ),
-                        response,
+                    messages.append(build_assistant_message(
+                        clean,
+                        reasoning_content=response.reasoning_content,
+                        thinking_blocks=response.thinking_blocks,
                     ))
-                    messages.append(build_length_recovery_message(clean or ""))
+                    messages.append(build_length_recovery_message(clean))
                     await hook.after_iteration(context)
                     continue
 
@@ -712,7 +626,7 @@ class AgentRunner:
             ):
                 await hook.on_stream(
                     context,
-                    _restore_outer_whitespace(clean or "", original_content),
+                    _restore_outer_whitespace(clean, original_content),
                 )
                 context.streamed_content = True
 
@@ -723,22 +637,15 @@ class AgentRunner:
                     reasoning_content=response.reasoning_content,
                     thinking_blocks=response.thinking_blocks,
                 )
-                assistant_message = conversation_state.project_response_message(
-                    assistant_message,
-                    response,
-                )
 
             # Check for mid-turn injections BEFORE signaling stream end.
             # If injections are found we keep the stream alive (resuming=True)
             # so streaming channels don't prematurely finalize the card.
             should_continue, injection_cycles = await self._try_drain_injections(
                 spec, messages, assistant_message, injection_cycles,
-                conversation_state=conversation_state,
                 phase="after final response",
                 iteration=iteration,
-                allow_goal_continue=(
-                    response.finish_reason not in {"refusal", "content_filter"}
-                ),
+                allow_goal_continue=True,
             )
             if should_continue:
                 had_injections = True
@@ -791,17 +698,11 @@ class AgentRunner:
                     continue
                 break
 
-            messages.append(
-                assistant_message
-                or conversation_state.project_response_message(
-                    build_assistant_message(
-                        clean,
-                        reasoning_content=response.reasoning_content,
-                        thinking_blocks=response.thinking_blocks,
-                    ),
-                    response,
-                )
-            )
+            messages.append(assistant_message or build_assistant_message(
+                clean,
+                reasoning_content=response.reasoning_content,
+                thinking_blocks=response.thinking_blocks,
+            ))
             await self._emit_checkpoint(
                 spec,
                 {
@@ -811,13 +712,12 @@ class AgentRunner:
                     "assistant_message": messages[-1],
                     "completed_tool_results": [],
                     "pending_tool_calls": [],
-                    "provider_state": conversation_state.checkpoint(messages),
                 },
             )
             if length_recovery_parts:
                 final_content = (
                     "".join(length_recovery_parts)
-                    + _restore_outer_whitespace(clean or "", original_content)
+                    + _restore_outer_whitespace(clean, original_content)
                 ).strip()
             else:
                 final_content = clean
@@ -845,7 +745,6 @@ class AgentRunner:
                     hook,
                     messages,
                     usage,
-                    conversation_state,
                 )
             if terminal_content is None:
                 terminal_content = self._max_iterations_fallback(spec)
@@ -869,7 +768,6 @@ class AgentRunner:
             tool_events=tool_events,
             had_injections=had_injections,
             pending_stream_content=pending_stream_content,
-            provider_state=conversation_state.finish(messages),
         )
 
     def _build_request_kwargs(
@@ -890,6 +788,7 @@ class AgentRunner:
         kwargs["temperature"] = generation.temperature
         kwargs["max_tokens"] = generation.max_tokens
         kwargs["reasoning_effort"] = generation.reasoning_effort
+        kwargs["supports_image_input"] = spec.runtime.supports_image_input
         return kwargs
 
     async def _request_model(
@@ -900,9 +799,7 @@ class AgentRunner:
         context: AgentHookContext,
         *,
         malformed_retry: bool = False,
-        conversation_state: ProviderConversationStateController,
-        provider_context: ProviderCallContext | None = None,
-    ) -> LLMResponse:
+    ):
         timeout_s: float | None = spec.llm_timeout_s
         if timeout_s is None:
             # Default to a finite timeout to avoid per-session lock starvation when an LLM
@@ -913,7 +810,7 @@ class AgentRunner:
                 timeout_s = float(raw)
             except (TypeError, ValueError):
                 timeout_s = 300.0
-        if timeout_s <= 0:
+        if timeout_s is not None and timeout_s <= 0:
             timeout_s = None
 
         kwargs = self._build_request_kwargs(
@@ -922,11 +819,10 @@ class AgentRunner:
             tools=spec.tools.get_definitions(),
         )
         wants_streaming = hook.wants_streaming()
-        progress_callback = spec.progress_callback
         wants_progress_streaming = (
             not wants_streaming
             and spec.stream_progress_deltas
-            and progress_callback is not None
+            and spec.progress_callback is not None
             and getattr(spec.runtime.provider, "supports_progress_deltas", False) is True
         )
 
@@ -971,7 +867,6 @@ class AgentRunner:
 
             coro = spec.runtime.provider.chat_stream_with_retry(
                 **kwargs,
-                provider_context=provider_context,
                 on_content_delta=_stream,
                 on_thinking_delta=_thinking,
                 on_tool_call_delta=_provider_tool_event,
@@ -1000,21 +895,15 @@ class AgentRunner:
                         await hook.emit_reasoning_end()
                         progress_state["reasoning_open"] = False
                     context.streamed_content = True
-                    callback = progress_callback
-                    if callback is not None:
-                        await callback(incremental)
+                    await spec.progress_callback(incremental)
 
             coro = spec.runtime.provider.chat_stream_with_retry(
                 **kwargs,
-                provider_context=provider_context,
                 on_content_delta=_stream_progress,
                 on_tool_call_delta=_provider_tool_event,
             )
         else:
-            coro = spec.runtime.provider.chat_with_retry(
-                **kwargs,
-                provider_context=provider_context,
-            )
+            coro = spec.runtime.provider.chat_with_retry(**kwargs)
 
         # Streaming requests also have provider-level idle timeouts
         # (NANOBOT_STREAM_IDLE_TIMEOUT_S), but a stream that keeps producing
@@ -1076,10 +965,6 @@ class AgentRunner:
             return await self._request_model(
                 spec, retry_messages, hook, context,
                 malformed_retry=True,
-                conversation_state=conversation_state,
-                provider_context=conversation_state.independent_request_context(
-                    context_window_tokens=spec.runtime.context_window_tokens,
-                ),
             )
         if (
             all_dropped
@@ -1092,13 +977,7 @@ class AgentRunner:
             fallback_messages = self._malformed_tool_call_retry_messages(
                 messages, response.content,
             )
-            return await self._request_no_tools(
-                spec,
-                fallback_messages,
-                provider_context=conversation_state.independent_request_context(
-                    context_window_tokens=spec.runtime.context_window_tokens,
-                ),
-            )
+            return await self._request_no_tools(spec, fallback_messages)
         return response
 
     @staticmethod
@@ -1131,10 +1010,6 @@ class AgentRunner:
             original_finish_reason,
         )
         response.tool_calls = valid
-        # The opaque candidate still contains every raw function_call item.
-        # Advancing it after dropping even one call would replay an unmatched
-        # call without a corresponding tool output on the next request.
-        response.provider_state = None
         if not valid:
             response.finish_reason = "stop"
         return (dropped, not valid, original_finish_reason)
@@ -1164,27 +1039,9 @@ class AgentRunner:
         self,
         spec: AgentRunSpec,
         messages: list[dict[str, Any]],
-        *,
-        transcript: list[dict[str, Any]],
-        conversation_state: ProviderConversationStateController,
-    ) -> LLMResponse:
+    ):
         retry_messages = self._finalization_retry_messages(messages)
-        provider_context = conversation_state.prepare_request(
-            transcript,
-            context_window_tokens=spec.runtime.context_window_tokens,
-            supplemental_messages=[retry_messages[-1]],
-        )
-        response = await self._request_no_tools(
-            spec,
-            retry_messages,
-            provider_context=provider_context,
-        )
-        conversation_state.observe_response(
-            response,
-            transcript,
-            adopt_candidate_state=False,
-        )
-        return response
+        return await self._request_no_tools(spec, retry_messages)
 
     @staticmethod
     def _finalization_retry_messages(messages: list[dict[str, Any]]) -> list[dict[str, Any]]:
@@ -1198,17 +1055,10 @@ class AgentRunner:
         hook: AgentHook,
         messages: list[dict[str, Any]],
         usage: dict[str, int],
-        conversation_state: ProviderConversationStateController,
     ) -> str | None:
         retry_messages = self._budget_exhausted_finalization_messages(messages)
         try:
-            response = await self._request_no_tools(
-                spec,
-                retry_messages,
-                provider_context=conversation_state.independent_request_context(
-                    context_window_tokens=spec.runtime.context_window_tokens,
-                ),
-            )
+            response = await self._request_no_tools(spec, retry_messages)
         except Exception:
             logger.exception(
                 "Budget-exhausted finalization failed for {}; using fallback",
@@ -1244,18 +1094,9 @@ class AgentRunner:
         self,
         spec: AgentRunSpec,
         messages: list[dict[str, Any]],
-        *,
-        provider_context: ProviderCallContext | None = None,
     ) -> LLMResponse:
-        kwargs = self._build_request_kwargs(
-            spec,
-            messages,
-            tools=None,
-        )
-        return await spec.runtime.provider.chat_with_retry(
-            **kwargs,
-            provider_context=provider_context,
-        )
+        kwargs = self._build_request_kwargs(spec, messages, tools=None)
+        return await spec.runtime.provider.chat_with_retry(**kwargs)
 
     @staticmethod
     def _budget_exhausted_finalization_messages(
@@ -1384,7 +1225,7 @@ class AgentRunner:
                 ))
                 tool_results.extend(batch_results)
             else:
-                batch_results: list[tuple[Any, dict[str, str], BaseException | None]] = []
+                batch_results = []
                 for tool_call in batch:
                     result = await self._run_tool(
                         spec,
@@ -1433,17 +1274,12 @@ class AgentRunner:
             if spec.fail_on_tool_error:
                 return lookup_error + hint, event, RuntimeError(lookup_error)
             return lookup_error + hint, event, None
-        prepare_call = cast(
-            Callable[[str, Any], object] | None,
-            getattr(spec.tools, "prepare_call", None),
-        )
+        prepare_call = getattr(spec.tools, "prepare_call", None)
         tool, params, prep_error = None, tool_call.arguments, None
         if callable(prepare_call):
             prepared = prepare_call(tool_call.name, tool_call.arguments)
-            if isinstance(prepared, tuple):
-                prepared_tuple = cast(tuple[object, ...], prepared)
-                if len(prepared_tuple) == 3:
-                    tool, params, prep_error = cast(tuple[Any, Any, str | None], prepared_tuple)
+            if isinstance(prepared, tuple) and len(prepared) == 3:
+                tool, params, prep_error = prepared
         if prep_error:
             event = {
                 "name": tool_call.name,
@@ -1655,7 +1491,7 @@ class AgentRunner:
         batches: list[list[ToolCallRequest]] = []
         current: list[ToolCallRequest] = []
         for tool_call in tool_calls:
-            get_tool = cast(Callable[[str], Any] | None, getattr(spec.tools, "get", None))
+            get_tool = getattr(spec.tools, "get", None)
             tool = get_tool(tool_call.name) if callable(get_tool) else None
             can_batch = bool(tool and tool.concurrency_safe)
             if can_batch:

nanobot/agent/skills.py

@@ -5,7 +5,6 @@ import os
 import re
 import shutil
 from pathlib import Path
-from typing import Any, cast
 
 import yaml
 
@@ -17,7 +16,6 @@ _STRIP_SKILL_FRONTMATTER = re.compile(
     r"^---\s*\r?\n(.*?)\r?\n---\s*\r?\n?",
     re.DOTALL,
 )
-_SKILL_REFERENCE = re.compile(r"(?<![\w$])\$([A-Za-z0-9_-]+)")
 
 
 class SkillsLoader:
@@ -110,21 +108,6 @@ class SkillsLoader:
         ]
         return "\n\n---\n\n".join(parts)
 
-    def get_explicitly_invoked_skills(self, text: str) -> list[str]:
-        """Resolve ``$skill-name`` references to enabled, available skills."""
-        if not text:
-            return []
-        available = {
-            entry["name"]
-            for entry in self.list_skills(filter_unavailable=True)
-        }
-        invoked: list[str] = []
-        for match in _SKILL_REFERENCE.finditer(text):
-            name = match.group(1)
-            if name in available and name not in invoked:
-                invoked.append(name)
-        return invoked
-
     def build_skills_summary(self, exclude: set[str] | None = None) -> str:
         """
         Build a summary of all skills (name, description, path, availability).
@@ -161,7 +144,7 @@ class SkillsLoader:
                 skill_name = entry["name"]
                 meta = self._get_skill_meta(skill_name)
                 available = self._check_requirements(meta)
-                desc = self.get_skill_description(skill_name)
+                desc = self._get_skill_description(skill_name)
                 suffix = ""
                 if not available:
                     missing = self._get_missing_requirements(meta)
@@ -172,18 +155,18 @@ class SkillsLoader:
         return "\n\n".join(sections)
 
     @staticmethod
-    def _requirement_lists(skill_meta: dict[str, Any]) -> tuple[list[str], list[str]]:
+    def _requirement_lists(skill_meta: dict) -> tuple[list[str], list[str]]:
         """Return (bins, env) lists from skill metadata, tolerating null/wrong shapes."""
-        requires = cast(dict[str, Any], skill_meta.get("requires") or {})
-        if not isinstance(skill_meta.get("requires") or {}, dict):
+        requires = skill_meta.get("requires") or {}
+        if not isinstance(requires, dict):
             return [], []
-        bins_raw: object = requires.get("bins") or []
-        env_raw: object = requires.get("env") or []
-        bins = [value for value in cast(list[object], bins_raw) if isinstance(value, str) and value.strip()] if isinstance(bins_raw, list) else []
-        env = [value for value in cast(list[object], env_raw) if isinstance(value, str) and value.strip()] if isinstance(env_raw, list) else []
+        bins_raw = requires.get("bins") or []
+        env_raw = requires.get("env") or []
+        bins = [str(v) for v in bins_raw if isinstance(v, str) and v.strip()] if isinstance(bins_raw, list) else []
+        env = [str(v) for v in env_raw if isinstance(v, str) and v.strip()] if isinstance(env_raw, list) else []
         return bins, env
 
-    def _get_missing_requirements(self, skill_meta: dict[str, Any]) -> str:
+    def _get_missing_requirements(self, skill_meta: dict) -> str:
         """Get a description of missing requirements."""
         required_bins, required_env_vars = self._requirement_lists(skill_meta)
         return ", ".join(
@@ -207,12 +190,11 @@ class SkillsLoader:
             "missing_env": [value for value in env if not os.environ.get(value)],
         }
 
-    def get_skill_description(self, name: str) -> str:
+    def _get_skill_description(self, name: str) -> str:
         """Get the description of a skill from its frontmatter."""
         meta = self.get_skill_metadata(name)
-        description = meta.get("description") if meta else None
-        if isinstance(description, str) and description:
-            return description
+        if meta and meta.get("description"):
+            return meta["description"]
         return name  # Fallback to skill name
 
     def _strip_frontmatter(self, content: str) -> str:
@@ -224,13 +206,13 @@ class SkillsLoader:
             return content[match.end():].strip()
         return content
 
-    def _parse_nanobot_metadata(self, raw: object) -> dict[str, Any]:
+    def _parse_nanobot_metadata(self, raw: object) -> dict:
         """Extract nanobot/openclaw metadata from a frontmatter field.
 
         ``raw`` may be a dict (already parsed by yaml.safe_load) or a JSON str.
         """
         if isinstance(raw, dict):
-            data = cast(dict[str, Any], raw)
+            data = raw
         elif isinstance(raw, str):
             try:
                 data = json.loads(raw)
@@ -240,18 +222,17 @@ class SkillsLoader:
             return {}
         if not isinstance(data, dict):
             return {}
-        data_object = cast(dict[str, Any], data)
-        payload = data_object.get("nanobot", data_object.get("openclaw", {}))
-        return cast(dict[str, Any], payload) if isinstance(payload, dict) else {}
+        payload = data.get("nanobot", data.get("openclaw", {}))
+        return payload if isinstance(payload, dict) else {}
 
-    def _check_requirements(self, skill_meta: dict[str, Any]) -> bool:
+    def _check_requirements(self, skill_meta: dict) -> bool:
         """Check if skill requirements are met (bins, env vars)."""
         required_bins, required_env_vars = self._requirement_lists(skill_meta)
         return all(shutil.which(cmd) for cmd in required_bins) and all(
             os.environ.get(var) for var in required_env_vars
         )
 
-    def _get_skill_meta(self, name: str) -> dict[str, Any]:
+    def _get_skill_meta(self, name: str) -> dict:
         """Get nanobot metadata for a skill (cached in frontmatter)."""
         raw_meta = self.get_skill_metadata(name) or {}
         return self._parse_nanobot_metadata(raw_meta.get("metadata"))
@@ -268,7 +249,7 @@ class SkillsLoader:
             )
         ]
 
-    def get_skill_metadata(self, name: str) -> dict[str, object] | None:
+    def get_skill_metadata(self, name: str) -> dict | None:
         """
         Get metadata from a skill's frontmatter.
 
@@ -293,6 +274,6 @@ class SkillsLoader:
         # yaml.safe_load returns native types (int, bool, list, etc.);
         # keep values as-is so downstream consumers get correct types.
         metadata: dict[str, object] = {}
-        for key, value in cast(dict[object, object], parsed).items():
+        for key, value in parsed.items():
             metadata[str(key)] = value
         return metadata

nanobot/agent/subagent.py

@@ -7,12 +7,12 @@ import uuid
 import warnings
 from dataclasses import dataclass, field
 from pathlib import Path
-from typing import Any, Callable, TypedDict
+from typing import Any, Callable
 
 from loguru import logger
 
 from nanobot.agent.hook import AgentHook, AgentHookContext
-from nanobot.agent.runner import AgentRunner, AgentRunResult, AgentRunSpec
+from nanobot.agent.runner import AgentRunner, AgentRunSpec
 from nanobot.agent.tools.base import ToolResult
 from nanobot.agent.tools.context import (
     RequestContext,
@@ -26,7 +26,7 @@ from nanobot.agent.tools.loader import ToolLoader
 from nanobot.agent.tools.registry import ToolRegistry
 from nanobot.bus.events import InboundMessage
 from nanobot.bus.queue import MessageBus
-from nanobot.config.schema import AgentDefaults, ToolsConfig
+from nanobot.config.schema import AgentDefaults, ModelPresetConfig, ToolsConfig
 from nanobot.providers.base import LLMProvider
 from nanobot.security.workspace_access import (
     WorkspaceScope,
@@ -38,12 +38,6 @@ from nanobot.utils.llm_runtime import LLMRuntime
 from nanobot.utils.prompt_templates import render_template
 
 
-class _SubagentOrigin(TypedDict):
-    channel: str
-    chat_id: str
-    session_key: str | None
-
-
 @dataclass(slots=True)
 class SubagentStatus:
     """Real-time status of a running subagent."""
@@ -54,8 +48,8 @@ class SubagentStatus:
     started_at: float          # time.monotonic()
     phase: str = "initializing"  # initializing | awaiting_tools | tools_completed | final_response | done | error
     iteration: int = 0
-    tool_events: list[dict[str, str]] = field(default_factory=list)
-    usage: dict[str, int] = field(default_factory=dict)
+    tool_events: list = field(default_factory=list)   # [{name, status, detail}, ...]
+    usage: dict = field(default_factory=dict)          # token usage
     stop_reason: str | None = None
     error: str | None = None
 
@@ -127,7 +121,9 @@ class SubagentManager:
             self._compat_runtime = LLMRuntime.capture(
                 provider,
                 model or provider.get_default_model(),
-                context_window_tokens=defaults.context_window_tokens,
+                context_window_tokens=ModelPresetConfig(
+                    model=model or provider.get_default_model()
+                ).context_window_tokens,
             )
         self.workspace = workspace
         self.bus = bus
@@ -167,7 +163,7 @@ class SubagentManager:
         context_window_tokens = (
             self._compat_runtime.context_window_tokens
             if self._compat_runtime is not None
-            else AgentDefaults().context_window_tokens
+            else ModelPresetConfig(model=model).context_window_tokens
         )
         self._compat_runtime = LLMRuntime.capture(
             provider,
@@ -243,11 +239,7 @@ class SubagentManager:
             runtime = runtime.with_generation_overrides(temperature=temperature)
         task_id = str(uuid.uuid4())[:8]
         display_label = label or task[:30] + ("..." if len(task) > 30 else "")
-        origin: _SubagentOrigin = {
-            "channel": origin_channel,
-            "chat_id": origin_chat_id,
-            "session_key": session_key,
-        }
+        origin = {"channel": origin_channel, "chat_id": origin_chat_id, "session_key": session_key}
 
         status = SubagentStatus(
             task_id=task_id,
@@ -273,7 +265,7 @@ class SubagentManager:
         if session_key:
             self._session_tasks.setdefault(session_key, set()).add(task_id)
 
-        def _cleanup(_: asyncio.Task[str]) -> None:
+        def _cleanup(_: asyncio.Task) -> None:
             self._running_tasks.pop(task_id, None)
             self._task_statuses.pop(task_id, None)
             if session_key and (ids := self._session_tasks.get(session_key)):
@@ -306,7 +298,7 @@ class SubagentManager:
             runtime = runtime.with_generation_overrides(temperature=temperature)
         task_id = str(uuid.uuid4())[:8]
         display_label = label or task[:30] + ("..." if len(task) > 30 else "")
-        origin: _SubagentOrigin = {
+        origin = {
             "channel": origin_channel,
             "chat_id": origin_chat_id,
             "session_key": session_key,
@@ -353,7 +345,7 @@ class SubagentManager:
         task_id: str,
         task: str,
         label: str,
-        origin: _SubagentOrigin,
+        origin: dict[str, str],
         status: SubagentStatus,
         runtime: LLMRuntime,
         origin_message_id: str | None = None,
@@ -364,7 +356,7 @@ class SubagentManager:
         """Execute the subagent task and announce the result."""
         logger.info("Subagent [{}] starting task: {}", task_id, label)
 
-        async def _on_checkpoint(payload: dict[str, Any]) -> None:
+        async def _on_checkpoint(payload: dict) -> None:
             status.phase = payload.get("phase", status.phase)
             status.iteration = payload.get("iteration", status.iteration)
 
@@ -466,7 +458,7 @@ class SubagentManager:
         label: str,
         task: str,
         result: str,
-        origin: _SubagentOrigin,
+        origin: dict[str, str],
         status: str,
         origin_message_id: str | None = None,
     ) -> None:
@@ -506,7 +498,7 @@ class SubagentManager:
         logger.debug("Subagent [{}] announced result to {}:{}", task_id, origin['channel'], origin['chat_id'])
 
     @staticmethod
-    def _format_partial_progress(result: AgentRunResult) -> str:
+    def _format_partial_progress(result) -> str:
         completed = [e for e in result.tool_events if e["status"] == "ok"]
         failure = next((e for e in reversed(result.tool_events) if e["status"] == "error"), None)
         lines: list[str] = []

nanobot/agent/tools/apply_patch.py

@@ -5,10 +5,10 @@ from __future__ import annotations
 import difflib
 from dataclasses import dataclass
 from pathlib import Path
-from typing import Any, cast
+from typing import Any
 
 from nanobot.agent.tools.base import ToolResult, tool_parameters
-from nanobot.agent.tools.filesystem import _FsTool  # pyright: ignore[reportPrivateUsage]
+from nanobot.agent.tools.filesystem import _FsTool
 from nanobot.agent.tools.schema import (
     ArraySchema,
     BooleanSchema,
@@ -134,7 +134,7 @@ class ApplyPatchTool(_FsTool):
 
     async def execute(
         self,
-        edits: list[object] | None = None,
+        edits: list[dict] | None = None,
         dry_run: bool = False,
         **kwargs: Any,
     ) -> str:
@@ -145,10 +145,9 @@ class ApplyPatchTool(_FsTool):
             writes: dict[Path, str] = {}
             summaries: list[_PatchSummary] = []
 
-            for edit_value in edits:
-                if not isinstance(edit_value, dict):
+            for edit in edits:
+                if not isinstance(edit, dict):
                     raise _PatchError("each edit must be an object")
-                edit = cast(dict[str, Any], edit_value)
                 raw_path = edit.get("path")
                 if not isinstance(raw_path, str):
                     raise _PatchError("path required for edit")
@@ -162,7 +161,6 @@ class ApplyPatchTool(_FsTool):
                     new_text = edit.get("new_text")
                     if new_text is None:
                         raise _PatchError(f"new_text required for add: {path}")
-                    new_text = cast(str, new_text)
 
                     pending = writes.get(source)
                     if pending is not None:
@@ -206,11 +204,9 @@ class ApplyPatchTool(_FsTool):
                     old_text = edit.get("old_text") or ""
                     if not old_text:
                         raise _PatchError(f"old_text required for replace: {path}")
-                    old_text = cast(str, old_text)
                     new_text = edit.get("new_text")
                     if new_text is None:
                         raise _PatchError(f"new_text required for replace: {path}")
-                    new_text = cast(str, new_text)
 
                     pending = writes.get(source)
                     if pending is not None:

nanobot/agent/tools/base.py

@@ -5,7 +5,7 @@ import typing
 from abc import ABC, abstractmethod
 from collections.abc import Callable
 from copy import deepcopy
-from typing import Any, TypeVar, cast
+from typing import Any, TypeVar
 
 if typing.TYPE_CHECKING:
     from pydantic import BaseModel
@@ -38,9 +38,8 @@ class Schema(ABC):
     def resolve_json_schema_type(t: Any) -> str | None:
         """Resolve the non-null type name from JSON Schema ``type`` (e.g. ``['string','null']`` -> ``'string'``)."""
         if isinstance(t, list):
-            types = cast(list[Any], t)
-            return cast(str | None, next((x for x in types if x != "null"), None))
-        return cast(str | None, t)
+            return next((x for x in t if x != "null"), None)
+        return t  # type: ignore[return-value]
 
     @staticmethod
     def subpath(path: str, key: str) -> str:
@@ -77,41 +76,33 @@ class Schema(ABC):
             if "maximum" in schema and val > schema["maximum"]:
                 errors.append(f"{label} must be <= {schema['maximum']}")
         if t == "string":
-            string_value = cast(str, val)
-            if "minLength" in schema and len(string_value) < schema["minLength"]:
+            if "minLength" in schema and len(val) < schema["minLength"]:
                 errors.append(f"{label} must be at least {schema['minLength']} chars")
-            if "maxLength" in schema and len(string_value) > schema["maxLength"]:
+            if "maxLength" in schema and len(val) > schema["maxLength"]:
                 errors.append(f"{label} must be at most {schema['maxLength']} chars")
         if t == "object":
-            object_value = cast(dict[str, Any], val)
-            props = cast(dict[str, Any], schema.get("properties", {}))
-            required = cast(list[Any], schema.get("required", []))
-            for k in required:
-                if k not in object_value:
+            props = schema.get("properties", {})
+            for k in schema.get("required", []):
+                if k not in val:
                     errors.append(f"missing required {Schema.subpath(path, k)}")
             additional = schema.get("additionalProperties", True)
-            for k, v in object_value.items():
+            for k, v in val.items():
                 if k in props:
                     errors.extend(Schema.validate_json_schema_value(v, props[k], Schema.subpath(path, k)))
                 elif additional is False:
                     errors.append(f"unexpected parameter {Schema.subpath(path, k)}")
                 elif isinstance(additional, dict):
                     errors.extend(
-                        Schema.validate_json_schema_value(
-                            v,
-                            cast(dict[str, Any], additional),
-                            Schema.subpath(path, k),
-                        )
+                        Schema.validate_json_schema_value(v, additional, Schema.subpath(path, k))
                     )
         if t == "array":
-            array_value = cast(list[Any], val)
-            if "minItems" in schema and len(array_value) < schema["minItems"]:
+            if "minItems" in schema and len(val) < schema["minItems"]:
                 errors.append(f"{label} must have at least {schema['minItems']} items")
-            if "maxItems" in schema and len(array_value) > schema["maxItems"]:
+            if "maxItems" in schema and len(val) > schema["maxItems"]:
                 errors.append(f"{label} must be at most {schema['maxItems']} items")
             if "items" in schema:
                 prefix = f"{path}[{{}}]" if path else "[{}]"
-                for i, item in enumerate(array_value):
+                for i, item in enumerate(val):
                     errors.extend(
                         Schema.validate_json_schema_value(item, schema["items"], prefix.format(i))
                     )
@@ -123,9 +114,9 @@ class Schema(ABC):
         # Try to_json_schema first: Schema instances must be distinguished from dicts that are already JSON Schema
         to_js = getattr(value, "to_json_schema", None)
         if callable(to_js):
-            return cast(dict[str, Any], to_js())
+            return to_js()
         if isinstance(value, dict):
-            return cast(dict[str, Any], value)
+            return value
         raise TypeError(f"Expected schema object or dict, got {type(value).__name__}")
 
     @abstractmethod
@@ -232,15 +223,14 @@ class Tool(ABC):
     def _cast_object(self, obj: Any, schema: dict[str, Any]) -> dict[str, Any]:
         if not isinstance(obj, dict):
             return obj
-        props = cast(dict[str, Any], schema.get("properties", {}))
+        props = schema.get("properties", {})
         additional = schema.get("additionalProperties")
         casted: dict[str, Any] = {}
-        object_value = cast(dict[str, Any], obj)
-        for k, v in object_value.items():
+        for k, v in obj.items():
             if k in props:
                 casted[k] = self._cast_value(v, props[k])
             elif isinstance(additional, dict):
-                casted[k] = self._cast_value(v, cast(dict[str, Any], additional))
+                casted[k] = self._cast_value(v, additional)
             else:
                 casted[k] = v
         return casted
@@ -283,8 +273,7 @@ class Tool(ABC):
 
         if t == "array" and isinstance(val, list):
             items = schema.get("items")
-            array_value = cast(list[Any], val)
-            return [self._cast_value(x, items) for x in array_value] if items else array_value
+            return [self._cast_value(x, items) for x in val] if items else val
 
         if t == "object" and isinstance(val, dict):
             return self._cast_object(val, schema)
@@ -293,7 +282,7 @@ class Tool(ABC):
 
     def validate_params(self, params: dict[str, Any]) -> list[str]:
         """Validate against JSON schema; empty list means valid."""
-        if not isinstance(cast(object, params), dict):
+        if not isinstance(params, dict):
             return [f"parameters must be an object, got {type(params).__name__}"]
         schema = self.parameters or {}
         if schema.get("type", "object") != "object":

nanobot/agent/tools/cli_apps.py

@@ -1,15 +1,14 @@
 """Controlled runner for installed CLI Apps."""
 
-# pyright: reportIncompatibleMethodOverride=false
-
 from __future__ import annotations
 
 from pathlib import Path
+from typing import Any
 
 from pydantic import Field
 
 from nanobot.agent.tools.base import Tool, ToolResult, tool_parameters
-from nanobot.agent.tools.context import RequestContext, ToolContext
+from nanobot.agent.tools.context import RequestContext
 from nanobot.agent.tools.schema import (
     ArraySchema,
     BooleanSchema,
@@ -67,11 +66,11 @@ class CliAppsTool(Tool):
         return CliAppsToolConfig
 
     @classmethod
-    def enabled(cls, ctx: ToolContext) -> bool:
+    def enabled(cls, ctx: Any) -> bool:
         return ctx.config.cli_apps.enable
 
     @classmethod
-    def create(cls, ctx: ToolContext) -> Tool:
+    def create(cls, ctx: Any) -> Tool:
         cfg = ctx.config.cli_apps
         return cls(
             workspace=Path(ctx.workspace),

nanobot/agent/tools/context.py

@@ -8,16 +8,6 @@ from pathlib import Path
 from typing import TYPE_CHECKING, Any, Callable, Protocol, runtime_checkable
 
 if TYPE_CHECKING:
-    from nanobot.agent.subagent import SubagentManager
-    from nanobot.agent.tools.exec_session import ExecSessionManager
-    from nanobot.agent.tools.file_state import FileStates
-    from nanobot.bus.queue import MessageBus
-    from nanobot.bus.runtime_events import RuntimeEventBus
-    from nanobot.config.schema import ProviderConfig, ToolsConfig
-    from nanobot.cron.service import CronService
-    from nanobot.providers.factory import ProviderSnapshot
-    from nanobot.security.workspace_access import WorkspaceSandboxStatus
-    from nanobot.session.manager import SessionManager
     from nanobot.utils.llm_runtime import LLMRuntime
 
 _CURRENT_REQUEST_CONTEXT: ContextVar["RequestContext | None"] = ContextVar(
@@ -77,16 +67,16 @@ def current_request_session_key() -> str | None:
 
 @dataclass
 class ToolContext:
-    config: ToolsConfig
+    config: Any
     workspace: str
-    bus: MessageBus | None = None
-    subagent_manager: SubagentManager | None = None
-    cron_service: CronService | None = None
-    exec_session_manager: ExecSessionManager | None = None
-    sessions: SessionManager | None = None
-    file_state_store: FileStates | None = None
-    provider_snapshot_loader: Callable[..., ProviderSnapshot] | None = None
-    image_generation_provider_configs: dict[str, ProviderConfig] | None = None
+    bus: Any | None = None
+    subagent_manager: Any | None = None
+    cron_service: Any | None = None
+    exec_session_manager: Any | None = None
+    sessions: Any | None = None
+    file_state_store: Any = field(default=None)
+    provider_snapshot_loader: Callable[[], Any] | None = None
+    image_generation_provider_configs: dict[str, Any] | None = None
     timezone: str = "UTC"
-    workspace_sandbox: WorkspaceSandboxStatus | None = None
-    runtime_events: RuntimeEventBus | None = None
+    workspace_sandbox: Any | None = None
+    runtime_events: Any | None = None

nanobot/agent/tools/cron.py

@@ -1,15 +1,13 @@
 """Cron tool for scheduling reminders and tasks."""
 
-# pyright: reportIncompatibleMethodOverride=false
-
 from __future__ import annotations
 
-from contextvars import ContextVar, Token
+from contextvars import ContextVar
 from datetime import datetime
 from typing import Any
 
 from nanobot.agent.tools.base import Tool, ToolResult, tool_parameters
-from nanobot.agent.tools.context import ToolContext, current_request_context
+from nanobot.agent.tools.context import current_request_context
 from nanobot.agent.tools.schema import (
     IntegerSchema,
     StringSchema,
@@ -62,15 +60,12 @@ class CronTool(Tool):
         self._in_cron_context: ContextVar[bool] = ContextVar("cron_in_context", default=False)
 
     @classmethod
-    def enabled(cls, ctx: ToolContext) -> bool:
+    def enabled(cls, ctx: Any) -> bool:
         return ctx.cron_service is not None
 
     @classmethod
-    def create(cls, ctx: ToolContext) -> Tool:
-        cron_service = ctx.cron_service
-        if cron_service is None:
-            raise RuntimeError("CronTool requires an initialized cron service")
-        return cls(cron_service=cron_service, default_timezone=ctx.timezone)
+    def create(cls, ctx: Any) -> Tool:
+        return cls(cron_service=ctx.cron_service, default_timezone=ctx.timezone)
 
     @staticmethod
     def _request_route() -> tuple[str, str, str, dict[str, Any]]:
@@ -84,11 +79,11 @@ class CronTool(Tool):
         )
         return session_key, ctx.channel or "", ctx.chat_id or "", dict(ctx.metadata or {})
 
-    def set_cron_context(self, active: bool) -> Token[bool]:
+    def set_cron_context(self, active: bool):
         """Mark whether the tool is executing inside a cron job callback."""
         return self._in_cron_context.set(active)
 
-    def reset_cron_context(self, token: Token[bool]) -> None:
+    def reset_cron_context(self, token) -> None:
         """Restore previous cron context."""
         self._in_cron_context.reset(token)
 
@@ -262,7 +257,7 @@ class CronTool(Tool):
         jobs = self._cron.list_jobs()
         if not jobs:
             return "No scheduled jobs."
-        lines: list[str] = []
+        lines = []
         for j in jobs:
             timing = self._format_timing(j.schedule)
             parts = [f"- {j.name} (id: {j.id}, {timing})"]

nanobot/agent/tools/exec_session.py

@@ -5,13 +5,12 @@ from __future__ import annotations
 import asyncio
 import time
 import uuid
-from collections import deque
 from contextlib import suppress
 from dataclasses import dataclass
 from typing import Any
 
 from nanobot.agent.tools.base import Tool, ToolResult, tool_parameters
-from nanobot.agent.tools.context import ToolContext, current_request_session_key
+from nanobot.agent.tools.context import current_request_session_key
 from nanobot.agent.tools.schema import (
     BooleanSchema,
     IntegerSchema,
@@ -52,66 +51,6 @@ class ExecSessionInfo:
     owner_session_key: str | None = None
 
 
-class _BoundedOutputBuffer:
-    """Keep the first and most recent characters within a fixed budget."""
-
-    def __init__(self, max_chars: int) -> None:
-        self.max_chars = max_chars
-        self._content = ""
-        self._tail: deque[str] = deque()
-        self._tail_chars = 0
-        self._total_chars = 0
-        self._truncated = False
-
-    @property
-    def has_output(self) -> bool:
-        return self._total_chars > 0
-
-    @property
-    def retained_chars(self) -> int:
-        return len(self._content) + self._tail_chars
-
-    def append(self, text: str) -> None:
-        if not text:
-            return
-        self._total_chars += len(text)
-        if not self._truncated:
-            combined = self._content + text
-            if len(combined) <= self.max_chars:
-                self._content = combined
-                return
-            head_chars = self.max_chars // 2
-            tail_chars = self.max_chars - head_chars
-            self._content = combined[:head_chars]
-            self._tail.append(combined[-tail_chars:])
-            self._tail_chars = tail_chars
-            self._truncated = True
-            return
-
-        tail_chars = self.max_chars - len(self._content)
-        self._tail.append(text)
-        self._tail_chars += len(text)
-        while self._tail_chars > tail_chars:
-            excess = self._tail_chars - tail_chars
-            first = self._tail[0]
-            if len(first) <= excess:
-                self._tail.popleft()
-                self._tail_chars -= len(first)
-            else:
-                self._tail[0] = first[excess:]
-                self._tail_chars -= excess
-
-    def drain(self) -> tuple[str, int]:
-        output = self._content + "".join(self._tail)
-        truncated_chars = self._total_chars - len(output)
-        self._content = ""
-        self._tail.clear()
-        self._tail_chars = 0
-        self._total_chars = 0
-        self._truncated = False
-        return output, truncated_chars
-
-
 class _ExecSession:
     def __init__(
         self,
@@ -134,27 +73,30 @@ class _ExecSession:
         # timeout None/0 means no limit; an infinite deadline is never reached.
         self.deadline = time.monotonic() + timeout if timeout else float("inf")
         self.last_access = time.monotonic()
-        self._stdout = _BoundedOutputBuffer(MAX_OUTPUT_CHARS)
-        self._stderr = _BoundedOutputBuffer(MAX_OUTPUT_CHARS)
+        self._chunks: list[str] = []
         self._lock = asyncio.Lock()
         self._timed_out = False
-        self._stdout_task = asyncio.create_task(self._read_stream(process.stdout, self._stdout))
-        self._stderr_task = asyncio.create_task(self._read_stream(process.stderr, self._stderr))
+        self._stdout_task = asyncio.create_task(self._read_stream(process.stdout, ""))
+        self._stderr_task = asyncio.create_task(self._read_stream(process.stderr, "STDERR:\n"))
 
     async def _read_stream(
         self,
         stream: asyncio.StreamReader | None,
-        buffer: _BoundedOutputBuffer,
+        prefix: str,
     ) -> None:
         if stream is None:
             return
+        first = True
         while True:
             chunk = await stream.read(4096)
             if not chunk:
                 break
             text = chunk.decode("utf-8", errors="replace")
+            if prefix and first:
+                text = prefix + text
+                first = False
             async with self._lock:
-                buffer.append(text)
+                self._chunks.append(text)
 
     async def write(self, chars: str) -> str | None:
         if self.process.returncode is not None:
@@ -209,20 +151,16 @@ class _ExecSession:
                     timeout=2.0,
                 )
             # Safety-net reap after normal exit.
-            from nanobot.agent.tools.shell import _reap_pid  # pyright: ignore[reportPrivateUsage]
-            _reap_pid(self.process.pid)  # pyright: ignore[reportPrivateUsage]
+            from nanobot.agent.tools.shell import _reap_pid
+            _reap_pid(self.process.pid)
         elif yield_time_ms > 0:
             await self._wait_for_buffered_output()
 
         async with self._lock:
-            stdout, stdout_truncated = self._stdout.drain()
-            stderr, stderr_truncated = self._stderr.drain()
+            output = "".join(self._chunks)
+            self._chunks.clear()
 
-        output_parts = [stdout] if stdout else []
-        if stderr:
-            output_parts.append(f"STDERR:\n{stderr}")
-        output = "\n".join(output_parts)
-        output, response_truncated = _truncate_output(output, max_output_chars)
+        output, truncated = _truncate_output(output, max_output_chars)
         return _SessionPoll(
             output=output,
             done=self.process.returncode is not None,
@@ -231,7 +169,7 @@ class _ExecSession:
             timed_out=self._timed_out,
             terminated=terminated,
             stdin_closed=stdin_closed,
-            truncated_chars=stdout_truncated + stderr_truncated + response_truncated,
+            truncated_chars=truncated,
         )
 
     async def kill(self) -> None:
@@ -239,9 +177,9 @@ class _ExecSession:
 
         try:
             if self._process_tree:
-                await ExecTool._kill_process_tree(self.process)  # pyright: ignore[reportPrivateUsage]
+                await ExecTool._kill_process_tree(self.process)
             else:
-                await ExecTool._kill_process(self.process)  # pyright: ignore[reportPrivateUsage]
+                await ExecTool._kill_process(self.process)
         finally:
             with suppress(asyncio.TimeoutError):
                 await asyncio.wait_for(
@@ -257,7 +195,7 @@ class _ExecSession:
         deadline = time.monotonic() + OUTPUT_DRAIN_GRACE_S
         while time.monotonic() < deadline:
             async with self._lock:
-                if self._stdout.has_output or self._stderr.has_output:
+                if self._chunks:
                     return
             await asyncio.sleep(0.01)
 
@@ -373,13 +311,13 @@ class ExecSessionManager:
         """Terminate and remove all active sessions during shutdown."""
         async with self._lock:
             self._closed = True
-            sessions: list[_ExecSession] = list(self._sessions.values())
+            sessions = list(self._sessions.values())
             self._sessions.clear()
-        results: list[None | BaseException] = list(await asyncio.gather(
+        results = await asyncio.gather(
             *(session.kill() for session in sessions),
             return_exceptions=True,
-        ))
-        failures: list[tuple[_ExecSession, BaseException]] = [
+        )
+        failures = [
             (session, result)
             for session, result in zip(sessions, results, strict=True)
             if isinstance(result, BaseException)
@@ -399,15 +337,15 @@ class ExecSessionManager:
     async def terminate_by_owner(self, owner_session_key: str) -> int:
         """Terminate all sessions owned by owner_session_key. Returns count."""
         async with self._lock:
-            victims: list[_ExecSession] = []
+            victims = []
             for sid, s in list(self._sessions.items()):
                 if s.owner_session_key == owner_session_key:
                     victims.append(self._sessions.pop(sid))
-        results: list[None | BaseException] = list(await asyncio.gather(
+        results = await asyncio.gather(
             *(s.kill() for s in victims),
             return_exceptions=True,
-        ))
-        failures: list[tuple[_ExecSession, BaseException]] = [
+        )
+        failures = [
             (session, result)
             for session, result in zip(victims, results, strict=True)
             if isinstance(result, BaseException)
@@ -446,7 +384,7 @@ class ExecSessionManager:
     ) -> asyncio.subprocess.Process:
         from nanobot.agent.tools.shell import ExecTool
 
-        return await ExecTool._spawn(  # pyright: ignore[reportPrivateUsage]
+        return await ExecTool._spawn(
             command, cwd, env, shell_program, login,
             stdin=asyncio.subprocess.PIPE,
             process_tree=True,
@@ -465,16 +403,20 @@ def clamp_session_int(value: int | None, default: int, minimum: int, maximum: in
 def _truncate_output(output: str, max_output_chars: int) -> tuple[str, int]:
     if len(output) <= max_output_chars:
         return output, 0
-    head_chars = max_output_chars // 2
-    tail_chars = max_output_chars - head_chars
+    half = max_output_chars // 2
     omitted = len(output) - max_output_chars
-    return output[:head_chars] + output[-tail_chars:], omitted
+    return (
+        output[:half]
+        + f"\n\n... ({omitted:,} chars truncated) ...\n\n"
+        + output[-half:],
+        omitted,
+    )
 
 
 def format_session_poll(session_id: str, poll: _SessionPoll) -> str:
     parts = [poll.output] if poll.output else []
     if poll.truncated_chars:
-        parts.append(f"({poll.truncated_chars:,} chars truncated from output)")
+        parts.append(f"(output truncated by {poll.truncated_chars:,} chars)")
     if poll.timed_out:
         parts.append("Error: Command timed out; session was terminated.")
     if poll.terminated and not poll.timed_out:
@@ -547,7 +489,7 @@ class WriteStdinTool(Tool):
         return ExecToolConfig
 
     @classmethod
-    def enabled(cls, ctx: ToolContext) -> bool:
+    def enabled(cls, ctx: Any) -> bool:
         return ctx.config.exec.enable
 
     def __init__(
@@ -558,8 +500,8 @@ class WriteStdinTool(Tool):
         self._manager = manager or DEFAULT_EXEC_SESSION_MANAGER
 
     @classmethod
-    def create(cls, ctx: ToolContext) -> Tool:
-        return cls(manager=ctx.exec_session_manager)
+    def create(cls, ctx: Any) -> Tool:
+        return cls(manager=getattr(ctx, "exec_session_manager", None))
 
     @property
     def exclusive(self) -> bool:
@@ -580,7 +522,7 @@ class WriteStdinTool(Tool):
             "Do not use this to start new commands; start them with exec."
         )
 
-    async def execute(  # pyright: ignore[reportIncompatibleMethodOverride]
+    async def execute(
         self,
         session_id: str,
         chars: str | None = None,
@@ -645,9 +587,7 @@ class WriteStdinTool(Tool):
         max_output_chars: int,
     ) -> str:
         deadline = time.monotonic() + (wait_timeout_ms / 1000)
-        aggregate = _BoundedOutputBuffer(max_output_chars)
-        upstream_truncated = 0
-        search_overlap = ""
+        aggregate: list[str] = []
         first = True
         poll: _SessionPoll | None = None
 
@@ -660,24 +600,19 @@ class WriteStdinTool(Tool):
                 close_stdin=close_stdin if first else False,
                 terminate=terminate if first else False,
                 yield_time_ms=step_ms,
-                max_output_chars=MAX_OUTPUT_CHARS,
+                max_output_chars=max_output_chars,
                 owner_session_key=current_request_session_key(),
             )
             first = False
-            upstream_truncated += poll.truncated_chars
             if poll.output:
                 aggregate.append(poll.output)
-                searchable = search_overlap + poll.output
-                if wait_for in searchable:
-                    poll.output, aggregate_truncated = aggregate.drain()
-                    poll.truncated_chars = upstream_truncated + aggregate_truncated
+                joined = "".join(aggregate)
+                if wait_for in joined:
+                    poll.output = joined
                     result = format_session_poll(session_id, poll)
                     return ToolResult.error(result) if poll.timed_out else result
-                overlap_chars = max(0, len(wait_for) - 1)
-                search_overlap = searchable[-overlap_chars:] if overlap_chars else ""
             if poll.done or remaining_ms <= 0:
-                poll.output, aggregate_truncated = aggregate.drain()
-                poll.truncated_chars = upstream_truncated + aggregate_truncated
+                poll.output = "".join(aggregate)
                 result = format_session_poll(session_id, poll)
                 if wait_for not in poll.output:
                     result += f"\nWait target not observed: {wait_for!r}"
@@ -698,7 +633,7 @@ class ListExecSessionsTool(Tool):
         return ExecToolConfig
 
     @classmethod
-    def enabled(cls, ctx: ToolContext) -> bool:
+    def enabled(cls, ctx: Any) -> bool:
         return ctx.config.exec.enable
 
     def __init__(
@@ -709,8 +644,8 @@ class ListExecSessionsTool(Tool):
         self._manager = manager or DEFAULT_EXEC_SESSION_MANAGER
 
     @classmethod
-    def create(cls, ctx: ToolContext) -> Tool:
-        return cls(manager=ctx.exec_session_manager)
+    def create(cls, ctx: Any) -> Tool:
+        return cls(manager=getattr(ctx, "exec_session_manager", None))
 
     @property
     def name(self) -> str:
@@ -736,7 +671,7 @@ class ListExecSessionsTool(Tool):
             )
             if not sessions:
                 return "No active exec sessions."
-            lines: list[str] = []
+            lines = []
             for info in sessions:
                 command = " ".join(info.command.split())
                 if len(command) > 120:

nanobot/agent/tools/file_state.py

@@ -125,10 +125,6 @@ class FileStates:
         """Return the raw ReadState entry for a path, or None."""
         return self._state.get(str(Path(path).resolve()))
 
-    def raw_state(self) -> dict[str, ReadState]:
-        """Return the mutable backing map for legacy compatibility."""
-        return self._state
-
     def clear(self) -> None:
         """Clear all tracked state (useful for testing)."""
         self._state.clear()
@@ -205,5 +201,5 @@ def clear() -> None:
 # so existing imports keep working.
 def __getattr__(name: str):
     if name == "_state":
-        return _default.raw_state()
+        return _default._state
     raise AttributeError(name)

nanobot/agent/tools/filesystem.py

@@ -1,7 +1,5 @@
 """File system tools: read, write, edit, list."""
 
-# pyright: reportPrivateUsage=false, reportUnusedFunction=false
-
 import difflib
 import mimetypes
 import os
@@ -10,7 +8,6 @@ from pathlib import Path
 from typing import Any
 
 from nanobot.agent.tools.base import Tool, ToolResult, tool_parameters
-from nanobot.agent.tools.context import ToolContext
 from nanobot.agent.tools.file_state import FileStates, _hash_file, current_file_states
 from nanobot.agent.tools.path_utils import resolve_workspace_path
 from nanobot.agent.tools.schema import (
@@ -40,7 +37,7 @@ class _FsTool(Tool):
         return FileToolsConfig
 
     @classmethod
-    def enabled(cls, ctx: ToolContext) -> bool:
+    def enabled(cls, ctx: Any) -> bool:
         return ctx.config.file.enable
 
     def __init__(
@@ -80,7 +77,7 @@ class _FsTool(Tool):
         self._fallback_file_states = FileStates()
 
     @classmethod
-    def create(cls, ctx: ToolContext) -> Tool:
+    def create(cls, ctx: Any) -> Tool:
         from nanobot.agent.skills import BUILTIN_SKILLS_DIR
 
         agent_workspace = Path(ctx.workspace)
@@ -411,8 +408,7 @@ class ReadFileTool(_FsTool):
             result = "\n".join(numbered)
 
             if len(result) > self._MAX_CHARS:
-                trimmed: list[str] = []
-                chars = 0
+                trimmed, chars = [], 0
                 for line in numbered:
                     chars += len(line) + 1
                     if chars > self._MAX_CHARS:

nanobot/agent/tools/image_generation.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 
 import asyncio
 from pathlib import Path
-from typing import TYPE_CHECKING, Any, cast
+from typing import TYPE_CHECKING, Any
 
 from loguru import logger
 from pydantic import Field
@@ -23,7 +23,6 @@ from nanobot.bus.events import (
     RUNTIME_CONTROL_IMAGE_GENERATION_RELOAD,
     InboundMessage,
 )
-from nanobot.bus.queue import MessageBus
 from nanobot.config.paths import get_media_dir
 from nanobot.config_base import Base
 from nanobot.providers.image_generation import (
@@ -42,7 +41,6 @@ from nanobot.utils.artifacts import (
 from nanobot.utils.helpers import detect_image_mime
 
 if TYPE_CHECKING:
-    from nanobot.agent.tools.context import ToolContext
     from nanobot.config.schema import ProviderConfig
 
 
@@ -91,11 +89,11 @@ class ImageGenerationTool(Tool):
         return ImageGenerationToolConfig
 
     @classmethod
-    def enabled(cls, ctx: ToolContext) -> bool:
+    def enabled(cls, ctx: Any) -> bool:
         return ctx.config.image_generation.enabled
 
     @classmethod
-    def create(cls, ctx: ToolContext) -> Tool:
+    def create(cls, ctx: Any) -> Tool:
         return cls(
             workspace=ctx.workspace,
             config=ctx.config.image_generation,
@@ -136,14 +134,12 @@ class ImageGenerationTool(Tool):
         cls = get_image_gen_provider(self.config.provider)
         if cls is None:
             return None
-        kwargs: dict[str, Any] = {
-            "api_key": provider.api_key if provider and isinstance(provider.api_key, str) else None,
-            "api_base": provider.api_base if provider and isinstance(provider.api_base, str) else None,
-            "extra_headers": provider.extra_headers
-            if provider and isinstance(provider.extra_headers, dict) else None,
-            "extra_body": provider.extra_body
-            if provider and isinstance(provider.extra_body, dict) else None,
-            "proxy": provider.proxy if provider and isinstance(provider.proxy, str) else None,
+        kwargs = {
+            "api_key": provider.api_key if provider else None,
+            "api_base": provider.api_base if provider else None,
+            "extra_headers": provider.extra_headers if provider else None,
+            "extra_body": provider.extra_body if provider else None,
+            "proxy": provider.proxy if provider else None,
         }
         return cls(**kwargs)
 
@@ -176,7 +172,7 @@ class ImageGenerationTool(Tool):
             return []
         return [self._resolve_reference_image(value) for value in values if value]
 
-    async def execute(  # pyright: ignore[reportIncompatibleMethodOverride]
+    async def execute(
         self,
         prompt: str,
         reference_images: list[str] | None = None,
@@ -242,7 +238,7 @@ async def reload_image_generation_tool(state: Any, registry: ToolRegistry) -> di
         }
 
     next_tool = (
-        ImageGenerationTool(  # pyright: ignore[reportAbstractUsage]
+        ImageGenerationTool(
             workspace=state.workspace,
             config=tool_config,
             provider_configs=provider_configs,
@@ -275,7 +271,7 @@ async def reload_image_generation_tool(state: Any, registry: ToolRegistry) -> di
 
 
 async def request_image_generation_reload(
-    bus: MessageBus,
+    bus: Any,
     *,
     timeout: float = 5.0,
 ) -> dict[str, Any]:
@@ -302,13 +298,11 @@ async def request_image_generation_reload(
             "message": "Image generation hot reload timed out.",
             "requires_restart": True,
         }
-    if not isinstance(cast(object, result), dict):
-        return {
-            "ok": False,
-            "message": "Image generation hot reload returned an unexpected response.",
-            "requires_restart": True,
-        }
-    return result
+    return result if isinstance(result, dict) else {
+        "ok": False,
+        "message": "Image generation hot reload returned an unexpected response.",
+        "requires_restart": True,
+    }
 
 
 async def handle_runtime_control(
@@ -317,7 +311,7 @@ async def handle_runtime_control(
     registry: ToolRegistry,
 ) -> bool:
     """Handle an in-process image generation reload request."""
-    metadata = msg.metadata
+    metadata = msg.metadata if isinstance(msg.metadata, dict) else {}
     if metadata.get(INBOUND_META_RUNTIME_CONTROL) != RUNTIME_CONTROL_IMAGE_GENERATION_RELOAD:
         return False
 
@@ -333,5 +327,5 @@ async def handle_runtime_control(
             "error": str(exc),
         }
     if isinstance(ack, asyncio.Future) and not ack.done():
-        cast(asyncio.Future[Any], ack).set_result(result)
+        ack.set_result(result)
     return True

nanobot/agent/tools/loader.py

@@ -1,22 +1,16 @@
 """Tool discovery and registration via package scanning."""
-
-# pyright: reportIncompatibleVariableOverride=false
-
 from __future__ import annotations
 
 import importlib
 import pkgutil
 from importlib.metadata import entry_points
-from typing import TYPE_CHECKING, Any
+from typing import Any
 
 from loguru import logger
 
 from nanobot.agent.tools.base import Tool, ToolResult
 from nanobot.agent.tools.registry import ToolRegistry
 
-if TYPE_CHECKING:
-    from nanobot.agent.tools.context import RequestContext, ToolContext
-
 _SKIP_MODULES = frozenset({
     "base", "schema", "registry", "context", "loader", "config",
     "file_state", "sandbox", "mcp", "__init__", "runtime_state",
@@ -89,7 +83,7 @@ class ToolLoader:
         self._plugins = plugins
         return plugins
 
-    def load(self, ctx: ToolContext, registry: ToolRegistry, *, scope: str = "core") -> list[str]:
+    def load(self, ctx: Any, registry: ToolRegistry, *, scope: str = "core") -> list[str]:
         registered: list[str] = []
         builtin_names: set[str] = set()
         sources = [(self.discover(), False), (self._discover_plugins().values(), True)]
@@ -163,7 +157,7 @@ class _LegacyErrorPrefixTool(Tool):
     def config_key(self) -> str:
         return getattr(self._wrapped, "config_key", "")
 
-    def set_context(self, ctx: RequestContext) -> None:
+    def set_context(self, ctx: Any) -> None:
         set_context = getattr(self._wrapped, "set_context", None)
         if callable(set_context):
             set_context(ctx)

nanobot/agent/tools/long_task.py

@@ -1,7 +1,5 @@
 """Sustained-goal tools with explicit user opt-in at the execution boundary."""
 
-# pyright: reportIncompatibleMethodOverride=false
-
 from __future__ import annotations
 
 from copy import deepcopy
@@ -13,7 +11,7 @@ from nanobot.agent.goal_permission import (
     revoke_goal_mutation_permission,
 )
 from nanobot.agent.tools.base import Tool, ToolResult, tool_parameters
-from nanobot.agent.tools.context import RequestContext, ToolContext, current_request_context
+from nanobot.agent.tools.context import RequestContext, current_request_context
 from nanobot.agent.tools.schema import StringSchema, tool_parameters_schema
 from nanobot.bus.runtime_events import GoalStateChanged, RuntimeEventBus, RuntimeEventContext
 from nanobot.runtime_context import RuntimeContextBlock, wrap_runtime_context_lines
@@ -134,24 +132,23 @@ class CreateGoalTool(Tool, _GoalToolsMixin):
 
     def __init__(
         self,
-        sessions: SessionManager,
+        sessions: Any,
         runtime_events: RuntimeEventBus | None = None,
     ) -> None:
         _GoalToolsMixin.__init__(self, sessions, runtime_events)
 
     @classmethod
-    def create(cls, ctx: ToolContext) -> Tool:
-        sess = ctx.sessions
-        if sess is None:
-            raise RuntimeError("CreateGoalTool requires an initialized session manager")
+    def create(cls, ctx: Any) -> Tool:
+        sess = getattr(ctx, "sessions", None)
+        assert sess is not None
         return cls(
             sessions=sess,
-            runtime_events=ctx.runtime_events,
+            runtime_events=getattr(ctx, "runtime_events", None),
         )
 
     @classmethod
-    def enabled(cls, ctx: ToolContext) -> bool:
-        return ctx.sessions is not None
+    def enabled(cls, ctx: Any) -> bool:
+        return getattr(ctx, "sessions", None) is not None
 
     @property
     def name(self) -> str:
@@ -265,24 +262,23 @@ class UpdateGoalTool(Tool, _GoalToolsMixin):
 
     def __init__(
         self,
-        sessions: SessionManager,
+        sessions: Any,
         runtime_events: RuntimeEventBus | None = None,
     ) -> None:
         _GoalToolsMixin.__init__(self, sessions, runtime_events)
 
     @classmethod
-    def create(cls, ctx: ToolContext) -> Tool:
-        sess = ctx.sessions
-        if sess is None:
-            raise RuntimeError("UpdateGoalTool requires an initialized session manager")
+    def create(cls, ctx: Any) -> Tool:
+        sess = getattr(ctx, "sessions", None)
+        assert sess is not None
         return cls(
             sessions=sess,
-            runtime_events=ctx.runtime_events,
+            runtime_events=getattr(ctx, "runtime_events", None),
         )
 
     @classmethod
-    def enabled(cls, ctx: ToolContext) -> bool:
-        return ctx.sessions is not None
+    def enabled(cls, ctx: Any) -> bool:
+        return getattr(ctx, "sessions", None) is not None
 
     @property
     def name(self) -> str:

nanobot/agent/tools/mcp.py

@@ -7,9 +7,9 @@ import os
 import re
 import shutil
 import urllib.parse
-from collections.abc import AsyncIterator, Awaitable, Callable
+from collections.abc import Awaitable, Callable
 from contextlib import AsyncExitStack, suppress
-from typing import TYPE_CHECKING, Any, Mapping, Protocol, cast
+from typing import Any, Mapping, Protocol
 from weakref import WeakKeyDictionary
 
 import httpx
@@ -23,7 +23,6 @@ from nanobot.bus.events import (
     RUNTIME_CONTROL_MCP_RELOAD,
     InboundMessage,
 )
-from nanobot.bus.queue import MessageBus
 from nanobot.security.network import (
     PinnedDNSAsyncTransport,
     env_proxy_applies_to_url,
@@ -33,13 +32,6 @@ from nanobot.security.network import (
 )
 from nanobot.utils.cancellation import task_is_cancelling
 
-if TYPE_CHECKING:
-    from mcp import ClientSession
-    from mcp.types import Prompt, Resource
-    from mcp.types import Tool as MCPToolDefinition
-
-    from nanobot.config.schema import MCPServerConfig
-
 # Transient connection errors that warrant a single retry.
 # These typically happen when an MCP server restarts or a network
 # connection is interrupted between calls.
@@ -100,7 +92,7 @@ def _mcp_jsonrpc_payload(message: Any) -> Any:
 
 def _payload_value(payload: Any, key: str) -> Any:
     if isinstance(payload, Mapping):
-        return cast(Mapping[str, Any], payload).get(key)
+        return payload.get(key)
     return getattr(payload, key, None)
 
 
@@ -114,7 +106,7 @@ class _MalformedProgressNotificationFilter:
     def __init__(self, read_stream: Any, server_name: str) -> None:
         self._read_stream = read_stream
         self._server_name = server_name
-        self._iterator: AsyncIterator[Any] | None = None
+        self._iterator: Any | None = None
 
     async def __aenter__(self) -> "_MalformedProgressNotificationFilter":
         await self._read_stream.__aenter__()
@@ -128,13 +120,11 @@ class _MalformedProgressNotificationFilter:
         return self
 
     async def __anext__(self) -> Any:
-        iterator = self._iterator
-        if iterator is None:
-            iterator = self._read_stream.__aiter__()
-            self._iterator = iterator
+        if self._iterator is None:
+            self._iterator = self._read_stream.__aiter__()
 
         while True:
-            message = await anext(iterator)
+            message = await self._iterator.__anext__()
             if _is_malformed_mcp_progress_notification(message):
                 logger.debug(
                     "MCP server '{}': dropped progress notification without progressToken",
@@ -251,8 +241,8 @@ def _redact_url(url: str) -> str:
         return "<redacted-url>"
 
 
-def _pinned_transport_kwargs() -> dict[str, Any]:
-    kwargs: dict[str, Any] = {"transport": PinnedDNSAsyncTransport()}
+def _pinned_transport_kwargs() -> dict[str, object]:
+    kwargs: dict[str, object] = {"transport": PinnedDNSAsyncTransport()}
     mounts = httpx_env_proxy_mounts()
     if mounts:
         kwargs["mounts"] = mounts
@@ -312,14 +302,13 @@ def _extract_nullable_branch(options: Any) -> tuple[dict[str, Any], bool] | None
 
     non_null: list[dict[str, Any]] = []
     saw_null = False
-    for option in cast(list[object], options):
+    for option in options:
         if not isinstance(option, dict):
             return None
-        option_schema = cast(dict[str, Any], option)
-        if option_schema.get("type") == "null":
+        if option.get("type") == "null":
             saw_null = True
             continue
-        non_null.append(option_schema)
+        non_null.append(option)
 
     if saw_null and len(non_null) == 1:
         return non_null[0], True
@@ -341,9 +330,9 @@ def _resolve_local_schema_ref(root: dict[str, Any], ref: str) -> Any:
     for raw_part in pointer[1:].split("/"):
         part = raw_part.replace("~1", "/").replace("~0", "~")
         if isinstance(current, dict):
-            current = cast(dict[str, Any], current)[part]
+            current = current[part]
         elif isinstance(current, list):
-            current = cast(list[Any], current)[int(part)]
+            current = current[int(part)]
         else:
             raise KeyError(part)
     return current
@@ -356,15 +345,14 @@ def _rewrite_local_schema_refs(schema: dict[str, Any]) -> dict[str, Any]:
 
     def rewrite(value: Any) -> Any:
         if isinstance(value, list):
-            return [rewrite(item) for item in cast(list[Any], value)]
+            return [rewrite(item) for item in value]
         if not isinstance(value, dict):
             return value
 
-        rewritten = dict(cast(dict[str, Any], value))
-        raw_ref = rewritten.get("$ref")
-        ref = raw_ref if isinstance(raw_ref, str) else None
+        rewritten = dict(value)
+        ref = rewritten.get("$ref")
         is_rewritable_ref = False
-        if ref is not None and not ref.startswith("#/$defs/"):
+        if isinstance(ref, str) and not ref.startswith("#/$defs/"):
             try:
                 pointer = urllib.parse.unquote(ref[1:], errors="strict")
             except (UnicodeDecodeError, ValueError):
@@ -374,7 +362,6 @@ def _rewrite_local_schema_refs(schema: dict[str, Any]) -> dict[str, Any]:
                     not pointer or pointer.startswith("/")
                 )
         if is_rewritable_ref:
-            assert ref is not None
             name = rewritten_refs.get(ref)
             if name is None:
                 try:
@@ -382,6 +369,7 @@ def _rewrite_local_schema_refs(schema: dict[str, Any]) -> dict[str, Any]:
                 except (KeyError, IndexError, TypeError, UnicodeDecodeError, ValueError):
                     logger.warning("MCP tool schema contains an unresolved local $ref: {}", ref)
                 else:
+                    assert isinstance(ref, str)
                     name = f"ref_{hashlib.sha256(ref.encode()).hexdigest()[:12]}"
                     existing_defs = schema.get("$defs")
                     while isinstance(existing_defs, dict) and name in existing_defs:
@@ -395,7 +383,7 @@ def _rewrite_local_schema_refs(schema: dict[str, Any]) -> dict[str, Any]:
 
         return {key: rewrite(item) for key, item in rewritten.items()}
 
-    result = cast(dict[str, Any], rewrite(schema))
+    result = rewrite(schema)
     if generated_defs:
         existing_defs = result.get("$defs")
         result["$defs"] = {
@@ -410,9 +398,8 @@ def _normalize_nullable_schema(schema: dict[str, Any]) -> dict[str, Any]:
     normalized = dict(schema)
     raw_type = normalized.get("type")
     if isinstance(raw_type, list):
-        type_values = cast(list[Any], raw_type)
-        non_null = [item for item in type_values if item != "null"]
-        if "null" in type_values and len(non_null) == 1:
+        non_null = [item for item in raw_type if item != "null"]
+        if "null" in raw_type and len(non_null) == 1:
             normalized["type"] = non_null[0]
             normalized["nullable"] = True
 
@@ -426,28 +413,19 @@ def _normalize_nullable_schema(schema: dict[str, Any]) -> dict[str, Any]:
             normalized["nullable"] = True
             break
 
-    properties = normalized.get("properties")
-    if isinstance(properties, dict):
-        property_schemas = cast(dict[str, Any], properties)
+    if isinstance(normalized.get("properties"), dict):
         normalized["properties"] = {
-            name: (
-                _normalize_nullable_schema(cast(dict[str, Any], prop))
-                if isinstance(prop, dict)
-                else prop
-            )
-            for name, prop in property_schemas.items()
+            name: _normalize_nullable_schema(prop) if isinstance(prop, dict) else prop
+            for name, prop in normalized["properties"].items()
         }
-    items = normalized.get("items")
-    if isinstance(items, dict):
-        normalized["items"] = _normalize_nullable_schema(cast(dict[str, Any], items))
-    definitions = normalized.get("$defs")
-    if isinstance(definitions, dict):
-        definition_schemas = cast(dict[str, Any], definitions)
+    if isinstance(normalized.get("items"), dict):
+        normalized["items"] = _normalize_nullable_schema(normalized["items"])
+    if isinstance(normalized.get("$defs"), dict):
         normalized["$defs"] = {
-            name: _normalize_nullable_schema(cast(dict[str, Any], definition))
+            name: _normalize_nullable_schema(definition)
             if isinstance(definition, dict)
             else definition
-            for name, definition in definition_schemas.items()
+            for name, definition in normalized["$defs"].items()
         }
 
     if normalized.get("type") == "object":
@@ -460,19 +438,15 @@ def _normalize_schema_for_openai(schema: Any) -> dict[str, Any]:
     """Normalize MCP JSON Schema patterns for tool definitions."""
     if not isinstance(schema, dict):
         return {"type": "object", "properties": {}}
-    schema_mapping = cast(dict[str, Any], schema)
-    return _normalize_nullable_schema(_rewrite_local_schema_refs(schema_mapping))
+    return _normalize_nullable_schema(_rewrite_local_schema_refs(schema))
 
 
 class _MCPWrapperBase(Tool):
     """Common reconnect handling for wrappers bound to one MCP server session."""
 
     _plugin_discoverable = False
-    _session: "ClientSession"
-    _server_name: str
-    _name: str
 
-    def _set_mcp_connection(self, session: "ClientSession", server_name: str) -> None:
+    def _set_mcp_connection(self, session: Any, server_name: str) -> None:
         self._session = session
         self._server_name = server_name
         self._reconnect: _ReconnectCallback | None = None
@@ -526,10 +500,9 @@ def _image_block_data_url(block: Any, types: Any) -> str | None:
     if embedded_cls is not None and isinstance(block, embedded_cls):
         resource = getattr(block, "resource", None)
         if blob_cls is not None and isinstance(resource, blob_cls):
-            blob_resource = cast(Any, resource)
-            mime = getattr(blob_resource, "mimeType", None) or ""
+            mime = getattr(resource, "mimeType", None) or ""
             if isinstance(mime, str) and mime.startswith("image/"):
-                return f"data:{mime};base64,{blob_resource.blob}"
+                return f"data:{mime};base64,{resource.blob}"
     return None
 
 
@@ -560,13 +533,7 @@ class MCPToolWrapper(_MCPWrapperBase):
 
     _plugin_discoverable = False
 
-    def __init__(
-        self,
-        session: "ClientSession",
-        server_name: str,
-        tool_def: "MCPToolDefinition",
-        tool_timeout: int = 30,
-    ):
+    def __init__(self, session, server_name: str, tool_def, tool_timeout: int = 30):
         self._set_mcp_connection(session, server_name)
         self._original_name = tool_def.name
         self._name = _sanitize_mcp_tool_name(f"mcp_{server_name}_{tool_def.name}")
@@ -722,13 +689,7 @@ class MCPResourceWrapper(_MCPWrapperBase):
 
     _plugin_discoverable = False
 
-    def __init__(
-        self,
-        session: "ClientSession",
-        server_name: str,
-        resource_def: "Resource",
-        resource_timeout: int = 30,
-    ):
+    def __init__(self, session, server_name: str, resource_def, resource_timeout: int = 30):
         self._set_mcp_connection(session, server_name)
         self._uri = resource_def.uri
         self._name = _sanitize_mcp_tool_name(f"mcp_{server_name}_resource_{resource_def.name}")
@@ -814,7 +775,7 @@ class MCPResourceWrapper(_MCPWrapperBase):
                 for block in result.contents:
                     if isinstance(block, types.TextResourceContents):
                         parts.append(block.text)
-                    elif isinstance(cast(object, block), types.BlobResourceContents):
+                    elif isinstance(block, types.BlobResourceContents):
                         parts.append(f"[Binary resource: {len(block.blob)} bytes]")
                     else:
                         parts.append(str(block))
@@ -826,13 +787,7 @@ class MCPPromptWrapper(_MCPWrapperBase):
 
     _plugin_discoverable = False
 
-    def __init__(
-        self,
-        session: "ClientSession",
-        server_name: str,
-        prompt_def: "Prompt",
-        prompt_timeout: int = 30,
-    ):
+    def __init__(self, session, server_name: str, prompt_def, prompt_timeout: int = 30):
         self._set_mcp_connection(session, server_name)
         self._prompt_name = prompt_def.name
         self._name = _sanitize_mcp_tool_name(f"mcp_{server_name}_prompt_{prompt_def.name}")
@@ -961,7 +916,7 @@ class MCPPromptWrapper(_MCPWrapperBase):
 
 
 async def connect_mcp_servers(
-    mcp_servers: "dict[str, MCPServerConfig]", registry: ToolRegistry
+    mcp_servers: dict, registry: ToolRegistry
 ) -> dict[str, MCPConnection]:
     """Connect to configured MCP servers and register their tools, resources, prompts.
 
@@ -974,9 +929,7 @@ async def connect_mcp_servers(
     from mcp.client.stdio import stdio_client
     from mcp.client.streamable_http import streamable_http_client
 
-    async def open_single_server(
-        name: str, cfg: "MCPServerConfig"
-    ) -> tuple[str, AsyncExitStack | None]:
+    async def open_single_server(name: str, cfg) -> tuple[str, AsyncExitStack | None]:
         server_stack = AsyncExitStack()
         await server_stack.__aenter__()
 
@@ -1195,9 +1148,7 @@ async def connect_mcp_servers(
                 await server_stack.aclose()
             return name, None
 
-    async def connect_single_server(
-        name: str, cfg: "MCPServerConfig"
-    ) -> tuple[str, MCPConnection | None]:
+    async def connect_single_server(name: str, cfg) -> tuple[str, MCPConnection | None]:
         loop = asyncio.get_running_loop()
         ready: asyncio.Future[bool] = loop.create_future()
         close_requested = asyncio.Event()
@@ -1241,7 +1192,7 @@ async def connect_mcp_servers(
         except Exception as e:
             logger.exception("MCP server '{}' connection failed: {}", name, e)
             continue
-        if result[1] is not None:
+        if result is not None and result[1] is not None:
             server_stacks[result[0]] = result[1]
 
     return server_stacks
@@ -1384,11 +1335,7 @@ async def reload_servers(state: Any, registry: ToolRegistry) -> dict[str, Any]:
         }
 
 
-async def request_mcp_reload(
-    bus: MessageBus,
-    *,
-    timeout: float = 15.0,
-) -> dict[str, Any]:
+async def request_mcp_reload(bus: Any, *, timeout: float = 15.0) -> dict[str, Any]:
     """Ask the running agent loop to reconcile live MCP connections."""
     loop = asyncio.get_running_loop()
     ack: asyncio.Future[dict[str, Any]] = loop.create_future()
@@ -1412,7 +1359,7 @@ async def request_mcp_reload(
             "message": "MCP hot reload timed out. Restart nanobot to pick up changes.",
             "requires_restart": True,
         }
-    return result if isinstance(cast(object, result), dict) else {
+    return result if isinstance(result, dict) else {
         "ok": False,
         "message": "MCP hot reload returned an unexpected response.",
         "requires_restart": True,
@@ -1420,7 +1367,7 @@ async def request_mcp_reload(
 
 
 async def handle_runtime_control(state: Any, msg: InboundMessage, registry: ToolRegistry) -> bool:
-    metadata = msg.metadata if isinstance(cast(object, msg.metadata), dict) else {}
+    metadata = msg.metadata if isinstance(msg.metadata, dict) else {}
     control = metadata.get(INBOUND_META_RUNTIME_CONTROL)
     if control != RUNTIME_CONTROL_MCP_RELOAD:
         return False
@@ -1437,7 +1384,7 @@ async def handle_runtime_control(state: Any, msg: InboundMessage, registry: Tool
             "error": str(exc),
         }
     if isinstance(ack, asyncio.Future) and not ack.done():
-        cast(asyncio.Future[dict[str, Any]], ack).set_result(result)
+        ack.set_result(result)
     return True
 
 

nanobot/agent/tools/message.py

@@ -1,15 +1,13 @@
 """Message tool for sending messages to users."""
 
-# pyright: reportIncompatibleMethodOverride=false
-
-from contextvars import ContextVar, Token
+from contextvars import ContextVar
 from pathlib import Path
-from typing import Any, Awaitable, Callable, cast
+from typing import Any, Awaitable, Callable
 
 from loguru import logger
 
 from nanobot.agent.tools.base import Tool, ToolResult, tool_parameters
-from nanobot.agent.tools.context import ToolContext, current_request_context
+from nanobot.agent.tools.context import current_request_context
 from nanobot.agent.tools.path_utils import resolve_workspace_path
 from nanobot.agent.tools.schema import ArraySchema, StringSchema, tool_parameters_schema
 from nanobot.bus.events import OutboundMessage
@@ -75,7 +73,7 @@ class MessageTool(Tool):
         )
 
     @classmethod
-    def create(cls, ctx: ToolContext) -> Tool:
+    def create(cls, ctx: Any) -> Tool:
         send_callback = ctx.bus.publish_outbound if ctx.bus else None
         return cls(
             send_callback=send_callback,
@@ -91,11 +89,11 @@ class MessageTool(Tool):
         """Reset per-turn send tracking."""
         self._sent_in_turn = False
 
-    def set_suppress_delivery(self, active: bool) -> Token[bool]:
+    def set_suppress_delivery(self, active: bool):
         """Acknowledge but don't deliver tool sends (heartbeat internal check)."""
         return self._suppress_delivery_var.set(active)
 
-    def reset_suppress_delivery(self, token: Token[bool]) -> None:
+    def reset_suppress_delivery(self, token) -> None:
         """Restore previous delivery-suppression state."""
         self._suppress_delivery_var.reset(token)
 
@@ -150,23 +148,19 @@ class MessageTool(Tool):
         chat_id: str | None = None,
         message_id: str | None = None,
         media: list[str] | None = None,
-        buttons: Any = None,
+        buttons: list[list[str]] | None = None,
         **kwargs: Any,
-    ) -> str:  # pyright: ignore[reportIncompatibleMethodOverride]
+    ) -> str:
         from nanobot.utils.helpers import strip_think
 
         content = strip_think(content)
 
-        button_rows: list[list[str]] | None = None
         if buttons is not None:
-            raw_buttons = cast(list[Any], buttons) if isinstance(buttons, list) else None
-            if raw_buttons is None or any(
-                not isinstance(row, list)
-                or any(not isinstance(label, str) for label in cast(list[Any], row))
-                for row in raw_buttons
+            if not isinstance(buttons, list) or any(
+                not isinstance(row, list) or any(not isinstance(label, str) for label in row)
+                for row in buttons
             ):
                 return ToolResult.error("Error: buttons must be a list of list of strings")
-            button_rows = cast(list[list[str]], raw_buttons)
         request_ctx = current_request_context()
         default_channel = (
             request_ctx.channel if request_ctx is not None else self._fallback_channel
@@ -234,7 +228,7 @@ class MessageTool(Tool):
             chat_id=chat_id,
             content=content,
             media=media or [],
-            buttons=button_rows or [],
+            buttons=buttons or [],
             metadata=metadata,
         )
 
@@ -247,11 +241,7 @@ class MessageTool(Tool):
             if channel == default_channel and chat_id == default_chat_id:
                 self._sent_in_turn = True
             media_info = f" with {len(media)} attachments" if media else ""
-            button_info = (
-                f" with {sum(len(row) for row in button_rows)} button(s)"
-                if button_rows
-                else ""
-            )
+            button_info = f" with {sum(len(row) for row in buttons)} button(s)" if buttons else ""
             return f"Message sent to {channel}:{chat_id}{media_info}{button_info}"
         except Exception as e:
             return ToolResult.error(f"Error sending message: {str(e)}")

nanobot/agent/tools/registry.py

@@ -3,7 +3,7 @@
 from __future__ import annotations
 
 import json
-from typing import TYPE_CHECKING, Any, cast
+from typing import TYPE_CHECKING, Any
 
 from nanobot.agent.tools.base import Tool, ToolResult
 from nanobot.agent.tools.context import ContextAware, current_request_context
@@ -77,7 +77,7 @@ class ToolRegistry:
         """Extract a normalized tool name from either OpenAI or flat schemas."""
         fn = schema.get("function")
         if isinstance(fn, dict):
-            name = cast(dict[str, Any], fn).get("name")
+            name = fn.get("name")
             if isinstance(name, str):
                 return name
         name = schema.get("name")
@@ -140,7 +140,7 @@ class ToolRegistry:
                 )
             )
 
-        cast_params = tool.cast_params(cast(dict[str, Any], params))
+        cast_params = tool.cast_params(params)
         errors = tool.validate_params(cast_params)
         if errors:
             return tool, cast_params, (
@@ -176,15 +176,12 @@ class ToolRegistry:
 
     @classmethod
     def _unwrap_arguments_payload(cls, tool: Tool, params: Any) -> Any:
-        if not isinstance(params, dict):
+        if not isinstance(params, dict) or set(params) != {"arguments"}:
             return params
-        arguments_payload = cast(dict[str, Any], params)
-        if set(arguments_payload) != {"arguments"}:
-            return arguments_payload
         properties = (tool.parameters or {}).get("properties", {})
         if isinstance(properties, dict) and "arguments" in properties:
-            return arguments_payload
-        return cls._coerce_argument_value(arguments_payload.get("arguments"))
+            return params
+        return cls._coerce_argument_value(params.get("arguments"))
 
     async def execute(self, name: str, params: Any) -> Any:
         """Execute a tool by name with given parameters."""

nanobot/agent/tools/runtime_state.py

@@ -1,15 +1,6 @@
 """RuntimeState protocol: agent loop state exposed to MyTool."""
 
-from __future__ import annotations
-
-from pathlib import Path
-from typing import TYPE_CHECKING, Any, Protocol
-
-if TYPE_CHECKING:
-    from nanobot.agent.subagent import SubagentManager
-    from nanobot.agent.tools.shell import ExecToolConfig
-    from nanobot.agent.tools.web import WebToolsConfig
-    from nanobot.utils.llm_runtime import LLMRuntime
+from typing import Any, Protocol
 
 
 class RuntimeState(Protocol):
@@ -34,7 +25,7 @@ class RuntimeState(Protocol):
     def tool_names(self) -> list[str]: ...
 
     @property
-    def workspace(self) -> Path: ...
+    def workspace(self) -> str: ...
 
     @property
     def provider_retry_mode(self) -> str: ...
@@ -46,31 +37,34 @@ class RuntimeState(Protocol):
     def context_window_tokens(self) -> int: ...
 
     @property
-    def web_config(self) -> WebToolsConfig: ...
+    def web_config(self) -> Any: ...
 
     @property
-    def exec_config(self) -> ExecToolConfig: ...
+    def exec_config(self) -> Any: ...
 
     @property
-    def subagents(self) -> SubagentManager: ...
+    def workspace_sandbox(self) -> Any: ...
+
+    @property
+    def subagents(self) -> Any: ...
 
     @property
     def _runtime_vars(self) -> dict[str, Any]: ...
 
     @property
-    def _last_usage(self) -> dict[str, int]: ...
+    def _last_usage(self) -> Any: ...
 
     def _sync_subagent_runtime_limits(self) -> None: ...
 
-    def set_runtime_model(self, model: str) -> LLMRuntime: ...
+    def set_runtime_model(self, model: str) -> Any: ...
 
-    def set_runtime_context_window(self, context_window_tokens: int) -> LLMRuntime: ...
+    def set_runtime_context_window(self, context_window_tokens: int) -> Any: ...
 
     def set_session_model_preset(
         self,
         session_key: str,
         name: str,
-    ) -> LLMRuntime: ...
+    ) -> Any: ...
 
     @property
     def model_preset(self) -> str | None: ...

nanobot/agent/tools/search.py

@@ -1,7 +1,5 @@
 """Search tools: file discovery and grep."""
 
-# pyright: reportIncompatibleMethodOverride=false, reportPrivateUsage=false
-
 from __future__ import annotations
 
 import fnmatch

nanobot/agent/tools/self.py

@@ -1,14 +1,10 @@
 """MyTool: runtime state inspection and configuration for the agent loop."""
 
-# RuntimeState intentionally exposes a narrow set of AgentLoop internals to
-# this manually registered tool. Tool.execute accepts heterogeneous schemas.
-# pyright: reportPrivateUsage=false, reportIncompatibleMethodOverride=false
-
 from __future__ import annotations
 
 import time
 from collections.abc import Mapping
-from typing import TYPE_CHECKING, Any, TypeGuard, cast
+from typing import TYPE_CHECKING, Any
 
 from loguru import logger
 
@@ -19,7 +15,6 @@ from nanobot.config_base import Base
 
 if TYPE_CHECKING:
     from nanobot.agent.subagent import SubagentStatus
-    from nanobot.agent.tools.context import ToolContext
 
 
 class MyToolConfig(Base):
@@ -41,7 +36,7 @@ def _has_real_attr(obj: Any, key: str) -> bool:
     return False
 
 
-def _is_subagent_status(value: object) -> TypeGuard[SubagentStatus]:
+def _is_subagent_status(value: Any) -> bool:
     from nanobot.agent.subagent import SubagentStatus
 
     return isinstance(value, SubagentStatus)
@@ -58,7 +53,7 @@ class MyTool(Tool):
         return MyToolConfig
 
     @classmethod
-    def enabled(cls, ctx: ToolContext) -> bool:
+    def enabled(cls, ctx: Any) -> bool:
         return ctx.config.my.enable
 
     BLOCKED = frozenset({
@@ -210,7 +205,7 @@ class MyTool(Tool):
 
     def _resolve_path(self, path: str) -> tuple[Any, str | None]:
         parts = path.split(".")
-        obj: Any = self._runtime_state
+        obj = self._runtime_state
         for part in parts:
             if part in self._DENIED_ATTRS or part.startswith("__"):
                 return None, f"'{part}' is not accessible"
@@ -220,9 +215,8 @@ class MyTool(Tool):
                 return None, f"'{part}' is not accessible"
             try:
                 if isinstance(obj, Mapping):
-                    mapping = cast(Mapping[str, Any], obj)
-                    if part in mapping:
-                        obj = mapping[part]
+                    if part in obj:
+                        obj = obj[part]
                     else:
                         return None, f"'{part}' not found in mapping"
                 else:
@@ -265,40 +259,28 @@ class MyTool(Tool):
             detail = MyTool._format_status(val, "  ")
             return f"{header}\n  task: {val.task_description}\n{detail}"
         # SubagentManager: delegate to its _task_statuses dict
-        task_statuses = getattr(val, "_task_statuses", None)
-        if isinstance(task_statuses, dict):
-            return MyTool._format_value(task_statuses, key)
-        if isinstance(val, Mapping):
-            mapping = cast(Mapping[object, object], val)
-        else:
-            mapping = None
-        if (
-            mapping
-            and _is_subagent_status(next(iter(mapping.values())))
-        ):
-            status_mapping: Mapping[object, SubagentStatus] = cast(Any, mapping)
+        if hasattr(val, "_task_statuses") and isinstance(val._task_statuses, dict):
+            return MyTool._format_value(val._task_statuses, key)
+        if isinstance(val, Mapping) and val and _is_subagent_status(next(iter(val.values()))):
             prefix = f"{key}: " if key else ""
-            lines = [f"{prefix}{len(status_mapping)} subagent(s):"]
-            for tid, st in status_mapping.items():
+            lines = [f"{prefix}{len(val)} subagent(s):"]
+            for tid, st in val.items():
                 detail = MyTool._format_status(st, "    ")
                 lines.append(f"  [{tid}] '{st.label}'\n{detail}")
             return "\n".join(lines)
-        dynamic_value = cast(Any, val)
-        if hasattr(dynamic_value, "tool_names"):
-            tool_names: Any = getattr(dynamic_value, "tool_names")
-            return f"tools: {len(tool_names)} registered — {tool_names}"
+        if hasattr(val, "tool_names"):
+            return f"tools: {len(val.tool_names)} registered — {val.tool_names}"
         # Scalar types — repr is fine
         if isinstance(val, (str, int, float, bool, type(None))):
             r = repr(val)
             return f"{key}: {r}" if key else r
         # Mapping — small: show content; large: show keys for dot-path navigation
         if isinstance(val, Mapping):
-            value_mapping = cast(Mapping[object, object], val)
-            ks = list(value_mapping.keys())
+            ks = list(val.keys())
             if not ks:
                 return f"{key}: {{}}" if key else "{}"
             if len(ks) <= 5:
-                r = repr(value_mapping)
+                r = repr(val)
                 if len(r) <= 200:
                     return f"{key}: {r}" if key else r
             preview = ", ".join(str(k) for k in ks[:15])
@@ -306,20 +288,18 @@ class MyTool(Tool):
             return f"{key}: {{{preview}{suffix}}}" if key else f"{{{preview}{suffix}}}"
         # List/tuple — count for large, repr for small
         if isinstance(val, (list, tuple)):
-            sequence = cast(list[object] | tuple[object, ...], val)
-            if len(sequence) > 20:
-                return f"{key}: [{len(sequence)} items]" if key else f"[{len(sequence)} items]"
-            r = repr(sequence)
+            if len(val) > 20:
+                return f"{key}: [{len(val)} items]" if key else f"[{len(val)} items]"
+            r = repr(val)
             return f"{key}: {r}" if key else r
         # Complex object — small Pydantic models: show values; others: show field names for navigation
-        value_type = type(cast(object, val))
-        cls_name = value_type.__name__
-        model_fields = cast(object, getattr(value_type, "model_fields", None))
-        if isinstance(model_fields, Mapping) and model_fields:
-            fields = list(cast(Mapping[str, object], model_fields).keys())
+        cls_name = type(val).__name__
+        model_fields = getattr(type(val), "model_fields", None)
+        if model_fields:
+            fields = list(model_fields.keys())
             if len(fields) <= 8:
                 # Small config objects: show field=value pairs
-                pairs: list[str] = []
+                pairs = []
                 for f in fields:
                     fv = getattr(val, f, "?")
                     if MyTool._is_sensitive_field_name(f):
@@ -331,8 +311,7 @@ class MyTool(Tool):
                 preview = ", ".join(pairs)
                 return f"{key}: {preview}" if key else preview
         else:
-            attributes = cast(dict[str, Any], getattr(val, "__dict__", {}))
-            fields = [name for name in attributes if not name.startswith("__")]
+            fields = [a for a in getattr(val, "__dict__", {}) if not a.startswith("__")]
         if fields:
             preview = ", ".join(str(f) for f in fields[:20])
             suffix = ", ..." if len(fields) > 20 else ""
@@ -438,7 +417,6 @@ class MyTool(Tool):
     def _modify(self, key: str | None, value: Any) -> str:
         if err := self._validate_key(key):
             return err
-        key = cast(str, key)
         top = key.split(".")[0]
         if top in self.BLOCKED or top in self._DENIED_ATTRS or top.startswith("__") or top.lower() in self._SENSITIVE_NAMES:
             self._audit("modify", f"BLOCKED {key}")
@@ -500,7 +478,7 @@ class MyTool(Tool):
 
     def _modify_restricted(self, key: str, value: Any) -> str:
         spec = self.RESTRICTED[key]
-        expected = cast(type[Any], spec["type"])
+        expected = spec["type"]
         if expected is int and isinstance(value, bool):
             return ToolResult.error(f"Error: '{key}' must be {expected.__name__}, got bool")
         if not isinstance(value, expected):
@@ -521,9 +499,9 @@ class MyTool(Tool):
                 "during an active session; use a configured model_preset"
             )
         if key == "model":
-            self._runtime_state.set_runtime_model(cast(str, value))
+            self._runtime_state.set_runtime_model(value)
         elif key == "context_window_tokens":
-            self._runtime_state.set_runtime_context_window(cast(int, value))
+            self._runtime_state.set_runtime_context_window(value)
         else:
             setattr(self._runtime_state, key, value)
         if key == "max_iterations" and hasattr(
@@ -538,8 +516,7 @@ class MyTool(Tool):
         if _has_real_attr(self._runtime_state, key):
             old = getattr(self._runtime_state, key)
             if isinstance(old, (str, int, float, bool)):
-                old_t: type[Any] = type(old)
-                new_t = cast(type[Any], type(value))
+                old_t, new_t = type(old), type(value)
                 if old_t is float and new_t is int:
                     pass  # int → float coercion allowed
                 elif old_t is not new_t:
@@ -578,12 +555,12 @@ class MyTool(Tool):
         if isinstance(value, (str, int, float, bool, type(None))):
             return None
         if isinstance(value, list):
-            for i, item in enumerate(cast(list[Any], value)):
+            for i, item in enumerate(value):
                 if err := cls._validate_json_safe(item, depth + 1):
                     return f"list[{i}] contains {err}"
             return None
         if isinstance(value, dict):
-            for k, v in cast(dict[Any, Any], value).items():
+            for k, v in value.items():
                 if not isinstance(k, str):
                     return f"dict key must be str, got {type(k).__name__}"
                 if err := cls._validate_json_safe(v, depth + 1):

nanobot/agent/tools/shell.py

@@ -18,14 +18,13 @@ from loguru import logger
 from pydantic import Field
 
 from nanobot.agent.tools.base import Tool, ToolResult, tool_parameters
-from nanobot.agent.tools.context import ToolContext, current_request_session_key
+from nanobot.agent.tools.context import current_request_session_key
 from nanobot.agent.tools.exec_session import (
     DEFAULT_EXEC_SESSION_MANAGER,
     DEFAULT_MAX_OUTPUT_CHARS,
     DEFAULT_YIELD_MS,
     MAX_OUTPUT_CHARS,
     MAX_YIELD_MS,
-    ExecSessionManager,
     clamp_session_int,
     format_session_poll,
 )
@@ -175,11 +174,11 @@ class ExecTool(Tool):
         return ExecToolConfig
 
     @classmethod
-    def enabled(cls, ctx: ToolContext) -> bool:
+    def enabled(cls, ctx: Any) -> bool:
         return ctx.config.exec.enable
 
     @classmethod
-    def create(cls, ctx: ToolContext) -> Tool:
+    def create(cls, ctx: Any) -> Tool:
         cfg = ctx.config.exec
         return cls(
             working_dir=ctx.workspace,
@@ -194,7 +193,7 @@ class ExecTool(Tool):
             allowed_env_keys=cfg.allowed_env_keys,
             allow_patterns=cfg.allow_patterns,
             deny_patterns=cfg.deny_patterns,
-            session_manager=ctx.exec_session_manager,
+            session_manager=getattr(ctx, "exec_session_manager", None),
         )
 
     def __init__(
@@ -212,7 +211,7 @@ class ExecTool(Tool):
         sandbox_ro_binds: list[str] | None = None,
         sandbox_rw_binds: list[str] | None = None,
         allowed_env_keys: list[str] | None = None,
-        session_manager: ExecSessionManager | None = None,
+        session_manager: Any | None = None,
     ):
         self.timeout = timeout
         self.working_dir = working_dir
@@ -345,7 +344,7 @@ class ExecTool(Tool):
             # misses it, leaving a zombie.
             _reap_pid(process.pid)
 
-            output_parts: list[str] = []
+            output_parts = []
 
             if stdout:
                 output_parts.append(stdout.decode("utf-8", errors="replace"))
@@ -505,7 +504,7 @@ class ExecTool(Tool):
         )
 
     def _compose_path(self, current_path: str) -> str:
-        parts: list[str] = []
+        parts = []
         if self.path_prepend:
             parts.append(self.path_prepend)
         if current_path:
@@ -515,7 +514,7 @@ class ExecTool(Tool):
         return os.pathsep.join(parts)
 
     def _wrap_path_export(self, command: str, env: dict[str, str]) -> str:
-        segments: list[str] = []
+        segments = []
         if self.path_prepend:
             env["NANOBOT_PATH_PREPEND"] = self.path_prepend
             segments.append("$NANOBOT_PATH_PREPEND")
@@ -556,7 +555,6 @@ class ExecTool(Tool):
             command = ExecTool._normalize_powershell_command(command)
             command = (
                 "[Console]::OutputEncoding = [System.Text.UTF8Encoding]::new($false)\n"
-                "if ($PSVersionTable.PSVersion.Major -lt 6) { $OutputEncoding = [Console]::OutputEncoding }\n"
                 "$PSDefaultParameterValues['Out-File:Encoding'] = 'utf8'\n"
                 f"{command}\n"
                 "if ($LASTEXITCODE -ne $null) { exit $LASTEXITCODE }"
@@ -570,21 +568,11 @@ class ExecTool(Tool):
                 env=env,
             )
         shell_program = shell_program or shutil.which("bash") or "/bin/bash"
-        args: list[str] = [shell_program]
+        args = [shell_program]
         shell_name = Path(shell_program).name.lower()
         if login and shell_name in {"bash", "bash.exe", "zsh", "zsh.exe"}:
             args.append("-l")
         args.extend(["-c", command])
-        if process_tree:
-            return await asyncio.create_subprocess_exec(
-                *args,
-                stdin=stdin,
-                stdout=asyncio.subprocess.PIPE,
-                stderr=asyncio.subprocess.PIPE,
-                cwd=cwd,
-                env=env,
-                start_new_session=True,
-            )
         return await asyncio.create_subprocess_exec(
             *args,
             stdin=stdin,
@@ -592,6 +580,7 @@ class ExecTool(Tool):
             stderr=asyncio.subprocess.PIPE,
             cwd=cwd,
             env=env,
+            **({"start_new_session": True} if process_tree else {}),
         )
 
     @staticmethod

nanobot/agent/tools/spawn.py

@@ -1,7 +1,5 @@
 """Spawn tool for creating background subagents."""
 
-# pyright: reportIncompatibleMethodOverride=false
-
 from __future__ import annotations
 
 from typing import TYPE_CHECKING, Any
@@ -18,7 +16,6 @@ from nanobot.security.workspace_access import current_workspace_scope
 
 if TYPE_CHECKING:
     from nanobot.agent.subagent import SubagentManager
-    from nanobot.agent.tools.context import ToolContext
 
 
 @tool_parameters(
@@ -52,11 +49,8 @@ class SpawnTool(Tool):
         self._manager = manager
 
     @classmethod
-    def create(cls, ctx: ToolContext) -> Tool:
-        manager = ctx.subagent_manager
-        if manager is None:
-            raise RuntimeError("SpawnTool requires an initialized subagent manager")
-        return cls(manager=manager)
+    def create(cls, ctx: Any) -> Tool:
+        return cls(manager=ctx.subagent_manager)
 
     @property
     def name(self) -> str:

nanobot/agent/tools/web.py

@@ -1,7 +1,5 @@
 """Web tools: web_search and web_fetch."""
 
-# pyright: reportIncompatibleMethodOverride=false
-
 from __future__ import annotations
 
 import asyncio
@@ -9,8 +7,7 @@ import html
 import json
 import os
 import re
-from collections.abc import Callable
-from typing import Any, cast
+from typing import Any, Callable
 from urllib.parse import quote, urljoin, urlparse
 
 import httpx
@@ -18,7 +15,6 @@ from loguru import logger
 from pydantic import Field
 
 from nanobot.agent.tools.base import Tool, ToolResult, tool_parameters
-from nanobot.agent.tools.context import ToolContext
 from nanobot.agent.tools.schema import (
     BooleanSchema,
     IntegerSchema,
@@ -295,8 +291,8 @@ class WebSearchTool(Tool):
     """Search the web using configured provider."""
     _scopes = {"core", "subagent"}
 
-    name = "web_search"  # pyright: ignore[reportIncompatibleMethodOverride, reportAssignmentType]
-    description = (  # pyright: ignore[reportIncompatibleMethodOverride, reportAssignmentType]
+    name = "web_search"
+    description = (
         "Search the web. Returns titles, URLs, and snippets. "
         "count defaults to 5 (max 10). "
         "Some providers support timeRange, authLevel, and queryRewrite. "
@@ -306,21 +302,20 @@ class WebSearchTool(Tool):
     config_key = "web"
 
     @classmethod
-    def config_cls(cls) -> type[WebToolsConfig]:
+    def config_cls(cls):
         return WebToolsConfig
 
     @classmethod
-    def enabled(cls, ctx: ToolContext) -> bool:
+    def enabled(cls, ctx: Any) -> bool:
         return ctx.config.web.enable
 
     @classmethod
-    def create(cls, ctx: ToolContext) -> Tool:
-        config_loader: Callable[[], WebSearchConfig] | None = None
+    def create(cls, ctx: Any) -> Tool:
+        config_loader = None
         if ctx.provider_snapshot_loader is not None:
-            def _load_search_config() -> WebSearchConfig:
+            def config_loader():
                 from nanobot.config.loader import load_config, resolve_config_env_vars
                 return resolve_config_env_vars(load_config()).tools.web.search
-            config_loader = _load_search_config
         return cls(
             config=ctx.config.web.search,
             proxy=ctx.config.web.proxy,
@@ -409,7 +404,7 @@ class WebSearchTool(Tool):
         auth_level: int | None = None,
         query_rewrite: bool | None = None,
         **kwargs: Any,
-    ) -> str:  # pyright: ignore[reportIncompatibleMethodOverride]
+    ) -> str:
         self._refresh_config()
         provider = self.config.provider.strip().lower() or "brave"
         n = min(max(count or self.config.max_results, 1), 10)
@@ -453,20 +448,15 @@ class WebSearchTool(Tool):
 
     async def _search_olostep(self, query: str, n: int) -> str:
         try:
-            from olostep import (  # pyright: ignore[reportMissingImports]
-                AsyncOlostep,  # pyright: ignore[reportUnknownVariableType]
-                Olostep_BaseError,  # pyright: ignore[reportUnknownVariableType]
-            )
+            from olostep import AsyncOlostep, Olostep_BaseError
         except ImportError:
             return ToolResult.error("Error: olostep package not installed. Run: pip install olostep")
-        async_olostep = cast(Any, AsyncOlostep)
-        olostep_base_error = cast(type[Exception], Olostep_BaseError)
         api_key = self.config.api_key or os.environ.get("OLOSTEP_API_KEY", "")
         if not api_key:
             logger.warning("OLOSTEP_API_KEY not set, falling back to DuckDuckGo")
             return await self._search_duckduckgo(query, n)
         try:
-            async with async_olostep(api_key=api_key) as client:
+            async with AsyncOlostep(api_key=api_key) as client:
                 if self.proxy:
                     transport = getattr(client, "_transport", None)
                     http_client = getattr(transport, "_client", None)
@@ -482,16 +472,14 @@ class WebSearchTool(Tool):
                             ),
                             http2=True,
                         )
-                result: Any = await client.answers.create(task=query)
+                result = await client.answers.create(task=query)
 
-            sources = cast(list[Any], getattr(result, "sources", None) or [])
-            source_lines: list[str] = []
-            for i, source_value in enumerate(sources[:n], 1):
-                source: Any = source_value
+            sources = getattr(result, "sources", None) or []
+            source_lines = []
+            for i, source in enumerate(sources[:n], 1):
                 if isinstance(source, dict):
-                    source_dict = cast(dict[str, Any], source)
-                    title = source_dict.get("title", "")
-                    url = source_dict.get("url", "")
+                    title = source.get("title", "")
+                    url = source.get("url", "")
                 else:
                     title = getattr(source, "title", "")
                     url = getattr(source, "url", "")
@@ -505,7 +493,7 @@ class WebSearchTool(Tool):
             answer_text = getattr(result, "answer", "") or ""
             items = [{"title": answer_text or "Olostep answer", "url": "", "content": "\n".join(source_lines)}]
             return _format_results(query, items, n)
-        except olostep_base_error as e:
+        except Olostep_BaseError as e:
             return ToolResult.error(f"Error: Olostep search error: {type(e).__name__}: {e}")
         except Exception as e:
             return ToolResult.error(f"Error: Olostep search error: {type(e).__name__}: {e}")
@@ -522,7 +510,6 @@ class WebSearchTool(Tool):
                 "User-Agent": self.user_agent,
             }
             async with httpx.AsyncClient(proxy=self.proxy) as client:
-                r: httpx.Response | None = None
                 for attempt in range(2):
                     r = await client.get(
                         "https://api.search.brave.com/res/v1/web/search",
@@ -535,7 +522,6 @@ class WebSearchTool(Tool):
                     if attempt == 0:
                         logger.warning("Brave search rate limited; retrying once in 1.0s")
                         await asyncio.sleep(1.0)
-                assert r is not None
                 r.raise_for_status()
             items = [
                 {"title": x.get("title", ""), "url": x.get("url", ""), "content": x.get("description", "")}
@@ -705,19 +691,13 @@ class WebSearchTool(Tool):
                     timeout=float(self.config.timeout),
                 )
                 r.raise_for_status()
-            data = cast(dict[str, Any], r.json())
-            items: list[dict[str, Any]] = []
-            for result_value in cast(list[object], data.get("results", [])):
-                if not isinstance(result_value, dict):
+            items = []
+            for result in r.json().get("results", []):
+                if not isinstance(result, dict):
                     continue
-                result = cast(dict[str, Any], result_value)
-                highlights: Any = result.get("highlights") or []
+                highlights = result.get("highlights") or []
                 if isinstance(highlights, list):
-                    content = "\n".join(
-                        str(highlight)
-                        for highlight in cast(list[object], highlights)
-                        if highlight
-                    )
+                    content = "\n".join(str(highlight) for highlight in highlights if highlight)
                 else:
                     content = str(highlights)
                 if not content:
@@ -757,17 +737,14 @@ class WebSearchTool(Tool):
                     timeout=float(self.config.timeout),
                 )
                 r.raise_for_status()
-            data = cast(dict[str, Any], r.json())
-            organic = cast(list[object], data.get("organic", []))
-            items: list[dict[str, Any]] = [
+            items = [
                 {
                     "title": result.get("title", ""),
                     "url": result.get("link", ""),
                     "content": result.get("snippet", ""),
                 }
-                for result_value in organic
-                if isinstance(result_value, dict)
-                for result in (cast(dict[str, Any], result_value),)
+                for result in r.json().get("organic", [])
+                if isinstance(result, dict)
             ]
             return _format_results(query, items, n)
         except httpx.HTTPStatusError as e:
@@ -829,7 +806,7 @@ class WebSearchTool(Tool):
                     timeout=float(self.config.timeout),
                 )
                 r.raise_for_status()
-            data = cast(dict[str, Any], r.json())
+            data = r.json()
         except httpx.HTTPStatusError as e:
             if e.response.status_code == 429:
                 return ToolResult.error("Error: Volcengine search rate limited. Try again later or reduce search frequency.")
@@ -837,36 +814,20 @@ class WebSearchTool(Tool):
         except Exception as e:
             return ToolResult.error(f"Error: Volcengine search failed: {e}")
 
-        response_metadata = cast(
-            dict[str, Any],
-            data.get("ResponseMetadata") or {},
-        )
-        error = (
-            response_metadata.get("Error")
-            or data.get("Error")
-            or data.get("error")
-        )
+        error = (data.get("ResponseMetadata") or {}).get("Error") or data.get("Error") or data.get("error")
         if error:
             if isinstance(error, dict):
-                error = cast(dict[str, Any], error)
                 code = error.get("Code") or error.get("code") or "unknown"
                 message = error.get("Message") or error.get("message") or error
                 return ToolResult.error(f"Error: Volcengine search error {code}: {message}")
             return ToolResult.error(f"Error: Volcengine search error: {error}")
 
-        result = cast(dict[str, Any], data.get("Result") or data)
-        web_results = cast(
-            list[object],
-            result.get("WebResults")
-            or result.get("webResults")
-            or result.get("results")
-            or [],
-        )
+        result = data.get("Result") or data
+        web_results = result.get("WebResults") or result.get("webResults") or result.get("results") or []
         items: list[dict[str, Any]] = []
-        for item_value in web_results:
-            if not isinstance(item_value, dict):
+        for item in web_results:
+            if not isinstance(item, dict):
                 continue
-            item = cast(dict[str, Any], item_value)
             meta_parts = [
                 str(part)
                 for part in (
@@ -876,7 +837,7 @@ class WebSearchTool(Tool):
                 )
                 if part
             ]
-            summary = cast(str, (
+            summary = (
                 item.get("Summary")
                 or item.get("summary")
                 or item.get("Snippet")
@@ -884,7 +845,7 @@ class WebSearchTool(Tool):
                 or item.get("Content")
                 or item.get("content")
                 or ""
-            ))
+            )
             content = "\n".join(part for part in (" | ".join(meta_parts), summary) if part)
             items.append(
                 {
@@ -900,20 +861,18 @@ class WebSearchTool(Tool):
         try:
             # Note: duckduckgo_search is synchronous and does its own requests
             # We run it in a thread to avoid blocking the loop
-            from ddgs import DDGS  # pyright: ignore[reportUnknownVariableType]
+            from ddgs import DDGS
 
-            ddgs_type = cast(Any, DDGS)
-            ddgs = ddgs_type(timeout=10, proxy=self.proxy)
+            ddgs = DDGS(timeout=10, proxy=self.proxy)
             raw = await asyncio.wait_for(
                 asyncio.to_thread(ddgs.text, query, max_results=n),
                 timeout=self.config.timeout,
             )
             if not raw:
                 return f"No results for: {query}"
-            raw_items = cast(list[dict[str, Any]], raw)
-            items: list[dict[str, Any]] = [
+            items = [
                 {"title": r.get("title", ""), "url": r.get("href", ""), "content": r.get("body", "")}
-                for r in raw_items
+                for r in raw
             ]
             return _format_results(query, items, n)
         except Exception as e:
@@ -948,19 +907,15 @@ class WebSearchTool(Tool):
                 if r.status_code == 429:
                     return ToolResult.error("Error: Bocha search rate-limited (HTTP 429). Wait and retry.")
                 r.raise_for_status()
-            data = cast(dict[str, Any], r.json())
-            wrapped_data = data.get("data")
-            result_data = (
-                cast(dict[str, Any], wrapped_data)
-                if isinstance(wrapped_data, dict)
-                else data
+            data = r.json()
+            wrapped_data = data.get("data") if isinstance(data, dict) else None
+            result_data = wrapped_data if isinstance(wrapped_data, dict) else data
+            web_pages = (
+                result_data.get("webPages", {}).get("value", [])
+                if isinstance(result_data, dict)
+                else []
             )
-            web_pages_data = cast(
-                dict[str, Any],
-                result_data.get("webPages", {}),
-            )
-            web_pages = cast(list[dict[str, Any]], web_pages_data.get("value", []))
-            items: list[dict[str, Any]] = [
+            items = [
                 {
                     "title": x.get("name", ""),
                     "url": x.get("url", ""),
@@ -991,8 +946,8 @@ class WebFetchTool(Tool):
     """Fetch and extract content from a URL."""
     _scopes = {"core", "subagent"}
 
-    name = "web_fetch"  # pyright: ignore[reportIncompatibleMethodOverride, reportAssignmentType]
-    description = (  # pyright: ignore[reportIncompatibleMethodOverride, reportAssignmentType]
+    name = "web_fetch"
+    description = (
         "Fetch a URL and extract readable content (HTML → markdown/text). "
         "Output is capped at maxChars (default 50 000). "
         "Works for most web pages and docs; may fail on login-walled or JS-heavy sites."
@@ -1001,15 +956,15 @@ class WebFetchTool(Tool):
     config_key = "web"
 
     @classmethod
-    def config_cls(cls) -> type[WebToolsConfig]:
+    def config_cls(cls):
         return WebToolsConfig
 
     @classmethod
-    def enabled(cls, ctx: ToolContext) -> bool:
+    def enabled(cls, ctx: Any) -> bool:
         return ctx.config.web.enable
 
     @classmethod
-    def create(cls, ctx: ToolContext) -> Tool:
+    def create(cls, ctx: Any) -> Tool:
         return cls(
             config=ctx.config.web.fetch,
             proxy=ctx.config.web.proxy,
@@ -1032,10 +987,10 @@ class WebFetchTool(Tool):
         extract_mode: str = "markdown",
         max_chars: int | None = None,
         **kwargs: Any,
-    ) -> Any:  # pyright: ignore[reportIncompatibleMethodOverride]
+    ) -> Any:
         url = url.strip(" \t\r\n`\"'")
         extract_mode = kwargs.pop("extractMode", extract_mode)
-        max_chars = cast(int, kwargs.pop("maxChars", max_chars) or self.max_chars)
+        max_chars = kwargs.pop("maxChars", max_chars) or self.max_chars
         is_valid, error_msg = _validate_url_safe(url)
         if not is_valid:
             return json.dumps({"error": f"URL validation failed: {error_msg}", "url": url}, ensure_ascii=False)
@@ -1164,10 +1119,10 @@ class WebFetchTool(Tool):
             return json.dumps({"error": str(e), "url": url}, ensure_ascii=False)
 
     def _extract_readable_html(self, html_content: str, extract_mode: str) -> str:
-        from readability import Document  # pyright: ignore[reportMissingTypeStubs]
+        from readability import Document
 
         doc = Document(html_content)
-        summary = cast(str, doc.summary())
+        summary = doc.summary()
         content = self._to_markdown(summary) if extract_mode == "markdown" else _strip_tags(summary)
         return f"# {doc.title()}\n\n{content}" if doc.title() else content
 

nanobot/agent/turn_delivery.py

@@ -6,7 +6,7 @@ import dataclasses
 import time
 from collections.abc import Awaitable, Callable
 from dataclasses import dataclass, field
-from typing import TYPE_CHECKING, Any, cast
+from typing import Any
 
 from nanobot.bus.events import InboundMessage, OutboundMessage
 from nanobot.bus.outbound_events import (
@@ -20,9 +20,6 @@ from nanobot.bus.progress import build_bus_progress_callback
 from nanobot.bus.queue import MessageBus
 from nanobot.bus.runtime_events import RuntimeEventBus, RuntimeEventPublisher
 
-if TYPE_CHECKING:
-    from nanobot.utils.llm_runtime import LLMRuntime
-
 
 @dataclass(frozen=True)
 class TurnRoute:
@@ -65,7 +62,7 @@ class TurnDeliveryFactory:
         route = self._default_route(msg, session_key)
         if self.route_policy is not None:
             route = self.route_policy(msg, session_key, route)
-            if not isinstance(cast(object, route), TurnRoute):
+            if not isinstance(route, TurnRoute):
                 raise TypeError("turn route policy must return TurnRoute")
         return TurnDelivery(
             bus=self.bus,
@@ -189,7 +186,7 @@ class TurnDelivery:
                 started_at=started_at,
             )
 
-    def record_runtime(self, runtime: LLMRuntime) -> None:
+    def record_runtime(self, runtime: Any) -> None:
         self.runtime_event_publisher.record_turn_runtime(self.session_key, runtime)
 
     def record_latency(self, latency_ms: int | None) -> None:

nanobot/api/runtime.py

@@ -35,7 +35,7 @@ def api_runtime_paths(config_path: Path) -> ProcessRuntimePaths:
     )
 
 
-class ApiRuntime(ManagedProcessRuntime[ApiStartOptions]):
+class ApiRuntime(ManagedProcessRuntime):
     """Manage a WebUI-controlled OpenAI-compatible API process."""
 
     service_name = "api"

nanobot/api/server.py

@@ -12,7 +12,7 @@ import hmac
 import json as _json
 import time
 import uuid
-from typing import TYPE_CHECKING, Any, Awaitable, Callable, cast
+from typing import Any
 
 from aiohttp import web
 from loguru import logger
@@ -30,9 +30,6 @@ from nanobot.utils.media_decode import (
 )
 from nanobot.utils.runtime import EMPTY_FINAL_RESPONSE_MESSAGE
 
-if TYPE_CHECKING:
-    from nanobot.agent.loop import AgentLoop
-
 __all__ = (
     "MAX_FILE_SIZE",
     "_FileSizeExceeded",
@@ -47,7 +44,7 @@ API_CHAT_ID = "default"
 _AGENT_LOOP_KEY = web.AppKey[Any]("agent_loop")
 _MODEL_NAME_KEY = web.AppKey[str]("model_name")
 _REQUEST_TIMEOUT_KEY = web.AppKey[float]("request_timeout")
-_SESSION_LOCKS_KEY = web.AppKey[dict[str, asyncio.Lock]]("session_locks")
+_SESSION_LOCKS_KEY = web.AppKey[dict]("session_locks")
 _MISSING = object()
 
 
@@ -114,26 +111,6 @@ def _response_text(value: Any) -> str:
         return str(getattr(value, "content") or "")
     return str(value)
 
-
-def _as_str(value: object) -> str:
-    """Return *value* when it is text, otherwise an empty string."""
-    return value if isinstance(value, str) else ""
-
-
-def _require_json_object(value: object, field: str) -> dict[str, Any]:
-    """Validate an object-valued field from an untrusted JSON request."""
-    if not isinstance(value, dict):
-        raise TypeError(f"{field} must be an object")
-    return cast(dict[str, Any], value)
-
-
-def _require_json_string(value: object, field: str) -> str:
-    """Validate a string-valued field from an untrusted JSON request."""
-    if not isinstance(value, str):
-        raise TypeError(f"{field} must be a string")
-    return value
-
-
 # ---------------------------------------------------------------------------
 # SSE helpers
 # ---------------------------------------------------------------------------
@@ -164,19 +141,13 @@ _SSE_DONE = b"data: [DONE]\n\n"
 # ---------------------------------------------------------------------------
 
 
-def _parse_json_content(body: dict[str, Any]) -> tuple[str, list[str]]:
+def _parse_json_content(body: dict) -> tuple[str, list[str]]:
     """Parse JSON request body. Returns (text, media_paths)."""
-    messages_value = cast(object, body.get("messages"))
-    if not isinstance(messages_value, list):
+    messages = body.get("messages")
+    if not isinstance(messages, list) or len(messages) != 1:
         raise ValueError("Only a single user message is supported")
-    messages = cast(list[object], messages_value)
-    if len(messages) != 1:
-        raise ValueError("Only a single user message is supported")
-    message_value: object = messages[0]
-    if not isinstance(message_value, dict):
-        raise ValueError("Only a single user message is supported")
-    message = cast(dict[str, Any], message_value)
-    if message.get("role") != "user":
+    message = messages[0]
+    if not isinstance(message, dict) or message.get("role") != "user":
         raise ValueError("Only a single user message is supported")
 
     user_content = message.get("content", "")
@@ -185,26 +156,13 @@ def _parse_json_content(body: dict[str, Any]) -> tuple[str, list[str]]:
 
     if isinstance(user_content, list):
         text_parts: list[str] = []
-        for part_value in cast(list[object], user_content):
-            if not isinstance(part_value, dict):
+        for part in user_content:
+            if not isinstance(part, dict):
                 continue
-            part = cast(dict[str, Any], part_value)
             if part.get("type") == "text":
-                text_parts.append(
-                    _require_json_string(
-                        cast(object, part.get("text", "")),
-                        "messages[0].content[].text",
-                    )
-                )
+                text_parts.append(part.get("text", ""))
             elif part.get("type") == "image_url":
-                image_url = _require_json_object(
-                    cast(object, part.get("image_url", {})),
-                    "messages[0].content[].image_url",
-                )
-                url = _require_json_string(
-                    cast(object, image_url.get("url", "")),
-                    "messages[0].content[].image_url.url",
-                )
+                url = part.get("image_url", {}).get("url", "")
                 if url.startswith("data:"):
                     saved = _save_base64_data_url(url, media_dir)
                     if saved:
@@ -233,7 +191,7 @@ async def _parse_multipart(request: web.Request) -> tuple[str, list[str], str |
     media_paths: list[str] = []
 
     while True:
-        part: Any = await reader.next()
+        part = await reader.next()
         if part is None:
             break
         if part.name == "message":
@@ -265,9 +223,11 @@ async def _parse_multipart(request: web.Request) -> tuple[str, list[str], str |
 # ---------------------------------------------------------------------------
 
 
-async def handle_chat_completions(request: web.Request) -> web.Response | web.StreamResponse:
+async def handle_chat_completions(request: web.Request) -> web.Response:
     """POST /v1/chat/completions — supports JSON and multipart/form-data."""
-    content_type = _as_str(cast(object, request.content_type or ""))
+    content_type = request.content_type or ""
+    if not isinstance(content_type, str):
+        content_type = ""
 
     agent_loop = _app_value(request.app, _AGENT_LOOP_KEY, "agent_loop")
     timeout_s: float = _app_value(
@@ -287,9 +247,6 @@ async def handle_chat_completions(request: web.Request) -> web.Response | web.St
                 body = await request.json()
             except Exception:
                 return _error_json(400, "Invalid JSON body")
-            if not isinstance(body, dict):
-                return _error_json(400, "Invalid JSON body")
-            body = cast(dict[str, Any], body)
             stream = body.get("stream", False)
             requested_model = body.get("model")
             text, media_paths = _parse_json_content(body)
@@ -448,7 +405,7 @@ async def handle_health(request: web.Request) -> web.Response:
 
 
 def create_app(
-    agent_loop: "AgentLoop",
+    agent_loop,
     model_name: str = "nanobot",
     request_timeout: float = 120.0,
     api_key: str = "",
@@ -468,10 +425,7 @@ def create_app(
     app[_SESSION_LOCKS_KEY] = {}  # per-user locks, keyed by session_key
 
     @web.middleware
-    async def auth_middleware(
-        request: web.Request,
-        handler: Callable[[web.Request], Awaitable[web.StreamResponse]],
-    ) -> web.StreamResponse:
+    async def auth_middleware(request: web.Request, handler) -> web.StreamResponse:
         # Allow unauthenticated health checks.
         if request.path == "/health":
             return await handler(request)

nanobot/apps/cli/service.py

@@ -10,11 +10,10 @@ import shutil
 import subprocess
 import sys
 import time
-from collections.abc import Iterable
 from dataclasses import dataclass
 from importlib import metadata as importlib_metadata
 from pathlib import Path
-from typing import Any, cast
+from typing import Any
 from urllib.parse import urlparse
 
 import httpx
@@ -205,11 +204,6 @@ def _now() -> float:
     return time.time()
 
 
-def _as_object_dict(value: object) -> dict[str, Any] | None:
-    """Narrow a JSON-like object to the string-keyed mapping used by this module."""
-    return cast(dict[str, Any], value) if isinstance(value, dict) else None
-
-
 def _safe_skill_name(name: str) -> str:
     clean = _SAFE_NAME_RE.sub("-", name.lower()).strip("-")
     return f"cli-app-{clean or 'app'}"
@@ -283,11 +277,10 @@ def _console_script_distribution(entry_point: str) -> str | None:
             if item.group != "console_scripts" or item.name != entry_point:
                 continue
             try:
-                name: object = cast(Any, distribution.metadata).get("Name")
+                name = distribution.metadata.get("Name")
             except Exception:
                 name = None
-            fallback_name = cast(object, getattr(distribution, "name", ""))
-            return str(name or fallback_name or "").strip() or None
+            return str(name or getattr(distribution, "name", "") or "").strip() or None
     return None
 
 
@@ -342,10 +335,10 @@ def _brand_payload(app: dict[str, Any]) -> tuple[str | None, str | None]:
 
 def _read_json(path: Path) -> dict[str, Any] | None:
     try:
-        data: object = json.loads(path.read_text(encoding="utf-8"))
+        data = json.loads(path.read_text(encoding="utf-8"))
     except (OSError, json.JSONDecodeError):
         return None
-    return _as_object_dict(data)
+    return data if isinstance(data, dict) else None
 
 
 def _write_json(path: Path, data: dict[str, Any]) -> None:
@@ -421,8 +414,8 @@ class CliAppManager:
         cached = _read_json(cache_path)
         if not cached:
             return None, 0.0
-        data = _as_object_dict(cached.get("data"))
-        if data is None:
+        data = cached.get("data")
+        if not isinstance(data, dict):
             return None, 0.0
         try:
             cached_at = float(cached.get("_cached_at", 0))
@@ -432,8 +425,8 @@ class CliAppManager:
 
     def _load_installed(self) -> dict[str, Any]:
         data = _read_json(self.installed_path) or {}
-        apps = _as_object_dict(data.get("apps"))
-        return apps if apps is not None else data
+        apps = data.get("apps") if isinstance(data.get("apps"), dict) else data
+        return apps if isinstance(apps, dict) else {}
 
     def _save_installed(self, installed: dict[str, Any]) -> None:
         _write_json(self.installed_path, {"schema_version": 1, "apps": installed})
@@ -460,8 +453,8 @@ class CliAppManager:
         try:
             response = httpx.get(url, timeout=15.0, follow_redirects=True)
             response.raise_for_status()
-            fetched = _as_object_dict(response.json())
-            if fetched is None:
+            fetched = response.json()
+            if not isinstance(fetched, dict):
                 raise ValueError("registry response must be an object")
         except Exception:
             if data is not None:
@@ -490,8 +483,8 @@ class CliAppManager:
             async with httpx.AsyncClient(timeout=15.0, follow_redirects=True) as client:
                 response = await client.get(url)
             response.raise_for_status()
-            fetched = _as_object_dict(response.json())
-            if fetched is None:
+            fetched = response.json()
+            if not isinstance(fetched, dict):
                 raise ValueError("registry response must be an object")
         except Exception:
             if data is not None:
@@ -541,14 +534,13 @@ class CliAppManager:
         apps_by_name: dict[str, dict[str, Any]] = {}
         updated_values: list[str] = []
         for source, raw_base, registry in registries:
-            meta = _as_object_dict(registry.get("meta"))
-            if meta is not None and isinstance(meta.get("updated"), str):
+            meta = registry.get("meta")
+            if isinstance(meta, dict) and isinstance(meta.get("updated"), str):
                 updated_values.append(meta["updated"])
-            for row in cast(Iterable[object], registry.get("clis", [])):
-                entry = _as_object_dict(row)
-                if entry is None or not entry.get("name"):
+            for row in registry.get("clis", []):
+                if not isinstance(row, dict) or not row.get("name"):
                     continue
-                entry = dict(entry)
+                entry = dict(row)
                 entry["_source"] = source
                 entry["_raw_base"] = raw_base
                 key = str(entry["name"]).lower()
@@ -596,7 +588,7 @@ class CliAppManager:
         if not installed:
             return []
         installed_by_name = {
-            str(name).lower(): (str(name), _as_object_dict(data) or {})
+            str(name).lower(): (str(name), data if isinstance(data, dict) else {})
             for name, data in installed.items()
         }
         seen: set[str] = set()
@@ -777,14 +769,12 @@ class CliAppManager:
             for app in cached_apps
             if app.get("name")
         }
-        rows: list[dict[str, Any]] = []
+        rows = []
         for name, raw_entry in sorted(installed.items()):
-            entry = _as_object_dict(raw_entry)
-            if entry is None:
-                entry = {}
+            entry = raw_entry if isinstance(raw_entry, dict) else {}
             strategy = str(entry.get("strategy") or "bundled")
             cached_app = cached_by_name.get(str(name).lower(), {})
-            app: dict[str, Any] = {
+            app = {
                 "name": str(name),
                 "display_name": str(
                     cached_app.get("display_name") or entry.get("display_name") or name
@@ -1175,9 +1165,7 @@ Use the `run_cli_app` tool with `name="{name}"` for command execution. Do not in
         if str(app["name"]) not in installed:
             raise CliAppError("CLI app is not installed")
         raw_installed_entry = installed.get(str(app["name"]))
-        installed_entry = _as_object_dict(raw_installed_entry)
-        if installed_entry is None:
-            installed_entry = {}
+        installed_entry = raw_installed_entry if isinstance(raw_installed_entry, dict) else {}
         strategy = self._strategy(app)
         entry_point = str(app.get("entry_point") or "").strip()
         managed_entry_path = str(installed_entry.get("entry_point_path") or "").strip()

nanobot/apps/cli/utils.py

@@ -3,7 +3,7 @@
 from __future__ import annotations
 
 from pathlib import Path
-from typing import Any, Mapping, cast
+from typing import Any, Mapping
 
 
 def session_extra(metadata: Mapping[str, Any] | None) -> dict[str, Any]:
@@ -29,11 +29,9 @@ def runtime_lines_for_request(
     """Return CLI App annotations from an immutable request snapshot."""
     structured = metadata.get("cli_apps") if isinstance(metadata, Mapping) else None
     if isinstance(structured, list):
-        structured_items = cast(list[Any], structured)
         mentions = [
-            cast(Mapping[str, Any], item) for item in structured_items
-            if isinstance(item, Mapping)
-            and isinstance(cast(Mapping[str, Any], item).get("name"), str)
+            item for item in structured
+            if isinstance(item, Mapping) and isinstance(item.get("name"), str)
         ]
         if mentions:
             return [
@@ -51,10 +49,7 @@ def runtime_lines_for_request(
     try:
         from nanobot.apps.cli import CliAppManager
 
-        mentions = cast(
-            list[dict[str, Any]],
-            CliAppManager(workspace=workspace).mentioned_installed_apps(text),
-        )
+        mentions = CliAppManager(workspace=workspace).mentioned_installed_apps(text)
     except Exception:
         return []
     return [

nanobot/audio/transcription.py

@@ -22,7 +22,6 @@ from nanobot.audio.transcription_registry import (
 )
 from nanobot.config.loader import resolve_env_refs
 from nanobot.config.paths import get_media_dir
-from nanobot.config.schema import Config, ProviderConfig
 from nanobot.providers.registry import find_by_name
 from nanobot.utils.media_decode import FileSizeExceeded, save_base64_data_url
 
@@ -74,9 +73,8 @@ def _as_provider(value: Any) -> TranscriptionProviderName | None:
     return spec.name if spec else None
 
 
-def _provider_config(config: Config, provider: str) -> ProviderConfig | None:
-    value = getattr(config.providers, provider, None)
-    return value if isinstance(value, ProviderConfig) else None
+def _provider_config(config: Any, provider: str) -> Any:
+    return getattr(getattr(config, "providers", None), provider, None)
 
 
 def _provider_default_api_base(provider: str) -> str | None:
@@ -84,10 +82,7 @@ def _provider_default_api_base(provider: str) -> str | None:
     return spec.default_api_base if spec else None
 
 
-def _resolve_transcription_api_key(
-    provider: str,
-    provider_cfg: ProviderConfig | None,
-) -> str:
+def _resolve_transcription_api_key(provider: str, provider_cfg: Any) -> str:
     api_key = resolve_env_refs(getattr(provider_cfg, "api_key", None) or "") if provider_cfg else ""
     if api_key:
         return api_key
@@ -99,13 +94,10 @@ def _resolve_transcription_api_key(
             return env_key
 
     env_key = spec.env_key if spec else ""
-    return os.environ.get(env_key, "") if env_key else ""
+    return os.environ.get(env_key) if env_key else ""
 
 
-def _resolve_transcription_api_base(
-    provider: str,
-    provider_cfg: ProviderConfig | None,
-) -> str:
+def _resolve_transcription_api_base(provider: str, provider_cfg: Any) -> str:
     api_base = resolve_env_refs(getattr(provider_cfg, "api_base", None) or "") if provider_cfg else ""
     if api_base:
         return api_base
@@ -119,7 +111,7 @@ def _extract_data_url_mime(url: str) -> str | None:
     return header[5:].split(";", 1)[0].strip().lower() or None
 
 
-def resolve_transcription_config(config: Config) -> EffectiveTranscriptionConfig:
+def resolve_transcription_config(config: Any) -> EffectiveTranscriptionConfig:
     """Resolve top-level transcription settings with legacy channel fallback."""
     top = getattr(config, "transcription", None)
     channels = getattr(config, "channels", None)

nanobot/bus/events.py

@@ -18,7 +18,6 @@ INBOUND_META_RUNTIME_CONTROL = "_runtime_control"
 RUNTIME_CONTROL_ACK = "_ack"
 RUNTIME_CONTROL_MCP_RELOAD = "mcp_reload"
 RUNTIME_CONTROL_IMAGE_GENERATION_RELOAD = "image_generation_reload"
-INBOUND_META_TRANSIENT_SESSION = "_transient_session"
 
 
 @dataclass
@@ -33,7 +32,6 @@ class InboundMessage:
     media: list[str] = field(default_factory=list)  # Media URLs
     metadata: dict[str, Any] = field(default_factory=dict)  # Channel-specific data
     session_key_override: str | None = None  # Optional override for thread-scoped sessions
-    transient_session: bool = False  # In-memory session whose lifetime is owned by the channel
 
     @property
     def session_key(self) -> str:

nanobot/bus/outbound_events.py

@@ -9,7 +9,7 @@ from __future__ import annotations
 
 from collections.abc import Mapping
 from dataclasses import dataclass, replace
-from typing import Any, cast
+from typing import Any
 
 from nanobot.bus.events import OutboundMessage
 
@@ -153,11 +153,7 @@ def _legacy_event_from_metadata(msg: OutboundMessage) -> OutboundEvent | None:
         )
     if meta.get("_goal_state_sync"):
         goal_state = meta.get("goal_state")
-        return GoalStateSyncEvent(
-            cast(dict[str, Any], goal_state)
-            if isinstance(goal_state, dict)
-            else {"active": False}
-        )
+        return GoalStateSyncEvent(goal_state if isinstance(goal_state, dict) else {"active": False})
     if meta.get("_goal_status"):
         status = meta.get("goal_status")
         if not isinstance(status, str) or not status:
@@ -170,7 +166,7 @@ def _legacy_event_from_metadata(msg: OutboundMessage) -> OutboundEvent | None:
         goal_state = meta.get("goal_state")
         return TurnEndEvent(
             latency_ms=_metadata_int(meta, "latency_ms"),
-            goal_state=cast(dict[str, Any], goal_state) if isinstance(goal_state, dict) else None,
+            goal_state=goal_state if isinstance(goal_state, dict) else None,
         )
     if meta.get("_session_updated"):
         return SessionUpdatedEvent(scope=_metadata_str(meta, "_session_update_scope"))
@@ -207,12 +203,8 @@ def _legacy_event_from_metadata(msg: OutboundMessage) -> OutboundEvent | None:
             reasoning_delta=bool(meta.get("_reasoning_delta")),
             reasoning_end=bool(meta.get("_reasoning_end")),
             stream_id=_metadata_str(meta, "_stream_id"),
-            tool_events=cast(list[dict[str, Any]], tool_events)
-            if isinstance(tool_events, list)
-            else None,
-            file_edit_events=cast(list[dict[str, Any]], file_edit_events)
-            if isinstance(file_edit_events, list)
-            else None,
+            tool_events=tool_events if isinstance(tool_events, list) else None,
+            file_edit_events=file_edit_events if isinstance(file_edit_events, list) else None,
         )
     return None
 

nanobot/bus/runtime_events.py

@@ -12,15 +12,12 @@ import contextlib
 import inspect
 from collections.abc import Awaitable, Callable
 from dataclasses import dataclass, field
-from typing import TYPE_CHECKING, Any
+from typing import Any
 
 from loguru import logger
 
 from nanobot.bus.events import InboundMessage
 
-if TYPE_CHECKING:
-    from nanobot.utils.llm_runtime import LLMRuntime
-
 
 @dataclass(frozen=True)
 class RuntimeEventContext:
@@ -55,7 +52,7 @@ class TurnCompleted:
 
     context: RuntimeEventContext
     latency_ms: int | None = None
-    runtime: LLMRuntime | None = None
+    runtime: Any | None = None
 
 
 @dataclass(frozen=True)
@@ -158,7 +155,7 @@ class RuntimeEventPublisher:
     def __init__(self, bus: RuntimeEventBus | None = None) -> None:
         self.bus = bus or RuntimeEventBus()
         self._turn_latency_ms: dict[str, int] = {}
-        self._turn_runtime: dict[str, LLMRuntime] = {}
+        self._turn_runtime: dict[str, Any] = {}
 
     @staticmethod
     def _context(
@@ -177,7 +174,7 @@ class RuntimeEventPublisher:
             attributes=dict(attributes or {}),
         )
 
-    def record_turn_runtime(self, session_key: str, runtime: LLMRuntime) -> None:
+    def record_turn_runtime(self, session_key: str, runtime: Any) -> None:
         self._turn_runtime[session_key] = runtime
 
     def record_turn_latency(self, session_key: str, latency_ms: int | None) -> None:

nanobot/channels/base.py

@@ -4,15 +4,11 @@ from __future__ import annotations
 
 from abc import ABC, abstractmethod
 from pathlib import Path
-from typing import Any, cast
+from typing import Any
 
 from loguru import logger
 
-from nanobot.bus.events import (
-    INBOUND_META_TRANSIENT_SESSION,
-    InboundMessage,
-    OutboundMessage,
-)
+from nanobot.bus.events import InboundMessage, OutboundMessage
 from nanobot.bus.queue import MessageBus
 from nanobot.pairing import (
     PAIRING_CODE_META_KEY,
@@ -205,21 +201,13 @@ class BaseChannel(ABC):
     def supports_streaming(self) -> bool:
         """True when config enables streaming AND this subclass implements send_delta."""
         cfg = self.config
-        config_mapping = cast(dict[str, Any], cfg) if isinstance(cfg, dict) else None
-        streaming: Any = (
-            config_mapping.get("streaming", False)
-            if config_mapping is not None
-            else getattr(cast(Any, cfg), "streaming", False)
-        )
+        streaming = cfg.get("streaming", False) if isinstance(cfg, dict) else getattr(cfg, "streaming", False)
         return bool(streaming) and type(self).send_delta is not BaseChannel.send_delta
 
     def is_allowed(self, sender_id: str) -> bool:
         """Check sender permission: star > allowlist > pairing store > deny."""
         if isinstance(self.config, dict):
-            config_mapping = cast(dict[str, Any], self.config)
-            allow_list: Any = (
-                config_mapping.get("allow_from") or config_mapping.get("allowFrom") or []
-            )
+            allow_list = self.config.get("allow_from") or self.config.get("allowFrom") or []
         else:
             allow_list = getattr(self.config, "allow_from", None) or []
         if "*" in allow_list:
@@ -252,15 +240,7 @@ class BaseChannel(ABC):
         permission_id = authorization_id if authorization_id is not None else sender_id
         if not self.is_allowed(permission_id):
             if is_dm:
-                try:
-                    code = generate_code(self.name, str(sender_id))
-                except OSError:
-                    # Transient pairing-store I/O failure: skip the pairing
-                    # reply for this message rather than crash the handler.
-                    self.logger.warning(
-                        "Pairing store unavailable; dropping DM from {}", sender_id
-                    )
-                    return
+                code = generate_code(self.name, str(sender_id))
                 await self.send(
                     OutboundMessage(
                         channel=self.name,
@@ -281,8 +261,7 @@ class BaseChannel(ABC):
                 )
             return
 
-        meta = dict(metadata or {})
-        transient_session = meta.pop(INBOUND_META_TRANSIENT_SESSION, False) is True
+        meta = metadata or {}
         if self.supports_streaming:
             meta = {**meta, "_wants_stream": True}
 
@@ -294,7 +273,6 @@ class BaseChannel(ABC):
             media=media or [],
             metadata=meta,
             session_key_override=session_key,
-            transient_session=transient_session,
         )
 
         await self.bus.publish_inbound(msg)

nanobot/channels/contracts.py

@@ -6,7 +6,7 @@ from collections.abc import Iterable
 from copy import deepcopy
 from dataclasses import dataclass
 from pathlib import Path
-from typing import TYPE_CHECKING, Any, Callable, Literal, TypeGuard, cast
+from typing import TYPE_CHECKING, Any, Callable, Literal
 
 if TYPE_CHECKING:
     from nanobot.channels.plugin import ChannelPlugin
@@ -22,8 +22,6 @@ class ChannelValidationContext:
     allow_local_service_access: bool = False
 
 
-# Keep callback contracts precise for static consumers. The public adapters below
-# still validate third-party implementations at runtime.
 SetupValidator = Callable[[dict[str, Any], ChannelValidationContext], dict[str, Any]]
 DefaultConfigFactory = Callable[[], dict[str, Any]]
 InstanceSpecsFactory = Callable[..., Iterable["ChannelInstanceSpec"]]
@@ -89,7 +87,7 @@ class ChannelActivation:
         instances = (
             tuple(
                 cls.from_config(item, include_instances=True)
-                for item in cast(list[Any], raw_instances)
+                for item in raw_instances
                 if _config_mapping(item) is not None
             )
             if isinstance(raw_instances, list)
@@ -195,7 +193,7 @@ class ChannelSetupSpec:
     def to_public_dict(self, channel_name: str) -> dict[str, Any]:
         """Serialize the writable setup contract for generic WebUI consumers."""
         simple_required = set(self.simple_required_fields)
-        fields: list[dict[str, Any]] = []
+        fields = []
         for name, field in self.fields.items():
             if not field.writable:
                 continue
@@ -270,37 +268,35 @@ def channel_default_config(plugin: ChannelPlugin) -> dict[str, Any]:
     defaults: dict[str, Any] = {"enabled": plugin.default_enabled}
     if plugin.setup is not None:
         for name, field in plugin.setup.fields.items():
-            value: Any = field.default
+            value = field.default
             if value is None:
-                fallback_defaults: dict[str, Any] = {
+                value = {
                     "string": "",
                     "secret": "",
                     "list": [],
                     "bool": False,
-                }
-                value = fallback_defaults.get(field.kind, _MISSING)
+                }.get(field.kind, _MISSING)
             if value is not _MISSING:
                 _assign_channel_field(defaults, name, deepcopy(value))
 
     factory = plugin.management.default_config
     if factory is None:
         return defaults
-    values_raw = cast(object, factory())
-    if not isinstance(values_raw, dict):
+    values = factory()
+    if not isinstance(values, dict):
         raise TypeError(f"ChannelPlugin.management.default_config for '{plugin.name}' must return a dict")
-    values = cast(dict[str, Any], values_raw)
-    return cast(dict[str, Any], merge_missing_defaults(values, defaults))
+    return merge_missing_defaults(values, defaults)
 
 
 def _assign_channel_field(values: dict[str, Any], field: str, value: Any) -> None:
     target = values
     parts = field.split(".")
     for part in parts[:-1]:
-        nested: object = target.get(part)
+        nested = target.get(part)
         if not isinstance(nested, dict):
             nested = {}
             target[part] = nested
-        target = cast(dict[str, Any], nested)
+        target = nested
     target[parts[-1]] = value
 
 
@@ -331,28 +327,27 @@ def channel_instance_specs(
     factory = plugin.management.instance_specs
     if factory is None:
         activation = ChannelActivation.from_config(section)
-        raw_specs: object = (
+        raw_specs: Iterable[ChannelInstanceSpec] = (
             []
             if enabled_only and not activation.resolve(default=plugin.default_enabled)
             else [ChannelInstanceSpec(instance_id="default", config=section)]
         )
     else:
-        raw_specs = cast(object, factory(section, enabled_only=enabled_only))
+        raw_specs = factory(section, enabled_only=enabled_only)
     if not isinstance(raw_specs, Iterable):
         raise TypeError(
             f"ChannelPlugin.management.instance_specs for '{plugin.name}' must return an iterable"
         )
-    specs = list(cast(Iterable[object], raw_specs))
-    if not _all_channel_instance_specs(specs):
-        raise TypeError(
-            f"ChannelPlugin.management.instance_specs for '{plugin.name}' returned an invalid item"
-        )
+    specs = list(raw_specs)
 
     instance_ids: set[str] = set()
     runtime_names: set[str] = set()
     for spec in specs:
-        instance_id = cast(object, spec.instance_id)
-        if not isinstance(instance_id, str) or not instance_id.strip():
+        if not isinstance(spec, ChannelInstanceSpec):
+            raise TypeError(
+                f"ChannelPlugin.management.instance_specs for '{plugin.name}' returned an invalid item"
+            )
+        if not isinstance(spec.instance_id, str) or not spec.instance_id.strip():
             raise ValueError(
                 f"ChannelPlugin.management.instance_specs for '{plugin.name}' returned an empty instance id"
             )
@@ -372,12 +367,6 @@ def channel_instance_specs(
     return specs
 
 
-def _all_channel_instance_specs(
-    values: list[object],
-) -> TypeGuard[list[ChannelInstanceSpec]]:
-    return all(isinstance(value, ChannelInstanceSpec) for value in values)
-
-
 def resolve_channel_action_target(
     requested_instance_id: str | None,
 ) -> str:
@@ -404,17 +393,8 @@ def channel_instance_config(
         return {}
     config = selected.config
     if hasattr(config, "model_dump"):
-        dumped: dict[str, Any] = config.model_dump(mode="json", by_alias=True)
-        copied: dict[str, Any] = {}
-        for key in dumped:
-            copied[key] = dumped[key]
-        return copied
-    if not isinstance(config, dict):
-        return {}
-    copied_config: dict[str, Any] = {}
-    for key, value in cast(dict[object, Any], config).items():
-        copied_config[cast(str, key)] = value
-    return copied_config
+        return dict(config.model_dump(mode="json", by_alias=True))
+    return dict(config) if isinstance(config, dict) else {}
 
 
 def channel_update_instance_config(
@@ -429,10 +409,7 @@ def channel_update_instance_config(
         if instance_id not in {"", "default"}:
             raise ValueError(f"{plugin.name} does not support multiple instances")
         return values
-    updated = cast(object, updater(section, values, instance_id=instance_id))
-    if not isinstance(updated, dict):
-        raise TypeError(f"ChannelPlugin.management.update_instance_config for '{plugin.name}' must return a dict")
-    return cast(dict[str, Any], updated)
+    return updater(section, values, instance_id=instance_id)
 
 
 def channel_set_config_enabled(
@@ -446,7 +423,7 @@ def channel_set_config_enabled(
     from nanobot.config.loader import merge_missing_defaults
 
     values = channel_instance_config(plugin, section, instance_id=instance_id)
-    values = cast(dict[str, Any], merge_missing_defaults(values, channel_default_config(plugin)))
+    values = merge_missing_defaults(values, channel_default_config(plugin))
     values["enabled"] = enabled
     return channel_update_instance_config(
         plugin,
@@ -463,16 +440,12 @@ def channel_feature_instances(
     setup_spec: ChannelSetupSpec | None = None,
 ) -> list[dict[str, Any]] | None:
     factory = plugin.management.feature_instances
-    overrides = (
-        cast(object, factory(section, setup_spec=setup_spec))
-        if factory is not None
-        else None
-    )
+    overrides = factory(section, setup_spec=setup_spec) if factory is not None else None
     if overrides is None and not plugin.management.multi_instance:
         return None
     if overrides is not None and (
         not isinstance(overrides, list)
-        or any(not isinstance(instance, dict) for instance in cast(list[object], overrides))
+        or any(not isinstance(instance, dict) for instance in overrides)
     ):
         raise TypeError(
             f"ChannelPlugin.management.feature_instances for '{plugin.name}' "
@@ -497,8 +470,7 @@ def channel_feature_instances(
 
     by_id = {instance["id"]: instance for instance in instances}
     seen: set[str] = set()
-    for override_value in cast(list[object], overrides):
-        override = cast(dict[str, Any], override_value)
+    for override in overrides:
         instance_id = override.get("id")
         if not isinstance(instance_id, str) or instance_id not in by_id:
             raise ValueError(
@@ -542,21 +514,20 @@ def _validate_runtime_name(plugin: ChannelPlugin, runtime_name: Any) -> None:
 
 
 def channel_field_value(values: Any, field_path: str) -> Any:
-    current: Any = values
+    current = values
     for part in field_path.split("."):
         candidates = (part, _camel_to_snake(part))
         if isinstance(current, dict):
             for candidate in candidates:
                 if candidate in current:
-                    current = cast(Any, current)[candidate]
+                    current = current[candidate]
                     break
             else:
                 return None
             continue
         for candidate in candidates:
-            current_value = current
-            if hasattr(current_value, candidate):
-                current = getattr(current_value, candidate)
+            if hasattr(current, candidate):
+                current = getattr(current, candidate)
                 break
         else:
             return None
@@ -571,7 +542,7 @@ def stringify_channel_value(value: Any) -> str:
     if isinstance(value, bool):
         return "true" if value else "false"
     if isinstance(value, list):
-        return ", ".join(str(item) for item in cast(list[Any], value))
+        return ", ".join(str(item) for item in value)
     return str(value)
 
 
@@ -615,8 +586,8 @@ def _channel_feature_instance(
 def _config_mapping(value: Any) -> dict[str, Any] | None:
     if hasattr(value, "model_dump"):
         dumped = value.model_dump(mode="json", by_alias=True)
-        return cast(dict[str, Any], dumped) if isinstance(dumped, dict) else None
-    return cast(dict[str, Any], value) if isinstance(value, dict) else None
+        return dumped if isinstance(dumped, dict) else None
+    return value if isinstance(value, dict) else None
 
 
 def _camel_to_snake(value: str) -> str:

nanobot/channels/dingtalk/runtime.py

@@ -1,4 +1,3 @@
-# pyright: reportConstantRedefinition=false, reportMissingTypeStubs=false, reportPrivateUsage=false
 """DingTalk/DingDing channel implementation using Stream Mode."""
 
 import asyncio
@@ -11,7 +10,7 @@ from contextlib import suppress
 from inspect import isawaitable
 from io import BytesIO
 from pathlib import Path
-from typing import Any, cast
+from typing import Any
 from urllib.parse import unquote, urljoin, urlparse
 
 import httpx
@@ -37,17 +36,11 @@ def _escape_markdown_sender_name(value: str) -> str:
         for char in normalized
     )
 
-DINGTALK_AVAILABLE = False
-AckMessage: Any = None
-CallbackHandler: Any = object
-Credential: Any = None
-DingTalkStreamClient: Any = None
-ChatbotMessage: Any = None
-
 try:
     from dingtalk_stream import (
         AckMessage,
         CallbackHandler,
+        CallbackMessage,
         Credential,
         DingTalkStreamClient,
     )
@@ -55,41 +48,41 @@ try:
 
     DINGTALK_AVAILABLE = True
 except ImportError:
-    pass
+    DINGTALK_AVAILABLE = False
+    # Fallback so class definitions don't crash at module level
+    CallbackHandler = object  # type: ignore[assignment,misc]
+    CallbackMessage = None  # type: ignore[assignment,misc]
+    AckMessage = None  # type: ignore[assignment,misc]
+    ChatbotMessage = None  # type: ignore[assignment,misc]
 
 
-_CallbackHandlerBase = CallbackHandler
-
-
-class NanobotDingTalkHandler(_CallbackHandlerBase):
+class NanobotDingTalkHandler(CallbackHandler):
     """
     Standard DingTalk Stream SDK Callback Handler.
     Parses incoming messages and forwards them to the Nanobot channel.
     """
 
     def __init__(self, channel: "DingTalkChannel"):
-        super().__init__()  # pyright: ignore[reportUnknownMemberType]
+        super().__init__()
         self.channel = channel
 
-    async def process(self, message: Any) -> tuple[Any, str]:
+    async def process(self, message: CallbackMessage):
         """Process incoming stream message."""
         try:
             # Parse using SDK's ChatbotMessage for robust handling
-            chatbot_msg: Any = ChatbotMessage.from_dict(message.data)
-            message_data = cast(dict[str, Any], message.data)
+            chatbot_msg = ChatbotMessage.from_dict(message.data)
 
             # Extract text content; fall back to raw dict if SDK object is empty
             content = ""
             if chatbot_msg.text:
-                content = cast(str, chatbot_msg.text.content).strip()
+                content = chatbot_msg.text.content.strip()
             elif chatbot_msg.extensions.get("content", {}).get("recognition"):
-                content = cast(str, chatbot_msg.extensions["content"]["recognition"]).strip()
+                content = chatbot_msg.extensions["content"]["recognition"].strip()
             if not content:
-                text_data = cast(dict[str, Any], message_data.get("text", {}))
-                content = cast(str, text_data.get("content", "")).strip()
+                content = message.data.get("text", {}).get("content", "").strip()
 
             # Handle file/image messages
-            file_paths: list[str] = []
+            file_paths = []
             if chatbot_msg.message_type == "picture" and chatbot_msg.image_content:
                 download_code = chatbot_msg.image_content.download_code
                 if download_code:
@@ -100,18 +93,8 @@ class NanobotDingTalkHandler(_CallbackHandlerBase):
                         content = content or "[Image]"
 
             elif chatbot_msg.message_type == "file":
-                message_content = cast(dict[str, Any], message_data.get("content", {}))
-                download_code = cast(
-                    str,
-                    message_content.get("downloadCode")
-                    or message_data.get("downloadCode"),
-                )
-                fname = cast(
-                    str,
-                    message_content.get("fileName")
-                    or message_data.get("fileName")
-                    or "file",
-                )
+                download_code = message.data.get("content", {}).get("downloadCode") or message.data.get("downloadCode")
+                fname = message.data.get("content", {}).get("fileName") or message.data.get("fileName") or "file"
                 if download_code:
                     sender_uid = chatbot_msg.sender_staff_id or chatbot_msg.sender_id or "unknown"
                     fp = await self.channel._download_dingtalk_file(download_code, fname, sender_uid)
@@ -120,17 +103,13 @@ class NanobotDingTalkHandler(_CallbackHandlerBase):
                         content = content or "[File]"
 
             elif chatbot_msg.message_type == "richText" and chatbot_msg.rich_text_content:
-                rich_list = cast(
-                    list[object],
-                    chatbot_msg.rich_text_content.rich_text_list or [],
-                )
-                for item_value in rich_list:
-                    if not isinstance(item_value, dict):
+                rich_list = chatbot_msg.rich_text_content.rich_text_list or []
+                for item in rich_list:
+                    if not isinstance(item, dict):
                         continue
-                    item = cast(dict[str, Any], item_value)
                     # A rich-text item may carry text and/or a downloadCode; the
                     # DingTalk SDK treats them independently, so handle both.
-                    t = cast(str, item.get("text", "")).strip()
+                    t = item.get("text", "").strip()
                     if t:
                         fmt = item.get("type", "")
                         if fmt == "bold":
@@ -145,8 +124,8 @@ class NanobotDingTalkHandler(_CallbackHandlerBase):
                             formatted = t
                         content = (content + " " + formatted).strip() if content else formatted
                     if item.get("downloadCode"):
-                        dc = cast(str, item["downloadCode"])
-                        fname = cast(str, item.get("fileName") or "file")
+                        dc = item["downloadCode"]
+                        fname = item.get("fileName") or "file"
                         sender_uid = chatbot_msg.sender_staff_id or chatbot_msg.sender_id or "unknown"
                         fp = await self.channel._download_dingtalk_file(dc, fname, sender_uid)
                         if fp:
@@ -164,22 +143,13 @@ class NanobotDingTalkHandler(_CallbackHandlerBase):
                 )
                 return AckMessage.STATUS_OK, "OK"
 
-            sender_id = cast(
-                str | None,
-                chatbot_msg.sender_staff_id or chatbot_msg.sender_id,
-            )
-            sender_name = cast(str, chatbot_msg.sender_nick or "Unknown")
+            sender_id = chatbot_msg.sender_staff_id or chatbot_msg.sender_id
+            sender_name = chatbot_msg.sender_nick or "Unknown"
 
-            conversation_type = cast(
-                str | None,
-                message_data.get("conversationType"),
-            )
+            conversation_type = message.data.get("conversationType")
             conversation_id = (
-                cast(
-                    str | None,
-                    message_data.get("conversationId")
-                    or message_data.get("openConversationId"),
-                )
+                message.data.get("conversationId")
+                or message.data.get("openConversationId")
             )
 
             self.channel.logger.info("Received message from {} ({}): {}", sender_name, sender_id, content)
@@ -248,14 +218,14 @@ class DingTalkChannel(BaseChannel):
         self.config: DingTalkConfig = config
         self._client: Any = None
         self._http: httpx.AsyncClient | None = None
-        self._start_task: asyncio.Task[Any] | None = None
+        self._start_task: asyncio.Task | None = None
 
         # Access Token management for sending messages
         self._access_token: str | None = None
         self._token_expiry: float = 0
 
         # Hold references to background tasks to prevent GC
-        self._background_tasks: set[asyncio.Task[None]] = set()
+        self._background_tasks: set[asyncio.Task] = set()
 
     async def start(self) -> None:
         """Start the DingTalk bot with Stream Mode."""
@@ -605,11 +575,7 @@ class DingTalkChannel(BaseChannel):
         try:
             resp = await self._http.post(url, files=files)
             text = resp.text
-            result = (
-                cast(dict[str, Any], resp.json())
-                if resp.headers.get("content-type", "").startswith("application/json")
-                else {}
-            )
+            result = resp.json() if resp.headers.get("content-type", "").startswith("application/json") else {}
             if resp.status_code >= 400:
                 self.logger.error("media upload failed status={} type={} body={}", resp.status_code, media_type, text[:500])
                 return None
@@ -617,7 +583,7 @@ class DingTalkChannel(BaseChannel):
             if errcode != 0:
                 self.logger.error("media upload api error type={} errcode={} body={}", media_type, errcode, text[:500])
                 return None
-            sub = cast(dict[str, Any], result.get("result") or {})
+            sub = result.get("result") or {}
             media_id = result.get("media_id") or result.get("mediaId") or sub.get("media_id") or sub.get("mediaId")
             if not media_id:
                 self.logger.error("media upload missing media_id body={}", text[:500])
@@ -668,7 +634,7 @@ class DingTalkChannel(BaseChannel):
                 self.logger.error("send failed msgKey={} status={} body={}", msg_key, resp.status_code, body[:500])
                 return False
             try:
-                result = cast(dict[str, Any], resp.json())
+                result = resp.json()
             except Exception:
                 result = {}
             errcode = result.get("errcode")

nanobot/channels/discord/runtime.py

@@ -1,5 +1,4 @@
 """Discord channel implementation using discord.py."""
-# pyright: reportPrivateUsage=false, reportUnusedFunction=false
 
 from __future__ import annotations
 
@@ -9,7 +8,7 @@ import time
 from contextlib import suppress
 from dataclasses import dataclass
 from pathlib import Path
-from typing import TYPE_CHECKING, Any, Literal, cast
+from typing import TYPE_CHECKING, Any, Literal
 
 from pydantic import Field
 
@@ -44,7 +43,7 @@ class _StreamBuf:
     """Per-chat streaming accumulator for progressive Discord message edits."""
 
     text: str = ""
-    message: discord.Message | None = None
+    message: Any | None = None
     last_edit: float = 0.0
     stream_id: str | None = None
 
@@ -267,14 +266,13 @@ if DISCORD_AVAILABLE:
                     self._channel.logger.warning("channel {} unavailable: {}", msg.chat_id, e)
                     raise
 
-            messageable_channel = cast(Messageable, channel)
-            reference, mention_settings = self._build_reply_context(messageable_channel, msg.reply_to)
+            reference, mention_settings = self._build_reply_context(channel, msg.reply_to)
             sent_media = False
             failed_media: list[str] = []
 
             for index, media_path in enumerate(msg.media or []):
                 if await self._send_file(
-                    messageable_channel,
+                    channel,
                     media_path,
                     reference=reference if index == 0 else None,
                     mention_settings=mention_settings,
@@ -290,7 +288,7 @@ if DISCORD_AVAILABLE:
                 if index == 0 and reference is not None and not sent_media:
                     kwargs["reference"] = reference
                     kwargs["allowed_mentions"] = mention_settings
-                await messageable_channel.send(**kwargs)
+                await channel.send(**kwargs)
 
         async def _send_file(
             self,
@@ -346,7 +344,7 @@ if DISCORD_AVAILABLE:
                 self._channel.logger.warning("Invalid reply target: {}", reply_to)
                 return None, mention_settings
 
-            return cast(Any, channel).get_partial_message(message_id), mention_settings
+            return channel.get_partial_message(message_id), mention_settings
 
 
 class DiscordChannel(BaseChannel):
@@ -425,8 +423,8 @@ class DiscordChannel(BaseChannel):
                 import aiohttp
 
                 proxy_auth = aiohttp.BasicAuth(
-                    login=cast(str, self.config.proxy_username),
-                    password=cast(str, self.config.proxy_password),
+                    login=self.config.proxy_username,
+                    password=self.config.proxy_password,
                 )
             elif has_user != has_pass:
                 self.logger.warning(
@@ -509,7 +507,7 @@ class DiscordChannel(BaseChannel):
                 return
             if stream_id is not None and buf.stream_id is not None and buf.stream_id != stream_id:
                 return
-            await self._finalize_stream(chat_id, buf, buf.message)
+            await self._finalize_stream(chat_id, buf)
             return
 
         buf = self._stream_bufs.get(chat_id)
@@ -637,12 +635,7 @@ class DiscordChannel(BaseChannel):
             self.logger.warning("channel {} unavailable: {}", chat_id, e)
             return None
 
-    async def _finalize_stream(
-        self,
-        chat_id: str,
-        buf: _StreamBuf,
-        message: discord.Message,
-    ) -> None:
+    async def _finalize_stream(self, chat_id: str, buf: _StreamBuf) -> None:
         """Commit the final streamed content and flush overflow chunks."""
         chunks = DiscordBotClient._build_chunks(buf.text, [], False)
         if not chunks:
@@ -650,12 +643,16 @@ class DiscordChannel(BaseChannel):
             return
 
         try:
-            await message.edit(content=chunks[0])
+            await buf.message.edit(content=chunks[0])
         except Exception as e:
             self.logger.warning("final stream edit failed: {}", e)
             raise
 
-        target = message.channel
+        target = getattr(buf.message, "channel", None) or await self._resolve_channel(chat_id)
+        if target is None:
+            self.logger.warning("stream follow-up target {} unavailable", chat_id)
+            self._stream_bufs.pop(chat_id, None)
+            return
 
         for extra_chunk in chunks[1:]:
             await target.send(content=extra_chunk)

nanobot/channels/email/runtime.py

@@ -17,7 +17,7 @@ from email.parser import BytesParser
 from email.utils import parseaddr
 from fnmatch import fnmatch
 from pathlib import Path
-from typing import Any, Literal, cast
+from typing import Any, Literal
 
 from loguru import logger
 from pydantic import Field
@@ -188,9 +188,7 @@ class EmailChannel(BaseChannel):
                         self.logger.exception("Error delivering email from {}", sender)
                         continue
 
-                    metadata = item.get("metadata")
-                    metadata_data = cast(dict[str, Any], metadata) if isinstance(metadata, dict) else {}
-                    uid = str(metadata_data.get("uid") or "")
+                    uid = str((item.get("metadata") or {}).get("uid") or "")
                     if uid and should_apply_post_action:
                         post_actions_uids.add(uid)
 
@@ -314,7 +312,7 @@ class EmailChannel(BaseChannel):
             raise
 
     def _validate_config(self) -> bool:
-        missing: list[str] = []
+        missing = []
         if not self.config.imap_host:
             missing.append("imap_host")
         if not self.config.imap_username:
@@ -429,7 +427,7 @@ class EmailChannel(BaseChannel):
         messages: list[dict[str, Any]],
         skipped_uids: set[str],
         cycle_uids: set[str],
-    ) -> list[dict[str, Any]] | None:
+    ) -> None:
         """Fetch messages by arbitrary IMAP search criteria."""
         mailbox = self.config.imap_mailbox or "INBOX"
 
@@ -767,10 +765,8 @@ class EmailChannel(BaseChannel):
     @staticmethod
     def _extract_message_bytes(fetched: list[Any]) -> bytes | None:
         for item in fetched:
-            if isinstance(item, tuple):
-                fetched_item = cast(tuple[Any, ...], item)
-                if len(fetched_item) >= 2 and isinstance(fetched_item[1], (bytes, bytearray)):
-                    return bytes(fetched_item[1])
+            if isinstance(item, tuple) and len(item) >= 2 and isinstance(item[1], (bytes, bytearray)):
+                return bytes(item[1])
         return None
 
     @staticmethod
@@ -841,8 +837,8 @@ class EmailChannel(BaseChannel):
         """
         spf_pass = False
         dkim_pass = False
-        for ar_header in cast(list[Any], parsed_msg.get_all("Authentication-Results") or []):
-            ar_lower = str(ar_header).lower()
+        for ar_header in parsed_msg.get_all("Authentication-Results") or []:
+            ar_lower = ar_header.lower()
             if re.search(r"\bspf\s*=\s*pass\b", ar_lower):
                 spf_pass = True
             if re.search(r"\bdkim\s*=\s*pass\b", ar_lower):

nanobot/channels/feishu/connect.py

@@ -1,7 +1,5 @@
 """Short-lived WebUI channel connection sessions."""
 
-# pyright: reportPrivateUsage=false
-
 from __future__ import annotations
 
 import asyncio

nanobot/channels/feishu/instances.py

@@ -3,7 +3,7 @@
 from __future__ import annotations
 
 import re
-from typing import Any, cast
+from typing import Any
 
 from loguru import logger
 
@@ -46,7 +46,7 @@ def update_managed_feishu_instance(
     *,
     instance_id: str = DEFAULT_INSTANCE_ID,
 ) -> dict[str, Any]:
-    existing = cast(dict[str, Any], section) if isinstance(section, dict) else {}
+    existing = section if isinstance(section, dict) else {}
     return upsert_feishu_instance(
         existing,
         feishu_default_config(),
@@ -69,8 +69,8 @@ def _normalize_feishu_instance(
     inherited: dict[str, Any] | None = None,
     fallback_id: str = DEFAULT_INSTANCE_ID,
 ) -> dict[str, Any]:
-    config = cast(dict[str, Any], merge_missing_defaults(inherited or {}, defaults))
-    config = cast(dict[str, Any], merge_missing_defaults(raw, config))
+    config = merge_missing_defaults(inherited or {}, defaults)
+    config = merge_missing_defaults(raw, config)
 
     raw_id = raw.get("id") or raw.get("instanceId") or raw.get("instance_id") or fallback_id
     instance_id = validate_instance_id(str(raw_id))
@@ -97,13 +97,12 @@ def _feishu_instance_inputs(
         section = section.model_dump(mode="json", by_alias=True)
     if not isinstance(section, dict):
         section = {}
-    section_data = cast(dict[str, Any], section)
 
-    instances = section_data.get("instances")
+    instances = section.get("instances")
     if isinstance(instances, list):
-        inherited = {key: value for key, value in section_data.items() if key != "instances"}
-        return list(cast(list[Any], instances)), inherited
-    return ([section_data] if section_data else [_base_feishu_instance_config(defaults)]), None
+        inherited = {key: value for key, value in section.items() if key != "instances"}
+        return list(instances), inherited
+    return ([section] if section else [_base_feishu_instance_config(defaults)]), None
 
 
 def feishu_instance_specs(
@@ -125,7 +124,7 @@ def feishu_instance_specs(
         fallback_id = DEFAULT_INSTANCE_ID if index == 0 else f"assistant-{index + 1}"
         try:
             config = _normalize_feishu_instance(
-                cast(dict[str, Any], raw),
+                raw,
                 defaults,
                 inherited=inherited,
                 fallback_id=fallback_id,
@@ -180,7 +179,7 @@ def canonical_feishu_section(section: Any, defaults: dict[str, Any]) -> dict[str
         fallback_id = DEFAULT_INSTANCE_ID if index == 0 else f"assistant-{index + 1}"
         try:
             config = _normalize_feishu_instance(
-                cast(dict[str, Any], raw),
+                raw,
                 defaults,
                 inherited=inherited,
                 fallback_id=fallback_id,
@@ -239,9 +238,9 @@ def update_feishu_instance_preserving_shape(
     if (
         instance_id == DEFAULT_INSTANCE_ID
         and isinstance(section, dict)
-        and not isinstance(cast(dict[str, Any], section).get("instances"), list)
+        and not isinstance(section.get("instances"), list)
     ):
-        return {**cast(dict[str, Any], section), **values}
+        return {**section, **values}
 
     return upsert_feishu_instance(section, defaults, instance_id, values)
 

nanobot/channels/feishu/runtime.py

@@ -1,5 +1,4 @@
 """Feishu/Lark channel implementation using lark-oapi SDK with WebSocket long connection."""
-# pyright: reportMissingModuleSource=false, reportMissingTypeStubs=false
 
 from __future__ import annotations
 
@@ -15,9 +14,8 @@ from collections import OrderedDict
 from contextlib import suppress
 from dataclasses import dataclass
 from datetime import UTC, datetime
-from functools import partial
 from pathlib import Path
-from typing import TYPE_CHECKING, Any, TypedDict, cast
+from typing import TYPE_CHECKING, Any
 
 from rich.console import Console
 from rich.markup import escape
@@ -46,10 +44,7 @@ from nanobot.utils.helpers import safe_filename
 from nanobot.utils.logging_bridge import redirect_lib_logging
 
 if TYPE_CHECKING:
-    from lark_oapi.api.im.v1.model import (  # pyright: ignore[reportMissingTypeStubs]
-        MentionEvent,
-        P2ImMessageReceiveV1,
-    )
+    from lark_oapi.api.im.v1.model import MentionEvent, P2ImMessageReceiveV1
 
 FEISHU_AVAILABLE = importlib.util.find_spec("lark_oapi") is not None
 _LOGIN_CONSOLE = Console()
@@ -60,20 +55,6 @@ def _identity_timestamp() -> str:
     return datetime.now(UTC).isoformat(timespec="seconds").replace("+00:00", "Z")
 
 
-def _as_json_object(value: Any) -> dict[str, Any] | None:
-    """Narrow untyped SDK/JSON objects at the channel boundary."""
-    return cast(dict[str, Any], value) if isinstance(value, dict) else None
-
-
-def _as_json_list(value: Any) -> list[Any] | None:
-    """Narrow untyped SDK/JSON arrays at the channel boundary."""
-    return cast(list[Any], value) if isinstance(value, list) else None
-
-
-def _ignore_event(_: Any) -> None:
-    """Consume SDK events that intentionally have no channel action."""
-
-
 def _load_lark_runtime() -> tuple[Any, str, str]:
     """Import the heavy Feishu SDK lazily.
 
@@ -88,12 +69,9 @@ def _load_lark_runtime() -> tuple[Any, str, str]:
     # close the same loop.
     with _LARK_RUNTIME_LOCK:
         ws_client_already_imported = "lark_oapi.ws.client" in sys.modules
-        import lark_oapi as lark  # pyright: ignore[reportMissingTypeStubs]
-        import lark_oapi.ws.client as lark_ws_client  # pyright: ignore[reportMissingTypeStubs]
-        from lark_oapi.core.const import (  # pyright: ignore[reportMissingTypeStubs]
-            FEISHU_DOMAIN,
-            LARK_DOMAIN,
-        )
+        import lark_oapi as lark
+        import lark_oapi.ws.client as lark_ws_client
+        from lark_oapi.core.const import FEISHU_DOMAIN, LARK_DOMAIN
 
         if (
             not ws_client_already_imported
@@ -128,7 +106,7 @@ def fetch_feishu_app_identity(
 
     try:
         lark, feishu_domain, lark_domain = _load_lark_runtime()
-        from lark_oapi.api.application.v6.model.get_application_request import (  # pyright: ignore[reportMissingTypeStubs]
+        from lark_oapi.api.application.v6.model.get_application_request import (
             GetApplicationRequest,
         )
 
@@ -173,9 +151,9 @@ MSG_TYPE_MAP = {
 }
 
 
-def _extract_share_card_content(content_json: dict[str, Any], msg_type: str) -> str:
+def _extract_share_card_content(content_json: dict, msg_type: str) -> str:
     """Extract text representation from share cards and interactive messages."""
-    parts: list[str] = []
+    parts = []
 
     if msg_type == "share_chat":
         parts.append(f"[shared chat: {content_json.get('chat_id', '')}]")
@@ -193,9 +171,9 @@ def _extract_share_card_content(content_json: dict[str, Any], msg_type: str) ->
     return "\n".join(parts) if parts else f"[{msg_type}]"
 
 
-def _extract_interactive_content(content: str | dict[str, Any]) -> list[str]:
+def _extract_interactive_content(content: dict) -> list[str]:
     """Recursively extract text and links from interactive card content."""
-    parts: list[str] = []
+    parts = []
 
     if isinstance(content, str):
         try:
@@ -211,9 +189,8 @@ def _extract_interactive_content(content: str | dict[str, Any]) -> list[str]:
     if isinstance(user_dsl, str) and user_dsl.strip():
         try:
             dsl = json.loads(user_dsl)
-            dsl_object = _as_json_object(dsl)
-            if dsl_object is not None:
-                parts.extend(_extract_interactive_content(dsl_object))
+            if isinstance(dsl, dict):
+                parts.extend(_extract_interactive_content(dsl))
                 if parts:
                     return parts
         except (json.JSONDecodeError, TypeError):
@@ -221,9 +198,8 @@ def _extract_interactive_content(content: str | dict[str, Any]) -> list[str]:
 
     if "title" in content:
         title = content["title"]
-        title_object = _as_json_object(title)
-        if title_object is not None:
-            title_content = title_object.get("content", "") or title_object.get("text", "")
+        if isinstance(title, dict):
+            title_content = title.get("content", "") or title.get("text", "")
             if title_content:
                 parts.append(f"title: {title_content}")
         elif isinstance(title, str):
@@ -231,39 +207,34 @@ def _extract_interactive_content(content: str | dict[str, Any]) -> list[str]:
 
     # Top-level elements: flat list or nested list format
     elements = content.get("elements")
-    elements_list = _as_json_list(elements)
-    if elements_list is not None:
-        if elements_list and isinstance(elements_list[0], list):
+    if isinstance(elements, list):
+        if elements and isinstance(elements[0], list):
             # Nested list: [[{tag:"text",text:"..."}], ...]
-            for row in elements_list:
-                row_list = _as_json_list(row)
-                if row_list is not None:
-                    for element in row_list:
+            for row in elements:
+                if isinstance(row, list):
+                    for element in row:
                         parts.extend(_extract_element_content(element))
         else:
             # Flat list: [{tag:"markdown",content:"..."}, ...]
-            for element in elements_list:
+            for element in elements:
                 parts.extend(_extract_element_content(element))
 
     # Body elements (schema 2.0)
     body = content.get("body", {})
-    body_object = _as_json_object(body)
-    if body_object is not None:
-        body_elements = _as_json_list(body_object.get("elements"))
-        if body_elements is not None:
+    if isinstance(body, dict):
+        body_elements = body.get("elements")
+        if isinstance(body_elements, list):
             for element in body_elements:
                 parts.extend(_extract_element_content(element))
 
     card = content.get("card", {})
-    card_object = _as_json_object(card)
-    if card_object:
-        parts.extend(_extract_interactive_content(card_object))
+    if card:
+        parts.extend(_extract_interactive_content(card))
 
     header = content.get("header", {})
-    header_object = _as_json_object(header)
-    if header_object is not None:
-        header_title = _as_json_object(header_object.get("title", {}))
-        if header_title is not None:
+    if header:
+        header_title = header.get("title", {})
+        if isinstance(header_title, dict):
             header_text = header_title.get("content", "") or header_title.get("text", "")
             if header_text:
                 parts.append(f"title: {header_text}")
@@ -271,16 +242,13 @@ def _extract_interactive_content(content: str | dict[str, Any]) -> list[str]:
     return parts
 
 
-def _extract_element_content(element: Any) -> list[str]:
+def _extract_element_content(element: dict) -> list[str]:
     """Extract content from a single card element."""
-    parts: list[str] = []
+    parts = []
 
-    element_object = _as_json_object(element)
-    if element_object is None:
+    if not isinstance(element, dict):
         return parts
 
-    element = element_object
-
     tag = element.get("tag", "")
 
     if tag in ("markdown", "lark_md"):
@@ -295,18 +263,16 @@ def _extract_element_content(element: Any) -> list[str]:
 
     elif tag == "div":
         text = element.get("text", {})
-        text_object = _as_json_object(text)
-        if text_object is not None:
-            text_content = text_object.get("content", "") or text_object.get("text", "")
+        if isinstance(text, dict):
+            text_content = text.get("content", "") or text.get("text", "")
             if text_content:
                 parts.append(text_content)
         elif isinstance(text, str):
             parts.append(text)
-        for field in _as_json_list(element.get("fields")) or []:
-            field_object = _as_json_object(field)
-            if field_object is not None:
-                field_text = _as_json_object(field_object.get("text", {}))
-                if field_text is not None:
+        for field in element.get("fields") or []:
+            if isinstance(field, dict):
+                field_text = field.get("text", {})
+                if isinstance(field_text, dict):
                     c = field_text.get("content", "")
                     if c:
                         parts.append(c)
@@ -321,33 +287,30 @@ def _extract_element_content(element: Any) -> list[str]:
 
     elif tag == "button":
         text = element.get("text", {})
-        text_object = _as_json_object(text)
-        if text_object is not None:
-            c = text_object.get("content", "")
+        if isinstance(text, dict):
+            c = text.get("content", "")
             if c:
                 parts.append(c)
-        multi_url: Any = element.get("multi_url") or {}
-        multi_url_object = _as_json_object(multi_url)
+        multi_url = element.get("multi_url") or {}
         url = element.get("url", "") or (
-            multi_url_object.get("url", "") if multi_url_object is not None else ""
+            multi_url.get("url", "") if isinstance(multi_url, dict) else ""
         )
         if url:
             parts.append(f"link: {url}")
 
     elif tag == "img":
-        alt = _as_json_object(element.get("alt", {}))
-        parts.append(alt.get("content", "[image]") if alt is not None else "[image]")
+        alt = element.get("alt", {})
+        parts.append(alt.get("content", "[image]") if isinstance(alt, dict) else "[image]")
 
     elif tag == "note":
-        for ne in _as_json_list(element.get("elements")) or []:
+        for ne in element.get("elements") or []:
             parts.extend(_extract_element_content(ne))
 
     elif tag == "column_set":
-        for col in _as_json_list(element.get("columns")) or []:
-            col_object = _as_json_object(col)
-            if col_object is None:
+        for col in element.get("columns") or []:
+            if not isinstance(col, dict):
                 continue
-            for ce in _as_json_list(col_object.get("elements")) or []:
+            for ce in col.get("elements") or []:
                 parts.extend(_extract_element_content(ce))
 
     elif tag == "plain_text":
@@ -356,44 +319,36 @@ def _extract_element_content(element: Any) -> list[str]:
             parts.append(content)
 
     elif tag == "table":
-        columns: list[tuple[str, str]] = []
-        for column in _as_json_list(element.get("columns")) or []:
-            column_object = _as_json_object(column)
-            if column_object is None:
-                continue
-            name = column_object.get("name")
-            if isinstance(name, str) and name:
-                columns.append((name, str(column_object.get("display_name") or name)))
-        rows = _as_json_list(element.get("rows")) or []
+        columns = [
+            (column["name"], str(column.get("display_name") or column["name"]))
+            for column in (element.get("columns") or [])
+            if isinstance(column, dict) and column.get("name")
+        ]
+        rows = element.get("rows") or []
         if columns:
             parts.append(" | ".join(header for _, header in columns))
-        if rows:
+        if isinstance(rows, list):
             for row in rows:
-                row_object = _as_json_object(row)
-                if row_object is None:
+                if not isinstance(row, dict):
                     continue
-                values: list[str] = []
+                values = []
                 for name, _ in columns:
-                    value = row_object.get(name)
+                    value = row.get(name)
                     if isinstance(value, list):
-                        value = " ".join(
-                            str(item).strip()
-                            for item in cast(list[Any], value)
-                            if item is not None
-                        )
+                        value = " ".join(str(item).strip() for item in value if item is not None)
                     values.append("" if value is None else str(value).strip())
                 row_text = " | ".join(values).strip()
                 if row_text:
                     parts.append(row_text)
 
     else:
-        for ne in _as_json_list(element.get("elements")) or []:
+        for ne in element.get("elements") or []:
             parts.extend(_extract_element_content(ne))
 
     return parts
 
 
-def _extract_post_content(content_json: dict[str, Any]) -> tuple[str, list[str]]:
+def _extract_post_content(content_json: dict) -> tuple[str, list[str]]:
     """Extract text and image keys from Feishu post (rich text) message.
 
     Handles three payload shapes:
@@ -402,48 +357,45 @@ def _extract_post_content(content_json: dict[str, Any]) -> tuple[str, list[str]]
     - Wrapped:   {"post": {"zh_cn": {"title": "...", "content": [...]}}}
     """
 
-    def _parse_block(block: dict[str, Any]) -> tuple[str | None, list[str]]:
-        content = _as_json_list(block.get("content"))
-        if content is None:
+    def _parse_block(block: dict) -> tuple[str | None, list[str]]:
+        if not isinstance(block, dict) or not isinstance(block.get("content"), list):
             return None, []
-        texts: list[str] = []
-        images: list[str] = []
+        texts, images = [], []
         title = block.get("title")
         if isinstance(title, str) and title:
             texts.append(title)
-        for row in content:
-            row_items = _as_json_list(row)
-            if row_items is None:
+        for row in block["content"]:
+            if not isinstance(row, list):
                 continue
-            for el in row_items:
-                element = _as_json_object(el)
-                if element is None:
+            for el in row:
+                if not isinstance(el, dict):
                     continue
-                tag = element.get("tag")
+                tag = el.get("tag")
                 if tag in ("text", "a"):
-                    text = element.get("text", "")
+                    text = el.get("text", "")
                     if isinstance(text, str):
                         texts.append(text)
                 elif tag == "at":
-                    user = element.get("user_name", "user")
+                    user = el.get("user_name", "user")
                     texts.append(f"@{user if isinstance(user, str) and user else 'user'}")
                 elif tag == "code_block":
-                    lang = element.get("language", "")
-                    code_text = element.get("text", "")
+                    lang = el.get("language", "")
+                    code_text = el.get("text", "")
                     if not isinstance(lang, str):
                         lang = ""
                     if not isinstance(code_text, str):
                         code_text = ""
                     texts.append(f"\n```{lang}\n{code_text}\n```\n")
-                elif tag == "img" and isinstance((key := element.get("image_key")), str):
+                elif tag == "img" and (key := el.get("image_key")):
                     images.append(key)
         return (" ".join(texts).strip() or None), images
 
     # Unwrap optional {"post": ...} envelope
     root = content_json
-    post = _as_json_object(root.get("post"))
-    if post is not None:
-        root = post
+    if isinstance(root, dict) and isinstance(root.get("post"), dict):
+        root = root["post"]
+    if not isinstance(root, dict):
+        return "", []
 
     # Direct format
     if "content" in root:
@@ -454,23 +406,19 @@ def _extract_post_content(content_json: dict[str, Any]) -> tuple[str, list[str]]
     # Localized: prefer known locales, then fall back to any dict child
     for key in ("zh_cn", "en_us", "ja_jp"):
         if key in root:
-            block = _as_json_object(root[key])
-            if block is None:
-                continue
-            text, imgs = _parse_block(block)
+            text, imgs = _parse_block(root[key])
             if text or imgs:
                 return text or "", imgs
     for val in root.values():
-        block = _as_json_object(val)
-        if block is not None:
-            text, imgs = _parse_block(block)
+        if isinstance(val, dict):
+            text, imgs = _parse_block(val)
             if text or imgs:
                 return text or "", imgs
 
     return "", []
 
 
-def _extract_post_text(content_json: dict[str, Any]) -> str:  # pyright: ignore[reportUnusedFunction]
+def _extract_post_text(content_json: dict) -> str:
     """Extract plain text from Feishu post (rich text) message content.
 
     Legacy wrapper for _extract_post_content, returns only text.
@@ -494,18 +442,11 @@ _REGISTRATION_PATH = "/oauth/v1/app/registration"
 _ONBOARD_REQUEST_TIMEOUT_S = 10
 
 
-class _RegistrationStart(TypedDict):
-    device_code: str
-    qr_url: str
-    interval: int
-    expire_in: int
-
-
 def _accounts_base_url(domain: str) -> str:
     return _ONBOARD_ACCOUNTS_URLS.get(domain, _ONBOARD_ACCOUNTS_URLS["feishu"])
 
 
-def _post_registration(base_url: str, body: dict[str, str]) -> dict[str, Any]:
+def _post_registration(base_url: str, body: dict[str, str]) -> dict:
     """POST form-encoded data to the registration endpoint, return parsed JSON.
 
     The registration endpoint returns JSON even on HTTP errors (e.g. poll
@@ -521,8 +462,7 @@ def _post_registration(base_url: str, body: dict[str, str]) -> dict[str, Any]:
         headers={"Content-Type": "application/x-www-form-urlencoded"},
     )
     try:
-        parsed = resp.json()
-        return _as_json_object(parsed) or {}
+        return resp.json()
     except json.JSONDecodeError:
         resp.raise_for_status()
         return {}
@@ -532,7 +472,7 @@ def _init_registration(domain: str = "feishu") -> None:
     """Verify the environment supports client_secret auth. Raises RuntimeError if not."""
     base_url = _accounts_base_url(domain)
     res = _post_registration(base_url, {"action": "init"})
-    methods = _as_json_list(res.get("supported_auth_methods")) or []
+    methods = res.get("supported_auth_methods") or []
     if "client_secret" not in methods:
         raise RuntimeError(
             f"Feishu / Lark registration does not support client_secret auth. "
@@ -540,7 +480,7 @@ def _init_registration(domain: str = "feishu") -> None:
         )
 
 
-def _begin_registration(domain: str = "feishu") -> _RegistrationStart:
+def _begin_registration(domain: str = "feishu") -> dict:
     """Start the device-code flow. Returns device_code, qr_url, interval, expire_in."""
     base_url = _accounts_base_url(domain)
     res = _post_registration(base_url, {
@@ -550,18 +490,16 @@ def _begin_registration(domain: str = "feishu") -> _RegistrationStart:
         "request_user_info": "open_id",
     })
     device_code = res.get("device_code")
-    if not isinstance(device_code, str) or not device_code:
+    if not device_code:
         raise RuntimeError("Feishu / Lark registration did not return a device_code")
     qr_url = res.get("verification_uri_complete", "")
-    if not isinstance(qr_url, str) or not qr_url:
+    if not qr_url:
         raise RuntimeError("Feishu / Lark registration did not return a login URL")
-    interval = res.get("interval")
-    expire_in = res.get("expire_in")
     return {
         "device_code": device_code,
         "qr_url": qr_url,
-        "interval": interval if isinstance(interval, int) else 5,
-        "expire_in": expire_in if isinstance(expire_in, int) else 600,
+        "interval": res.get("interval") or 5,
+        "expire_in": res.get("expire_in") or 600,
     }
 
 
@@ -571,7 +509,7 @@ def _poll_registration(
     interval: int,
     expire_in: int,
     domain: str = "feishu",
-) -> dict[str, Any] | None:
+) -> dict | None:
     """Poll until the user scans the QR code, or timeout/denial.
 
     Returns dict with app_id, app_secret, domain on success, None on failure.
@@ -610,7 +548,7 @@ def poll_registration_once(
     *,
     device_code: str,
     domain: str = "feishu",
-) -> dict[str, Any]:
+) -> dict:
     """Poll the Feishu/Lark device-code flow once.
 
     This non-blocking shape is used by WebUI. The CLI keeps using
@@ -624,7 +562,7 @@ def poll_registration_once(
         "tp": "ob_app",
     })
 
-    user_info = _as_json_object(res.get("user_info")) or {}
+    user_info = res.get("user_info") or {}
     tenant_brand = user_info.get("tenant_brand")
     if tenant_brand == "lark":
         current_domain = "lark"
@@ -703,7 +641,9 @@ def sync_saved_feishu_identity_boundary(
     from nanobot.config.loader import load_config, save_config
 
     full_config = load_config()
-    feishu_cfg = _as_json_object(getattr(full_config.channels, "feishu", None)) or {}
+    feishu_cfg = getattr(full_config.channels, "feishu", None) or {}
+    if not isinstance(feishu_cfg, dict):
+        feishu_cfg = {}
 
     defaults = feishu_default_config()
     previous_identity_key = ""
@@ -735,7 +675,7 @@ def sync_saved_feishu_identity_boundary(
 
 
 def save_registration_result(
-    result: dict[str, Any],
+    result: dict,
     *,
     instance_id: str = DEFAULT_INSTANCE_ID,
     name: str | None = None,
@@ -744,7 +684,9 @@ def save_registration_result(
     from nanobot.config.loader import load_config, save_config
 
     full_config = load_config()
-    feishu_cfg = _as_json_object(getattr(full_config.channels, "feishu", None)) or {}
+    feishu_cfg = getattr(full_config.channels, "feishu", None) or {}
+    if not isinstance(feishu_cfg, dict):
+        feishu_cfg = {}
     defaults = feishu_default_config()
     app_id = str(result["app_id"]).strip()
     domain = str(result.get("domain", "feishu") or "feishu").strip().lower()
@@ -867,7 +809,7 @@ def refresh_saved_feishu_identities(
 def qr_register(
     *,
     initial_domain: str = "feishu",
-) -> dict[str, Any] | None:
+) -> dict | None:
     """Run the Feishu / Lark scan-to-create QR registration flow.
 
     Returns on success:
@@ -911,7 +853,7 @@ def _print_qr_code(url: str) -> None:
 def _qr_register_inner(
     *,
     initial_domain: str,
-) -> dict[str, Any] | None:
+) -> dict | None:
     """Run init → begin → poll. Raises on network/protocol errors."""
     _LOGIN_CONSOLE.print("[cyan]Preparing Feishu/Lark login...[/cyan]")
     _init_registration(initial_domain)
@@ -993,7 +935,7 @@ class FeishuChannel(BaseChannel):
         self._loop: asyncio.AbstractEventLoop | None = None
         self._stream_bufs: dict[str, _FeishuStreamBuf] = {}
         self._bot_open_id: str | None = None
-        self._background_tasks: set[asyncio.Task[Any]] = set()
+        self._background_tasks: set[asyncio.Task] = set()
         self._reaction_ids: dict[str, str] = {}  # message_id → reaction_id
 
     # ------------------------------------------------------------------
@@ -1120,12 +1062,12 @@ class FeishuChannel(BaseChannel):
         builder = self._register_optional_event(
             builder,
             "register_p2_im_chat_member_bot_added_v1",
-            _ignore_event,
+            lambda _: None,
         )
         builder = self._register_optional_event(
             builder,
             "register_p2_im_chat_member_bot_deleted_v1",
-            _ignore_event,
+            lambda _: None,
         )
         event_handler = builder.build()
 
@@ -1184,11 +1126,9 @@ class FeishuChannel(BaseChannel):
             if response.success():
                 import json
 
-                data = _as_json_object(json.loads(response.raw.content)) or {}
-                wrapped = _as_json_object(data.get("data")) or data
-                bot = _as_json_object(wrapped.get("bot")) or _as_json_object(data.get("bot")) or {}
-                open_id = bot.get("open_id")
-                return open_id if isinstance(open_id, str) else None
+                data = json.loads(response.raw.content)
+                bot = (data.get("data") or data).get("bot") or data.get("bot") or {}
+                return bot.get("open_id")
             self.logger.warning("Failed to get bot info: code={}, msg={}", response.code, response.msg)
             return None
         except Exception as e:
@@ -1278,7 +1218,7 @@ class FeishuChannel(BaseChannel):
         if "@_all" in raw_content:
             return True
 
-        for mention in cast(list[Any], getattr(message, "mentions", None) or []):
+        for mention in getattr(message, "mentions", None) or []:
             if self._is_bot_mention_event(mention):
                 return True
         return False
@@ -1372,7 +1312,7 @@ class FeishuChannel(BaseChannel):
         loop = asyncio.get_running_loop()
         await loop.run_in_executor(None, self._remove_reaction_sync, message_id, reaction_id)
 
-    def _on_background_task_done(self, task: asyncio.Task[Any]) -> None:
+    def _on_background_task_done(self, task: asyncio.Task) -> None:
         """Callback: remove from tracking set and log unhandled exceptions."""
         self._background_tasks.discard(task)
         if task.cancelled():
@@ -1382,7 +1322,7 @@ class FeishuChannel(BaseChannel):
         except Exception as exc:
             self.logger.warning("Background task failed: {}", exc)
 
-    def _on_reaction_added(self, message_id: str, task: asyncio.Task[Any]) -> None:
+    def _on_reaction_added(self, message_id: str, task: asyncio.Task) -> None:
         """Callback: store reaction_id after background add-reaction completes."""
         if task.cancelled():
             return
@@ -1435,7 +1375,7 @@ class FeishuChannel(BaseChannel):
         return text
 
     @classmethod
-    def _parse_md_table(cls, table_text: str) -> dict[str, Any] | None:
+    def _parse_md_table(cls, table_text: str) -> dict | None:
         """Parse a markdown table into a Feishu table element."""
         lines = [_line.strip() for _line in table_text.strip().split("\n") if _line.strip()]
         if len(lines) < 3:
@@ -1459,7 +1399,7 @@ class FeishuChannel(BaseChannel):
             ],
         }
 
-    def _build_card_elements(self, content: str) -> list[dict[str, Any]]:
+    def _build_card_elements(self, content: str) -> list[dict]:
         """Split content into div/markdown + table elements for Feishu card."""
         protected = content
         code_blocks: list[str] = []
@@ -1467,8 +1407,7 @@ class FeishuChannel(BaseChannel):
             code_blocks.append(m.group(1))
             protected = protected.replace(m.group(1), f"\x00CODE{len(code_blocks) - 1}\x00", 1)
 
-        elements: list[dict[str, Any]] = []
-        last_end = 0
+        elements, last_end = [], 0
         for m in self._TABLE_RE.finditer(protected):
             before = protected[last_end : m.start()]
             if before.strip():
@@ -1490,8 +1429,8 @@ class FeishuChannel(BaseChannel):
 
     @staticmethod
     def _split_elements_by_table_limit(
-        elements: list[dict[str, Any]], max_tables: int = 1
-    ) -> list[list[dict[str, Any]]]:
+        elements: list[dict], max_tables: int = 1
+    ) -> list[list[dict]]:
         """Split card elements into groups with at most *max_tables* table elements each.
 
         Feishu cards have a hard limit of one table per card (API error 11310).
@@ -1500,8 +1439,8 @@ class FeishuChannel(BaseChannel):
         """
         if not elements:
             return [[]]
-        groups: list[list[dict[str, Any]]] = []
-        current: list[dict[str, Any]] = []
+        groups: list[list[dict]] = []
+        current: list[dict] = []
         table_count = 0
         for el in elements:
             if el.get("tag") == "table":
@@ -1518,15 +1457,15 @@ class FeishuChannel(BaseChannel):
             groups.append(current)
         return groups or [[]]
 
-    def _split_headings(self, content: str) -> list[dict[str, Any]]:
+    def _split_headings(self, content: str) -> list[dict]:
         """Split content by headings, converting headings to div elements."""
         protected = content
-        code_blocks: list[str] = []
+        code_blocks = []
         for m in self._CODE_BLOCK_RE.finditer(content):
             code_blocks.append(m.group(1))
             protected = protected.replace(m.group(1), f"\x00CODE{len(code_blocks) - 1}\x00", 1)
 
-        elements: list[dict[str, Any]] = []
+        elements = []
         last_end = 0
         for m in self._HEADING_RE.finditer(protected):
             before = protected[last_end : m.start()].strip()
@@ -1634,10 +1573,10 @@ class FeishuChannel(BaseChannel):
         Each line becomes a paragraph (row) in the post body.
         """
         lines = content.strip().split("\n")
-        paragraphs: list[list[dict[str, Any]]] = []
+        paragraphs: list[list[dict]] = []
 
         for line in lines:
-            elements: list[dict[str, Any]] = []
+            elements: list[dict] = []
             last_end = 0
 
             for m in cls._MD_LINK_RE.finditer(line):
@@ -1829,7 +1768,7 @@ class FeishuChannel(BaseChannel):
         return candidate
 
     async def _download_and_save_media(
-        self, msg_type: str, content_json: dict[str, Any], message_id: str | None = None
+        self, msg_type: str, content_json: dict, message_id: str | None = None
     ) -> tuple[str | None, str]:
         """
         Download media from Feishu and save to local disk.
@@ -2367,11 +2306,8 @@ class FeishuChannel(BaseChannel):
                 fallback_msg_id = self._thread_reply_target(meta)
                 if fallback_msg_id:
                     await loop.run_in_executor(
-                        None, partial(
-                            self._reply_message_sync,
-                            fallback_msg_id,
-                            "interactive",
-                            card,
+                        None, lambda: self._reply_message_sync(
+                            fallback_msg_id, "interactive", card,
                             reply_in_thread=self._should_use_reply_in_thread(meta),
                         ),
                     )
@@ -2627,9 +2563,6 @@ class FeishuChannel(BaseChannel):
             return
         try:
             event = data.event
-            if event is None or event.message is None or event.sender is None:
-                self.logger.warning("Ignoring incomplete Feishu message event")
-                return
             message = event.message
             sender = event.sender
 
@@ -2646,20 +2579,6 @@ class FeishuChannel(BaseChannel):
             chat_id = message.chat_id
             chat_type = message.chat_type
             msg_type = message.message_type
-            if not all(isinstance(value, str) and value for value in (
-                message_id,
-                sender_id,
-                chat_id,
-                chat_type,
-                msg_type,
-            )):
-                self.logger.warning("Ignoring Feishu message event with missing routing fields")
-                return
-            message_id = cast(str, message_id)
-            sender_id = cast(str, sender_id)
-            chat_id = cast(str, chat_id)
-            chat_type = cast(str, chat_type)
-            msg_type = cast(str, msg_type)
 
             if chat_type == "group" and not self._is_group_message_for_bot(message):
                 self.logger.debug("skipping group message (not mentioned)")
@@ -2697,19 +2616,17 @@ class FeishuChannel(BaseChannel):
             task.add_done_callback(lambda t: self._on_reaction_added(message_id, t))
 
             # Parse content
-            content_parts: list[str] = []
-            media_paths: list[str] = []
+            content_parts = []
+            media_paths = []
 
             try:
-                raw_content = message.content if isinstance(message.content, str) else ""
-                content_json = _as_json_object(json.loads(raw_content)) if raw_content else {}
+                content_json = json.loads(message.content) if message.content else {}
             except json.JSONDecodeError:
                 content_json = {}
-            content_json = content_json or {}
 
             if msg_type == "text":
                 text = content_json.get("text", "")
-                if isinstance(text, str) and text:
+                if text:
                     mentions = getattr(message, "mentions", None)
                     text = self._strip_leading_bot_mention(text, mentions)
                     text = self._resolve_mentions(text, mentions)
@@ -2759,12 +2676,9 @@ class FeishuChannel(BaseChannel):
                 content_parts.append(MSG_TYPE_MAP.get(msg_type, f"[{msg_type}]"))
 
             # Extract reply context (parent/root message IDs)
-            parent_id = getattr(message, "parent_id", None)
-            root_id = getattr(message, "root_id", None)
-            thread_id = getattr(message, "thread_id", None)
-            parent_id = parent_id if isinstance(parent_id, str) else None
-            root_id = root_id if isinstance(root_id, str) else None
-            thread_id = thread_id if isinstance(thread_id, str) else None
+            parent_id = getattr(message, "parent_id", None) or None
+            root_id = getattr(message, "root_id", None) or None
+            thread_id = getattr(message, "thread_id", None) or None
 
             # Prepend quoted message text when the user replied to another message
             if parent_id and self._client:

nanobot/channels/feishu/websocket.py

@@ -1,4 +1,3 @@
-# pyright: reportMissingTypeStubs=false, reportPrivateUsage=false
 """Shared Feishu/Lark WebSocket runtime.
 
 The official lark_oapi websocket client stores an asyncio loop in a module-level
@@ -149,7 +148,7 @@ class FeishuWsRunner:
     async def _client_main(
         self, key: str, client: _LarkWsClient, stop_event: asyncio.Event
     ) -> None:
-        ping_task: asyncio.Task[None] | None = None
+        ping_task: asyncio.Task | None = None
         while not stop_event.is_set():
             try:
                 await client._connect()
@@ -172,12 +171,12 @@ class FeishuWsRunner:
                     await client._disconnect()
 
 
-_runner: FeishuWsRunner | None = None
+_RUNNER: FeishuWsRunner | None = None
 
 
 def get_feishu_ws_runner() -> FeishuWsRunner:
     """Return the process-wide Feishu WebSocket runner."""
-    global _runner
-    if _runner is None:
-        _runner = FeishuWsRunner()
-    return _runner
+    global _RUNNER
+    if _RUNNER is None:
+        _RUNNER = FeishuWsRunner()
+    return _RUNNER

nanobot/channels/manager.py

@@ -5,10 +5,10 @@ from __future__ import annotations
 import asyncio
 import hashlib
 import inspect
-from collections.abc import Awaitable, Callable, Iterable
+from collections.abc import Callable, Iterable
 from contextlib import suppress
 from pathlib import Path
-from typing import TYPE_CHECKING, Any, cast
+from typing import TYPE_CHECKING, Any
 
 from loguru import logger
 
@@ -41,9 +41,7 @@ from nanobot.utils.restart import (
 )
 
 if TYPE_CHECKING:
-    from nanobot.cron.service import CronService
     from nanobot.session.manager import SessionManager
-    from nanobot.triggers.local_store import LocalTriggerStore
 
 
 def _default_webui_dist() -> Path | None:
@@ -92,16 +90,14 @@ class ChannelManager:
         bus: MessageBus,
         *,
         session_manager: "SessionManager | None" = None,
-        cron_service: CronService | None = None,
-        local_trigger_store: LocalTriggerStore | None = None,
+        cron_service: Any | None = None,
+        local_trigger_store: Any | None = None,
         webui_runtime_model_name: Callable[[], str | None] | None = None,
         webui_cron_pending_job_ids: Callable[[str], set[str]] | None = None,
         webui_local_trigger_pending_ids: Callable[[str], set[str]] | None = None,
-        webui_cancel_active_turn: Callable[[str], Awaitable[int]] | None = None,
         webui_static_dist: bool = True,
         webui_runtime_surface: str = "browser",
         webui_runtime_capabilities: dict[str, Any] | None = None,
-        webui_skill_state_action: Callable[[set[str]], None] | None = None,
     ):
         self.config = config
         self.bus = bus
@@ -111,17 +107,15 @@ class ChannelManager:
         self._webui_runtime_model_name = webui_runtime_model_name
         self._webui_cron_pending_job_ids = webui_cron_pending_job_ids
         self._webui_local_trigger_pending_ids = webui_local_trigger_pending_ids
-        self._webui_cancel_active_turn = webui_cancel_active_turn
         self._webui_static_dist = webui_static_dist
         self._webui_runtime_surface = webui_runtime_surface
         self._webui_runtime_capabilities = dict(webui_runtime_capabilities or {})
-        self._webui_skill_state_action = webui_skill_state_action
         self.channels: dict[str, BaseChannel] = {}
         self._channel_owners: dict[str, str] = {}
         self._channel_runtime_specs: dict[str, tuple[str, str]] = {}
         self._channel_errors: dict[str, str] = {}
-        self._channel_tasks: dict[str, asyncio.Task[None]] = {}
-        self._dispatch_task: asyncio.Task[None] | None = None
+        self._channel_tasks: dict[str, asyncio.Task] = {}
+        self._dispatch_task: asyncio.Task | None = None
         self._started = False
         self._origin_reply_fingerprints: dict[tuple[str, str, str], str] = {}
 
@@ -180,10 +174,8 @@ class ChannelManager:
                 local_trigger_store=self._local_trigger_store,
                 cron_pending_job_ids=self._webui_cron_pending_job_ids,
                 local_trigger_pending_ids=self._webui_local_trigger_pending_ids,
-                cancel_active_turn=self._webui_cancel_active_turn,
                 channel_feature_action=self.apply_channel_feature_action,
                 channel_runtime_status=self.get_status,
-                skill_state_action=self._webui_skill_state_action,
                 logger=logger,
             )
             kwargs["gateway"] = gateway
@@ -299,11 +291,10 @@ class ChannelManager:
         for name, ch in self.channels.items():
             cfg = ch.config
             if isinstance(cfg, dict):
-                config_data = cast(dict[str, Any], cfg)
-                if "allow_from" in config_data:
-                    allow = config_data.get("allow_from")
+                if "allow_from" in cfg:
+                    allow = cfg.get("allow_from")
                 else:
-                    allow = config_data.get("allowFrom")
+                    allow = cfg.get("allowFrom")
             else:
                 allow = getattr(cfg, "allow_from", None)
             if allow is None:
@@ -330,12 +321,11 @@ class ChannelManager:
         Pydantic models.
         """
         if isinstance(section, dict):
-            section_data = cast(dict[str, Any], section)
-            value = section_data.get(key)
+            value = section.get(key)
             if value is None:
                 camel = _BOOL_CAMEL_ALIASES.get(key)
                 if camel:
-                    value = section_data.get(camel)
+                    value = section.get(camel)
             return value if isinstance(value, bool) else default
         value = getattr(section, key, None)
         return value if isinstance(value, bool) else default
@@ -354,7 +344,7 @@ class ChannelManager:
             errors[name] = "Channel failed to start. Check gateway logs."
             logger.exception("Failed to start channel {}", name)
 
-    def _start_channel_task(self, name: str, channel: BaseChannel) -> asyncio.Task[None]:
+    def _start_channel_task(self, name: str, channel: BaseChannel) -> asyncio.Task:
         logger.info("Starting {} channel...", name)
         task = asyncio.create_task(self._start_channel(name, channel))
         self._channel_tasks[name] = task
@@ -371,8 +361,7 @@ class ChannelManager:
             await channel.stop()
             logger.info("Stopped {} channel", name)
         except asyncio.CancelledError:
-            current_task = asyncio.current_task()
-            if current_task is not None and current_task.cancelling():
+            if asyncio.current_task() and asyncio.current_task().cancelling():
                 raise
             logger.debug("Channel {} stop task was already cancelled", name)
         except Exception:
@@ -564,7 +553,7 @@ class ChannelManager:
         self._dispatch_task = asyncio.create_task(self._dispatch_outbound())
 
         # Start channels
-        tasks: list[asyncio.Task[None]] = []
+        tasks = []
         for name, channel in self.channels.items():
             tasks.append(self._start_channel_task(name, channel))
 

nanobot/channels/matrix/runtime.py

@@ -1,7 +1,5 @@
 """Matrix (Element) channel — inbound sync + outbound message/media delivery."""
 
-# pyright: reportMissingTypeStubs=false
-
 import asyncio
 import html
 import json
@@ -12,7 +10,7 @@ import time
 from contextlib import suppress
 from dataclasses import dataclass
 from pathlib import Path
-from typing import Any, Callable, Literal, Protocol, TypeAlias, cast
+from typing import Any, Literal, TypeAlias
 from urllib.parse import quote, unquote, urlparse
 
 from pydantic import Field
@@ -77,18 +75,6 @@ MATRIX_MEDIA_EVENT_FILTER = (RoomMessageMedia, RoomEncryptedMedia)
 MatrixMediaEvent: TypeAlias = RoomMessageMedia | RoomEncryptedMedia
 
 
-class _MatrixCallbackRegistrar(Protocol):
-    """Runtime callback surface whose upstream stubs reject valid filtered handlers."""
-
-    def add_event_callback(self, callback: Callable[..., Any], event_filter: Any) -> None: ...
-    def add_to_device_callback(
-        self,
-        callback: Callable[..., Any],
-        event_filter: Any,
-    ) -> None: ...
-    def add_response_callback(self, callback: Callable[..., Any], response_filter: Any) -> None: ...
-
-
 class _MediaTooLargeError(Exception):
     """Raised when an inbound Matrix media download exceeds the configured cap."""
 
@@ -201,7 +187,7 @@ def _render_markdown_html(text: str) -> str | None:
     """Render markdown to sanitized HTML; returns None for plain text."""
     try:
         masked_text = _mask_mxc_markdown_image_sources(text)
-        rendered = _mask_mxc_image_sources(cast(str, MATRIX_MARKDOWN(masked_text)))
+        rendered = _mask_mxc_image_sources(MATRIX_MARKDOWN(masked_text))
         formatted = _unmask_mxc_image_sources(MATRIX_HTML_CLEANER.clean(rendered).strip())
     except Exception:
         return None
@@ -243,17 +229,16 @@ def _build_matrix_text_content(
         content["format"] = MATRIX_HTML_FORMAT
         content["formatted_body"] = html
     if event_id:
-        new_content: dict[str, object] = {
+        content["m.new_content"] = {
             "body": text,
             "msgtype": "m.text",
         }
-        content["m.new_content"] = new_content
         content["m.relates_to"] = {
             "rel_type": "m.replace",
             "event_id": event_id,
         }
         if thread_relates_to:
-            new_content["m.relates_to"] = thread_relates_to
+            content["m.new_content"]["m.relates_to"] = thread_relates_to
     elif thread_relates_to:
         content["m.relates_to"] = thread_relates_to
 
@@ -291,7 +276,7 @@ class MatrixChannel(BaseChannel):
     name = "matrix"
     display_name = "Matrix"
     _STREAM_EDIT_INTERVAL = 2 # min seconds between edit_message_text calls
-    monotonic_time: Callable[[], float] = staticmethod(time.monotonic)
+    monotonic_time = time.monotonic
 
     @classmethod
     def default_config(cls) -> dict[str, Any]:
@@ -309,8 +294,8 @@ class MatrixChannel(BaseChannel):
             config = MatrixConfig.model_validate(config)
         super().__init__(config, bus)
         self.client: AsyncClient | None = None
-        self._sync_task: asyncio.Task[None] | None = None
-        self._typing_tasks: dict[str, asyncio.Task[None]] = {}
+        self._sync_task: asyncio.Task | None = None
+        self._typing_tasks: dict[str, asyncio.Task] = {}
         self._restrict_to_workspace = bool(restrict_to_workspace)
         self._workspace = (
             Path(workspace).expanduser().resolve(strict=False) if workspace is not None else None
@@ -340,7 +325,7 @@ class MatrixChannel(BaseChannel):
         self.client = AsyncClient(
             homeserver=self.config.homeserver,
             user=self.config.user_id,
-            store_path=str(self.store_path),
+            store_path=self.store_path,
             config=AsyncClientConfig(
                 store_sync_tokens=True,
                 encryption_enabled=self.config.e2ee_enabled,
@@ -401,16 +386,6 @@ class MatrixChannel(BaseChannel):
 
         self._sync_task = asyncio.create_task(self._sync_loop())
 
-    def _require_client(self) -> AsyncClient:
-        if self.client is None:
-            raise RuntimeError("Matrix client is not started")
-        return self.client
-
-    def _callback_registrar(self) -> _MatrixCallbackRegistrar:
-        # matrix-nio's callback annotations do not model filtered subtype or
-        # async handlers, although the runtime API supports both.
-        return cast(_MatrixCallbackRegistrar, self._require_client())
-
     async def stop(self) -> None:
         """Stop the Matrix channel with graceful sync shutdown."""
         self._running = False
@@ -453,10 +428,9 @@ class MatrixChannel(BaseChannel):
         seen: set[str] = set()
         candidates: list[Path] = []
         for raw in media:
-            raw_value = cast(object, raw)
-            if not isinstance(raw_value, str) or not raw_value.strip():
+            if not isinstance(raw, str) or not raw.strip():
                 continue
-            path = Path(raw_value.strip()).expanduser()
+            path = Path(raw.strip()).expanduser()
             try:
                 key = str(path.resolve(strict=False))
             except OSError:
@@ -561,13 +535,8 @@ class MatrixChannel(BaseChannel):
             self.logger.error("Matrix media upload failed for %s", filename, exc_info=True)
             return fail
 
-        is_tuple_result = isinstance(cast(object, upload_result), tuple)
-        upload_response = upload_result[0] if is_tuple_result else upload_result
-        encryption_info = (
-            upload_result[1]
-            if is_tuple_result and isinstance(cast(object, upload_result[1]), dict)
-            else None
-        )
+        upload_response = upload_result[0] if isinstance(upload_result, tuple) else upload_result
+        encryption_info = upload_result[1] if isinstance(upload_result, tuple) and isinstance(upload_result[1], dict) else None
         if isinstance(upload_response, UploadError):
             return fail
         mxc_url = getattr(upload_response, "content_uri", None)
@@ -676,31 +645,28 @@ class MatrixChannel(BaseChannel):
                 buf.last_edit = now
                 if not buf.event_id:
                     # we are editing the same message all the time, so only the first time the event id needs to be set
-                    buf.event_id = cast(RoomSendResponse, response).event_id
+                    buf.event_id = response.event_id
             except Exception:
                 self.logger.error("Stream send/edit failed for chat_id=%s", chat_id, exc_info=True)
                 await self._stop_typing_keepalive(chat_id, clear_typing=True)
 
 
     def _register_event_callbacks(self) -> None:
-        client = self._callback_registrar()
-        client.add_event_callback(self._on_message, RoomMessageText)
-        client.add_event_callback(self._on_media_message, MATRIX_MEDIA_EVENT_FILTER)
-        client.add_event_callback(self._on_room_invite, InviteEvent)
+        self.client.add_event_callback(self._on_message, RoomMessageText)
+        self.client.add_event_callback(self._on_media_message, MATRIX_MEDIA_EVENT_FILTER)
+        self.client.add_event_callback(self._on_room_invite, InviteEvent)
 
     def _register_to_device_callbacks(self) -> None:
         if self.config.e2ee_enabled and self.config.sas_verification:
-            client = self._callback_registrar()
-            client.add_to_device_callback(
+            self.client.add_to_device_callback(
                 self._on_key_verification_event,
                 (KeyVerificationEvent,),
             )
 
     def _register_response_callbacks(self) -> None:
-        client = self._callback_registrar()
-        client.add_response_callback(self._on_sync_error, SyncError)
-        client.add_response_callback(self._on_join_error, JoinError)
-        client.add_response_callback(self._on_send_error, RoomSendError)
+        self.client.add_response_callback(self._on_sync_error, SyncError)
+        self.client.add_response_callback(self._on_join_error, JoinError)
+        self.client.add_response_callback(self._on_send_error, RoomSendError)
 
     def _is_sas_sender_allowed(self, sender: str) -> bool:
         return bool(sender and self.is_allowed(sender))
@@ -825,8 +791,7 @@ class MatrixChannel(BaseChannel):
         backoff = 2.0
         while self._running:
             try:
-                client = self._require_client()
-                await client.sync_forever(timeout=30000, full_state=True)
+                await self.client.sync_forever(timeout=30000, full_state=True)
                 backoff = 2.0
             except asyncio.CancelledError:
                 break
@@ -838,8 +803,7 @@ class MatrixChannel(BaseChannel):
 
     async def _on_room_invite(self, room: MatrixRoom, event: InviteEvent) -> None:
         if self.is_allowed(event.sender):
-            client = self._require_client()
-            await client.join(room.room_id)
+            await self.client.join(room.room_id)
 
     def _is_direct_room(self, room: MatrixRoom) -> bool:
         count = getattr(room, "member_count", None)
@@ -850,19 +814,13 @@ class MatrixChannel(BaseChannel):
         source = getattr(event, "source", None)
         if not isinstance(source, dict):
             return False
-        source_data = cast(dict[str, Any], source)
-        content = cast(dict[str, Any], source_data.get("content") or {})
-        mentions = cast(object, content.get("m.mentions"))
+        mentions = (source.get("content") or {}).get("m.mentions")
         if not isinstance(mentions, dict):
             return False
-        mentions_data = cast(dict[str, Any], mentions)
-        user_ids = cast(object, mentions_data.get("user_ids"))
+        user_ids = mentions.get("user_ids")
         if isinstance(user_ids, list) and self.config.user_id in user_ids:
             return True
-        return bool(
-            self.config.allow_room_mentions
-            and mentions_data.get("room") is True
-        )
+        return bool(self.config.allow_room_mentions and mentions.get("room") is True)
 
     def _is_pre_startup_event(self, event: RoomMessage) -> bool:
         """Skip events that landed in the timeline before this process started.
@@ -897,21 +855,14 @@ class MatrixChannel(BaseChannel):
         source = getattr(event, "source", None)
         if not isinstance(source, dict):
             return {}
-        source_data = cast(dict[str, Any], source)
-        content = cast(object, source_data.get("content"))
-        return cast(dict[str, Any], content) if isinstance(content, dict) else {}
+        content = source.get("content")
+        return content if isinstance(content, dict) else {}
 
     def _event_thread_root_id(self, event: RoomMessage) -> str | None:
-        relates_to = cast(
-            object,
-            self._event_source_content(event).get("m.relates_to"),
-        )
-        if not isinstance(relates_to, dict):
+        relates_to = self._event_source_content(event).get("m.relates_to")
+        if not isinstance(relates_to, dict) or relates_to.get("rel_type") != "m.thread":
             return None
-        relation = cast(dict[str, Any], relates_to)
-        if relation.get("rel_type") != "m.thread":
-            return None
-        root_id = cast(object, relation.get("event_id"))
+        root_id = relates_to.get("event_id")
         return root_id if isinstance(root_id, str) and root_id else None
 
     def _thread_metadata(self, event: RoomMessage) -> dict[str, str] | None:
@@ -937,7 +888,7 @@ class MatrixChannel(BaseChannel):
 
     def _event_attachment_type(self, event: MatrixMediaEvent) -> str:
         msgtype = self._event_source_content(event).get("msgtype")
-        return _MSGTYPE_MAP.get(cast(str, msgtype), "file")
+        return _MSGTYPE_MAP.get(msgtype, "file")
 
     @staticmethod
     def _is_encrypted_media_event(event: MatrixMediaEvent) -> bool:
@@ -946,27 +897,16 @@ class MatrixChannel(BaseChannel):
                 and isinstance(getattr(event, "iv", None), str))
 
     def _event_declared_size_bytes(self, event: MatrixMediaEvent) -> int | None:
-        info = cast(object, self._event_source_content(event).get("info"))
-        size = (
-            cast(dict[str, Any], info).get("size")
-            if isinstance(info, dict)
-            else None
-        )
+        info = self._event_source_content(event).get("info")
+        size = info.get("size") if isinstance(info, dict) else None
         return size if type(size) is int and size >= 0 else None  # noqa: E721
 
     def _event_mime(self, event: MatrixMediaEvent) -> str | None:
-        info = cast(object, self._event_source_content(event).get("info"))
-        if (
-            isinstance(info, dict)
-            and isinstance(
-                mime := cast(dict[str, Any], info).get("mimetype"),
-                str,
-            )
-            and mime
-        ):
-            return mime
-        mime = getattr(event, "mimetype", None)
-        return mime if isinstance(mime, str) and mime else None
+        info = self._event_source_content(event).get("info")
+        if isinstance(info, dict) and isinstance(m := info.get("mimetype"), str) and m:
+            return m
+        m = getattr(event, "mimetype", None)
+        return m if isinstance(m, str) and m else None
 
     def _event_filename(self, event: MatrixMediaEvent, attachment_type: str) -> str:
         body = getattr(event, "body", None)
@@ -1033,21 +973,9 @@ class MatrixChannel(BaseChannel):
 
     def _decrypt_media_bytes(self, event: MatrixMediaEvent, ciphertext: bytes) -> bytes | None:
         key_obj, hashes, iv = getattr(event, "key", None), getattr(event, "hashes", None), getattr(event, "iv", None)
-        key = (
-            cast(dict[str, Any], key_obj).get("k")
-            if isinstance(key_obj, dict)
-            else None
-        )
-        sha256 = (
-            cast(dict[str, Any], hashes).get("sha256")
-            if isinstance(hashes, dict)
-            else None
-        )
-        if (
-            not isinstance(key, str)
-            or not isinstance(sha256, str)
-            or not isinstance(iv, str)
-        ):
+        key = key_obj.get("k") if isinstance(key_obj, dict) else None
+        sha256 = hashes.get("sha256") if isinstance(hashes, dict) else None
+        if not all(isinstance(v, str) for v in (key, sha256, iv)):
             return None
         try:
             return decrypt_attachment(ciphertext, key, sha256, iv)

nanobot/channels/mattermost/runtime.py

@@ -6,7 +6,7 @@ import asyncio
 import json
 import re
 from pathlib import Path
-from typing import Any, cast
+from typing import Any
 
 import httpx
 from pydantic import Field
@@ -86,7 +86,7 @@ class MattermostChannel(BaseChannel):
         self._server_url = config.server_url.rstrip("/")
         self._ws_url = _server_url_to_ws_url(self._server_url)
         self._http_client: httpx.AsyncClient | None = None
-        self._ws_task: asyncio.Task[None] | None = None
+        self._ws_task: asyncio.Task | None = None
         self._self_id: str | None = None
         self._self_username: str | None = None
         self._self_email: str | None = None
@@ -118,7 +118,7 @@ class MattermostChannel(BaseChannel):
         try:
             resp = await self._http_client.get("/api/v4/users/me")
             resp.raise_for_status()
-            me = cast(dict[str, Any], resp.json())
+            me = resp.json()
             self._self_id = me.get("id")
             self._self_username = me.get("username")
             self._self_email = me.get("email", "")
@@ -169,7 +169,7 @@ class MattermostChannel(BaseChannel):
                     self.logger.debug("websocket connected")
                     delay = MATTERMOST_WS_RECONNECT_BASE_DELAY
                     async for raw in ws:
-                        await self._handle_ws_message(cast(dict[str, Any], json.loads(raw)))
+                        await self._handle_ws_message(json.loads(raw))
             except asyncio.CancelledError:
                 break
             except Exception as e:
@@ -191,15 +191,12 @@ class MattermostChannel(BaseChannel):
     # Event: posted ------------------------------------------------------------
 
     async def _handle_posted_event(self, msg: dict[str, Any]) -> None:
-        data = cast(dict[str, Any], msg.get("data", {}))
-        broadcast = cast(dict[str, Any], msg.get("broadcast", {}))
+        data = msg.get("data", {})
+        broadcast = msg.get("broadcast", {})
 
         raw_post = data.get("post", "{}")
         try:
-            post = cast(
-                dict[str, Any],
-                json.loads(raw_post) if isinstance(raw_post, str) else raw_post,
-            )
+            post = json.loads(raw_post) if isinstance(raw_post, str) else raw_post
         except json.JSONDecodeError:
             self.logger.warning("failed to parse post json")
             return
@@ -209,7 +206,7 @@ class MattermostChannel(BaseChannel):
         message_text = post.get("message", "")
         root_id = post.get("root_id", "") or ""
         post_id = post.get("id", "")
-        file_ids = cast(list[str], post.get("file_ids", []))
+        file_ids: list[str] = post.get("file_ids", [])
 
         if self._self_id and sender_id == self._self_id:
             return
@@ -295,11 +292,11 @@ class MattermostChannel(BaseChannel):
     # Event: action ------------------------------------------------------------
 
     async def _handle_action_event(self, msg: dict[str, Any]) -> None:
-        data = cast(dict[str, Any], msg.get("data", {}))
+        data = msg.get("data", {})
         sender_id = data.get("user_id", "")
         channel_id = data.get("channel_id", "")
-        context = cast(dict[str, Any], data.get("context", {}) or {})
-        value = cast(str, context.get("selected_option", ""))
+        context = data.get("context", {}) or {}
+        value = context.get("selected_option", "")
 
         if not sender_id or not channel_id or not value:
             return
@@ -322,13 +319,10 @@ class MattermostChannel(BaseChannel):
     # Event: post_deleted ------------------------------------------------------
 
     async def _handle_post_deleted_event(self, msg: dict[str, Any]) -> None:
-        data = cast(dict[str, Any], msg.get("data", {}))
+        data = msg.get("data", {})
         raw_post = data.get("post", "{}")
         try:
-            post = cast(
-                dict[str, Any],
-                json.loads(raw_post) if isinstance(raw_post, str) else raw_post,
-            )
+            post = json.loads(raw_post) if isinstance(raw_post, str) else raw_post
         except json.JSONDecodeError:
             return
         post_id = post.get("id", "")
@@ -369,15 +363,15 @@ class MattermostChannel(BaseChannel):
             return chat_id in self.config.group_allow_from
         return False
 
-    _bot_mention_re: re.Pattern[str] | None = None
+    _BOT_MENTION_RE: re.Pattern | None = None
 
     def _is_mentioned(self, text: str) -> bool:
         if not self._self_username:
             return False
-        if self._bot_mention_re is None:
+        if self._BOT_MENTION_RE is None:
             pat = r"(?<![@\w])@" + re.escape(self._self_username) + r"(?![@\w])"
-            self._bot_mention_re = re.compile(pat)
-        return bool(self._bot_mention_re.search(text))
+            self._BOT_MENTION_RE = re.compile(pat)
+        return bool(self._BOT_MENTION_RE.search(text))
 
     def _strip_bot_mention(self, text: str) -> str:
         if not text or not self._self_username:
@@ -438,8 +432,8 @@ class MattermostChannel(BaseChannel):
             self.logger.warning("thread context unavailable for {}: {}", key, e)
             return text
 
-        posts = cast(dict[str, dict[str, Any]], data.get("posts", {}))
-        order = cast(list[str], data.get("order", []))
+        posts = data.get("posts", {})
+        order = data.get("order", [])
         if not order:
             return text
 
@@ -473,11 +467,8 @@ class MattermostChannel(BaseChannel):
         try:
             chat_id = msg.chat_id
             meta = msg.metadata or {}
-            mm_meta = cast(dict[str, Any], meta.get("mattermost", {}) or {})
-            root_id = cast(
-                str | None,
-                mm_meta.get("root_id") or mm_meta.get("thread_ts") or meta.get("root_id"),
-            )
+            mm_meta = meta.get("mattermost", {}) or {}
+            root_id = mm_meta.get("root_id") or mm_meta.get("thread_ts") or meta.get("root_id")
 
             file_ids: list[str] = []
             for media_path in msg.media or []:
@@ -530,7 +521,7 @@ class MattermostChannel(BaseChannel):
             return
 
         meta = metadata or {}
-        stream_id = cast(str, stream_id or meta.get("_stream_id") or chat_id)
+        stream_id = stream_id or meta.get("_stream_id") or chat_id
         stream_end = stream_end or bool(meta.get("_stream_end"))
         resuming = resuming or bool(meta.get("_resuming"))
 
@@ -550,17 +541,13 @@ class MattermostChannel(BaseChannel):
                 return
 
             if final and not meta.get("_progress"):
-                mm_meta = (
-                    cast(dict[str, Any], meta.get("mattermost", {}) or {})
-                    if isinstance(meta.get("mattermost"), dict)
-                    else {}
-                )
-                root_id = cast(str | None, (
+                mm_meta = (meta.get("mattermost", {}) or {}) if isinstance(meta.get("mattermost"), dict) else {}
+                root_id = (
                     mm_meta.get("root_id")
                     or mm_meta.get("thread_ts")
                     or meta.get("root_id")
                     or self._stream_root_ids.get(stream_id)
-                ))
+                )
                 chunks = split_message(final, MATTERMOST_MAX_MESSAGE_LEN)
                 first_post_id: str | None = None
                 try:
@@ -592,15 +579,8 @@ class MattermostChannel(BaseChannel):
         if not delta.strip():
             return
 
-        mm_meta = (
-            cast(dict[str, Any], meta.get("mattermost", {}) or {})
-            if isinstance(meta.get("mattermost"), dict)
-            else {}
-        )
-        root_id = cast(
-            str | None,
-            mm_meta.get("root_id") or mm_meta.get("thread_ts") or meta.get("root_id"),
-        )
+        mm_meta = (meta.get("mattermost", {}) or {}) if isinstance(meta.get("mattermost"), dict) else {}
+        root_id = mm_meta.get("root_id") or mm_meta.get("thread_ts") or meta.get("root_id")
         if root_id:
             self._stream_root_ids[stream_id] = root_id
         committed = self._stream_committed.get(stream_id, "")
@@ -618,25 +598,20 @@ class MattermostChannel(BaseChannel):
 
     # API helpers ---------------------------------------------------------------
 
-    def _require_http_client(self) -> httpx.AsyncClient:
-        if self._http_client is None:
-            raise RuntimeError("Mattermost client is not started")
-        return self._http_client
-
     async def _api_get(self, path: str) -> dict[str, Any]:
-        resp = await self._require_http_client().get(path)
+        resp = await self._http_client.get(path)
         resp.raise_for_status()
-        return cast(dict[str, Any], resp.json())
+        return resp.json()
 
     async def _api_post(self, path: str, json_data: dict[str, Any]) -> dict[str, Any]:
-        resp = await self._require_http_client().post(path, json=json_data)
+        resp = await self._http_client.post(path, json=json_data)
         resp.raise_for_status()
-        return cast(dict[str, Any], resp.json())
+        return resp.json()
 
     async def _api_put(self, path: str, json_data: dict[str, Any]) -> dict[str, Any]:
-        resp = await self._require_http_client().put(path, json=json_data)
+        resp = await self._http_client.put(path, json=json_data)
         resp.raise_for_status()
-        return cast(dict[str, Any], resp.json())
+        return resp.json()
 
     async def _create_post(
         self,
@@ -667,14 +642,14 @@ class MattermostChannel(BaseChannel):
 
         try:
             files = {"files": (path.name, path.read_bytes())}
-            resp = await self._require_http_client().post(
+            resp = await self._http_client.post(
                 "/api/v4/files",
                 data={"channel_id": channel_id},
                 files=files,
             )
             resp.raise_for_status()
-            data = cast(dict[str, Any], resp.json())
-            infos = cast(list[dict[str, Any]], data.get("file_infos", []))
+            data = resp.json()
+            infos = data.get("file_infos", [])
             if infos:
                 return infos[0].get("id")
         except Exception as e:
@@ -683,15 +658,14 @@ class MattermostChannel(BaseChannel):
 
     async def _download_file(self, file_id: str) -> str | None:
         try:
-            client = self._require_http_client()
-            info_resp = await client.get(f"/api/v4/files/{file_id}/info")
+            info_resp = await self._http_client.get(f"/api/v4/files/{file_id}/info")
             info_resp.raise_for_status()
-            info = cast(dict[str, Any], info_resp.json())
+            info = info_resp.json()
             name = Path(info.get("name", file_id)).name
             out = Path(get_media_dir("mattermost")) / safe_filename(f"{file_id}_{name}")
             out.parent.mkdir(parents=True, exist_ok=True)
 
-            dl = await client.get(f"/api/v4/files/{file_id}")
+            dl = await self._http_client.get(f"/api/v4/files/{file_id}")
             dl.raise_for_status()
             out.write_bytes(dl.content)
             return str(out)
@@ -711,7 +685,7 @@ class MattermostChannel(BaseChannel):
     async def _remove_reaction(self, post_id: str, emoji: str) -> None:
         if not self._self_id or not emoji:
             return
-        resp = await self._require_http_client().delete(
+        resp = await self._http_client.delete(
             f"/api/v4/users/{self._self_id}/posts/{post_id}/reactions/{emoji}",
         )
         if resp.status_code >= 400:

nanobot/channels/mochat/runtime.py

@@ -1,4 +1,3 @@
-# pyright: reportConstantRedefinition=false, reportMissingTypeStubs=false
 """Mochat channel implementation using Socket.IO with HTTP polling fallback."""
 
 from __future__ import annotations
@@ -6,11 +5,10 @@ from __future__ import annotations
 import asyncio
 import json
 from collections import deque
-from collections.abc import Awaitable, Callable
 from contextlib import suppress
 from dataclasses import dataclass, field
 from datetime import datetime
-from typing import Any, cast
+from typing import Any
 
 import httpx
 from pydantic import Field
@@ -29,7 +27,7 @@ except ImportError:
     SOCKETIO_AVAILABLE = False
 
 try:
-    import msgpack  # noqa: F401  # pyright: ignore[reportUnusedImport]
+    import msgpack  # noqa: F401
     MSGPACK_AVAILABLE = True
 except ImportError:
     MSGPACK_AVAILABLE = False
@@ -59,7 +57,7 @@ class DelayState:
     """Per-target delayed message state."""
     entries: list[MochatBufferedEntry] = field(default_factory=list)
     lock: asyncio.Lock = field(default_factory=asyncio.Lock)
-    timer: asyncio.Task[None] | None = None
+    timer: asyncio.Task | None = None
 
 
 @dataclass
@@ -73,12 +71,12 @@ class MochatTarget:
 # Pure helpers
 # ---------------------------------------------------------------------------
 
-def _safe_dict(value: Any) -> dict[str, Any]:
+def _safe_dict(value: Any) -> dict:
     """Return *value* if it's a dict, else empty dict."""
-    return cast(dict[str, Any], value) if isinstance(value, dict) else {}
+    return value if isinstance(value, dict) else {}
 
 
-def _str_field(src: dict[str, Any], *keys: str) -> str:
+def _str_field(src: dict, *keys: str) -> str:
     """Return the first non-empty str value found for *keys*, stripped."""
     for k in keys:
         v = src.get(k)
@@ -102,7 +100,7 @@ def _make_synthetic_event(
         payload["authorInfo"] = _safe_dict(author_info)
     return {
         "type": "message.add",
-        "timestamp": timestamp or datetime.utcnow().isoformat(),  # pyright: ignore[reportDeprecated]
+        "timestamp": timestamp or datetime.utcnow().isoformat(),
         "payload": payload,
     }
 
@@ -143,12 +141,11 @@ def extract_mention_ids(value: Any) -> list[str]:
     if not isinstance(value, list):
         return []
     ids: list[str] = []
-    for item in cast(list[object], value):
+    for item in value:
         if isinstance(item, str):
             if item.strip():
                 ids.append(item.strip())
         elif isinstance(item, dict):
-            item = cast(dict[str, Any], item)
             for key in ("id", "userId", "_id"):
                 candidate = item.get(key)
                 if isinstance(candidate, str) and candidate.strip():
@@ -161,7 +158,6 @@ def resolve_was_mentioned(payload: dict[str, Any], agent_user_id: str) -> bool:
     """Resolve mention state from payload metadata and text fallback."""
     meta = payload.get("meta")
     if isinstance(meta, dict):
-        meta = cast(dict[str, Any], meta)
         if meta.get("mentioned") is True or meta.get("wasMentioned") is True:
             return True
         for f in ("mentions", "mentionIds", "mentionedUserIds", "mentionedUsers"):
@@ -282,7 +278,7 @@ class MochatChannel(BaseChannel):
         self._state_dir = get_runtime_subdir("mochat")
         self._cursor_path = self._state_dir / "session_cursors.json"
         self._session_cursor: dict[str, int] = {}
-        self._cursor_save_task: asyncio.Task[None] | None = None
+        self._cursor_save_task: asyncio.Task | None = None
 
         self._session_set: set[str] = set()
         self._panel_set: set[str] = set()
@@ -296,9 +292,9 @@ class MochatChannel(BaseChannel):
         self._delay_states: dict[str, DelayState] = {}
 
         self._fallback_mode = False
-        self._session_fallback_tasks: dict[str, asyncio.Task[None]] = {}
-        self._panel_fallback_tasks: dict[str, asyncio.Task[None]] = {}
-        self._refresh_task: asyncio.Task[None] | None = None
+        self._session_fallback_tasks: dict[str, asyncio.Task] = {}
+        self._panel_fallback_tasks: dict[str, asyncio.Task] = {}
+        self._refresh_task: asyncio.Task | None = None
         self._target_locks: dict[str, asyncio.Lock] = {}
 
     # ---- lifecycle ---------------------------------------------------------
@@ -356,11 +352,7 @@ class MochatChannel(BaseChannel):
 
         parts = ([msg.content.strip()] if msg.content and msg.content.strip() else [])
         if msg.media:
-            parts.extend(
-                m
-                for m in msg.media
-                if isinstance(cast(object, m), str) and m.strip()
-            )
+            parts.extend(m for m in msg.media if isinstance(m, str) and m.strip())
         content = "\n".join(parts).strip()
         if not content:
             return
@@ -412,8 +404,7 @@ class MochatChannel(BaseChannel):
             else:
                 self.logger.warning("msgpack not installed but socket_disable_msgpack=false; using JSON")
 
-        socketio_module = cast(Any, socketio)
-        client: Any = socketio_module.AsyncClient(
+        client = socketio.AsyncClient(
             reconnection=True,
             reconnection_attempts=self.config.max_retry_attempts or None,
             reconnection_delay=max(0.1, self.config.socket_reconnect_delay_ms / 1000.0),
@@ -421,6 +412,7 @@ class MochatChannel(BaseChannel):
             logger=False, engineio_logger=False, serializer=serializer,
         )
 
+        @client.event
         async def connect() -> None:
             self._ws_connected, self._ws_ready = True, False
             self.logger.info("websocket connected")
@@ -428,6 +420,7 @@ class MochatChannel(BaseChannel):
             self._ws_ready = subscribed
             await (self._stop_fallback_workers() if subscribed else self._ensure_fallback_workers())
 
+        @client.event
         async def disconnect() -> None:
             if not self._running:
                 return
@@ -435,21 +428,18 @@ class MochatChannel(BaseChannel):
             self.logger.warning("websocket disconnected")
             await self._ensure_fallback_workers()
 
+        @client.event
         async def connect_error(data: Any) -> None:
             self.logger.error("websocket connect error: {}", data)
 
+        @client.on("claw.session.events")
         async def on_session_events(payload: dict[str, Any]) -> None:
             await self._handle_watch_payload(payload, "session")
 
+        @client.on("claw.panel.events")
         async def on_panel_events(payload: dict[str, Any]) -> None:
             await self._handle_watch_payload(payload, "panel")
 
-        client.event(connect)
-        client.event(disconnect)
-        client.event(connect_error)
-        client.on("claw.session.events", on_session_events)
-        client.on("claw.panel.events", on_panel_events)
-
         for ev in ("notify:chat.inbox.append", "notify:chat.message.add",
                     "notify:chat.message.update", "notify:chat.message.recall",
                     "notify:chat.message.delete"):
@@ -473,10 +463,7 @@ class MochatChannel(BaseChannel):
             self._socket = None
             return False
 
-    def _build_notify_handler(
-        self,
-        event_name: str,
-    ) -> Callable[[Any], Awaitable[None]]:
+    def _build_notify_handler(self, event_name: str):
         async def handler(payload: Any) -> None:
             if event_name == "notify:chat.inbox.append":
                 await self._handle_notify_inbox_append(payload)
@@ -511,20 +498,11 @@ class MochatChannel(BaseChannel):
         data = ack.get("data")
         items: list[dict[str, Any]] = []
         if isinstance(data, list):
-            items = [
-                cast(dict[str, Any], item)
-                for item in cast(list[object], data)
-                if isinstance(item, dict)
-            ]
+            items = [i for i in data if isinstance(i, dict)]
         elif isinstance(data, dict):
-            data = cast(dict[str, Any], data)
             sessions = data.get("sessions")
             if isinstance(sessions, list):
-                items = [
-                    cast(dict[str, Any], item)
-                    for item in cast(list[object], sessions)
-                    if isinstance(item, dict)
-                ]
+                items = [i for i in sessions if isinstance(i, dict)]
             elif "sessionId" in data:
                 items = [data]
         for p in items:
@@ -547,11 +525,7 @@ class MochatChannel(BaseChannel):
             raw = await self._socket.call(event_name, payload, timeout=10)
         except Exception as e:
             return {"result": False, "message": str(e)}
-        return (
-            cast(dict[str, Any], raw)
-            if isinstance(raw, dict)
-            else {"result": True, "data": raw}
-        )
+        return raw if isinstance(raw, dict) else {"result": True, "data": raw}
 
     # ---- refresh / discovery -----------------------------------------------
 
@@ -584,11 +558,10 @@ class MochatChannel(BaseChannel):
             return
 
         new_ids: list[str] = []
-        for session_value in cast(list[object], sessions):
-            if not isinstance(session_value, dict):
+        for s in sessions:
+            if not isinstance(s, dict):
                 continue
-            session = cast(dict[str, Any], session_value)
-            sid = _str_field(session, "sessionId")
+            sid = _str_field(s, "sessionId")
             if not sid:
                 continue
             if sid not in self._session_set:
@@ -596,7 +569,7 @@ class MochatChannel(BaseChannel):
                 new_ids.append(sid)
                 if sid not in self._session_cursor:
                     self._cold_sessions.add(sid)
-            cid = _str_field(session, "converseId")
+            cid = _str_field(s, "converseId")
             if cid:
                 self._session_by_converse[cid] = sid
 
@@ -619,14 +592,13 @@ class MochatChannel(BaseChannel):
             return
 
         new_ids: list[str] = []
-        for panel_value in cast(list[object], raw_panels):
-            if not isinstance(panel_value, dict):
+        for p in raw_panels:
+            if not isinstance(p, dict):
                 continue
-            panel = cast(dict[str, Any], panel_value)
-            pt = panel.get("type")
+            pt = p.get("type")
             if isinstance(pt, int) and pt != 0:
                 continue
-            pid = _str_field(panel, "id", "_id")
+            pid = _str_field(p, "id", "_id")
             if pid and pid not in self._panel_set:
                 self._panel_set.add(pid)
                 new_ids.append(pid)
@@ -686,19 +658,16 @@ class MochatChannel(BaseChannel):
                 })
                 msgs = resp.get("messages")
                 if isinstance(msgs, list):
-                    for message_value in reversed(cast(list[object], msgs)):
-                        if not isinstance(message_value, dict):
+                    for m in reversed(msgs):
+                        if not isinstance(m, dict):
                             continue
-                        message = cast(dict[str, Any], message_value)
                         evt = _make_synthetic_event(
-                            message_id=str(message.get("messageId") or ""),
-                            author=str(message.get("author") or ""),
-                            content=message.get("content"),
-                            meta=message.get("meta"),
-                            group_id=str(resp.get("groupId") or ""),
-                            converse_id=panel_id,
-                            timestamp=message.get("createdAt"),
-                            author_info=message.get("authorInfo"),
+                            message_id=str(m.get("messageId") or ""),
+                            author=str(m.get("author") or ""),
+                            content=m.get("content"),
+                            meta=m.get("meta"), group_id=str(resp.get("groupId") or ""),
+                            converse_id=panel_id, timestamp=m.get("createdAt"),
+                            author_info=m.get("authorInfo"),
                         )
                         await self._process_inbound_event(panel_id, evt, "panel")
             except asyncio.CancelledError:
@@ -710,7 +679,7 @@ class MochatChannel(BaseChannel):
     # ---- inbound event processing ------------------------------------------
 
     async def _handle_watch_payload(self, payload: dict[str, Any], target_kind: str) -> None:
-        if not isinstance(cast(object, payload), dict):
+        if not isinstance(payload, dict):
             return
         target_id = _str_field(payload, "sessionId")
         if not target_id:
@@ -730,10 +699,9 @@ class MochatChannel(BaseChannel):
                 self._cold_sessions.discard(target_id)
                 return
 
-            for event_value in cast(list[object], raw_events):
-                if not isinstance(event_value, dict):
+            for event in raw_events:
+                if not isinstance(event, dict):
                     continue
-                event = cast(dict[str, Any], event_value)
                 seq = event.get("seq")
                 if target_kind == "session" and isinstance(seq, int) and seq > self._session_cursor.get(target_id, prev):
                     self._mark_session_cursor(target_id, seq)
@@ -744,7 +712,6 @@ class MochatChannel(BaseChannel):
         payload = event.get("payload")
         if not isinstance(payload, dict):
             return
-        payload = cast(dict[str, Any], payload)
 
         author = _str_field(payload, "author")
         if not author or (self.config.agent_user_id and author == self.config.agent_user_id):
@@ -854,7 +821,6 @@ class MochatChannel(BaseChannel):
     async def _handle_notify_chat_message(self, payload: Any) -> None:
         if not isinstance(payload, dict):
             return
-        payload = cast(dict[str, Any], payload)
         group_id = _str_field(payload, "groupId")
         panel_id = _str_field(payload, "converseId", "panelId")
         if not group_id or not panel_id:
@@ -872,15 +838,11 @@ class MochatChannel(BaseChannel):
         await self._process_inbound_event(panel_id, evt, "panel")
 
     async def _handle_notify_inbox_append(self, payload: Any) -> None:
-        if not isinstance(payload, dict):
-            return
-        payload = cast(dict[str, Any], payload)
-        if payload.get("type") != "message":
+        if not isinstance(payload, dict) or payload.get("type") != "message":
             return
         detail = payload.get("payload")
         if not isinstance(detail, dict):
             return
-        detail = cast(dict[str, Any], detail)
         if _str_field(detail, "groupId"):
             return
         converse_id = _str_field(detail, "converseId")
@@ -924,14 +886,9 @@ class MochatChannel(BaseChannel):
         except Exception as e:
             self.logger.warning("Failed to read cursor file: {}", e)
             return
-        data_object = cast(object, data)
-        cursors = (
-            cast(dict[str, Any], data_object).get("cursors")
-            if isinstance(data_object, dict)
-            else None
-        )
+        cursors = data.get("cursors") if isinstance(data, dict) else None
         if isinstance(cursors, dict):
-            for sid, cur in cast(dict[object, object], cursors).items():
+            for sid, cur in cursors.items():
                 if isinstance(sid, str) and isinstance(cur, int) and cur >= 0:
                     self._session_cursor[sid] = cur
 
@@ -939,8 +896,7 @@ class MochatChannel(BaseChannel):
         try:
             self._state_dir.mkdir(parents=True, exist_ok=True)
             self._cursor_path.write_text(json.dumps({
-                "schemaVersion": 1,
-                "updatedAt": datetime.utcnow().isoformat(),  # pyright: ignore[reportDeprecated]
+                "schemaVersion": 1, "updatedAt": datetime.utcnow().isoformat(),
                 "cursors": self._session_cursor,
             }, ensure_ascii=False, indent=2) + "\n", "utf-8")
         except Exception as e:
@@ -961,22 +917,13 @@ class MochatChannel(BaseChannel):
             parsed = response.json()
         except Exception:
             parsed = response.text
-        if isinstance(parsed, dict):
-            parsed_dict = cast(dict[str, Any], parsed)
-            if isinstance(parsed_dict.get("code"), int):
-                if parsed_dict["code"] != 200:
-                    msg = str(
-                        parsed_dict.get("message")
-                        or parsed_dict.get("name")
-                        or "request failed"
-                    )
-                    raise RuntimeError(
-                        f"Mochat API error: {msg} (code={parsed_dict['code']})"
-                    )
-                data = parsed_dict.get("data")
-                return cast(dict[str, Any], data) if isinstance(data, dict) else {}
-            return parsed_dict
-        return {}
+        if isinstance(parsed, dict) and isinstance(parsed.get("code"), int):
+            if parsed["code"] != 200:
+                msg = str(parsed.get("message") or parsed.get("name") or "request failed")
+                raise RuntimeError(f"Mochat API error: {msg} (code={parsed['code']})")
+            data = parsed.get("data")
+            return data if isinstance(data, dict) else {}
+        return parsed if isinstance(parsed, dict) else {}
 
     async def _api_send(self, path: str, id_key: str, id_val: str,
                         content: str, reply_to: str | None, group_id: str | None = None) -> dict[str, Any]:
@@ -990,7 +937,7 @@ class MochatChannel(BaseChannel):
 
     @staticmethod
     def _read_group_id(metadata: dict[str, Any]) -> str | None:
-        if not isinstance(cast(object, metadata), dict):
+        if not isinstance(metadata, dict):
             return None
         value = metadata.get("group_id") or metadata.get("groupId")
         return value.strip() if isinstance(value, str) and value.strip() else None

nanobot/channels/msteams/runtime.py

@@ -23,8 +23,7 @@ import time
 from contextlib import contextmanager, suppress
 from dataclasses import dataclass
 from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
-from pathlib import Path
-from typing import TYPE_CHECKING, Any, Generator, cast
+from typing import TYPE_CHECKING, Any
 from urllib.parse import urlparse
 
 try:  # pragma: no cover - Windows fallback path
@@ -48,11 +47,9 @@ MSTEAMS_AVAILABLE = (
 
 if TYPE_CHECKING:
     import jwt
-    from jwt.algorithms import RSAAlgorithm
 
 if MSTEAMS_AVAILABLE:
     import jwt
-    from jwt.algorithms import RSAAlgorithm
 
 MSTEAMS_REF_TTL_DAYS = 30
 MSTEAMS_WEBCHAT_HOST = "webchat.botframework.com"
@@ -185,10 +182,9 @@ class MSTeamsChannel(BaseChannel):
                 auth_header = self.headers.get("Authorization", "")
                 if channel.config.validate_inbound_auth:
                     try:
-                        loop = cast(asyncio.AbstractEventLoop, channel._loop)
                         fut = asyncio.run_coroutine_threadsafe(
                             channel._validate_inbound_auth(auth_header, payload),
-                            loop,
+                            channel._loop,
                         )
                         fut.result(timeout=15)
                     except Exception as e:
@@ -199,10 +195,9 @@ class MSTeamsChannel(BaseChannel):
                         self.wfile.write(b'{"error":"unauthorized"}')
                         return
                 try:
-                    loop = cast(asyncio.AbstractEventLoop, channel._loop)
                     fut = asyncio.run_coroutine_threadsafe(
                         channel._handle_activity(payload),
-                        loop,
+                        channel._loop,
                     )
                     fut.result(timeout=15)
                 except Exception as e:
@@ -274,7 +269,7 @@ class MSTeamsChannel(BaseChannel):
             "text": msg.content or " ",
         }
         if use_thread_reply:
-            payload["replyToId"] = cast(str, ref.activity_id)
+            payload["replyToId"] = ref.activity_id
 
         try:
             resp = await self._http.post(base_url, headers=headers, json=payload)
@@ -290,10 +285,10 @@ class MSTeamsChannel(BaseChannel):
         if activity.get("type") != "message":
             return
 
-        conversation = cast(dict[str, Any], activity.get("conversation") or {})
-        from_user = cast(dict[str, Any], activity.get("from") or {})
-        recipient = cast(dict[str, Any], activity.get("recipient") or {})
-        channel_data = cast(dict[str, Any], activity.get("channelData") or {})
+        conversation = activity.get("conversation") or {}
+        from_user = activity.get("from") or {}
+        recipient = activity.get("recipient") or {}
+        channel_data = activity.get("channelData") or {}
 
         sender_id = str(from_user.get("aadObjectId") or from_user.get("id") or "").strip()
         conversation_id = str(conversation.get("id") or "").strip()
@@ -341,16 +336,7 @@ class MSTeamsChannel(BaseChannel):
                 bot_id=str(recipient.get("id") or "") or None,
                 activity_id=activity_id or None,
                 conversation_type=conversation_type or None,
-                tenant_id=(
-                    str(
-                        cast(
-                            dict[str, Any],
-                            channel_data.get("tenant") or {},
-                        ).get("id")
-                        or ""
-                    )
-                    or None
-                ),
+                tenant_id=str((channel_data.get("tenant") or {}).get("id") or "") or None,
                 updated_at=time.time(),
             )
             self._save_refs_locked()
@@ -375,7 +361,7 @@ class MSTeamsChannel(BaseChannel):
         text = self._strip_possible_bot_mention(text)
         text = self._normalize_html_whitespace(text)
 
-        channel_data = cast(dict[str, Any], activity.get("channelData") or {})
+        channel_data = activity.get("channelData") or {}
         reply_to_id = str(activity.get("replyToId") or "").strip()
         normalized_preview = html.unescape(text).replace("&rsquo", "’").strip()
         normalized_preview = normalized_preview.replace("\xa0", " ")
@@ -487,15 +473,15 @@ class MSTeamsChannel(BaseChannel):
             raise ValueError("missing token kid")
 
         jwks = await self._get_botframework_jwks()
-        keys = cast(list[dict[str, Any]], jwks.get("keys") or [])
+        keys = jwks.get("keys") or []
         jwk = next((key for key in keys if key.get("kid") == kid), None)
         if not jwk:
             raise ValueError(f"signing key not found for kid={kid}")
 
-        public_key = RSAAlgorithm.from_jwk(json.dumps(jwk))
+        public_key = jwt.algorithms.RSAAlgorithm.from_jwk(json.dumps(jwk))
         claims = jwt.decode(
             token,
-            key=cast(Any, public_key),
+            key=public_key,
             algorithms=["RS256"],
             audience=self.config.app_id,
             issuer="https://api.botframework.com",
@@ -523,10 +509,9 @@ class MSTeamsChannel(BaseChannel):
 
         resp = await self._http.get(self._botframework_openid_config_url)
         resp.raise_for_status()
-        openid_config = cast(dict[str, Any], resp.json())
-        self._botframework_openid_config = openid_config
+        self._botframework_openid_config = resp.json()
         self._botframework_openid_config_expires_at = now + 3600
-        return openid_config
+        return self._botframework_openid_config
 
     async def _get_botframework_jwks(self) -> dict[str, Any]:
         """Fetch and cache Bot Framework JWKS."""
@@ -545,38 +530,36 @@ class MSTeamsChannel(BaseChannel):
 
         resp = await self._http.get(jwks_uri)
         resp.raise_for_status()
-        jwks = cast(dict[str, Any], resp.json())
-        self._botframework_jwks = jwks
+        self._botframework_jwks = resp.json()
         self._botframework_jwks_expires_at = now + 3600
-        return jwks
+        return self._botframework_jwks
 
     @staticmethod
-    def _safe_float(value: object) -> float | None:
+    def _safe_float(value: Any) -> float | None:
         try:
-            out = float(cast(Any, value))
+            out = float(value)
             if out > 0:
                 return out
         except (TypeError, ValueError):
             return None
         return None
 
-    def _normalize_ref_record(self, value: object) -> ConversationRef | None:
+    def _normalize_ref_record(self, value: Any) -> ConversationRef | None:
         """Normalize a stored ref record from legacy/current schema."""
         if not isinstance(value, dict):
             return None
-        record = cast(dict[str, Any], value)
-        service_url = str(record.get("service_url") or "").strip()
-        conversation_id = str(record.get("conversation_id") or "").strip()
+        service_url = str(value.get("service_url") or "").strip()
+        conversation_id = str(value.get("conversation_id") or "").strip()
         if not service_url or not conversation_id:
             return None
         return ConversationRef(
             service_url=service_url,
             conversation_id=conversation_id,
-            bot_id=str(record.get("bot_id") or "") or None,
-            activity_id=str(record.get("activity_id") or "") or None,
-            conversation_type=str(record.get("conversation_type") or "") or None,
-            tenant_id=str(record.get("tenant_id") or "") or None,
-            updated_at=self._safe_float(cast(object, record.get("updated_at"))),
+            bot_id=str(value.get("bot_id") or "") or None,
+            activity_id=str(value.get("activity_id") or "") or None,
+            conversation_type=str(value.get("conversation_type") or "") or None,
+            tenant_id=str(value.get("tenant_id") or "") or None,
+            updated_at=self._safe_float(value.get("updated_at")),
         )
 
     def _load_refs_raw(self) -> tuple[dict[str, Any], dict[str, Any], bool]:
@@ -587,19 +570,17 @@ class MSTeamsChannel(BaseChannel):
 
         if self._refs_path.exists():
             try:
-                loaded: object = json.loads(self._refs_path.read_text(encoding="utf-8"))
+                loaded = json.loads(self._refs_path.read_text(encoding="utf-8"))
                 if isinstance(loaded, dict):
-                    main_data = cast(dict[str, Any], loaded)
+                    main_data = loaded
             except Exception as e:
                 self.logger.warning("Failed to load conversation refs: {}", e)
 
         if meta_exists:
             try:
-                loaded_meta: object = json.loads(
-                    self._refs_meta_path.read_text(encoding="utf-8")
-                )
+                loaded_meta = json.loads(self._refs_meta_path.read_text(encoding="utf-8"))
                 if isinstance(loaded_meta, dict):
-                    meta_data = cast(dict[str, Any], loaded_meta)
+                    meta_data = loaded_meta
             except Exception as e:
                 self.logger.warning("Failed to load conversation refs metadata: {}", e)
 
@@ -618,11 +599,10 @@ class MSTeamsChannel(BaseChannel):
             if not ref:
                 continue
 
-            meta_entry = cast(object, meta_data.get(key))
-            meta_ts: float | None = None
+            meta_entry = meta_data.get(key) if isinstance(meta_data, dict) else None
+            meta_ts = None
             if isinstance(meta_entry, dict):
-                meta_record = cast(dict[str, Any], meta_entry)
-                meta_ts = self._safe_float(cast(object, meta_record.get("updated_at")))
+                meta_ts = self._safe_float(meta_entry.get("updated_at"))
             elif meta_entry is not None:
                 meta_ts = self._safe_float(meta_entry)
 
@@ -643,7 +623,7 @@ class MSTeamsChannel(BaseChannel):
         return self._load_refs_from_disk()
 
     @contextmanager
-    def _refs_file_lock(self) -> Generator[None, None, None]:
+    def _refs_file_lock(self):
         """Cross-process lock while merging and writing refs state."""
         self._refs_path.parent.mkdir(parents=True, exist_ok=True)
         lock_fp = self._refs_lock_path.open("a+", encoding="utf-8")
@@ -762,7 +742,7 @@ class MSTeamsChannel(BaseChannel):
             if persist:
                 self._save_refs_locked()
 
-    def _write_json_atomically(self, path: Path, data: dict[str, Any]) -> None:
+    def _write_json_atomically(self, path, data: dict[str, Any]) -> None:
         """Write refs JSON atomically to reduce corruption risk during crashes."""
         payload = json.dumps(data, indent=2)
         tmp_path: str | None = None
@@ -836,8 +816,7 @@ class MSTeamsChannel(BaseChannel):
         }
         resp = await self._http.post(token_url, data=data)
         resp.raise_for_status()
-        payload = cast(dict[str, Any], resp.json())
-        token = cast(str, payload["access_token"])
-        self._token = token
+        payload = resp.json()
+        self._token = payload["access_token"]
         self._token_expires_at = now + int(payload.get("expires_in", 3600))
-        return token
+        return self._token

nanobot/channels/napcat/runtime.py

@@ -11,7 +11,7 @@ import time
 import uuid
 from collections import deque
 from pathlib import Path
-from typing import Annotated, Any, Literal, cast
+from typing import Annotated, Any, Literal
 
 import aiohttp
 from loguru import logger
@@ -103,7 +103,7 @@ class NapcatChannel(BaseChannel):
                 await asyncio.sleep(next(backoff, 30))
 
     async def _run_once(self) -> None:
-        headers: list[tuple[str, str]] = []
+        headers = []
         if self.config.access_token:
             headers.append(("Authorization", f"Bearer {self.config.access_token}"))
 
@@ -132,17 +132,12 @@ class NapcatChannel(BaseChannel):
                         payload = json.loads(raw)
                     except json.JSONDecodeError:
                         continue
-                    if isinstance(payload, dict):
-                        login_payload = cast(dict[str, Any], payload)
-                    else:
-                        login_payload = None
-                    if login_payload is not None and login_payload.get("echo") == echo:
-                        data = login_payload.get("data")
-                        login_data = cast(dict[str, Any], data) if isinstance(data, dict) else {}
+                    if isinstance(payload, dict) and payload.get("echo") == echo:
+                        data = payload.get("data") or {}
                         logger.info(
                             "napcat: logged in as {} (user_id={})",
-                            login_data.get("nickname"),
-                            login_data.get("user_id"),
+                            data.get("nickname"),
+                            data.get("user_id"),
                         )
                         break
                     await self._dispatch_frame(raw)
@@ -194,27 +189,26 @@ class NapcatChannel(BaseChannel):
             return
         if not isinstance(payload, dict):
             return
-        frame = cast(dict[str, Any], payload)
 
         # Action response: identified by `echo` and absence of post_type.
-        if "echo" in frame and frame.get("post_type") is None:
-            echo = frame.get("echo")
+        if "echo" in payload and payload.get("post_type") is None:
+            echo = payload.get("echo")
             fut = self._pending.pop(echo, None) if isinstance(echo, str) else None
             if fut and not fut.done():
-                fut.set_result(frame)
+                fut.set_result(payload)
             return
 
-        if (sid := frame.get("self_id")) is not None:
+        if (sid := payload.get("self_id")) is not None:
             try:
                 self._self_id = int(sid)
             except (TypeError, ValueError):
                 pass
 
-        post_type = frame.get("post_type")
+        post_type = payload.get("post_type")
         if post_type == "message":
-            self._create_background_task(self._on_message(frame), "message")
+            self._create_background_task(self._on_message(payload), "message")
         elif post_type == "notice":
-            self._create_background_task(self._on_notice(frame), "notice")
+            self._create_background_task(self._on_notice(payload), "notice")
 
     def _create_background_task(self, coro: Any, kind: str) -> None:
         task = asyncio.create_task(coro)
@@ -255,8 +249,7 @@ class NapcatChannel(BaseChannel):
             if local := await self._download_image(info):
                 media_paths.append(local)
 
-        sender_raw = ev.get("sender")
-        sender = cast(dict[str, Any], sender_raw) if isinstance(sender_raw, dict) else {}
+        sender = ev.get("sender") or {}
         nickname = sender.get("card") or sender.get("nickname")
 
         if message_type == "group":
@@ -277,7 +270,7 @@ class NapcatChannel(BaseChannel):
             chat_id = f"group:{group_id}"
             content = self._format_group_content(
                 text=text,
-                nickname=cast(str, nickname),
+                nickname=nickname,
                 user_id=user_id,
             )
         else:
@@ -306,7 +299,7 @@ class NapcatChannel(BaseChannel):
         # segment rather than parsing CQ codes — that path is fragile and
         # users can configure napcat to emit arrays.
         if isinstance(message, list):
-            return [cast(dict[str, Any], seg) for seg in cast(list[Any], message) if isinstance(seg, dict)]
+            return [seg for seg in message if isinstance(seg, dict)]
         if isinstance(message, str) and message:
             return [{"type": "text", "data": {"text": message}}]
         return []
@@ -322,8 +315,7 @@ class NapcatChannel(BaseChannel):
 
         for seg in segments:
             stype = seg.get("type")
-            raw_data = seg.get("data")
-            data = cast(dict[str, Any], raw_data) if isinstance(raw_data, dict) else {}
+            data = seg.get("data") or {}
             if stype == "text":
                 if txt := data.get("text"):
                     parts.append(str(txt))
@@ -463,8 +455,7 @@ class NapcatChannel(BaseChannel):
             params["user_id"] = int(target)
 
         resp = await self._call_action("send_msg", params)
-        raw_data = resp.get("data")
-        data = cast(dict[str, Any], raw_data) if isinstance(raw_data, dict) else {}
+        data = resp.get("data") or {}
         if (mid := data.get("message_id")) is not None:
             self._bot_outbound_ids.append(int(mid))
 

nanobot/channels/plugin.py

@@ -7,7 +7,7 @@ import re
 from dataclasses import dataclass
 from functools import lru_cache
 from importlib.resources import files
-from typing import TYPE_CHECKING, Any, cast
+from typing import TYPE_CHECKING, Any
 
 from packaging.requirements import InvalidRequirement, Requirement
 
@@ -49,12 +49,12 @@ class ChannelPlugin:
         _target_parts(self.runtime, label="runtime")
         if self.connector is not None:
             _target_parts(self.connector, label="connector")
-        if self.setup is not None and not isinstance(cast(object, self.setup), ChannelSetupSpec):
+        if self.setup is not None and not isinstance(self.setup, ChannelSetupSpec):
             raise TypeError("channel plugin setup must be a ChannelSetupSpec or None")
-        if not isinstance(cast(object, self.management), ChannelManagementSpec):
+        if not isinstance(self.management, ChannelManagementSpec):
             raise TypeError("channel plugin management must be a ChannelManagementSpec")
-        if not isinstance(cast(object, self.dependencies), tuple) or not all(
-            isinstance(cast(object, requirement), str) and requirement.strip()
+        if not isinstance(self.dependencies, tuple) or not all(
+            isinstance(requirement, str) and requirement.strip()
             for requirement in self.dependencies
         ):
             raise TypeError("channel plugin dependencies must be a tuple of requirements")

nanobot/channels/qq/runtime.py

@@ -16,8 +16,6 @@ Notes:
 - Attachment structures differ across botpy versions; we try multiple field candidates.
 """
 
-# pyright: reportConstantRedefinition=false, reportMissingTypeStubs=false, reportPrivateUsage=false
-
 from __future__ import annotations
 
 import asyncio
@@ -29,7 +27,7 @@ import time
 from collections import deque
 from contextlib import suppress
 from pathlib import Path
-from typing import Any, BinaryIO, Literal, cast
+from typing import TYPE_CHECKING, Any, Literal
 from urllib.parse import unquote, urlparse
 
 import aiohttp
@@ -60,6 +58,11 @@ except ImportError:  # pragma: no cover
     BotWebSocket = None
     Route = None
 
+if TYPE_CHECKING:
+    from botpy.message import BaseMessage, C2CMessage, GroupMessage
+    from botpy.types.message import Media
+
+
 # QQ rich media file_type: 1=image, 4=file
 # (2=voice, 3=video are restricted; we only use image vs file)
 QQ_FILE_TYPE_IMAGE = 1
@@ -115,34 +118,30 @@ def _is_network_error(exc: BaseException) -> bool:
     )
 
 
-def _make_bot_class(channel: QQChannel) -> type[Any]:
+def _make_bot_class(channel: QQChannel) -> type[botpy.Client]:
     """Create a botpy client with per-session reconnect backoff."""
-    botpy_sdk = cast(Any, botpy)
-    intents = botpy_sdk.Intents(public_messages=True, direct_message=True)
+    intents = botpy.Intents(public_messages=True, direct_message=True)
 
-    class _Bot(botpy_sdk.Client):
+    class _Bot(botpy.Client):
         def __init__(self):
             # Disable botpy's file log — nanobot uses loguru; default "botpy.log" fails on read-only fs
-            super().__init__(  # pyright: ignore[reportUnknownMemberType]
-                intents=intents,
-                ext_handlers=False,
-            )
+            super().__init__(intents=intents, ext_handlers=False)
             self._ws_backoff: dict[int, int] = {}
             self._ws_retry_at: dict[int, float] = {}
 
         async def on_ready(self):
             logger.info("QQ bot ready: {}", self.robot.name)
 
-        async def on_c2c_message_create(self, message: object) -> None:
+        async def on_c2c_message_create(self, message: C2CMessage):
             await channel._on_message(message, is_group=False)
 
-        async def on_group_at_message_create(self, message: object) -> None:
+        async def on_group_at_message_create(self, message: GroupMessage):
             await channel._on_message(message, is_group=True)
 
-        async def on_direct_message_create(self, message: object) -> None:
+        async def on_direct_message_create(self, message):
             await channel._on_message(message, is_group=False)
 
-        async def bot_connect(self, session: object) -> None:
+        async def bot_connect(self, session):
             """Connect a botpy session with exponential retry backoff."""
             session_id = id(session)
             retry_at = self._ws_retry_at.pop(session_id, None)
@@ -151,8 +150,7 @@ def _make_bot_class(channel: QQChannel) -> type[Any]:
                 if remaining > 0:
                     await asyncio.sleep(remaining)
 
-            websocket_class = cast(Any, BotWebSocket)
-            client = websocket_class(session, self._connection)
+            client = BotWebSocket(session, self._connection)
             backoff = self._ws_backoff.get(session_id, _RECONNECT_BACKOFF_START)
             try:
                 await client.ws_connect()
@@ -209,7 +207,7 @@ class QQChannel(BaseChannel):
         super().__init__(config, bus)
         self.config: QQConfig = config
 
-        self._client: Any | None = None
+        self._client: botpy.Client | None = None
         self._http: aiohttp.ClientSession | None = None
 
         self._processed_ids: deque[str] = deque(maxlen=1000)
@@ -262,8 +260,7 @@ class QQChannel(BaseChannel):
         max_backoff = 300
         while self._running:
             try:
-                client = cast(Any, self._client)
-                await client.start(appid=self.config.app_id, secret=self.config.secret)
+                await self._client.start(appid=self.config.app_id, secret=self.config.secret)
                 backoff = 5
             except Exception as e:
                 if _is_network_error(e):
@@ -493,7 +490,7 @@ class QQChannel(BaseChannel):
         file_data: str,
         file_name: str | None = None,
         srv_send_msg: bool = False,
-    ) -> dict[str, Any]:
+    ) -> Media:
         """Upload base64-encoded file and return Media object."""
         if not self._client:
             raise RuntimeError("QQ client not initialized")
@@ -517,44 +514,39 @@ class QQChannel(BaseChannel):
         if file_type != QQ_FILE_TYPE_IMAGE and file_name:
             payload["file_name"] = file_name
 
-        route_class = cast(Any, Route)
-        route = route_class("POST", endpoint, **{id_key: chat_id})
-        client = self._client
-        result: object = await client.api._http.request(route, json=payload)
+        route = Route("POST", endpoint, **{id_key: chat_id})
+        result = await self._client.api._http.request(route, json=payload)
 
         # Extract only the file_info field to avoid extra fields (file_uuid, ttl, etc.)
         # that may confuse QQ client when sending the media object.
         if isinstance(result, dict) and "file_info" in result:
-            result_data = cast(dict[str, Any], result)
-            return {"file_info": result_data["file_info"]}
-        return cast(dict[str, Any], result)
+            return {"file_info": result["file_info"]}
+        return result
 
     # ---------------------------
     # Inbound (receive)
     # ---------------------------
 
-    async def _on_message(self, data: object, is_group: bool = False) -> None:
+    async def _on_message(self, data: C2CMessage | GroupMessage, is_group: bool = False) -> None:
         """Parse inbound message, download attachments, and publish to the bus."""
         try:
-            message = cast(Any, data)
             if is_group:
-                chat_id = cast(str, message.group_openid)
-                user_id = cast(str, message.author.member_openid)
+                chat_id = data.group_openid
+                user_id = data.author.member_openid
                 chat_type = "group"
             else:
                 chat_id = str(
-                    getattr(message.author, "id", None)
-                    or getattr(message.author, "user_openid", "unknown")
+                    getattr(data.author, "id", None)
+                    or getattr(data.author, "user_openid", "unknown")
                 )
                 user_id = chat_id
                 chat_type = "c2c"
 
-            content = str(message.content or "").strip()
+            content = (data.content or "").strip()
 
-            message_id = cast(str, message.id)
-            if message_id in self._processed_ids:
+            if data.id in self._processed_ids:
                 return
-            self._processed_ids.append(message_id)
+            self._processed_ids.append(data.id)
             self._chat_type_cache[chat_id] = chat_type
 
             # Early permission check — avoid attachment downloads and ack side effects
@@ -572,10 +564,7 @@ class QQChannel(BaseChannel):
 
             # the data used by tests don't contain attachments property
             # so we use getattr with a default of [] to avoid AttributeError in tests
-            attachments = cast(
-                list[object],
-                getattr(message, "attachments", None) or [],
-            )
+            attachments = getattr(data, "attachments", None) or []
             media_paths, recv_lines, att_meta = await self._handle_attachments(attachments)
 
             # Compose content that always contains actionable saved paths
@@ -598,7 +587,7 @@ class QQChannel(BaseChannel):
                     await self._send_text_only(
                         chat_id=chat_id,
                         is_group=is_group,
-                        msg_id=message_id,
+                        msg_id=data.id,
                         content=self.config.ack_message,
                     )
                 except Exception:
@@ -610,20 +599,17 @@ class QQChannel(BaseChannel):
                 content=content,
                 media=media_paths if media_paths else None,
                 metadata={
-                    "message_id": message_id,
+                    "message_id": data.id,
                     "attachments": att_meta,
                 },
                 is_dm=not is_group,
             )
         except Exception:
-            self.logger.exception(
-                "Error handling inbound message id={}",
-                getattr(data, "id", "?"),
-            )
+            self.logger.exception("Error handling inbound message id={}", getattr(data, "id", "?"))
 
     async def _handle_attachments(
         self,
-        attachments: list[object],
+        attachments: list[BaseMessage._Attachments],
     ) -> tuple[list[str], list[str], list[dict[str, Any]]]:
         """Extract, download (chunked), and format attachments for agent consumption."""
         media_paths: list[str] = []
@@ -732,11 +718,9 @@ class QQChannel(BaseChannel):
                     1024 * 1024, int(self.config.download_max_bytes or (200 * 1024 * 1024))
                 )
 
-                active_tmp_path = tmp_path
-
-                def _open_tmp() -> BinaryIO:
-                    active_tmp_path.parent.mkdir(parents=True, exist_ok=True)
-                    return active_tmp_path.open("wb")  # noqa: SIM115
+                def _open_tmp():
+                    tmp_path.parent.mkdir(parents=True, exist_ok=True)
+                    return open(tmp_path, "wb")  # noqa: SIM115
 
                 f = await asyncio.to_thread(_open_tmp)
                 try:
@@ -756,7 +740,7 @@ class QQChannel(BaseChannel):
                     await asyncio.to_thread(f.close)
 
                 # Atomic rename
-                await asyncio.to_thread(os.replace, active_tmp_path, target)
+                await asyncio.to_thread(os.replace, tmp_path, target)
                 tmp_path = None  # mark as moved
                 self.logger.info("file saved: {}", str(target))
                 return str(target)

nanobot/channels/signal/runtime.py

@@ -12,7 +12,7 @@ from collections.abc import AsyncIterator, Callable
 from contextlib import asynccontextmanager
 from dataclasses import dataclass, field
 from pathlib import Path
-from typing import Any, TypedDict, cast
+from typing import Any
 
 import httpx
 from pydantic import Field, computed_field, field_validator
@@ -53,7 +53,7 @@ _SIG_TOKEN_RE = re.compile(r"\x00C(\d+)\x00")
 # stripper needs a fixed, narrow subset (no single-asterisk italic, no
 # single-tilde strikethrough) and benefits from each pattern's group 1 being
 # the content directly.
-_SIG_CELL_STRIP_PATTERNS: tuple[tuple[re.Pattern[str], str], ...] = (
+_SIG_CELL_STRIP_PATTERNS: tuple[tuple[re.Pattern, str], ...] = (
     (re.compile(r"\*\*(.+?)\*\*"), r"\1"),
     (re.compile(r"__(.+?)__"), r"\1"),
     (re.compile(r"~~(.+?)~~"), r"\1"),
@@ -61,27 +61,6 @@ _SIG_CELL_STRIP_PATTERNS: tuple[tuple[re.Pattern[str], str], ...] = (
 )
 
 
-def _as_json_object(value: object) -> dict[str, Any] | None:
-    """Return an untrusted JSON value only when it is an object."""
-    if isinstance(value, dict):
-        return cast(dict[str, Any], value)
-    return None
-
-
-def _as_json_object_list(value: object) -> list[dict[str, Any]]:
-    """Return the object members of an untrusted JSON array."""
-    if not isinstance(value, list):
-        return []
-    return [cast(dict[str, Any], item) for item in cast(list[object], value) if isinstance(item, dict)]
-
-
-class _BufferedMessage(TypedDict):
-    sender_name: str
-    sender_number: str
-    content: str
-    timestamp: int | None
-
-
 def _utf16_len(s: str) -> int:
     """UTF-16 code-unit length, matching Signal BodyRange semantics."""
     return len(s.encode("utf-16-le")) // 2
@@ -139,7 +118,7 @@ def _markdown_to_signal(text: str) -> tuple[str, list[str]]:
     # so they're protected from inline-style processing.
     protected: list[str] = []
 
-    def save_code(m: re.Match[str]) -> str:
+    def save_code(m: re.Match) -> str:
         protected.append(m.group(1))
         return f"\x00C{len(protected) - 1}\x00"
 
@@ -170,8 +149,8 @@ def _markdown_to_signal(text: str) -> tuple[str, list[str]]:
     runs: list[_Run] = [_Run(text)]
 
     def transform(
-        pattern: re.Pattern[str],
-        make_runs: Callable[[re.Match[str], frozenset[str]], list[_Run]],
+        pattern: re.Pattern,
+        make_runs: Callable[[re.Match, frozenset[str]], list[_Run]],
     ) -> None:
         new_runs: list[_Run] = []
         for run in runs:
@@ -210,7 +189,7 @@ def _markdown_to_signal(text: str) -> tuple[str, list[str]]:
     transform(_SIG_OLIST_RE, lambda m, s: [_Run(m.group(1) + ". ", s)])
 
     # Links → "text (url)" or bare url when text equals url.
-    def _link_runs(m: re.Match[str], s: frozenset[str]) -> list[_Run]:
+    def _link_runs(m: re.Match, s: frozenset) -> list[_Run]:
         link_text, url = m.group(1), m.group(2)
 
         def _norm(u: str) -> str:
@@ -378,15 +357,15 @@ class SignalChannel(BaseChannel):
         self.config: SignalConfig = config
         self._http: httpx.AsyncClient | None = None
         self._request_id = 0
-        self._sse_task: asyncio.Task[None] | None = None
-        self._typing_tasks: dict[str, asyncio.Task[None]] = {}
+        self._sse_task: asyncio.Task | None = None
+        self._typing_tasks: dict[str, asyncio.Task] = {}
         self._typing_uuid_warnings: set[str] = set()
         self._account_id_aliases: set[str] = set()
         self._remember_account_id_alias(self.config.phone_number)
 
         # Rolling message buffer for group context (group_id -> deque of messages)
         # Each message is a dict with: sender_name, sender_number, content, timestamp
-        self._group_buffers: dict[str, deque[_BufferedMessage]] = {}
+        self._group_buffers: dict[str, deque] = {}
 
     def is_allowed(self, sender_id: str) -> bool:
         """Override base check to normalize and split pipe-joined identifiers.
@@ -430,7 +409,6 @@ class SignalChannel(BaseChannel):
         metadata: dict[str, Any] | None = None,
         session_key: str | None = None,
         is_dm: bool = False,
-        authorization_id: str | None = None,
     ) -> None:
         """Handle an inbound message whose policy has already been checked.
 
@@ -440,7 +418,6 @@ class SignalChannel(BaseChannel):
         ``super()._handle_message`` instead, which goes through
         ``is_allowed`` and issues a pairing code.
         """
-        del authorization_id
         meta = metadata or {}
         if self.supports_streaming:
             meta = {**meta, "_wants_stream": True}
@@ -617,7 +594,7 @@ class SignalChannel(BaseChannel):
                 self.logger.info("Subscribed to Signal messages via SSE")
 
                 # Buffer for accumulating SSE data across multiple lines
-                event_buffer: list[str] = []
+                event_buffer = []
 
                 async for line in response.aiter_lines():
                     if not self._running:
@@ -628,7 +605,7 @@ class SignalChannel(BaseChannel):
                         self.logger.debug("SSE line received: {}", line[:200])
 
                     # SSE format handling
-                    if isinstance(line, str):  # pyright: ignore[reportUnnecessaryIsInstance]
+                    if isinstance(line, str):
                         # Empty line signals end of event
                         if not line or line == ":":
                             if event_buffer:
@@ -636,10 +613,7 @@ class SignalChannel(BaseChannel):
                                 data_str = ""
                                 try:
                                     data_str = "\n".join(event_buffer)
-                                    data = _as_json_object(json.loads(data_str))
-                                    if data is None:
-                                        self.logger.warning("Ignoring non-object SSE event: {}", data_str[:200])
-                                        continue
+                                    data = json.loads(data_str)
                                     self.logger.debug("SSE event parsed: {}", data)
                                     await self._handle_receive_notification(data)
                                 except json.JSONDecodeError as e:
@@ -670,7 +644,7 @@ class SignalChannel(BaseChannel):
             self.logger.error("Error in SSE receive loop: {}", e)
             raise
 
-    @asynccontextmanager  # pyright: ignore[reportDeprecated]
+    @asynccontextmanager
     async def _safe_handle(self, action: str, payload: Any = None) -> AsyncIterator[None]:
         """Swallow and log any exception from a top-level handler block.
 
@@ -692,18 +666,17 @@ class SignalChannel(BaseChannel):
         self.logger.debug("_handle_receive_notification called with: {}", params)
         async with self._safe_handle("receive notification", params):
             # Extract envelope from SSE notification: {"envelope": {...}}
-            envelope = _as_json_object(params.get("envelope"))
+            envelope = params.get("envelope", {})
 
             self.logger.debug("Extracted envelope: {}", envelope)
 
-            if envelope is None:
+            if not envelope:
                 self.logger.debug("No envelope found in params")
                 return
 
             # Extract sender information
             sender_parts = self._collect_sender_id_parts(envelope)
-            source_name_value = envelope.get("sourceName")
-            source_name = source_name_value if isinstance(source_name_value, str) else None
+            source_name = envelope.get("sourceName")
 
             if not sender_parts:
                 self.logger.debug("Received message without source, skipping")
@@ -718,10 +691,10 @@ class SignalChannel(BaseChannel):
                     self._remember_account_id_alias(part)
 
             # Check different message types
-            data_message = _as_json_object(envelope.get("dataMessage"))
-            sync_message = _as_json_object(envelope.get("syncMessage"))
-            typing_message = _as_json_object(envelope.get("typingMessage"))
-            receipt_message = _as_json_object(envelope.get("receiptMessage"))
+            data_message = envelope.get("dataMessage")
+            sync_message = envelope.get("syncMessage")
+            typing_message = envelope.get("typingMessage")
+            receipt_message = envelope.get("receiptMessage")
 
             # Ignore receipt messages (delivery/read receipts)
             if receipt_message:
@@ -732,7 +705,8 @@ class SignalChannel(BaseChannel):
                 await self._handle_data_message(sender_id, sender_number, data_message, source_name)
 
             # Handle sync messages (messages sent from another device)
-            elif sync_message and (sent_msg := _as_json_object(sync_message.get("sentMessage"))):
+            elif sync_message and sync_message.get("sentMessage"):
+                sent_msg = sync_message["sentMessage"]
                 destination = sent_msg.get("destination") or sent_msg.get("destinationNumber")
                 if destination:
                     self.logger.debug(
@@ -751,12 +725,10 @@ class SignalChannel(BaseChannel):
         sender_name: str | None,
     ) -> None:
         """Handle a data message (text, attachments, etc.)."""
-        message_value = data_message.get("message")
-        message_text = message_value if isinstance(message_value, str) else ""
-        attachments = _as_json_object_list(data_message.get("attachments"))
-        mentions = _as_json_object_list(data_message.get("mentions"))
-        timestamp_value = data_message.get("timestamp")
-        timestamp = timestamp_value if isinstance(timestamp_value, int) else None
+        message_text = data_message.get("message") or ""
+        attachments = data_message.get("attachments", [])
+        mentions = data_message.get("mentions", [])
+        timestamp = data_message.get("timestamp")
 
         self.logger.info(
             "Data message from {}: groupInfo={}, groupV2={}, keys={}",
@@ -843,7 +815,7 @@ class SignalChannel(BaseChannel):
         group_id: str | None,
         is_group_message: bool,
         message_text: str,
-        mentions: list[dict[str, Any]],
+        mentions: list,
         sender_name: str | None,
         timestamp: int | None,
     ) -> tuple[bool, str]:
@@ -905,8 +877,8 @@ class SignalChannel(BaseChannel):
         sender_name: str | None,
         sender_number: str,
         message_text: str,
-        attachments: list[dict[str, Any]],
-        mentions: list[dict[str, Any]],
+        attachments: list,
+        mentions: list,
         is_group_message: bool,
         chat_id: str,
     ) -> tuple[str, list[str]]:
@@ -980,9 +952,7 @@ class SignalChannel(BaseChannel):
         """
         # Create buffer for this group if it doesn't exist
         if group_id not in self._group_buffers:
-            self._group_buffers[group_id] = deque[_BufferedMessage](
-                maxlen=self.config.group_message_buffer_size
-            )
+            self._group_buffers[group_id] = deque(maxlen=self.config.group_message_buffer_size)
 
         # Add message to buffer (deque will automatically drop oldest when full)
         self._group_buffers[group_id].append(
@@ -1022,7 +992,7 @@ class SignalChannel(BaseChannel):
         # We want to show context BEFORE the mention
         context_messages = list(buffer)[:-1]  # Exclude the last (current) message
 
-        lines: list[str] = []
+        lines = []
         for msg in context_messages:
             sender = msg["sender_name"]
             content = msg["content"][:200]  # Limit to 200 chars per message
@@ -1083,6 +1053,8 @@ class SignalChannel(BaseChannel):
         """Remember known bot identifiers for mention matching."""
         if not value:
             return
+        if not isinstance(value, str):
+            return
         for candidate in self._normalize_signal_id(value):
             self._account_id_aliases.add(candidate)
 
@@ -1090,6 +1062,8 @@ class SignalChannel(BaseChannel):
         """Return True when an identifier refers to the bot account."""
         if not value:
             return False
+        if not isinstance(value, str):
+            return False
         return any(
             candidate in self._account_id_aliases for candidate in self._normalize_signal_id(value)
         )
@@ -1123,14 +1097,13 @@ class SignalChannel(BaseChannel):
         return sender_parts[0] if sender_parts else ""
 
     @staticmethod
-    def _extract_group_id(group_info: object, group_v2: object) -> str | None:
+    def _extract_group_id(group_info: Any, group_v2: Any) -> str | None:
         """Extract group ID from groupInfo/groupV2 payloads across signal-cli variants."""
         for group_obj in (group_info, group_v2):
             if not isinstance(group_obj, dict):
                 continue
-            group = cast(dict[str, Any], group_obj)
             for key in ("groupId", "id", "groupID"):
-                value = group.get(key)
+                value = group_obj.get(key)
                 if isinstance(value, str) and value:
                     return value
         return None
@@ -1140,19 +1113,18 @@ class SignalChannel(BaseChannel):
         """Extract possible identifier fields from a mention payload."""
         ids: list[str] = []
 
-        def _walk(value: object, depth: int = 0) -> None:
+        def _walk(value: dict[str, Any] | Any, depth: int = 0) -> None:
             if depth > 2:
                 return
             if not isinstance(value, dict):
                 return
-            object_value = cast(dict[str, Any], value)
-            for key, child in object_value.items():
-                key_lower = key.lower()
+            for key, child in value.items():
+                key_lower = str(key).lower()
                 if isinstance(child, str) and child:
                     if any(token in key_lower for token in ("number", "uuid", "serviceid", "aci")):
                         ids.append(child)
                 elif isinstance(child, dict):
-                    _walk(cast(object, child), depth + 1)
+                    _walk(child, depth + 1)
 
         _walk(mention)
         return list(dict.fromkeys(ids))
@@ -1215,6 +1187,8 @@ class SignalChannel(BaseChannel):
 
         # If mention is required, check if bot was mentioned.
         for mention in mentions:
+            if not isinstance(mention, dict):
+                continue
             for mention_id in self._mention_id_candidates(mention):
                 if self._id_matches_account(mention_id):
                     return True
@@ -1223,13 +1197,15 @@ class SignalChannel(BaseChannel):
         # (for handle-style mentions). Accept a leading identifier-less mention
         # as a mention of the bot to avoid false negatives.
         for mention in mentions:
+            if not isinstance(mention, dict):
+                continue
             if self._mention_id_candidates(mention):
                 continue
             span = self._mention_span(mention)
             if not span:
                 continue
             start, _ = span
-            if not message_text[:start].strip():
+            if message_text is not None and not message_text[:start].strip():
                 self.logger.debug("Accepting identifier-less leading mention as bot mention")
                 return True
 
@@ -1265,8 +1241,10 @@ class SignalChannel(BaseChannel):
             return text
 
         # Build a list of (start, length) tuples for our bot's mentions
-        bot_mentions: list[tuple[int, int]] = []
+        bot_mentions = []
         for mention in mentions:
+            if not isinstance(mention, dict):
+                continue
             mention_ids = self._mention_id_candidates(mention)
             span = self._mention_span(mention)
             if not span:
@@ -1404,7 +1382,7 @@ class SignalChannel(BaseChannel):
         request_id = self._request_id
 
         # Build JSON-RPC request
-        request: dict[str, Any] = {"jsonrpc": "2.0", "method": method, "id": request_id}
+        request = {"jsonrpc": "2.0", "method": method, "id": request_id}
 
         if params:
             request["params"] = params
@@ -1419,10 +1397,7 @@ class SignalChannel(BaseChannel):
         try:
             response = await self._http.post("/api/v1/rpc", json=request)
             response.raise_for_status()
-            response_json = _as_json_object(response.json())
-            if response_json is None:
-                return {"error": {"message": "signal-cli returned a non-object JSON-RPC response"}}
-            return response_json
+            return response.json()
         except Exception as e:
             self.logger.error("HTTP request failed: {}", e)
             return {"error": {"message": str(e)}}

nanobot/channels/slack/runtime.py

@@ -3,16 +3,15 @@
 import asyncio
 import re
 from pathlib import Path
-from typing import Any, Protocol, cast
+from typing import Any
 
 import httpx
 from pydantic import Field
-from slack_sdk.socket_mode.async_client import AsyncBaseSocketModeClient
 from slack_sdk.socket_mode.request import SocketModeRequest
 from slack_sdk.socket_mode.response import SocketModeResponse
 from slack_sdk.socket_mode.websockets import SocketModeClient
 from slack_sdk.web.async_client import AsyncWebClient
-from slackify_markdown import slackify_markdown  # pyright: ignore[reportMissingTypeStubs]
+from slackify_markdown import slackify_markdown
 
 from nanobot.bus.events import OutboundMessage
 from nanobot.bus.outbound_events import ProgressEvent
@@ -24,30 +23,6 @@ from nanobot.pairing import is_approved
 from nanobot.utils.helpers import safe_filename, split_message
 
 
-def _as_json_object(value: Any) -> dict[str, Any] | None:
-    """Narrow Slack's untyped Socket Mode payloads at the boundary."""
-    return cast(dict[str, Any], value) if isinstance(value, dict) else None
-
-
-def _as_json_list(value: Any) -> list[Any] | None:
-    """Narrow Slack's untyped Socket Mode arrays at the boundary."""
-    return cast(list[Any], value) if isinstance(value, list) else None
-
-
-class _SlackWebAPI(Protocol):
-    """Subset of slack-sdk's dynamically typed Web API used by this channel."""
-
-    async def auth_test(self, **kwargs: Any) -> Any: ...
-    async def chat_postMessage(self, **kwargs: Any) -> Any: ...  # noqa: N802
-    async def conversations_list(self, **kwargs: Any) -> Any: ...
-    async def conversations_open(self, **kwargs: Any) -> Any: ...
-    async def conversations_replies(self, **kwargs: Any) -> Any: ...
-    async def files_upload_v2(self, **kwargs: Any) -> Any: ...
-    async def reactions_add(self, **kwargs: Any) -> Any: ...
-    async def reactions_remove(self, **kwargs: Any) -> Any: ...
-    async def users_list(self, **kwargs: Any) -> Any: ...
-
-
 class SlackDMConfig(Base):
     """Slack DM policy configuration."""
 
@@ -115,13 +90,6 @@ class SlackChannel(BaseChannel):
         self._target_cache: dict[str, str] = {}
         self._thread_context_attempted: set[str] = set()
 
-    def _require_web_api(self) -> _SlackWebAPI:
-        if self._web_client is None:
-            raise RuntimeError("Slack Web API client is not started")
-        # slack-sdk's public methods are runtime-stable but its annotations do
-        # not expose a useful shared interface, so narrow once at the SDK edge.
-        return cast(_SlackWebAPI, self._web_client)
-
     async def start(self) -> None:
         """Start the Slack Socket Mode client."""
         if not self.config.bot_token or not self.config.app_token:
@@ -143,8 +111,7 @@ class SlackChannel(BaseChannel):
 
         # Resolve bot user ID for mention handling
         try:
-            web_api = self._require_web_api()
-            auth = await web_api.auth_test()
+            auth = await self._web_client.auth_test()
             self._bot_user_id = auth.get("user_id")
             self.logger.info("bot connected as {}", self._bot_user_id)
         except Exception as e:
@@ -188,17 +155,10 @@ class SlackChannel(BaseChannel):
             self.logger.warning("client not running")
             return
         try:
-            web_api = self._require_web_api()
             target_chat_id = await self._resolve_target_chat_id(msg.chat_id)
-            raw_slack_meta: Any = msg.metadata.get("slack", {}) if msg.metadata else {}
-            slack_meta: dict[str, Any] = (
-                cast(dict[str, Any], raw_slack_meta)
-                if isinstance(raw_slack_meta, dict)
-                else {}
-            )
+            slack_meta = msg.metadata.get("slack", {}) if msg.metadata else {}
             thread_ts = slack_meta.get("thread_ts")
-            event_meta = cast(dict[str, Any], slack_meta.get("event", {}) or {})
-            origin_chat_id = str(event_meta.get("channel") or msg.chat_id)
+            origin_chat_id = str((slack_meta.get("event", {}) or {}).get("channel") or msg.chat_id)
             # Reply in the same thread the inbound message belongs to (works
             # for both real channel threads and DM threads). When the agent
             # is forwarding to a different channel, drop thread_ts because it
@@ -210,20 +170,7 @@ class SlackChannel(BaseChannel):
                 pass  # skip empty progress messages (e.g. tool-event-only updates)
             elif msg.content or not (msg.media or []):
                 mrkdwn = self._to_mrkdwn(msg.content) if msg.content else " "
-                raw_buttons = getattr(msg, "buttons", None)
-                buttons: list[list[str]] = (
-                    cast(list[list[str]], raw_buttons)
-                    if isinstance(raw_buttons, list)
-                    and all(
-                        isinstance(row, list)
-                        and all(
-                            isinstance(label, str)
-                            for label in cast(list[object], row)
-                        )
-                        for row in cast(list[object], raw_buttons)
-                    )
-                    else []
-                )
+                buttons = getattr(msg, "buttons", None) or []
                 chunks = split_message(mrkdwn, SLACK_MAX_MESSAGE_LEN)
                 for index, chunk in enumerate(chunks):
                     kwargs: dict[str, Any] = dict(
@@ -231,11 +178,11 @@ class SlackChannel(BaseChannel):
                     )
                     if buttons and index == len(chunks) - 1:
                         kwargs["blocks"] = self._build_button_blocks(chunk, buttons)
-                    await web_api.chat_postMessage(**kwargs)
+                    await self._web_client.chat_postMessage(**kwargs)
 
             for media_path in msg.media or []:
                 try:
-                    await web_api.files_upload_v2(
+                    await self._web_client.files_upload_v2(
                         channel=target_chat_id,
                         file=media_path,
                         thread_ts=thread_ts_param,
@@ -245,16 +192,8 @@ class SlackChannel(BaseChannel):
 
             # Update reaction emoji when the final (non-progress) response is sent
             if not is_progress:
-                raw_event = slack_meta.get("event", {})
-                event = (
-                    cast(dict[str, Any], raw_event)
-                    if isinstance(raw_event, dict)
-                    else {}
-                )
-                await self._update_react_emoji(
-                    origin_chat_id,
-                    cast(str | None, event.get("ts")),
-                )
+                event = slack_meta.get("event", {})
+                await self._update_react_emoji(origin_chat_id, event.get("ts"))
 
         except Exception:
             self.logger.exception("Error sending message")
@@ -298,26 +237,20 @@ class SlackChannel(BaseChannel):
             return self._target_cache[cache_key]
 
         cursor: str | None = None
-        web_api = self._require_web_api()
         while True:
-            response = cast(dict[str, Any], await web_api.conversations_list(
+            response = await self._web_client.conversations_list(
                 types="public_channel,private_channel",
                 exclude_archived=True,
                 limit=200,
                 cursor=cursor,
-            ))
-            for channel_value in cast(list[object], response.get("channels", [])):
-                channel = cast(dict[str, Any], channel_value)
+            )
+            for channel in response.get("channels", []):
                 if self._normalize_target_name(str(channel.get("name") or "")) == normalized:
                     channel_id = str(channel.get("id") or "")
                     if channel_id:
                         self._target_cache[cache_key] = channel_id
                         return channel_id
-            response_metadata = cast(
-                dict[str, Any],
-                response.get("response_metadata") or {},
-            )
-            cursor = str(response_metadata.get("next_cursor") or "").strip()
+            cursor = ((response.get("response_metadata") or {}).get("next_cursor") or "").strip()
             if not cursor:
                 break
 
@@ -336,14 +269,9 @@ class SlackChannel(BaseChannel):
             return self._target_cache[cache_key]
 
         cursor: str | None = None
-        web_api = self._require_web_api()
         while True:
-            response = cast(
-                dict[str, Any],
-                await web_api.users_list(limit=200, cursor=cursor),
-            )
-            for member_value in cast(list[object], response.get("members", [])):
-                member = cast(dict[str, Any], member_value)
+            response = await self._web_client.users_list(limit=200, cursor=cursor)
+            for member in response.get("members", []):
                 if self._member_matches_handle(member, normalized):
                     user_id = str(member.get("id") or "")
                     if not user_id:
@@ -351,11 +279,7 @@ class SlackChannel(BaseChannel):
                     dm_id = await self._open_dm_for_user(user_id)
                     self._target_cache[cache_key] = dm_id
                     return dm_id
-            response_metadata = cast(
-                dict[str, Any],
-                response.get("response_metadata") or {},
-            )
-            cursor = str(response_metadata.get("next_cursor") or "").strip()
+            cursor = ((response.get("response_metadata") or {}).get("next_cursor") or "").strip()
             if not cursor:
                 break
 
@@ -364,13 +288,8 @@ class SlackChannel(BaseChannel):
         )
 
     async def _open_dm_for_user(self, user_id: str) -> str:
-        web_api = self._require_web_api()
-        response = cast(
-            dict[str, Any],
-            await web_api.conversations_open(users=user_id),
-        )
-        channel = cast(dict[str, Any], response.get("channel") or {})
-        channel_id = str(channel.get("id") or "")
+        response = await self._web_client.conversations_open(users=user_id)
+        channel_id = str(((response.get("channel") or {}).get("id")) or "")
         if not channel_id:
             raise ValueError(f"Slack DM target for user '{user_id}' could not be opened.")
         return channel_id
@@ -381,7 +300,7 @@ class SlackChannel(BaseChannel):
 
     @classmethod
     def _member_matches_handle(cls, member: dict[str, Any], normalized: str) -> bool:
-        profile = cast(dict[str, Any], member.get("profile") or {})
+        profile = member.get("profile") or {}
         candidates = {
             str(member.get("name") or ""),
             str(profile.get("display_name") or ""),
@@ -393,7 +312,7 @@ class SlackChannel(BaseChannel):
 
     async def _on_socket_request(
         self,
-        client: AsyncBaseSocketModeClient,
+        client: SocketModeClient,
         req: SocketModeRequest,
     ) -> None:
         """Handle incoming Socket Mode requests."""
@@ -408,8 +327,8 @@ class SlackChannel(BaseChannel):
             SocketModeResponse(envelope_id=req.envelope_id)
         )
 
-        payload = _as_json_object(cast(Any, req).payload) or {}
-        event = _as_json_object(payload.get("event")) or {}
+        payload = req.payload or {}
+        event = payload.get("event") or {}
         event_type = event.get("type")
 
         # Handle app mentions or plain messages
@@ -430,8 +349,6 @@ class SlackChannel(BaseChannel):
         # Avoid double-processing: Slack sends both `message` and `app_mention`
         # for mentions in channels. Prefer `app_mention`.
         text = event.get("text") or ""
-        if not isinstance(text, str):
-            return
         if event_type == "message" and self._bot_user_id and f"<@{self._bot_user_id}>" in text:
             return
 
@@ -445,12 +362,10 @@ class SlackChannel(BaseChannel):
             event.get("channel_type"),
             text[:80],
         )
-        if not isinstance(sender_id, str) or not sender_id or not isinstance(chat_id, str) or not chat_id:
+        if not sender_id or not chat_id:
             return
 
         channel_type = event.get("channel_type") or ""
-        if not isinstance(channel_type, str):
-            channel_type = ""
 
         if not self._is_allowed(sender_id, chat_id, channel_type):
             if channel_type == "im" and self.config.dm.enabled:
@@ -468,9 +383,7 @@ class SlackChannel(BaseChannel):
         text = self._strip_bot_mention(text)
 
         event_ts = event.get("ts")
-        event_ts = event_ts if isinstance(event_ts, str) else None
         raw_thread_ts = event.get("thread_ts")
-        raw_thread_ts = raw_thread_ts if isinstance(raw_thread_ts, str) else None
         thread_ts = raw_thread_ts
         # In DMs we don't auto-open a thread on top-level messages (it would
         # bury replies under "1 reply"). But if the user explicitly opened a
@@ -483,28 +396,27 @@ class SlackChannel(BaseChannel):
             thread_ts = event_ts
         # Add :eyes: reaction to the triggering message (best-effort)
         try:
-            if self._web_client and event_ts:
-                web_api = self._require_web_api()
-                await web_api.reactions_add(
+            if self._web_client and event.get("ts"):
+                await self._web_client.reactions_add(
                     channel=chat_id,
                     name=self.config.react_emoji,
-                    timestamp=event_ts,
+                    timestamp=event.get("ts"),
                 )
         except Exception as e:
             self.logger.debug("reactions_add failed: {}", e)
 
-        # Thread-scoped session key whenever the turn lives in a thread: either the
-        # message arrived inside one (raw_thread_ts) or reply_in_thread opens a new
-        # thread for this channel message. DM roots have no thread_ts and keep the
-        # default per-chat session, so context doesn't bleed across thread boundaries.
-        session_key = f"slack:{chat_id}:{thread_ts}" if thread_ts else None
+        # Thread-scoped session key whenever the user is in a real thread
+        # (raw_thread_ts is set). DM threads get their own session, separate
+        # from the DM root, so context doesn't bleed across thread boundaries.
+        session_key = (
+            f"slack:{chat_id}:{thread_ts}" if thread_ts and raw_thread_ts else None
+        )
         media_paths: list[str] = []
         file_markers: list[str] = []
-        for file_info in _as_json_list(event.get("files")) or []:
-            file_info_object = _as_json_object(file_info)
-            if file_info_object is None:
+        for file_info in event.get("files") or []:
+            if not isinstance(file_info, dict):
                 continue
-            file_path, marker = await self._download_slack_file(file_info_object)
+            file_path, marker = await self._download_slack_file(file_info)
             if file_path:
                 media_paths.append(file_path)
             if marker:
@@ -591,30 +503,22 @@ class SlackChannel(BaseChannel):
         preview = response.content[:256].lstrip().lower()
         return preview.startswith(_HTML_DOWNLOAD_PREFIXES)
 
-    async def _on_block_action(
-        self,
-        client: AsyncBaseSocketModeClient,
-        req: SocketModeRequest,
-    ) -> None:
+    async def _on_block_action(self, client: SocketModeClient, req: SocketModeRequest) -> None:
         """Handle button clicks from inline action buttons."""
         await client.send_socket_mode_response(SocketModeResponse(envelope_id=req.envelope_id))
-        payload = cast(dict[str, Any], cast(Any, req).payload or {})
-        actions = cast(list[Any], payload.get("actions") or [])
+        payload = req.payload or {}
+        actions = payload.get("actions") or []
         if not actions:
             return
-        action = cast(dict[str, Any], actions[0])
-        value = str(action.get("value") or "")
-        user_info = cast(dict[str, Any], payload.get("user") or {})
+        value = str(actions[0].get("value") or "")
+        user_info = payload.get("user") or {}
         sender_id = str(user_info.get("id") or "")
-        channel_info = cast(dict[str, Any], payload.get("channel") or {})
+        channel_info = payload.get("channel") or {}
         chat_id = str(channel_info.get("id") or "")
         if not sender_id or not chat_id or not value:
             return
-        message_info = cast(dict[str, Any], payload.get("message") or {})
-        thread_ts = cast(
-            str | None,
-            message_info.get("thread_ts") or message_info.get("ts"),
-        )
+        message_info = payload.get("message") or {}
+        thread_ts = message_info.get("thread_ts") or message_info.get("ts")
         channel_type = self._infer_channel_type(chat_id)
         if not self._is_allowed(sender_id, chat_id, channel_type):
             return
@@ -659,18 +563,17 @@ class SlackChannel(BaseChannel):
         self._thread_context_attempted.add(key)
 
         try:
-            web_api = self._require_web_api()
-            response = cast(dict[str, Any], await web_api.conversations_replies(
+            response = await self._web_client.conversations_replies(
                 channel=chat_id,
                 ts=thread_ts,
                 limit=max(1, self.config.thread_context_limit),
-            ))
+            )
         except Exception as e:
             self.logger.warning("thread context unavailable for {}: {}", key, e)
             return text
 
         lines = self._format_thread_context(
-            cast(list[dict[str, Any]], response.get("messages", [])),
+            response.get("messages", []),
             current_ts=current_ts,
         )
         if not lines:
@@ -702,7 +605,7 @@ class SlackChannel(BaseChannel):
         blocks: list[dict[str, Any]] = [
             {"type": "section", "text": {"type": "mrkdwn", "text": text[:3000]}},
         ]
-        elements: list[dict[str, Any]] = []
+        elements = []
         for row in buttons:
             for label in row:
                 elements.append({
@@ -719,9 +622,8 @@ class SlackChannel(BaseChannel):
         """Remove the in-progress reaction and optionally add a done reaction."""
         if not self._web_client or not ts:
             return
-        web_api = self._require_web_api()
         try:
-            await web_api.reactions_remove(
+            await self._web_client.reactions_remove(
                 channel=chat_id,
                 name=self.config.react_emoji,
                 timestamp=ts,
@@ -730,7 +632,7 @@ class SlackChannel(BaseChannel):
             self.logger.debug("reactions_remove failed: {}", e)
         if self.config.done_emoji:
             try:
-                await web_api.reactions_add(
+                await self._web_client.reactions_add(
                     channel=chat_id,
                     name=self.config.done_emoji,
                     timestamp=ts,
@@ -801,7 +703,7 @@ class SlackChannel(BaseChannel):
             return ""
         code_blocks: list[str] = []
 
-        def _save_fence(m: re.Match[str]) -> str:
+        def _save_fence(m: re.Match) -> str:
             code_blocks.append(m.group(0))
             return f"\x00CB{len(code_blocks) - 1}\x00"
 
@@ -816,7 +718,7 @@ class SlackChannel(BaseChannel):
         """Fix markdown artifacts that slackify_markdown misses."""
         code_blocks: list[str] = []
 
-        def _save_code(m: re.Match[str]) -> str:
+        def _save_code(m: re.Match) -> str:
             code_blocks.append(m.group(0))
             return f"\x00CB{len(code_blocks) - 1}\x00"
 
@@ -824,17 +726,14 @@ class SlackChannel(BaseChannel):
         text = cls._INLINE_CODE_RE.sub(_save_code, text)
         text = cls._LEFTOVER_BOLD_RE.sub(r"*\1*", text)
         text = cls._LEFTOVER_HEADER_RE.sub(r"*\1*", text)
-        text = cls._BARE_URL_RE.sub(
-            lambda m: m.group(0).replace("&amp;", "&"),
-            text,
-        )
+        text = cls._BARE_URL_RE.sub(lambda m: m.group(0).replace("&amp;", "&"), text)
 
         for i, block in enumerate(code_blocks):
             text = text.replace(f"\x00CB{i}\x00", block)
         return text
 
     @staticmethod
-    def _convert_table(match: re.Match[str]) -> str:
+    def _convert_table(match: re.Match) -> str:
         """Convert a Markdown table to a Slack-readable list."""
         lines = [ln.strip() for ln in match.group(0).strip().splitlines() if ln.strip()]
         if len(lines) < 2:

nanobot/channels/slack/tests/test_slack_channel.py

@@ -555,113 +555,6 @@ async def test_dm_thread_message_keeps_thread_ts_and_threaded_session() -> None:
     assert kwargs["metadata"]["slack"]["thread_ts"] == "1700000000.000100"
 
 
-def _channel_mention_request(envelope_id: str, ts: str) -> SimpleNamespace:
-    return SimpleNamespace(
-        type="events_api",
-        envelope_id=envelope_id,
-        payload={
-            "event": {
-                "type": "app_mention",
-                "user": "U1",
-                "channel": "C123",
-                "text": "<@UBOT> hello",
-                "ts": ts,
-            }
-        },
-    )
-
-
-@pytest.mark.asyncio
-async def test_channel_root_message_uses_thread_scoped_session() -> None:
-    """A channel mention that opens a thread belongs to that thread's session."""
-    channel = SlackChannel(SlackConfig(enabled=True), MessageBus())
-    channel._bot_user_id = "UBOT"
-    channel._web_client = _FakeAsyncWebClient()
-    channel._handle_message = AsyncMock()  # type: ignore[method-assign]
-    client = SimpleNamespace(send_socket_mode_response=AsyncMock())
-
-    req = _channel_mention_request("env-c1", "1700000000.000100")
-
-    await channel._on_socket_request(client, req)
-
-    channel._handle_message.assert_awaited_once()
-    kwargs = channel._handle_message.await_args.kwargs
-    assert kwargs["session_key"] == "slack:C123:1700000000.000100"
-    assert kwargs["metadata"]["slack"]["thread_ts"] == "1700000000.000100"
-
-
-@pytest.mark.asyncio
-async def test_channel_root_messages_do_not_share_one_session() -> None:
-    """Two threads opened in the same channel must not collapse into one session."""
-    channel = SlackChannel(SlackConfig(enabled=True), MessageBus())
-    channel._bot_user_id = "UBOT"
-    channel._web_client = _FakeAsyncWebClient()
-    channel._handle_message = AsyncMock()  # type: ignore[method-assign]
-    client = SimpleNamespace(send_socket_mode_response=AsyncMock())
-
-    first = _channel_mention_request("env-c1", "1700000000.000100")
-    second = _channel_mention_request("env-c2", "1700000000.000200")
-
-    await channel._on_socket_request(client, first)
-    await channel._on_socket_request(client, second)
-
-    session_keys = [call.kwargs["session_key"] for call in channel._handle_message.await_args_list]
-    assert session_keys == [
-        "slack:C123:1700000000.000100",
-        "slack:C123:1700000000.000200",
-    ]
-
-
-@pytest.mark.asyncio
-async def test_channel_root_message_without_reply_in_thread_uses_channel_session() -> None:
-    """With reply_in_thread disabled no thread is opened, so the channel session is used."""
-    channel = SlackChannel(SlackConfig(enabled=True, reply_in_thread=False), MessageBus())
-    channel._bot_user_id = "UBOT"
-    channel._web_client = _FakeAsyncWebClient()
-    channel._handle_message = AsyncMock()  # type: ignore[method-assign]
-    client = SimpleNamespace(send_socket_mode_response=AsyncMock())
-
-    req = _channel_mention_request("env-c3", "1700000000.000300")
-
-    await channel._on_socket_request(client, req)
-
-    channel._handle_message.assert_awaited_once()
-    kwargs = channel._handle_message.await_args.kwargs
-    assert kwargs["session_key"] is None
-    assert kwargs["metadata"]["slack"]["thread_ts"] is None
-
-
-@pytest.mark.asyncio
-async def test_channel_thread_reply_keeps_thread_session() -> None:
-    """A reply inside a channel thread stays in the session opened by the root message."""
-    channel = SlackChannel(SlackConfig(enabled=True), MessageBus())
-    channel._bot_user_id = "UBOT"
-    channel._web_client = _FakeAsyncWebClient()
-    channel._handle_message = AsyncMock()  # type: ignore[method-assign]
-    channel._with_thread_context = AsyncMock(return_value="hello")  # type: ignore[method-assign]
-    client = SimpleNamespace(send_socket_mode_response=AsyncMock())
-    req = SimpleNamespace(
-        type="events_api",
-        envelope_id="env-c4",
-        payload={
-            "event": {
-                "type": "app_mention",
-                "user": "U1",
-                "channel": "C123",
-                "text": "<@UBOT> follow up",
-                "ts": "1700000000.000400",
-                "thread_ts": "1700000000.000100",
-            }
-        },
-    )
-
-    await channel._on_socket_request(client, req)
-
-    channel._handle_message.assert_awaited_once()
-    kwargs = channel._handle_message.await_args.kwargs
-    assert kwargs["session_key"] == "slack:C123:1700000000.000100"
-
-
 @pytest.mark.asyncio
 async def test_slack_slash_command_skips_thread_context() -> None:
     channel = SlackChannel(SlackConfig(enabled=True, allow_from=[]), MessageBus())

nanobot/channels/telegram/runtime.py

@@ -8,9 +8,8 @@ import time
 import unicodedata
 from contextlib import suppress
 from dataclasses import dataclass
-from datetime import timedelta
 from pathlib import Path
-from typing import Any, Awaitable, Callable, Literal, TypeAlias, TypeVar, cast
+from typing import Any, Literal
 from urllib.parse import urlparse
 
 from pydantic import Field, field_validator, model_validator
@@ -18,12 +17,9 @@ from telegram import (
     BotCommand,
     InlineKeyboardButton,
     InlineKeyboardMarkup,
-    Message,
-    MessageEntity,
     ReactionTypeEmoji,
     ReplyParameters,
     Update,
-    User,
 )
 from telegram.error import BadRequest, NetworkError, TimedOut
 from telegram.ext import Application, CallbackQueryHandler, ContextTypes, MessageHandler, filters
@@ -47,12 +43,6 @@ TELEGRAM_MAX_MESSAGE_LEN = 4000  # Telegram message character limit
 TELEGRAM_HTML_MAX_LEN = 4096
 TELEGRAM_REPLY_CONTEXT_MAX_LEN = TELEGRAM_MAX_MESSAGE_LEN  # Max length for reply context in user message
 
-# python-telegram-bot exposes a six-parameter Application generic. Nanobot
-# doesn't customize its context/data/job-queue types, so keep that SDK boundary
-# explicit rather than allowing unspecialized generics to spread Unknown.
-TelegramApplication: TypeAlias = Application[Any, Any, Any, Any, Any, Any]
-_T = TypeVar("_T")
-
 
 def _split_telegram_markdown(content: str, max_len: int) -> list[str]:
     """Split raw Telegram Markdown without leaving fenced code blocks unbalanced."""
@@ -228,7 +218,7 @@ def _markdown_to_telegram_html(text: str) -> str:
 
     # 1. Extract and protect code blocks (preserve content from other processing)
     code_blocks: list[str] = []
-    def save_code_block(m: re.Match[str]) -> str:
+    def save_code_block(m: re.Match) -> str:
         code_blocks.append(m.group(1))
         return f"\x00CB{len(code_blocks) - 1}\x00"
 
@@ -257,7 +247,7 @@ def _markdown_to_telegram_html(text: str) -> str:
 
     # 2. Extract and protect inline code
     inline_codes: list[str] = []
-    def save_inline_code(m: re.Match[str]) -> str:
+    def save_inline_code(m: re.Match) -> str:
         inline_codes.append(m.group(1))
         return f"\x00IC{len(inline_codes) - 1}\x00"
 
@@ -360,7 +350,7 @@ class _QueuedTelegramUpdate:
 
     kind: Literal["command", "message"]
     update: Update
-    context: ContextTypes.DEFAULT_TYPE
+    context: Any
     sort_key: tuple[int, int]
 
 
@@ -431,7 +421,7 @@ class TelegramChannel(BaseChannel):
     display_name = "Telegram"
 
     # Commands registered with Telegram's command menu
-    BOT_COMMANDS: list[BotCommand] = [
+    BOT_COMMANDS = [
         BotCommand("start", "Start the bot"),
         BotCommand("new", "Start a new conversation"),
         BotCommand("stop", "Stop the current task"),
@@ -465,24 +455,19 @@ class TelegramChannel(BaseChannel):
             config = TelegramConfig.model_validate(config)
         super().__init__(config, bus)
         self.config: TelegramConfig = config
-        self._app: TelegramApplication | None = None
+        self._app: Application | None = None
         self._chat_ids: dict[str, int] = {}  # Map sender_id to chat_id for replies
-        self._typing_tasks: dict[str, asyncio.Task[None]] = {}  # chat_id -> typing loop task
-        self._media_group_buffers: dict[str, dict[str, Any]] = {}
-        self._media_group_tasks: dict[str, asyncio.Task[None]] = {}
+        self._typing_tasks: dict[str, asyncio.Task] = {}  # chat_id -> typing loop task
+        self._media_group_buffers: dict[str, dict] = {}
+        self._media_group_tasks: dict[str, asyncio.Task] = {}
         self._message_threads: dict[tuple[str, int], int] = {}
         self._bot_user_id: int | None = None
         self._bot_username: str | None = None
         self._stream_bufs: dict[str, _StreamBuf] = {}  # chat_id -> streaming state
         self._inbound_buffers: dict[str, list[_QueuedTelegramUpdate]] = {}
-        self._inbound_workers: dict[str, asyncio.Task[None]] = {}
+        self._inbound_workers: dict[str, asyncio.Task] = {}
         self._rich_send_disabled: bool = False  # Latch off if Bot API < 10.1
 
-    def _require_app(self) -> TelegramApplication:
-        if self._app is None:
-            raise RuntimeError("Telegram application is not started")
-        return self._app
-
     def is_allowed(self, sender_id: str) -> bool:
         """Preserve Telegram's legacy id|username allowlist matching."""
         if super().is_allowed(sender_id):
@@ -610,7 +595,7 @@ class TelegramChannel(BaseChannel):
         if self.config.mode == "webhook":
             # ``url_path`` is the local HTTP route. ``webhook_url`` is the
             # public HTTPS URL Telegram calls; reverse proxies may rewrite it.
-            await cast(Any, self._app.updater).start_webhook(
+            await self._app.updater.start_webhook(
                 listen=self.config.webhook_listen_host,
                 port=self.config.webhook_listen_port,
                 url_path=self.config.webhook_path.lstrip("/"),
@@ -622,7 +607,7 @@ class TelegramChannel(BaseChannel):
             )
         else:
             # Start polling (this runs until stopped)
-            await cast(Any, self._app.updater).start_polling(
+            await self._app.updater.start_polling(
                 allowed_updates=allowed_updates,
                 drop_pending_updates=False,  # Process pending messages on startup
                 error_callback=self._on_polling_error,
@@ -652,7 +637,7 @@ class TelegramChannel(BaseChannel):
 
         if self._app:
             self.logger.info("Stopping bot...")
-            await cast(Any, self._app.updater).stop()
+            await self._app.updater.stop()
             await self._app.stop()
             await self._app.shutdown()
             self._app = None
@@ -689,9 +674,9 @@ class TelegramChannel(BaseChannel):
         self,
         chat_id: int,
         content: str,
-        reply_params: ReplyParameters | dict[str, int | bool] | None = None,
-        thread_kwargs: dict[str, int] | None = None,
-        reply_markup: InlineKeyboardMarkup | None = None,
+        reply_params=None,
+        thread_kwargs: dict | None = None,
+        reply_markup=None,
     ) -> bool:
         """Attempt sendRichMessage (Bot API 10.1). Returns True on success."""
         if not self._app:
@@ -707,17 +692,13 @@ class TelegramChannel(BaseChannel):
             # sendRichMessage uses reply_parameters (object), not reply_to_message_id.
             if hasattr(reply_params, "message_id"):
                 payload["reply_parameters"] = {
-                    "message_id": cast(ReplyParameters, reply_params).message_id,
+                    "message_id": reply_params.message_id,
                     "allow_sending_without_reply": True,
                 }
             else:
                 payload["reply_parameters"] = reply_params
         if thread_kwargs:
-            payload.update({
-                k: v
-                for k, v in thread_kwargs.items()
-                if v is not None  # pyright: ignore[reportUnnecessaryComparison]
-            })
+            payload.update({k: v for k, v in thread_kwargs.items() if v is not None})
         if reply_markup is not None:
             payload["reply_markup"] = reply_markup
 
@@ -768,7 +749,7 @@ class TelegramChannel(BaseChannel):
         message_thread_id = msg.metadata.get("message_thread_id")
         if message_thread_id is None and reply_to_message_id is not None:
             message_thread_id = self._message_threads.get((msg.chat_id, reply_to_message_id))
-        thread_kwargs: dict[str, int] = {}
+        thread_kwargs = {}
         if message_thread_id is not None:
             thread_kwargs["message_thread_id"] = message_thread_id
 
@@ -839,7 +820,7 @@ class TelegramChannel(BaseChannel):
         # Send text content
         if msg.content and msg.content != "[empty message]":
             render_as_blockquote = bool(progress_event and progress_event.tool_hint)
-            buttons = cast(list[list[str]], getattr(msg, "buttons", None) or [])
+            buttons = getattr(msg, "buttons", None) or []
             reply_markup = self._build_keyboard(buttons) if buttons else None
             text = msg.content
             # Fallback: no native keyboard → splice labels into the message so the choices survive.
@@ -869,12 +850,7 @@ class TelegramChannel(BaseChannel):
                     reply_markup=reply_markup if is_last else None,
                 )
 
-    async def _call_with_retry(
-        self,
-        fn: Callable[..., Awaitable[_T]],
-        *args: Any,
-        **kwargs: Any,
-    ) -> _T:
+    async def _call_with_retry(self, fn, *args, **kwargs):
         """Call an async Telegram API function with retry on pool/network timeout and RetryAfter."""
         from telegram.error import RetryAfter
 
@@ -893,34 +869,27 @@ class TelegramChannel(BaseChannel):
             except RetryAfter as e:
                 if attempt == _SEND_MAX_RETRIES:
                     raise
-                retry_after = e.retry_after
-                delay = (
-                    retry_after.total_seconds()
-                    if isinstance(retry_after, timedelta)
-                    else float(retry_after)
-                )
+                delay = float(e.retry_after)
                 self.logger.warning(
                     "Flood Control (attempt {}/{}), retrying in {:.1f}s",
                     attempt, _SEND_MAX_RETRIES, delay,
                 )
                 await asyncio.sleep(delay)
-        raise RuntimeError("Telegram retry loop exited unexpectedly")
 
     async def _send_text(
         self,
         chat_id: int,
         text: str,
-        reply_params: ReplyParameters | None = None,
-        thread_kwargs: dict[str, int] | None = None,
+        reply_params=None,
+        thread_kwargs: dict | None = None,
         render_as_blockquote: bool = False,
-        reply_markup: InlineKeyboardMarkup | None = None,
+        reply_markup=None,
     ) -> None:
         """Send a plain text message with HTML fallback."""
-        app = self._require_app()
         try:
             html = _tool_hint_to_telegram_blockquote(text) if render_as_blockquote else _markdown_to_telegram_html(text)
             await self._call_with_retry(
-                app.bot.send_message,
+                self._app.bot.send_message,
                 chat_id=chat_id, text=html, parse_mode="HTML",
                 reply_parameters=reply_params,
                 reply_markup=reply_markup,
@@ -930,7 +899,7 @@ class TelegramChannel(BaseChannel):
             self.logger.warning("HTML parse failed, falling back to plain text: {}", e)
             try:
                 await self._call_with_retry(
-                    app.bot.send_message,
+                    self._app.bot.send_message,
                     chat_id=chat_id,
                     text=text,
                     reply_parameters=reply_params,
@@ -976,7 +945,7 @@ class TelegramChannel(BaseChannel):
             if reply_to_message_id := meta.get("message_id"):
                 with suppress(ValueError):
                     await self._remove_reaction(chat_id, int(reply_to_message_id))
-            thread_kwargs: dict[str, int] = {}
+            thread_kwargs = {}
             if message_thread_id := meta.get("message_thread_id"):
                 thread_kwargs["message_thread_id"] = message_thread_id
             raw_text = buf.text
@@ -1063,16 +1032,16 @@ class TelegramChannel(BaseChannel):
             return
 
         now = time.monotonic()
-        stream_thread_kwargs: dict[str, int] = {}
+        thread_kwargs = {}
         if message_thread_id := meta.get("message_thread_id"):
-            stream_thread_kwargs["message_thread_id"] = message_thread_id
+            thread_kwargs["message_thread_id"] = message_thread_id
         if buf.message_id is None:
             preview = _strip_md_block(buf.text)
             try:
                 sent = await self._call_with_retry(
                     self._app.bot.send_message,
                     chat_id=int_chat_id, text=preview,
-                    **stream_thread_kwargs,
+                    **thread_kwargs,
                 )
                 buf.message_id = sent.message_id
                 buf.last_edit = now
@@ -1081,7 +1050,7 @@ class TelegramChannel(BaseChannel):
                 raise  # Let ChannelManager handle retry
         elif (now - buf.last_edit) >= self.config.stream_edit_interval:
             if len(buf.text) > TELEGRAM_MAX_MESSAGE_LEN:
-                await self._flush_stream_overflow(int_chat_id, buf, stream_thread_kwargs)
+                await self._flush_stream_overflow(int_chat_id, buf, thread_kwargs)
                 buf.last_edit = now
                 return
             preview = _strip_md_block(buf.text)
@@ -1103,7 +1072,7 @@ class TelegramChannel(BaseChannel):
         self,
         chat_id: int,
         buf: "_StreamBuf",
-        thread_kwargs: dict[str, int],
+        thread_kwargs: dict,
     ) -> None:
         """Split an oversized stream buffer mid-flight.
 
@@ -1114,11 +1083,10 @@ class TelegramChannel(BaseChannel):
         chunks = _split_telegram_markdown_html_chunks(buf.text, TELEGRAM_HTML_MAX_LEN)
         if len(chunks) <= 1:
             return
-        app = self._require_app()
         first_markdown, first_html = chunks[0]
         try:
             await self._call_with_retry(
-                app.bot.edit_message_text,
+                self._app.bot.edit_message_text,
                 chat_id=chat_id, message_id=buf.message_id,
                 text=first_html,
                 parse_mode="HTML",
@@ -1130,7 +1098,7 @@ class TelegramChannel(BaseChannel):
                 )
                 try:
                     await self._call_with_retry(
-                        app.bot.edit_message_text,
+                        self._app.bot.edit_message_text,
                         chat_id=chat_id, message_id=buf.message_id,
                         text=first_markdown,
                     )
@@ -1145,7 +1113,7 @@ class TelegramChannel(BaseChannel):
         async def send_chunk(markdown: str, html: str) -> Any:
             try:
                 return await self._call_with_retry(
-                    app.bot.send_message,
+                    self._app.bot.send_message,
                     chat_id=chat_id, text=html, parse_mode="HTML", **thread_kwargs,
                 )
             except BadRequest as e:
@@ -1153,7 +1121,7 @@ class TelegramChannel(BaseChannel):
                     "Stream overflow HTML send failed, falling back to plain text: {}", e
                 )
                 return await self._call_with_retry(
-                    app.bot.send_message,
+                    self._app.bot.send_message,
                     chat_id=chat_id, text=markdown, **thread_kwargs,
                 )
 
@@ -1192,14 +1160,12 @@ class TelegramChannel(BaseChannel):
         await update.message.reply_text(build_help_text())
 
     @staticmethod
-    def _sender_id(user: User) -> str:
+    def _sender_id(user) -> str:
         """Build sender_id with username for allowlist matching."""
         sid = str(user.id)
         return f"{sid}|{user.username}" if user.username else sid
 
-    async def _send_pairing_code_if_private(
-        self, sender_id: str, message: Message, user: User
-    ) -> None:
+    async def _send_pairing_code_if_private(self, sender_id: str, message, user) -> None:
         if message.chat.type != "private":
             return
         await self._handle_message(
@@ -1211,7 +1177,7 @@ class TelegramChannel(BaseChannel):
         )
 
     @staticmethod
-    def _derive_topic_session_key(message: Message) -> str | None:
+    def _derive_topic_session_key(message) -> str | None:
         """Derive topic-scoped session key for Telegram chats with threads."""
         message_thread_id = getattr(message, "message_thread_id", None)
         if message_thread_id is None:
@@ -1219,7 +1185,7 @@ class TelegramChannel(BaseChannel):
         return f"telegram:{message.chat_id}:topic:{message_thread_id}"
 
     @staticmethod
-    def _build_message_metadata(message: Message, user: User) -> dict[str, Any]:
+    def _build_message_metadata(message, user) -> dict:
         """Build common Telegram inbound metadata payload."""
         reply_to = getattr(message, "reply_to_message", None)
         return {
@@ -1233,7 +1199,7 @@ class TelegramChannel(BaseChannel):
             "reply_to_message_id": getattr(reply_to, "message_id", None) if reply_to else None,
         }
 
-    async def _extract_reply_context(self, message: Message) -> str | None:
+    async def _extract_reply_context(self, message) -> str | None:
         """Extract text from the message being replied to, if any."""
         reply = getattr(message, "reply_to_message", None)
         if not reply:
@@ -1258,7 +1224,7 @@ class TelegramChannel(BaseChannel):
             return f"[Reply to: {text}]"
 
     async def _download_message_media(
-        self, msg: Message, *, add_failure_content: bool = False
+        self, msg, *, add_failure_content: bool = False
     ) -> tuple[list[str], list[str]]:
         """Download media from a message (current or reply). Returns (media_paths, content_parts)."""
         media_file = None
@@ -1289,7 +1255,7 @@ class TelegramChannel(BaseChannel):
         try:
             file = await self._app.bot.get_file(media_file.file_id)
             ext = self._get_extension(
-                cast(str, media_type),
+                media_type,
                 getattr(media_file, "mime_type", None),
                 getattr(media_file, "file_name", None),
             )
@@ -1325,7 +1291,7 @@ class TelegramChannel(BaseChannel):
     @staticmethod
     def _has_mention_entity(
         text: str,
-        entities: list[MessageEntity] | None,
+        entities,
         bot_username: str,
         bot_id: int | None,
     ) -> bool:
@@ -1348,7 +1314,7 @@ class TelegramChannel(BaseChannel):
                 return True
         return handle in text.lower()
 
-    async def _is_group_message_for_bot(self, message: Message) -> bool:
+    async def _is_group_message_for_bot(self, message) -> bool:
         """Allow group messages when policy is open, @mentioned, or replying to the bot."""
         if message.chat.type == "private" or self.config.group_policy == "open":
             return True
@@ -1375,7 +1341,7 @@ class TelegramChannel(BaseChannel):
         reply_user = getattr(getattr(message, "reply_to_message", None), "from_user", None)
         return bool(bot_id and reply_user and reply_user.id == bot_id)
 
-    def _remember_thread_context(self, message: Message) -> None:
+    def _remember_thread_context(self, message) -> None:
         """Cache Telegram thread context by chat/message id for follow-up replies."""
         message_thread_id = getattr(message, "message_thread_id", None)
         if message_thread_id is None:
@@ -1386,7 +1352,7 @@ class TelegramChannel(BaseChannel):
             self._message_threads.pop(next(iter(self._message_threads)))
 
     @staticmethod
-    def _queue_key_for_message(message: Message) -> str:
+    def _queue_key_for_message(message) -> str:
         """Return the final nanobot session key used for ordered Telegram ingress."""
         return TelegramChannel._derive_topic_session_key(message) or f"telegram:{message.chat_id}"
 
@@ -1407,8 +1373,6 @@ class TelegramChannel(BaseChannel):
     ) -> None:
         """Stage a Telegram update behind a short per-session reorder window."""
         message = update.message
-        if message is None:
-            return
         key = self._queue_key_for_message(message)
         self._inbound_buffers.setdefault(key, []).append(
             _QueuedTelegramUpdate(
@@ -1468,8 +1432,6 @@ class TelegramChannel(BaseChannel):
         """Process a queued slash command."""
         message = update.message
         user = update.effective_user
-        if message is None or user is None:
-            return
         sender_id = self._sender_id(user)
         if not self.is_allowed(sender_id):
             await self._send_pairing_code_if_private(sender_id, message, user)
@@ -1507,8 +1469,6 @@ class TelegramChannel(BaseChannel):
 
         message = update.message
         user = update.effective_user
-        if message is None or user is None:
-            return
         chat_id = message.chat_id
         sender_id = self._sender_id(user)
         if not self.is_allowed(sender_id):
@@ -1523,8 +1483,8 @@ class TelegramChannel(BaseChannel):
             return
 
         # Build content from text and/or media
-        content_parts: list[str] = []
-        media_paths: list[str] = []
+        content_parts = []
+        media_paths = []
 
         # Text content
         if message.text:
@@ -1665,10 +1625,8 @@ class TelegramChannel(BaseChannel):
             self.logger.debug("Typing indicator stopped for {}: {}", chat_id, e)
 
     @staticmethod
-    def _format_telegram_error(exc: Exception | None) -> str:
+    def _format_telegram_error(exc: Exception) -> str:
         """Return a short, readable error summary for logs."""
-        if exc is None:
-            return "None"
         text = str(exc).strip()
         if text:
             return text
@@ -1724,7 +1682,7 @@ class TelegramChannel(BaseChannel):
 
         return ""
 
-    def _build_keyboard(self, buttons: list[list[str]]) -> InlineKeyboardMarkup | None:
+    def _build_keyboard(self, buttons: list) -> InlineKeyboardMarkup | None:
         """Build inline keyboard markup if inline_keyboards is enabled."""
         if not buttons or not self.config.inline_keyboards:
             return None
@@ -1753,8 +1711,7 @@ class TelegramChannel(BaseChannel):
             return
         query = update.callback_query
         user = update.effective_user
-        query_message = query.message
-        chat_id = query_message.chat.id if query_message else None
+        chat_id = query.message.chat_id if query.message else None
         sender_id = self._sender_id(user)
         if not chat_id:
             self.logger.warning("Callback query without chat_id")
@@ -1763,9 +1720,9 @@ class TelegramChannel(BaseChannel):
             return
         button_label = query.data or ""
         await query.answer()
-        if isinstance(query_message, Message):
+        if query.message:
             with suppress(Exception):
-                await query_message.edit_reply_markup(reply_markup=None)
+                await query.message.edit_reply_markup(reply_markup=None)
         self.logger.debug("Inline button tap from {}: {}", sender_id, button_label)
         self._start_typing(str(chat_id))
         await self._handle_message(

nanobot/channels/telegram/tests/test_telegram_channel.py

@@ -1,5 +1,4 @@
 import asyncio
-from datetime import timedelta
 from pathlib import Path
 from types import SimpleNamespace
 from unittest.mock import AsyncMock
@@ -1912,36 +1911,6 @@ async def test_on_message_location_with_text() -> None:
 # Tests for retry amplification fix (issue #3050)
 # ---------------------------------------------------------------------------
 
-@pytest.mark.asyncio
-async def test_call_with_retry_accepts_timedelta_retry_after(
-    monkeypatch: pytest.MonkeyPatch,
-) -> None:
-    from telegram.error import RetryAfter
-
-    channel = TelegramChannel(
-        TelegramConfig(enabled=True, token="123:abc", allow_from=["*"]),
-        MessageBus(),
-    )
-    attempts = 0
-
-    async def retry_once() -> str:
-        nonlocal attempts
-        attempts += 1
-        if attempts == 1:
-            raise RetryAfter(timedelta(seconds=1.5))
-        return "ok"
-
-    sleep = AsyncMock()
-    monkeypatch.setenv("PTB_TIMEDELTA", "1")
-    monkeypatch.setattr(
-        "nanobot.channels.telegram.runtime.asyncio.sleep",
-        sleep,
-    )
-
-    assert await channel._call_with_retry(retry_once) == "ok"
-    sleep.assert_awaited_once_with(1.5)
-
-
 @pytest.mark.asyncio
 async def test_send_text_does_not_fallback_on_network_timeout() -> None:
     """TimedOut should propagate immediately, NOT trigger plain-text fallback.
@@ -2349,7 +2318,7 @@ async def test_callback_query_ignores_unauthorized_user_before_side_effects() ->
         data="Yes",
         answer=AsyncMock(),
         message=SimpleNamespace(
-            chat=SimpleNamespace(id=123),
+            chat_id=123,
             edit_reply_markup=AsyncMock(),
         ),
     )
@@ -2363,35 +2332,3 @@ async def test_callback_query_ignores_unauthorized_user_before_side_effects() ->
     query.answer.assert_not_awaited()
     query.message.edit_reply_markup.assert_not_awaited()
     channel._handle_message.assert_not_awaited()
-
-
-@pytest.mark.asyncio
-async def test_callback_query_handles_inaccessible_message() -> None:
-    from telegram import Chat, InaccessibleMessage
-
-    channel = TelegramChannel(
-        TelegramConfig(enabled=True, token="123:abc", allow_from=["*"], inline_keyboards=True),
-        MessageBus(),
-    )
-    channel._handle_message = AsyncMock()
-    channel._start_typing = lambda _chat_id: None
-
-    query = SimpleNamespace(
-        id="cb_inaccessible",
-        data="Yes",
-        answer=AsyncMock(),
-        message=InaccessibleMessage(
-            chat=Chat(id=123, type="private"),
-            message_id=456,
-        ),
-    )
-    update = SimpleNamespace(
-        callback_query=query,
-        effective_user=SimpleNamespace(id=12345, username="alice", first_name="Alice"),
-    )
-
-    await channel._on_callback_query(update, None)
-
-    query.answer.assert_awaited_once()
-    channel._handle_message.assert_awaited_once()
-    assert channel._handle_message.await_args.kwargs["chat_id"] == "123"

nanobot/channels/telegram/validation.py

@@ -1,7 +1,7 @@
 """Telegram setup validation owned by the channel package."""
 
 import re
-from typing import Any, cast
+from typing import Any
 from urllib.parse import urlparse
 
 import httpx
@@ -39,7 +39,7 @@ def _get_me(token: str, proxy: str | None) -> dict[str, Any]:
         response = client.get(f"https://api.telegram.org/bot{token}/getMe")
         response.raise_for_status()
         data = response.json()
-    return cast(dict[str, Any], data) if isinstance(data, dict) else {}
+    return data if isinstance(data, dict) else {}
 
 
 def validate(values: dict[str, Any], _context: ChannelValidationContext) -> dict[str, Any]:

nanobot/channels/validation.py

@@ -11,7 +11,7 @@ import re
 import socket
 import ssl
 from datetime import UTC, datetime
-from typing import Any, cast
+from typing import Any
 
 import httpx
 
@@ -76,7 +76,7 @@ def validate_channel_config(
             allow_local_service_access=config.tools.webui_allow_local_service_access,
         )
         custom_payload = setup_spec.validator(values, context)
-        if cast(object, custom_payload) is not None:
+        if custom_payload is not None:
             payload = dict(custom_payload)
             payload.setdefault("checks", [])
             payload.setdefault("missing_fields", [])
@@ -116,7 +116,7 @@ def _channel_config(
     if hasattr(section, "model_dump"):
         return dict(section.model_dump(mode="json", by_alias=True))
     if isinstance(section, dict):
-        return dict(cast(dict[str, Any], section))
+        return dict(section)
     return {}
 
 
@@ -130,9 +130,9 @@ def _merge_form_values(
     merged = dict(values)
     prefix = f"channels.{name}."
     spec = setup_spec
-    secrets: frozenset[str] = spec.secrets if spec is not None else frozenset()
+    secrets = spec.secrets if spec is not None else frozenset()
     for raw_key, raw_value in raw_values.items():
-        if not raw_key:
+        if not isinstance(raw_key, str) or not raw_key:
             continue
         field = raw_key[len(prefix):] if raw_key.startswith(prefix) else raw_key
         if field in secrets and not _str(raw_value):
@@ -281,7 +281,7 @@ def _assign(values: dict[str, Any], field: str, value: Any) -> None:
         if not isinstance(current, dict):
             current = {}
             target[part] = current
-        target = cast(dict[str, Any], current)
+        target = current
     target[parts[-1]] = value
 
 
@@ -290,7 +290,7 @@ def _get(values: dict[str, Any], field: str) -> Any:
     for part in field.split("."):
         if not isinstance(target, dict):
             return None
-        target = cast(dict[str, Any], target).get(part)
+        target = target.get(part)
     return target
 
 
@@ -346,7 +346,7 @@ def _http_get(url: str, *, headers: dict[str, str] | None = None) -> dict[str, A
         response = client.get(url, headers=headers)
         response.raise_for_status()
         data = response.json()
-    return cast(dict[str, Any], data) if isinstance(data, dict) else {}
+    return data if isinstance(data, dict) else {}
 
 
 def _http_post(url: str, *, headers: dict[str, str] | None = None) -> dict[str, Any]:
@@ -354,7 +354,7 @@ def _http_post(url: str, *, headers: dict[str, str] | None = None) -> dict[str,
         response = client.post(url, headers=headers)
         response.raise_for_status()
         data = response.json()
-    return cast(dict[str, Any], data) if isinstance(data, dict) else {}
+    return data if isinstance(data, dict) else {}
 
 
 def _probe_tcp(host: str, port: int, *, allow_loopback: bool = False) -> None:

nanobot/channels/websocket/runtime.py

@@ -11,18 +11,14 @@ import uuid
 from collections.abc import Callable
 from contextlib import suppress
 from pathlib import Path
-from typing import Any, Self, TypeGuard, cast
+from typing import Any, Self
 
 from pydantic import Field, field_validator, model_validator
 from websockets.asyncio.server import ServerConnection, serve, unix_serve
 from websockets.exceptions import ConnectionClosed
 from websockets.http11 import Request as WsRequest
 
-from nanobot.bus.events import (
-    INBOUND_META_TRANSIENT_SESSION,
-    OUTBOUND_META_AGENT_UI,
-    OutboundMessage,
-)
+from nanobot.bus.events import OUTBOUND_META_AGENT_UI, OutboundMessage
 from nanobot.bus.outbound_events import (
     GoalStateSyncEvent,
     GoalStatusEvent,
@@ -36,10 +32,6 @@ from nanobot.bus.outbound_events import (
 )
 from nanobot.bus.queue import MessageBus
 from nanobot.channels.base import BaseChannel
-from nanobot.channels.websocket.temporary_chat import (
-    TemporaryChatLifecycle,
-    TemporaryChatLifecycleError,
-)
 from nanobot.command.builtin import builtin_command_starts_agent_turn
 from nanobot.config.schema import Base
 from nanobot.runtime_context import (
@@ -75,7 +67,6 @@ from nanobot.webui.http_utils import (
 from nanobot.webui.mcp_presets_api import normalize_mcp_preset_mentions
 from nanobot.webui.metadata import (
     WEBSOCKET_TURN_OWNER_METADATA_KEY,
-    WEBUI_SYSTEM_COMMAND_TURN_PREFIX,
     WEBUI_TURN_METADATA_KEY,
 )
 from nanobot.webui.transcript import WEBUI_TRANSCRIPT_INCOMPLETE_KEY
@@ -84,8 +75,6 @@ from nanobot.webui.websocket_logging import websockets_server_logger
 
 # Plain HTTP WebUI routes also run through websockets.process_request.
 _WEBUI_HTTP_OPEN_TIMEOUT_S = 360.0
-_TEMPORARY_CHAT_ID_PREFIX = "temporary-"
-_TEMPORARY_COMMANDS = frozenset({"/model", "/stop"})
 
 
 class WebSocketConfig(Base):
@@ -202,13 +191,12 @@ def _parse_inbound_payload(raw: str) -> str | None:
         return None
     if text.startswith("{"):
         try:
-            data = cast(object, json.loads(text))
+            data = json.loads(text)
         except json.JSONDecodeError:
             return text
         if isinstance(data, dict):
-            payload = cast(dict[str, Any], data)
             for key in ("content", "text", "message"):
-                value = payload.get(key)
+                value = data.get(key)
                 if isinstance(value, str) and value.strip():
                     return value
             return None
@@ -221,14 +209,10 @@ def _parse_inbound_payload(raw: str) -> str | None:
 _CHAT_ID_RE = re.compile(r"^[A-Za-z0-9_:-]{1,64}$")
 
 
-def _is_valid_chat_id(value: Any) -> TypeGuard[str]:
+def _is_valid_chat_id(value: Any) -> bool:
     return isinstance(value, str) and _CHAT_ID_RE.match(value) is not None
 
 
-def _is_temporary_chat_id(value: Any) -> TypeGuard[str]:
-    return _is_valid_chat_id(value) and value.startswith(_TEMPORARY_CHAT_ID_PREFIX)
-
-
 def _parse_envelope(raw: str) -> dict[str, Any] | None:
     """Return a typed envelope dict if the frame is a new-style JSON envelope, else None.
 
@@ -240,16 +224,15 @@ def _parse_envelope(raw: str) -> dict[str, Any] | None:
     if not text.startswith("{"):
         return None
     try:
-        data = cast(object, json.loads(text))
+        data = json.loads(text)
     except json.JSONDecodeError:
         return None
     if not isinstance(data, dict):
         return None
-    envelope = cast(dict[str, Any], data)
-    t = envelope.get("type")
+    t = data.get("type")
     if not isinstance(t, str):
         return None
-    return envelope
+    return data
 
 
 def _is_websocket_upgrade(request: WsRequest) -> bool:
@@ -281,13 +264,13 @@ class WebSocketChannel(BaseChannel):
         super().__init__(config, bus)
         self.config: WebSocketConfig = config
         # chat_id -> connections subscribed to it (fan-out target).
-        self._subs: dict[str, set[ServerConnection]] = {}
+        self._subs: dict[str, set[Any]] = {}
         # connection -> chat_ids it is subscribed to (O(1) cleanup on disconnect).
-        self._conn_chats: dict[ServerConnection, set[str]] = {}
+        self._conn_chats: dict[Any, set[str]] = {}
         # connection -> default chat_id for legacy frames that omit routing.
-        self._conn_default: dict[ServerConnection, str] = {}
+        self._conn_default: dict[Any, str] = {}
         # Connections authenticated with a one-time token from /webui/bootstrap.
-        self._webui_connections: set[ServerConnection] = set()
+        self._webui_connections: set[Any] = set()
         self._stop_event: asyncio.Event | None = None
         self._server_task: asyncio.Task[None] | None = None
 
@@ -300,78 +283,29 @@ class WebSocketChannel(BaseChannel):
         self._workspaces = gateway.workspaces
 
         self._stream_text_buffers: dict[tuple[str, str], list[str]] = {}
-        self._temporary_chats = TemporaryChatLifecycle(
-            sessions=gateway.session_manager,
-            cancel_active_turn=gateway.cancel_active_turn,
-            attach=self._attach,
-            detach=self._detach,
-            clear_stream_buffers=self._clear_stream_buffers,
-        )
 
     # -- Subscription bookkeeping -------------------------------------------
 
-    def _workspace_controls_available(self, connection: ServerConnection) -> bool:
+    def _workspace_controls_available(self, connection: Any) -> bool:
         return self._http_router.workspace_controls_available(connection)
 
-    def _attach(self, connection: ServerConnection, chat_id: str) -> None:
+    def _attach(self, connection: Any, chat_id: str) -> None:
         """Idempotently subscribe *connection* to *chat_id*."""
         self._subs.setdefault(chat_id, set()).add(connection)
         self._conn_chats.setdefault(connection, set()).add(chat_id)
 
-    def _detach(self, connection: ServerConnection, chat_id: str) -> None:
-        chats = self._conn_chats.get(connection)
-        if chats is not None:
-            chats.discard(chat_id)
-            if not chats:
-                self._conn_chats.pop(connection, None)
-        subscribers = self._subs.get(chat_id)
-        if subscribers is not None:
-            subscribers.discard(connection)
-            if not subscribers:
-                self._subs.pop(chat_id, None)
-
-    def _clear_stream_buffers(self, chat_id: str) -> None:
-        for key in tuple(self._stream_text_buffers):
-            if key[0] == chat_id:
-                self._stream_text_buffers.pop(key, None)
-
-    async def send_webui_protocol_error(
-        self,
-        connection: ServerConnection,
-        detail: str,
-    ) -> None:
-        """Send a stable protocol error from a WebUI-owned orchestration helper."""
-        await self._send_event(connection, "error", detail=detail)
-
-    async def attach_webui_fork(
-        self,
-        connection: ServerConnection,
-        *,
-        fork_id: str,
-        fork_key: str,
-    ) -> None:
-        """Attach and hydrate a newly created WebUI chat fork."""
-        scope = self._workspaces.scope_for_session_key(fork_key)
-        self._attach(connection, fork_id)
-        await self._send_event(connection, "attached", chat_id=fork_id)
-        await self._send_event(
-            connection,
-            "session_updated",
-            chat_id=fork_id,
-            scope="metadata",
-            workspace_scope=scope.payload(),
-        )
-        await self._hydrate_after_subscribe(fork_id)
-
-    async def _cleanup_connection(self, connection: ServerConnection) -> None:
+    def _cleanup_connection(self, connection: Any) -> None:
         """Remove *connection* from every subscription set; safe to call multiple times."""
-        try:
-            await self._temporary_chats.discard_owner(connection)
-        finally:
-            for chat_id in tuple(self._conn_chats.get(connection, ())):
-                self._detach(connection, chat_id)
-            self._conn_default.pop(connection, None)
-            self._webui_connections.discard(connection)
+        chat_ids = self._conn_chats.pop(connection, set())
+        for cid in chat_ids:
+            subs = self._subs.get(cid)
+            if subs is None:
+                continue
+            subs.discard(connection)
+            if not subs:
+                self._subs.pop(cid, None)
+        self._conn_default.pop(connection, None)
+        self._webui_connections.discard(connection)
 
     async def _maybe_push_active_goal_state(self, chat_id: str) -> None:
         """Replay an active sustained goal from session metadata after *chat_id* is subscribed.
@@ -383,11 +317,10 @@ class WebSocketChannel(BaseChannel):
         if self.gateway.session_manager is None:
             return
         row = self.gateway.session_manager.read_session_file(f"websocket:{chat_id}")
-        row_data = row if isinstance(row, dict) else {}
-        meta = row_data.get("metadata", {})
+        meta = row.get("metadata", {}) if isinstance(row, dict) else {}
         if not isinstance(meta, dict):
             meta = {}
-        blob = goal_state_ws_blob(cast(dict[str, Any], meta))
+        blob = goal_state_ws_blob(meta)
         if not blob.get("active"):
             return
         await self.send_goal_state(chat_id, blob)
@@ -409,12 +342,7 @@ class WebSocketChannel(BaseChannel):
         await self._maybe_push_active_goal_state(chat_id)
         await self._maybe_push_turn_run_wall_clock(chat_id)
 
-    async def _send_event(
-        self,
-        connection: ServerConnection,
-        event: str,
-        **fields: Any,
-    ) -> None:
+    async def _send_event(self, connection: Any, event: str, **fields: Any) -> None:
         """Send a control event (attached, error, ...) to a single connection."""
         payload: dict[str, Any] = {"event": event}
         payload.update(fields)
@@ -422,7 +350,7 @@ class WebSocketChannel(BaseChannel):
         try:
             await connection.send(raw)
         except ConnectionClosed:
-            await self._cleanup_connection(connection)
+            self._cleanup_connection(connection)
         except Exception as e:
             self.logger.warning("failed to send {} event: {}", event, e)
 
@@ -449,7 +377,7 @@ class WebSocketChannel(BaseChannel):
 
     # -- HTTP dispatch ------------------------------------------------------
 
-    async def _dispatch_http(self, connection: ServerConnection, request: WsRequest) -> Any:
+    async def _dispatch_http(self, connection: Any, request: WsRequest) -> Any:
         """Route an inbound HTTP request to the HTTP handler or WS upgrade."""
         got, query = _parse_request_path(request.path)
 
@@ -466,11 +394,7 @@ class WebSocketChannel(BaseChannel):
         # Everything else goes to the HTTP handler
         return await self._http_router.dispatch(connection, request)
 
-    def _authorize_websocket_handshake(
-        self,
-        connection: ServerConnection,
-        query: dict[str, list[str]],
-    ) -> Any:
+    def _authorize_websocket_handshake(self, connection: Any, query: dict[str, list[str]]) -> Any:
         supplied = _query_first(query, "token")
         static_token = self.config.token.strip()
 
@@ -490,7 +414,7 @@ class WebSocketChannel(BaseChannel):
             self._consume_issued_token(connection, supplied)
         return None
 
-    def _consume_issued_token(self, connection: ServerConnection, token: str) -> bool:
+    def _consume_issued_token(self, connection: Any, token: str) -> bool:
         audience = self._tokens.take_issued_token_audience(token)
         if audience == "webui":
             self._webui_connections.add(connection)
@@ -585,7 +509,7 @@ class WebSocketChannel(BaseChannel):
         self._server_task = asyncio.create_task(runner())
         await self._server_task
 
-    async def _connection_loop(self, connection: ServerConnection) -> None:
+    async def _connection_loop(self, connection: Any) -> None:
         request = connection.request
         path_part = request.path if request else "/"
         _, query = _parse_request_path(path_part)
@@ -644,13 +568,13 @@ class WebSocketChannel(BaseChannel):
         except Exception as e:
             self.logger.debug("connection ended: {}", e)
         finally:
-            await self._cleanup_connection(connection)
+            self._cleanup_connection(connection)
 
     # -- Inbound WebSocket envelopes ---------------------------------------
 
     async def _dispatch_envelope(
         self,
-        connection: ServerConnection,
+        connection: Any,
         client_id: str,
         envelope: dict[str, Any],
     ) -> None:
@@ -682,36 +606,11 @@ class WebSocketChannel(BaseChannel):
         if t == "fork_chat":
             await handle_webui_fork_chat(self, connection, envelope)
             return
-        if t == "discard_temporary_chat":
-            cid = envelope.get("chat_id")
-            if not _is_temporary_chat_id(cid):
-                await self._send_event(connection, "error", detail="invalid temporary chat_id")
-                return
-            try:
-                await self._temporary_chats.discard(connection, cid)
-            except TemporaryChatLifecycleError as exc:
-                await self._send_event(
-                    connection,
-                    "error",
-                    detail=exc.detail,
-                    chat_id=cid,
-                )
-                return
-            await self._send_event(connection, "temporary_chat_discarded", chat_id=cid)
-            return
         if t == "attach":
             cid = envelope.get("chat_id")
             if not _is_valid_chat_id(cid):
                 await self._send_event(connection, "error", detail="invalid chat_id")
                 return
-            if _is_temporary_chat_id(cid):
-                await self._send_event(
-                    connection,
-                    "error",
-                    detail="temporary_chat_cannot_attach",
-                    chat_id=cid,
-                )
-                return
             self._attach(connection, cid)
             await self._send_event(connection, "attached", chat_id=cid)
             await self._hydrate_after_subscribe(cid)
@@ -721,14 +620,6 @@ class WebSocketChannel(BaseChannel):
             if not _is_valid_chat_id(cid):
                 await self._send_event(connection, "error", detail="invalid chat_id")
                 return
-            if _is_temporary_chat_id(cid):
-                await self._send_event(
-                    connection,
-                    "error",
-                    detail="temporary_chat_has_no_workspace",
-                    chat_id=cid,
-                )
-                return
             scope = await self._workspace_scope_or_error(
                 connection,
                 lambda: self._workspaces.scope_for_set_request(
@@ -760,15 +651,6 @@ class WebSocketChannel(BaseChannel):
             if not _is_valid_chat_id(cid):
                 await self._send_event(connection, "error", detail="invalid chat_id")
                 return
-            temporary = envelope.get("temporary") is True
-            if _is_temporary_chat_id(cid) != temporary:
-                await self._send_event(
-                    connection,
-                    "error",
-                    detail="temporary_chat_mismatch",
-                    chat_id=cid,
-                )
-                return
             raw_turn_id = envelope.get("turn_id")
             turn_id = raw_turn_id if isinstance(raw_turn_id, str) and raw_turn_id else None
             rejection_fields = {
@@ -805,17 +687,6 @@ class WebSocketChannel(BaseChannel):
                     **rejection_fields,
                 )
                 return
-            if temporary:
-                await self._dispatch_temporary_message(
-                    connection,
-                    client_id=client_id,
-                    chat_id=cid,
-                    content=content,
-                    turn_id=turn_id,
-                    envelope=envelope,
-                    rejection_fields=rejection_fields,
-                )
-                return
 
             raw_media = envelope.get("media")
             media_paths: list[str] = []
@@ -829,7 +700,7 @@ class WebSocketChannel(BaseChannel):
                         **rejection_fields,
                     )
                     return
-                media_paths, reason = self._media.store_inbound_attachments(cast(list[Any], raw_media))
+                media_paths, reason = self._media.store_inbound_attachments(raw_media)
                 if reason is not None:
                     await self._send_event(
                         connection,
@@ -937,106 +808,9 @@ class WebSocketChannel(BaseChannel):
             return
         await self._send_event(connection, "error", detail=f"unknown type: {t!r}")
 
-    async def _dispatch_temporary_message(
-        self,
-        connection: ServerConnection,
-        *,
-        client_id: str,
-        chat_id: str,
-        content: str,
-        turn_id: str | None,
-        envelope: dict[str, Any],
-        rejection_fields: dict[str, str],
-    ) -> None:
-        """Admit a WebUI-only message without durable or local-agent capabilities."""
-        if connection not in self._webui_connections:
-            await self._send_event(
-                connection,
-                "error",
-                detail="temporary_chat_unavailable",
-                **rejection_fields,
-            )
-            return
-        forbidden = (
-            "media",
-            "cli_apps",
-            "mcp_presets",
-            "quoted_context",
-            "workspace_scope",
-        )
-        if any(field in envelope for field in forbidden):
-            await self._send_event(
-                connection,
-                "error",
-                detail="temporary_chat_capability_rejected",
-                **rejection_fields,
-            )
-            return
-        if not content.strip():
-            await self._send_event(
-                connection,
-                "error",
-                detail="missing content",
-                **rejection_fields,
-            )
-            return
-        command = content.strip().partition(" ")[0].lower()
-        if command.startswith("/") and command not in _TEMPORARY_COMMANDS:
-            await self._send_event(
-                connection,
-                "error",
-                detail="temporary_chat_command_rejected",
-                **rejection_fields,
-            )
-            return
-
-        try:
-            session_key = self._temporary_chats.claim(connection, chat_id)
-        except TemporaryChatLifecycleError as exc:
-            await self._send_event(
-                connection,
-                "error",
-                detail=exc.detail,
-                **rejection_fields,
-            )
-            return
-
-        metadata: dict[str, Any] = {
-            "remote": getattr(connection, "remote_address", None),
-            "webui": True,
-            INBOUND_META_TRANSIENT_SESSION: True,
-            **self._transcripts.client_turn_metadata(turn_id),
-        }
-        queued_owner = None
-        if builtin_command_starts_agent_turn(content):
-            queued_owner = register_queued_websocket_turn_if_idle(chat_id, turn_id)
-            if queued_owner is not None:
-                metadata[WEBSOCKET_TURN_OWNER_METADATA_KEY] = queued_owner
-        accepted = False
-        try:
-            await self._handle_message(
-                sender_id=client_id,
-                chat_id=chat_id,
-                content=content,
-                metadata=metadata,
-                session_key=session_key,
-                is_dm=False,
-            )
-            accepted = True
-        finally:
-            if not accepted and queued_owner is not None:
-                clear_websocket_turn_if_current(chat_id, queued_owner)
-        if turn_id:
-            await self._send_event(
-                connection,
-                "message_accepted",
-                chat_id=chat_id,
-                turn_id=turn_id,
-            )
-
     async def _workspace_scope_or_error(
         self,
-        connection: ServerConnection,
+        connection: Any,
         resolver: Callable[[], Any],
         *,
         chat_id: str | None = None,
@@ -1067,33 +841,24 @@ class WebSocketChannel(BaseChannel):
             try:
                 await self._server_task
             except asyncio.CancelledError:
-                current_task = asyncio.current_task()
-                if current_task is not None and current_task.cancelling():
+                if asyncio.current_task() and asyncio.current_task().cancelling():
                     raise
                 self.logger.debug("server task was already cancelled during shutdown")
             except Exception as e:
                 self.logger.warning("server task error during shutdown: {}", e)
             self._server_task = None
-        for connection in tuple(self._conn_chats):
-            await self._temporary_chats.discard_owner(connection)
         self._subs.clear()
         self._conn_chats.clear()
         self._conn_default.clear()
         self._webui_connections.clear()
         self._tokens.clear()
 
-    async def _safe_send_to(
-        self,
-        connection: ServerConnection,
-        raw: str,
-        *,
-        label: str = "",
-    ) -> None:
+    async def _safe_send_to(self, connection: Any, raw: str, *, label: str = "") -> None:
         """Send a raw frame to one connection, cleaning up on ConnectionClosed."""
         try:
             await connection.send(raw)
         except ConnectionClosed:
-            await self._cleanup_connection(connection)
+            self._cleanup_connection(connection)
             self.logger.warning("connection gone{}", label)
         except Exception:
             self.logger.exception("send failed{}", label)
@@ -1110,8 +875,6 @@ class WebSocketChannel(BaseChannel):
         transcript_overrides: dict[str, Any] | None = None,
     ) -> bool:
         """Persist one canonical turn event and retain unsafe owners on failure."""
-        if _is_temporary_chat_id(chat_id):
-            return True
         persisted = self._transcripts.prepare_and_append(
             chat_id,
             event,
@@ -1193,13 +956,6 @@ class WebSocketChannel(BaseChannel):
             return
         # Signal that the agent has fully finished processing the current turn.
         if isinstance(event, TurnEndEvent):
-            turn_id = (msg.metadata or {}).get(WEBUI_TURN_METADATA_KEY)
-            session_update_scope = (
-                "metadata"
-                if isinstance(turn_id, str)
-                and turn_id.startswith(WEBUI_SYSTEM_COMMAND_TURN_PREFIX)
-                else "thread"
-            )
             turn_owner = (msg.metadata or {}).get(WEBSOCKET_TURN_OWNER_METADATA_KEY)
             await self.send_turn_end(
                 msg.chat_id,
@@ -1208,7 +964,7 @@ class WebSocketChannel(BaseChannel):
                 metadata=msg.metadata,
                 turn_owner=turn_owner if isinstance(turn_owner, str) else None,
             )
-            await self.send_session_updated(msg.chat_id, scope=session_update_scope)
+            await self.send_session_updated(msg.chat_id, scope="thread")
             return
         if isinstance(event, SessionUpdatedEvent):
             if conns:
@@ -1405,7 +1161,6 @@ class WebSocketChannel(BaseChannel):
             body,
             metadata=meta,
             phase="answer",
-            include_source=True,
         )
         raw = json.dumps(body, ensure_ascii=False)
         if not conns:

nanobot/channels/websocket/temporary_chat.py

@@ -1,85 +0,0 @@
-"""Connection-owned lifecycle for WebUI Temporary Chat sessions."""
-
-from __future__ import annotations
-
-from collections.abc import Awaitable, Callable
-
-from websockets.asyncio.server import ServerConnection
-
-from nanobot.session.manager import SessionManager
-from nanobot.session.webui_turns import clear_websocket_turns
-
-
-class TemporaryChatLifecycleError(RuntimeError):
-    """A stable WebSocket protocol error raised by the temporary-chat lifecycle."""
-
-    def __init__(self, detail: str) -> None:
-        self.detail = detail
-        super().__init__(detail)
-
-
-class TemporaryChatLifecycle:
-    """Own temporary session identity, cancellation, and cleanup ordering."""
-
-    def __init__(
-        self,
-        *,
-        sessions: SessionManager | None,
-        cancel_active_turn: Callable[[str], Awaitable[int]] | None,
-        attach: Callable[[ServerConnection, str], None],
-        detach: Callable[[ServerConnection, str], None],
-        clear_stream_buffers: Callable[[str], None],
-    ) -> None:
-        self._sessions = sessions
-        self._cancel_active_turn = cancel_active_turn
-        self._attach = attach
-        self._detach = detach
-        self._clear_stream_buffers = clear_stream_buffers
-        self._owners: dict[str, ServerConnection] = {}
-
-    def claim(self, owner: ServerConnection, chat_id: str) -> str:
-        """Claim *chat_id* for *owner* and return its in-memory session key."""
-        if self._sessions is None or self._cancel_active_turn is None:
-            raise TemporaryChatLifecycleError("temporary_chat_unavailable")
-        current = self._owners.get(chat_id)
-        if current is not None and current is not owner:
-            raise TemporaryChatLifecycleError("temporary_chat_not_owned")
-
-        session_key = f"websocket:{chat_id}"
-        self._sessions.get_or_create_transient(session_key)
-        self._owners[chat_id] = owner
-        self._attach(owner, chat_id)
-        return session_key
-
-    async def discard(self, owner: ServerConnection, chat_id: str) -> None:
-        """Discard an owned chat; an unused chat is already discarded."""
-        current = self._owners.get(chat_id)
-        if current is None:
-            return
-        if current is not owner:
-            raise TemporaryChatLifecycleError("temporary_chat_not_owned")
-        await self._discard_owned(owner, chat_id)
-
-    async def discard_owner(self, owner: ServerConnection) -> None:
-        """Discard every temporary chat held by a disconnected owner."""
-        chat_ids = (
-            chat_id
-            for chat_id, current in self._owners.items()
-            if current is owner
-        )
-        for chat_id in tuple(chat_ids):
-            await self._discard_owned(owner, chat_id)
-
-    async def _discard_owned(self, owner: ServerConnection, chat_id: str) -> None:
-        self._owners.pop(chat_id, None)
-        self._detach(owner, chat_id)
-
-        session_key = f"websocket:{chat_id}"
-        assert self._sessions is not None
-        assert self._cancel_active_turn is not None
-        self._sessions.discard_transient(session_key)
-        try:
-            await self._cancel_active_turn(session_key)
-        finally:
-            clear_websocket_turns(chat_id)
-            self._clear_stream_buffers(chat_id)

nanobot/channels/websocket/tests/test_websocket_channel.py

@@ -49,12 +49,7 @@ from nanobot.webui.http_utils import (
 from nanobot.webui.http_utils import (
     parse_request_path as _parse_request_path,
 )
-from nanobot.webui.metadata import (
-    WEBSOCKET_TURN_OWNER_METADATA_KEY,
-    WEBUI_MESSAGE_SOURCE_METADATA_KEY,
-    WEBUI_SYSTEM_COMMAND_TURN_PREFIX,
-    WEBUI_TURN_METADATA_KEY,
-)
+from nanobot.webui.metadata import WEBSOCKET_TURN_OWNER_METADATA_KEY
 from nanobot.webui.settings_api import settings_payload, update_provider_settings
 from nanobot.webui.transcript import (
     append_transcript_object,
@@ -111,7 +106,6 @@ def _basic_handler(bus: Any, **kw: Any) -> GatewayServices:
         runtime_model_name=None,
         runtime_surface=kw.get("runtime_surface", "browser"),
         runtime_capabilities_overrides=kw.get("runtime_capabilities_overrides"),
-        cancel_active_turn=kw.get("cancel_active_turn"),
     )
 
 
@@ -191,182 +185,6 @@ def isolate_webui_workspace_state(tmp_path, monkeypatch) -> None:
     wth._WEBSOCKET_TURN_OWNERS.clear()
 
 
-@pytest.mark.asyncio
-async def test_temporary_message_registers_in_memory_session(bus, tmp_path) -> None:
-    sessions = SessionManager(tmp_path)
-    cancel = AsyncMock(return_value=0)
-    channel = WebSocketChannel(
-        {"enabled": True, "allowFrom": ["*"]},
-        bus,
-        gateway=_basic_handler(
-            bus,
-            session_manager=sessions,
-            cancel_active_turn=cancel,
-        ),
-    )
-    connection = AsyncMock()
-    connection.remote_address = None
-    channel._webui_connections.add(connection)
-    chat_id = "temporary-test"
-
-    await channel._dispatch_envelope(
-        connection,
-        "client",
-        {
-            "type": "message",
-            "chat_id": chat_id,
-            "content": "hello",
-            "turn_id": "turn-1",
-            "temporary": True,
-            "webui": True,
-        },
-    )
-
-    inbound = bus.publish_inbound.await_args.args[0]
-    assert inbound.session_key == f"websocket:{chat_id}"
-    assert inbound.transient_session is True
-    assert sessions.is_transient_active(inbound.session_key) is True
-    assert sessions.get_cached(inbound.session_key).transient is True
-    assert read_transcript_lines(inbound.session_key) == []
-    assert json.loads(connection.send.await_args.args[0])["event"] == "message_accepted"
-
-
-@pytest.mark.asyncio
-@pytest.mark.parametrize(
-    "envelope",
-    [
-        {"type": "attach", "chat_id": "temporary-test"},
-        {
-            "type": "set_workspace_scope",
-            "chat_id": "temporary-test",
-            "workspace_scope": {},
-        },
-        {
-            "type": "message",
-            "chat_id": "temporary-test",
-            "content": "hello",
-            "temporary": True,
-            "media": [],
-        },
-        {
-            "type": "message",
-            "chat_id": "temporary-test",
-            "content": "/history",
-            "temporary": True,
-        },
-    ],
-)
-async def test_temporary_chat_rejects_persistent_capabilities(
-    bus,
-    tmp_path,
-    envelope,
-) -> None:
-    channel = WebSocketChannel(
-        {"enabled": True, "allowFrom": ["*"]},
-        bus,
-        gateway=_basic_handler(
-            bus,
-            session_manager=SessionManager(tmp_path),
-            cancel_active_turn=AsyncMock(return_value=0),
-        ),
-    )
-    connection = AsyncMock()
-    connection.remote_address = None
-    channel._webui_connections.add(connection)
-
-    await channel._dispatch_envelope(connection, "client", envelope)
-
-    payload = json.loads(connection.send.await_args.args[0])
-    assert payload["event"] == "error"
-    bus.publish_inbound.assert_not_awaited()
-
-
-@pytest.mark.asyncio
-async def test_discard_temporary_chat_cancels_then_forgets_session(bus, tmp_path) -> None:
-    sessions = SessionManager(tmp_path)
-    cancel = AsyncMock(return_value=1)
-    channel = WebSocketChannel(
-        {"enabled": True, "allowFrom": ["*"]},
-        bus,
-        gateway=_basic_handler(
-            bus,
-            session_manager=sessions,
-            cancel_active_turn=cancel,
-        ),
-    )
-    connection = AsyncMock()
-    connection.remote_address = None
-    channel._webui_connections.add(connection)
-    chat_id = "temporary-test"
-    session_key = channel._temporary_chats.claim(connection, chat_id)
-    sessions.get_cached(session_key).add_message("user", "private")
-
-    await channel._dispatch_envelope(
-        connection,
-        "client",
-        {"type": "discard_temporary_chat", "chat_id": chat_id},
-    )
-
-    cancel.assert_awaited_once_with(session_key)
-    assert sessions.get_cached(session_key) is None
-    assert chat_id not in channel._subs
-    assert json.loads(connection.send.await_args.args[0]) == {
-        "event": "temporary_chat_discarded",
-        "chat_id": chat_id,
-    }
-
-
-@pytest.mark.asyncio
-async def test_discard_unused_temporary_chat_is_idempotent(bus, tmp_path) -> None:
-    cancel = AsyncMock(return_value=0)
-    channel = WebSocketChannel(
-        {"enabled": True, "allowFrom": ["*"]},
-        bus,
-        gateway=_basic_handler(
-            bus,
-            session_manager=SessionManager(tmp_path),
-            cancel_active_turn=cancel,
-        ),
-    )
-    connection = AsyncMock()
-
-    await channel._dispatch_envelope(
-        connection,
-        "client",
-        {"type": "discard_temporary_chat", "chat_id": "temporary-unused"},
-    )
-
-    cancel.assert_not_awaited()
-    assert json.loads(connection.send.await_args.args[0]) == {
-        "event": "temporary_chat_discarded",
-        "chat_id": "temporary-unused",
-    }
-
-
-@pytest.mark.asyncio
-async def test_disconnect_discards_owned_temporary_chat(bus, tmp_path) -> None:
-    sessions = SessionManager(tmp_path)
-    cancel = AsyncMock(return_value=1)
-    channel = WebSocketChannel(
-        {"enabled": True, "allowFrom": ["*"]},
-        bus,
-        gateway=_basic_handler(
-            bus,
-            session_manager=sessions,
-            cancel_active_turn=cancel,
-        ),
-    )
-    connection = AsyncMock()
-    chat_id = "temporary-disconnect"
-    session_key = channel._temporary_chats.claim(connection, chat_id)
-
-    await channel._cleanup_connection(connection)
-
-    cancel.assert_awaited_once_with(session_key)
-    assert sessions.get_cached(session_key) is None
-    assert chat_id not in channel._subs
-
-
 @pytest.mark.asyncio
 async def test_send_session_updated_broadcasts_to_other_webui_connections(bus) -> None:
     class Conn:
@@ -1528,35 +1346,6 @@ async def test_send_delta_emits_delta_and_stream_end() -> None:
     assert "text" not in second
 
 
-@pytest.mark.asyncio
-async def test_send_delta_preserves_webui_source_metadata() -> None:
-    bus = MagicMock()
-    channel = WebSocketChannel({"enabled": True, "allowFrom": ["*"], "streaming": True}, bus, gateway=_basic_handler(bus))
-    mock_ws = AsyncMock()
-    channel._attach(mock_ws, "chat-source-stream")
-    source = {"kind": "cron", "label": "Repo check"}
-    metadata = {WEBUI_MESSAGE_SOURCE_METADATA_KEY: source}
-
-    await channel.send_delta("chat-source-stream", "done", metadata=metadata, stream_id="sid")
-    await channel.send_delta(
-        "chat-source-stream",
-        "",
-        metadata=metadata,
-        stream_id="sid",
-        stream_end=True,
-    )
-
-    first = json.loads(mock_ws.send.call_args_list[0][0][0])
-    second = json.loads(mock_ws.send.call_args_list[1][0][0])
-    assert first["event"] == "delta"
-    assert first["source"] == source
-    assert second["event"] == "stream_end"
-    assert second["source"] == source
-    lines = read_transcript_lines("websocket:chat-source-stream")
-    assert lines[-2]["source"] == source
-    assert lines[-1]["source"] == source
-
-
 @pytest.mark.asyncio
 async def test_send_delta_marks_resuming_stream_end() -> None:
     bus = MagicMock()
@@ -1829,43 +1618,6 @@ async def test_send_turn_end_emits_turn_end_event() -> None:
     ]
 
 
-@pytest.mark.asyncio
-async def test_system_command_turn_end_only_refreshes_session_metadata() -> None:
-    bus = MagicMock()
-    channel = WebSocketChannel(
-        {"enabled": True, "allowFrom": ["*"]},
-        bus,
-        gateway=_basic_handler(bus),
-    )
-    mock_ws = AsyncMock()
-    channel._attach(mock_ws, "chat-model")
-
-    await channel.send(OutboundMessage(
-        channel="websocket",
-        chat_id="chat-model",
-        content="",
-        metadata={
-            WEBUI_TURN_METADATA_KEY: f"{WEBUI_SYSTEM_COMMAND_TURN_PREFIX}model-switch",
-        },
-        event=TurnEndEvent(),
-    ))
-
-    assert _sent_ws_payloads(mock_ws) == [
-        {
-            "event": "turn_end",
-            "chat_id": "chat-model",
-            "turn_id": f"{WEBUI_SYSTEM_COMMAND_TURN_PREFIX}model-switch",
-            "turn_phase": "complete",
-            "turn_seq": 1,
-        },
-        {
-            "event": "session_updated",
-            "chat_id": "chat-model",
-            "scope": "metadata",
-        },
-    ]
-
-
 @pytest.mark.asyncio
 @pytest.mark.parametrize(
     ("active_owner", "event_owner", "expected_cleared"),
@@ -2710,7 +2462,7 @@ async def test_settings_api_returns_safe_subset_and_updates_whitelist(
     port = 29891
     config_path = tmp_path / "config.json"
     config = Config()
-    config.agents.defaults.model = "openai/gpt-4o"
+    config.resolve_default_preset().model = "openai/gpt-4o"
     config.providers.openai.api_key = "secret-key"
     config.model_presets["deep"] = ModelPresetConfig(
         model="anthropic/claude-opus-4-5",
@@ -3043,8 +2795,8 @@ async def test_settings_api_returns_safe_subset_and_updates_whitelist(
         assert bad_image.status_code == 400
 
         saved = load_config(config_path)
-        assert saved.agents.defaults.model == "atomic_chat/test"
-        assert saved.agents.defaults.provider == "atomic_chat"
+        assert saved.resolve_default_preset().model == "atomic_chat/test"
+        assert saved.resolve_default_preset().provider == "atomic_chat"
         assert saved.agents.defaults.model_preset == "fast-writing"
         assert saved.agents.defaults.fallback_models == ["deep"]
         assert saved.model_presets["fast-writing"].label == "Codex"
@@ -3249,7 +3001,7 @@ def test_settings_payload_normalizes_camel_case_provider(
 ) -> None:
     config_path = tmp_path / "config.json"
     config = Config()
-    config.agents.defaults.provider = "minimaxAnthropic"
+    config.resolve_default_preset().provider = "minimaxAnthropic"
     save_config(config, config_path)
     monkeypatch.setattr("nanobot.config.loader._current_config_path", config_path)
 

nanobot/channels/websocket/tests/test_websocket_http_routes.py

@@ -519,8 +519,6 @@ async def test_webui_skills_route_requires_token_and_hides_paths(
             "name": "workspace-skill",
             "description": "Workspace skill.",
             "source": "workspace",
-            "enabled": True,
-            "deletable": True,
             "available": True,
             "unavailable_reason": "",
         }
@@ -550,366 +548,6 @@ async def test_webui_skills_route_requires_token_and_hides_paths(
         await server_task
 
 
-@pytest.mark.asyncio
-async def test_webui_skill_management_routes(
-    bus: MagicMock,
-    tmp_path: Path,
-    monkeypatch: pytest.MonkeyPatch,
-) -> None:
-    skill_dir = tmp_path / "skills" / "custom-skill"
-    skill_dir.mkdir(parents=True)
-    (skill_dir / "SKILL.md").write_text(
-        "---\nname: custom-skill\ndescription: Custom skill.\n---\n",
-        encoding="utf-8",
-    )
-
-    def set_enabled(
-        workspace: Path,
-        name: str,
-        *,
-        enabled: bool,
-        disabled_skills: set[str],
-    ) -> dict[str, Any]:
-        assert workspace == tmp_path
-        assert name == "custom-skill"
-        assert enabled is False
-        disabled_skills.add(name)
-        return {"name": name, "enabled": enabled, "deleted": False}
-
-    def delete(
-        workspace: Path,
-        name: str,
-        *,
-        disabled_skills: set[str],
-    ) -> dict[str, Any]:
-        assert workspace == tmp_path
-        assert name == "custom-skill"
-        disabled_skills.discard(name)
-        for child in skill_dir.iterdir():
-            child.unlink()
-        skill_dir.rmdir()
-        return {"name": name, "enabled": False, "deleted": True}
-
-    monkeypatch.setattr("nanobot.webui.ws_http.set_webui_skill_enabled", set_enabled)
-    monkeypatch.setattr("nanobot.webui.ws_http.delete_webui_skill", delete)
-
-    port = _free_port()
-    channel = _ch(
-        bus,
-        session_manager=_seed_session(tmp_path),
-        workspace_path=tmp_path,
-        port=port,
-    )
-    server_task = asyncio.create_task(channel.start())
-    try:
-        token = channel.gateway.tokens.issue_api_token(300)
-        headers = {"Authorization": f"Bearer {token}"}
-        update_response = await _http_get(
-            f"http://127.0.0.1:{port}/api/webui/skills/update"
-            "?name=custom-skill&enabled=false",
-            headers=headers,
-        )
-        assert update_response.status_code == 200
-        assert update_response.json()["last_action"]["enabled"] is False
-        custom = next(
-            item
-            for item in update_response.json()["skills"]
-            if item["name"] == "custom-skill"
-        )
-        assert custom["enabled"] is False
-
-        delete_response = await _http_get(
-            f"http://127.0.0.1:{port}/api/webui/skills/delete"
-            "?name=custom-skill",
-            headers=headers,
-        )
-        assert delete_response.status_code == 200
-        assert delete_response.json()["last_action"]["deleted"] is True
-        assert all(
-            item["name"] != "custom-skill"
-            for item in delete_response.json()["skills"]
-        )
-    finally:
-        await channel.stop()
-        await server_task
-
-
-@pytest.mark.asyncio
-async def test_webui_skills_marketplace_routes_search_and_install(
-    bus: MagicMock,
-    tmp_path: Path,
-    monkeypatch: pytest.MonkeyPatch,
-) -> None:
-    search = AsyncMock(return_value={
-        "query": "react",
-        "install_supported": True,
-        "skills": [{
-            "id": "acme/agent-skills/react-testing",
-            "skill_id": "react-testing",
-            "name": "React Testing",
-            "source": "acme/agent-skills",
-            "installs": 42,
-            "url": "https://skills.sh/acme/agent-skills/react-testing",
-            "installed": False,
-        }],
-    })
-    trending = AsyncMock(return_value={
-        "period": "24h",
-        "install_supported": True,
-        "skills": [{
-            "id": "acme/agent-skills/react-testing",
-            "skill_id": "react-testing",
-            "name": "React Testing",
-            "source": "acme/agent-skills",
-            "installs": 12,
-            "url": "https://skills.sh/acme/agent-skills/react-testing",
-            "installed": False,
-            "rank": 1,
-        }],
-    })
-    trends = AsyncMock(return_value={
-        "trends": {"acme/agent-skills/react-testing": [2, 4, 3, 8]},
-    })
-
-    async def install(
-        source: str,
-        skill_id: str,
-        workspace: Path,
-        *,
-        provider: str,
-        version: str,
-    ) -> dict[str, Any]:
-        assert source == "acme/agent-skills"
-        assert skill_id == "react-testing"
-        assert workspace == tmp_path
-        assert provider == "skills_sh"
-        assert version == ""
-        skill_dir = workspace / "skills" / skill_id
-        skill_dir.mkdir(parents=True)
-        (skill_dir / "SKILL.md").write_text(
-            "---\nname: react-testing\ndescription: Test React apps.\n---\n",
-            encoding="utf-8",
-        )
-        return {"installed": True, "already_installed": False, "name": skill_id}
-
-    install_mock = AsyncMock(side_effect=install)
-    monkeypatch.setattr("nanobot.webui.ws_http.search_marketplace_skills", search)
-    monkeypatch.setattr("nanobot.webui.ws_http.trending_marketplace_skills", trending)
-    monkeypatch.setattr("nanobot.webui.ws_http.marketplace_skill_trends", trends)
-    monkeypatch.setattr("nanobot.webui.ws_http.install_marketplace_skill", install_mock)
-
-    port = _free_port()
-    channel = _ch(
-        bus,
-        session_manager=_seed_session(tmp_path),
-        workspace_path=tmp_path,
-        port=port,
-    )
-    server_task = asyncio.create_task(channel.start())
-    try:
-        denied = await _http_get(
-            f"http://127.0.0.1:{port}/api/webui/skills/search?q=react"
-        )
-        assert denied.status_code == 401
-
-        token = channel.gateway.tokens.issue_api_token(300)
-        headers = {"Authorization": f"Bearer {token}"}
-        search_response = await _http_get(
-            f"http://127.0.0.1:{port}/api/webui/skills/search?q=react",
-            headers=headers,
-        )
-        assert search_response.status_code == 200
-        assert search_response.json()["skills"][0]["skill_id"] == "react-testing"
-        search.assert_awaited_once_with("react", tmp_path, provider="all")
-
-        trending_response = await _http_get(
-            f"http://127.0.0.1:{port}/api/webui/skills/trending",
-            headers=headers,
-        )
-        assert trending_response.status_code == 200
-        assert trending_response.json()["period"] == "24h"
-        trending.assert_awaited_once_with(tmp_path, provider="all")
-
-        trends_response = await _http_get(
-            f"http://127.0.0.1:{port}/api/webui/skills/trends"
-            "?id=acme%2Fagent-skills%2Freact-testing",
-            headers=headers,
-        )
-        assert trends_response.status_code == 200
-        assert trends_response.json()["trends"] == {
-            "acme/agent-skills/react-testing": [2, 4, 3, 8],
-        }
-        trends.assert_awaited_once_with(["acme/agent-skills/react-testing"])
-
-        params = urlencode({
-            "source": "acme/agent-skills",
-            "skill": "react-testing",
-        })
-        install_response = await _http_get(
-            f"http://127.0.0.1:{port}/api/webui/skills/install?{params}",
-            headers=headers,
-        )
-        assert install_response.status_code == 200
-        body = install_response.json()
-        assert body["last_action"] == {
-            "installed": True,
-            "already_installed": False,
-            "name": "react-testing",
-        }
-        assert next(
-            skill for skill in body["skills"] if skill["name"] == "react-testing"
-        )["source"] == "workspace"
-        install_mock.assert_awaited_once()
-    finally:
-        await channel.stop()
-        await server_task
-
-
-@pytest.mark.asyncio
-async def test_webui_skill_install_rejects_overlapping_requests(
-    bus: MagicMock,
-    tmp_path: Path,
-    monkeypatch: pytest.MonkeyPatch,
-) -> None:
-    started = asyncio.Event()
-    finish = asyncio.Event()
-
-    async def install(
-        source: str,
-        skill_id: str,
-        workspace: Path,
-        *,
-        provider: str,
-        version: str,
-    ) -> dict[str, Any]:
-        started.set()
-        await finish.wait()
-        skill_dir = workspace / "skills" / skill_id
-        skill_dir.mkdir(parents=True)
-        (skill_dir / "SKILL.md").write_text(
-            "---\nname: react-testing\ndescription: Test React apps.\n---\n",
-            encoding="utf-8",
-        )
-        return {"installed": True, "already_installed": False, "name": skill_id}
-
-    install_mock = AsyncMock(side_effect=install)
-    monkeypatch.setattr("nanobot.webui.ws_http.install_marketplace_skill", install_mock)
-    channel = _ch(
-        bus,
-        session_manager=_seed_session(tmp_path),
-        workspace_path=tmp_path,
-        port=_free_port(),
-    )
-    token = channel.gateway.tokens.issue_api_token(300)
-    path = (
-        "/api/webui/skills/install"
-        "?source=acme%2Fagent-skills&skill=react-testing"
-    )
-    request = _FakeReq(
-        {
-            "Authorization": f"Bearer {token}",
-            "Host": "127.0.0.1:8765",
-        },
-        path=path,
-    )
-
-    first = asyncio.create_task(channel.gateway.http.dispatch(_LOCAL, request))
-    await started.wait()
-    overlapping = await channel.gateway.http.dispatch(_LOCAL, request)
-
-    assert overlapping.status_code == 409
-    assert "already in progress" in overlapping.body.decode()
-    assert install_mock.await_count == 1
-
-    finish.set()
-    completed = await first
-    assert completed.status_code == 200
-    assert install_mock.await_count == 1
-
-
-@pytest.mark.asyncio
-async def test_webui_skill_delete_remains_local_only(
-    bus: MagicMock,
-    tmp_path: Path,
-    monkeypatch: pytest.MonkeyPatch,
-) -> None:
-    delete = MagicMock()
-    policy = MagicMock()
-    policy.tools.webui_allow_remote_package_install = True
-    monkeypatch.setattr("nanobot.config.loader.load_config", lambda: policy)
-    monkeypatch.setattr("nanobot.webui.ws_http.delete_webui_skill", delete)
-    channel = _ch(
-        bus,
-        session_manager=_seed_session(tmp_path),
-        workspace_path=tmp_path,
-        port=_free_port(),
-    )
-    token = channel.gateway.tokens.issue_api_token(300)
-    response = await channel.gateway.http.dispatch(
-        _REMOTE,
-        _FakeReq(
-            {"Authorization": f"Bearer {token}"},
-            path="/api/webui/skills/delete?name=custom-skill",
-        ),
-    )
-
-    assert response.status_code == 403
-    assert "remote skill deletion is disabled" in response.body.decode()
-    delete.assert_not_called()
-
-
-@pytest.mark.asyncio
-async def test_webui_skill_install_honors_remote_install_opt_in(
-    bus: MagicMock,
-    tmp_path: Path,
-    monkeypatch: pytest.MonkeyPatch,
-) -> None:
-    policy = MagicMock()
-    policy.tools.webui_allow_remote_package_install = True
-    monkeypatch.setattr("nanobot.config.loader.load_config", lambda: policy)
-
-    async def install(
-        source: str,
-        skill_id: str,
-        workspace: Path,
-        *,
-        provider: str,
-        version: str,
-    ) -> dict[str, Any]:
-        skill_dir = workspace / "skills" / skill_id
-        skill_dir.mkdir(parents=True)
-        (skill_dir / "SKILL.md").write_text(
-            "---\nname: react-testing\ndescription: Test React apps.\n---\n",
-            encoding="utf-8",
-        )
-        return {"installed": True, "already_installed": False, "name": skill_id}
-
-    monkeypatch.setattr(
-        "nanobot.webui.ws_http.install_marketplace_skill",
-        AsyncMock(side_effect=install),
-    )
-    channel = _ch(
-        bus,
-        session_manager=_seed_session(tmp_path),
-        workspace_path=tmp_path,
-        port=_free_port(),
-    )
-    token = channel.gateway.tokens.issue_api_token(300)
-    response = await channel.gateway.http.dispatch(
-        _REMOTE,
-        _FakeReq(
-            {"Authorization": f"Bearer {token}"},
-            path=(
-                "/api/webui/skills/install"
-                "?source=acme%2Fagent-skills&skill=react-testing"
-            ),
-        ),
-    )
-
-    assert response.status_code == 200
-    assert json.loads(response.body.decode())["last_action"]["name"] == "react-testing"
-
-
 @pytest.mark.asyncio
 async def test_cli_apps_routes_require_token_and_return_payload(
     bus: MagicMock,
@@ -2937,17 +2575,6 @@ async def test_webui_thread_resigns_assistant_media_urls(
         assert media[0]["url"].startswith("/api/media/")
         assert media[0]["url"] != "/api/media/old-sig/old-payload"
 
-        repeated = await _http_get(
-            "http://127.0.0.1:29914/api/sessions/websocket:video-replay/webui-thread",
-            headers=auth,
-        )
-        repeated_assistant = next(
-            m for m in repeated.json()["messages"] if m["role"] == "assistant"
-        )
-        assert repeated_assistant["id"] == assistant["id"]
-        assert repeated_assistant["media"][0]["url"] == media[0]["url"]
-        assert len(list(websocket_media.iterdir())) == 1
-
         fetched = await _http_get(f"http://127.0.0.1:29914{media[0]['url']}")
         assert fetched.status_code == 200
         assert fetched.content == b"video"

nanobot/channels/websocket/tests/test_websocket_media_route.py

@@ -146,41 +146,16 @@ def test_local_markdown_image_is_staged_and_rewritten(
     channel = _ch(bus, workspace_path=workspace, port=0)
 
     with patch("nanobot.webui.media_gateway.get_media_dir", side_effect=_fake_media_dir(media)):
-        first = channel.gateway.media.rewrite_local_markdown_images(
-            "The result:\n![Cloud Architecture Diagram](demo_arch.png)"
-        )
-        second = channel.gateway.media.rewrite_local_markdown_images(
+        rewritten = channel.gateway.media.rewrite_local_markdown_images(
             "The result:\n![Cloud Architecture Diagram](demo_arch.png)"
         )
 
-    assert "![Cloud Architecture Diagram](/api/media/" in first
-    assert second == first
+    assert "![Cloud Architecture Diagram](/api/media/" in rewritten
     staged = list((media / "websocket").iterdir())
     assert len(staged) == 1
     assert staged[0].read_bytes() == _PNG_BYTES
 
 
-def test_modified_local_markdown_image_gets_a_new_immutable_url(
-    bus: MagicMock,
-    tmp_path: Path,
-) -> None:
-    workspace = tmp_path / "workspace"
-    workspace.mkdir()
-    source = workspace / "demo_arch.png"
-    source.write_bytes(_PNG_BYTES)
-    media = tmp_path / "media"
-    channel = _ch(bus, workspace_path=workspace, port=0)
-    markdown = "![Cloud Architecture Diagram](demo_arch.png)"
-
-    with patch("nanobot.webui.media_gateway.get_media_dir", side_effect=_fake_media_dir(media)):
-        first = channel.gateway.media.rewrite_local_markdown_images(markdown)
-        source.write_bytes(_PNG_BYTES + b"updated")
-        second = channel.gateway.media.rewrite_local_markdown_images(markdown)
-
-    assert second != first
-    assert len(list((media / "websocket").iterdir())) == 2
-
-
 def test_local_markdown_video_is_staged_and_rewritten(
     bus: MagicMock,
     tmp_path: Path,

nanobot/channels/wecom/runtime.py

@@ -1,4 +1,3 @@
-# pyright: reportMissingTypeStubs=false
 """WeCom (Enterprise WeChat) channel implementation using wecom_aibot_sdk."""
 
 import asyncio
@@ -8,9 +7,8 @@ import importlib.util
 import os
 import re
 from collections import OrderedDict
-from collections.abc import Callable
 from pathlib import Path
-from typing import Any, cast
+from typing import Any
 
 from pydantic import Field
 
@@ -98,7 +96,7 @@ class WecomChannel(BaseChannel):
         self._client: Any = None
         self._processed_message_ids: OrderedDict[str, None] = OrderedDict()
         self._loop: asyncio.AbstractEventLoop | None = None
-        self._generate_req_id: Callable[[str], str] | None = None
+        self._generate_req_id = None
         # Store frame headers for each chat to enable replies
         self._chat_frames: dict[str, Any] = {}
 
@@ -119,8 +117,7 @@ class WecomChannel(BaseChannel):
         self._generate_req_id = generate_req_id
 
         # Create WebSocket client
-        ws_client = cast(Any, WSClient)
-        self._client = ws_client({
+        self._client = WSClient({
             "bot_id": self.config.bot_id,
             "secret": self.config.secret,
             "reconnect_interval": 1000,
@@ -198,16 +195,14 @@ class WecomChannel(BaseChannel):
         """Handle enter_chat event (user opens chat with bot)."""
         try:
             # Extract body from WsFrame dataclass or dict
-            if hasattr(frame, "body"):
-                body: Any = frame.body or {}
+            if hasattr(frame, 'body'):
+                body = frame.body or {}
             elif isinstance(frame, dict):
-                frame_dict = cast(dict[str, Any], frame)
-                body = frame_dict.get("body", frame_dict)
+                body = frame.get("body", frame)
             else:
                 body = {}
 
-            body_dict = cast(dict[str, Any], body) if isinstance(body, dict) else {}
-            chat_id = cast(str, body_dict.get("chatid", ""))
+            chat_id = body.get("chatid", "") if isinstance(body, dict) else ""
 
             if chat_id and not self.is_allowed(chat_id):
                 return
@@ -224,32 +219,26 @@ class WecomChannel(BaseChannel):
         """Process incoming message and forward to bus."""
         try:
             # Extract body from WsFrame dataclass or dict
-            if hasattr(frame, "body"):
-                body: Any = frame.body or {}
+            if hasattr(frame, 'body'):
+                body = frame.body or {}
             elif isinstance(frame, dict):
-                frame_dict = cast(dict[str, Any], frame)
-                body = frame_dict.get("body", frame_dict)
+                body = frame.get("body", frame)
             else:
                 body = {}
 
             # Ensure body is a dict
             if not isinstance(body, dict):
-                self.logger.warning("Invalid body type: {}", type(cast(object, body)))
+                self.logger.warning("Invalid body type: {}", type(body))
                 return
-            body = cast(dict[str, Any], body)
 
             # Extract message info
-            msg_id = cast(str, body.get("msgid", ""))
+            msg_id = body.get("msgid", "")
             if not msg_id:
                 msg_id = f"{body.get('chatid', '')}_{body.get('sendertime', '')}"
 
             # Extract sender info from "from" field (SDK format)
             from_info = body.get("from", {})
-            sender_id = (
-                cast(str, cast(dict[str, Any], from_info).get("userid", "unknown"))
-                if isinstance(from_info, dict)
-                else "unknown"
-            )
+            sender_id = from_info.get("userid", "unknown") if isinstance(from_info, dict) else "unknown"
             if not self.is_allowed(sender_id):
                 return
 
@@ -264,22 +253,21 @@ class WecomChannel(BaseChannel):
 
             # For single chat, chatid is the sender's userid
             # For group chat, chatid is provided in body
-            chat_type = cast(str, body.get("chattype", "single"))
-            chat_id = cast(str, body.get("chatid", sender_id))
+            chat_type = body.get("chattype", "single")
+            chat_id = body.get("chatid", sender_id)
 
-            content_parts: list[str] = []
+            content_parts = []
             media_paths: list[str] = []
 
             if msg_type == "text":
-                text_info = cast(dict[str, Any], body.get("text", {}))
-                text = cast(str, text_info.get("content", ""))
+                text = body.get("text", {}).get("content", "")
                 if text:
                     content_parts.append(text)
 
             elif msg_type == "image":
-                image_info = cast(dict[str, Any], body.get("image", {}))
-                file_url = cast(str, image_info.get("url", ""))
-                aes_key = cast(str, image_info.get("aeskey", ""))
+                image_info = body.get("image", {})
+                file_url = image_info.get("url", "")
+                aes_key = image_info.get("aeskey", "")
 
                 if file_url and aes_key:
                     file_path = await self._download_and_save_media(file_url, aes_key, "image")
@@ -293,19 +281,19 @@ class WecomChannel(BaseChannel):
                     content_parts.append("[image: download failed]")
 
             elif msg_type == "voice":
-                voice_info = cast(dict[str, Any], body.get("voice", {}))
+                voice_info = body.get("voice", {})
                 # Voice message already contains transcribed content from WeCom
-                voice_content = cast(str, voice_info.get("content", ""))
+                voice_content = voice_info.get("content", "")
                 if voice_content:
                     content_parts.append(f"[voice] {voice_content}")
                 else:
                     content_parts.append("[voice]")
 
             elif msg_type == "file":
-                file_info = cast(dict[str, Any], body.get("file", {}))
-                file_url = cast(str, file_info.get("url", ""))
-                aes_key = cast(str, file_info.get("aeskey", ""))
-                file_name = cast(str | None, file_info.get("name") or None)
+                file_info = body.get("file", {})
+                file_url = file_info.get("url", "")
+                aes_key = file_info.get("aeskey", "")
+                file_name = file_info.get("name") or None
 
                 if file_url and aes_key:
                     file_path = await self._download_and_save_media(file_url, aes_key, "file", file_name)
@@ -320,20 +308,16 @@ class WecomChannel(BaseChannel):
 
             elif msg_type == "mixed":
                 # Mixed content contains multiple message items
-                mixed_info = cast(dict[str, Any], body.get("mixed", {}))
-                msg_items = cast(list[Any], mixed_info.get("msg_item", []))
-                for raw_item in msg_items:
-                    item = cast(dict[str, Any], raw_item)
-                    item_type = cast(str, item.get("msgtype", ""))
+                msg_items = body.get("mixed", {}).get("msg_item", [])
+                for item in msg_items:
+                    item_type = item.get("msgtype", "")
                     if item_type == "text":
-                        text_info = cast(dict[str, Any], item.get("text", {}))
-                        text = cast(str, text_info.get("content", ""))
+                        text = item.get("text", {}).get("content", "")
                         if text:
                             content_parts.append(text)
                     elif item_type == "image":
-                        image_info = cast(dict[str, Any], item.get("image", {}))
-                        file_url = cast(str, image_info.get("url", ""))
-                        aes_key = cast(str, image_info.get("aeskey", ""))
+                        file_url = item.get("image", {}).get("url", "")
+                        aes_key = item.get("image", {}).get("aeskey", "")
                         if file_url and aes_key:
                             file_path = await self._download_and_save_media(file_url, aes_key, "image")
                             if file_path:
@@ -401,7 +385,7 @@ class WecomChannel(BaseChannel):
             media_dir = get_media_dir("wecom")
             if not filename:
                 filename = fname or f"{media_type}_{hash(file_url) % 100000}"
-            filename = _sanitize_filename(cast(str, filename))
+            filename = _sanitize_filename(filename)
 
             file_path = media_dir / filename
             await asyncio.to_thread(file_path.write_bytes, data)
@@ -413,10 +397,8 @@ class WecomChannel(BaseChannel):
             return None
 
     async def _upload_media_ws(
-        self,
-        client: Any,
-        file_path: str,
-    ) -> tuple[str, str] | tuple[None, None]:
+        self, client: Any, file_path: str,
+    ) -> "tuple[str, str] | tuple[None, None]":
         """Upload a local file to WeCom via WebSocket 3-step protocol (base64).
 
         Uses the WeCom WebSocket upload commands directly via
@@ -435,7 +417,7 @@ class WecomChannel(BaseChannel):
             media_type = _guess_wecom_media_type(fname)
 
             # Read file size and data in a thread to avoid blocking the event loop
-            def _read_file() -> tuple[int, bytes]:
+            def _read_file():
                 file_size = os.path.getsize(file_path)
                 if file_size > WECOM_UPLOAD_MAX_BYTES:
                     raise ValueError(
@@ -548,10 +530,7 @@ class WecomChannel(BaseChannel):
                 # Both progress and final messages must use reply_stream (cmd="aibot_respond_msg").
                 # The plain reply() uses cmd="reply" which does not support "text" msgtype
                 # and causes errcode=40008 from WeCom API.
-                generate_req_id = self._generate_req_id
-                if generate_req_id is None:
-                    raise RuntimeError("WeCom request-id generator is not initialized")
-                stream_id = generate_req_id("stream")
+                stream_id = self._generate_req_id("stream")
                 await self._client.reply_stream(
                     frame,
                     stream_id,

nanobot/channels/weixin/connect.py

@@ -4,22 +4,22 @@ from __future__ import annotations
 
 import secrets
 import time
+from contextlib import suppress
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, cast
+from typing import Any
+
+import httpx
 
 from nanobot.channels.connect import ChannelConnectError, QueryParams, query_first
 from nanobot.config.loader import load_config
 
-if TYPE_CHECKING:
-    from nanobot.channels.weixin.runtime import WeixinChannel
-
 
 @dataclass(slots=True)
 class WeixinConnectSession:
     id: str
     qrcode_id: str
     qr_url: str
-    channel: WeixinChannel
+    channel: Any
     current_poll_base_url: str
     refresh_count: int
     created_wall: float
@@ -58,8 +58,9 @@ class WeixinConnectStore:
         channel = self._build_channel()
         if force:
             # Preserve the working account until a replacement scan succeeds.
-            channel.connect_reset_pending_credentials()
-        elif channel.connect_load_state():
+            channel._token = ""
+            channel._get_updates_buf = ""
+        elif channel._load_state():
             return {
                 "session_id": "",
                 "status": "succeeded",
@@ -67,9 +68,13 @@ class WeixinConnectStore:
                 "interval_ms": 2000,
             }
 
-        channel.connect_open_client()
+        channel._client = httpx.AsyncClient(
+            timeout=httpx.Timeout(60, connect=30),
+            follow_redirects=True,
+        )
+        channel._running = True
         try:
-            qrcode_id, qr_url = await channel.connect_fetch_qr_code()
+            qrcode_id, qr_url = await channel._fetch_qr_code()
         except Exception as exc:
             await self._close_channel(channel)
             raise ChannelConnectError(
@@ -84,7 +89,7 @@ class WeixinConnectStore:
             qrcode_id=qrcode_id,
             qr_url=qr_url,
             channel=channel,
-            current_poll_base_url=channel.connect_base_url,
+            current_poll_base_url=channel.config.base_url,
             refresh_count=0,
             created_wall=now_wall,
             deadline=time.monotonic() + 600,
@@ -102,12 +107,14 @@ class WeixinConnectStore:
             }
 
         try:
-            status_data = await session.channel.connect_poll_qr_code(
+            status_data = await session.channel._api_get_with_base(
                 base_url=session.current_poll_base_url,
-                qrcode_id=session.qrcode_id,
+                endpoint="ilink/bot/get_qrcode_status",
+                params={"qrcode": session.qrcode_id},
+                auth=False,
             )
         except Exception as exc:
-            if session.channel.connect_poll_error_is_retryable(exc):
+            if session.channel._is_retryable_qr_poll_error(exc):
                 session.last_error = str(exc)
                 return self._pending_payload(session)
             self._sessions.pop(session_id, None)
@@ -118,8 +125,10 @@ class WeixinConnectStore:
                 "message": f"WeChat QR login failed: {exc}",
             }
 
-        status_payload = status_data
-        status = status_payload.get("status", "")
+        if not isinstance(status_data, dict):
+            return self._pending_payload(session)
+
+        status = status_data.get("status", "")
         if status == "confirmed":
             if self._sessions.get(session_id) is not session:
                 return {
@@ -127,7 +136,7 @@ class WeixinConnectStore:
                     "status": "cancelled",
                     "message": "WeChat login cancelled.",
                 }
-            token = str(status_payload.get("bot_token", "") or "")
+            token = str(status_data.get("bot_token", "") or "")
             if not token:
                 self._sessions.pop(session_id, None)
                 await self._close_channel(session.channel)
@@ -136,19 +145,22 @@ class WeixinConnectStore:
                     "status": "failed",
                     "message": "WeChat confirmed the scan but returned no token.",
                 }
-            base_url = str(status_payload.get("baseurl", "") or "")
-            session.channel.connect_commit_account(token=token, base_url=base_url)
+            base_url = str(status_data.get("baseurl", "") or "")
+            session.channel._token = token
+            if base_url:
+                session.channel.config.base_url = base_url
+            session.channel._save_state()
             self._sessions.pop(session_id, None)
             await self._close_channel(session.channel)
             return {
                 "session_id": session_id,
                 "status": "succeeded",
                 "message": "WeChat is connected.",
-                "account": str(status_payload.get("ilink_user_id", "") or ""),
+                "account": str(status_data.get("ilink_user_id", "") or ""),
             }
 
         if status == "scaned_but_redirect":
-            redirect_host = str(status_payload.get("redirect_host", "") or "").strip()
+            redirect_host = str(status_data.get("redirect_host", "") or "").strip()
             if redirect_host:
                 session.current_poll_base_url = (
                     redirect_host
@@ -170,9 +182,7 @@ class WeixinConnectStore:
                     "message": "This WeChat QR code expired. Start again.",
                 }
             try:
-                session.qrcode_id, session.qr_url = (
-                    await session.channel.connect_fetch_qr_code()
-                )
+                session.qrcode_id, session.qr_url = await session.channel._fetch_qr_code()
             except Exception as exc:
                 self._sessions.pop(session_id, None)
                 await self._close_channel(session.channel)
@@ -181,7 +191,7 @@ class WeixinConnectStore:
                     "status": "failed",
                     "message": f"Could not refresh WeChat QR code: {exc}",
                 }
-            session.current_poll_base_url = session.channel.connect_base_url
+            session.current_poll_base_url = session.channel.config.base_url
             return self._pending_payload(session)
 
         return self._pending_payload(session)
@@ -209,22 +219,27 @@ class WeixinConnectStore:
                 await self._close_channel(session.channel)
 
     @staticmethod
-    def _build_channel() -> WeixinChannel:
+    def _build_channel() -> Any:
         from nanobot.bus.queue import MessageBus
         from nanobot.channels.weixin.runtime import WeixinChannel
 
         section = getattr(load_config().channels, "weixin", None)
-        if section is not None and hasattr(section, "model_dump"):
+        if hasattr(section, "model_dump"):
             config = section.model_dump(mode="json", by_alias=True)
         elif isinstance(section, dict):
-            config = dict(cast(dict[str, Any], section))
+            config = dict(section)
         else:
             config = {}
         return WeixinChannel(config, MessageBus())
 
     @staticmethod
-    async def _close_channel(channel: WeixinChannel) -> None:
-        await channel.connect_close_client()
+    async def _close_channel(channel: Any) -> None:
+        channel._running = False
+        client = getattr(channel, "_client", None)
+        if client is not None:
+            with suppress(Exception):
+                await client.aclose()
+            channel._client = None
 
     @staticmethod
     def _start_payload(session: WeixinConnectSession) -> dict[str, Any]:

nanobot/channels/weixin/runtime.py

@@ -21,7 +21,7 @@ import uuid
 from collections import OrderedDict
 from contextlib import suppress
 from pathlib import Path
-from typing import Any, cast
+from typing import Any
 from urllib.parse import quote
 
 import httpx
@@ -168,10 +168,10 @@ class WeixinChannel(BaseChannel):
         self._processed_ids: OrderedDict[str, None] = OrderedDict()
         self._state_dir: Path | None = None
         self._token: str = ""
-        self._poll_task: asyncio.Task[None] | None = None
+        self._poll_task: asyncio.Task | None = None
         self._next_poll_timeout_s: int = DEFAULT_LONG_POLL_TIMEOUT_S
         self._session_pause_until: float = 0.0
-        self._typing_tasks: dict[str, asyncio.Task[None]] = {}
+        self._typing_tasks: dict[str, asyncio.Task] = {}
         self._typing_tickets: dict[str, dict[str, Any]] = {}
         self._context_token_at: dict[str, float] = {}
         self._pending_tool_hints: dict[str, list[str]] = {}
@@ -201,14 +201,14 @@ class WeixinChannel(BaseChannel):
         if not state_file.exists():
             return False
         try:
-            data = cast(dict[str, Any], json.loads(state_file.read_text()))
+            data = json.loads(state_file.read_text())
             self._token = data.get("token", "")
             self._get_updates_buf = data.get("get_updates_buf", "")
             context_tokens = data.get("context_tokens", {})
             if isinstance(context_tokens, dict):
                 self._context_tokens = {
                     str(user_id): str(token)
-                    for user_id, token in cast(dict[object, object], context_tokens).items()
+                    for user_id, token in context_tokens.items()
                     if str(user_id).strip() and str(token).strip()
                 }
             else:
@@ -216,8 +216,8 @@ class WeixinChannel(BaseChannel):
             typing_tickets = data.get("typing_tickets", {})
             if isinstance(typing_tickets, dict):
                 self._typing_tickets = {
-                    str(user_id): cast(dict[str, Any], ticket)
-                    for user_id, ticket in cast(dict[object, object], typing_tickets).items()
+                    str(user_id): ticket
+                    for user_id, ticket in typing_tickets.items()
                     if str(user_id).strip() and isinstance(ticket, dict)
                 }
             else:
@@ -230,30 +230,9 @@ class WeixinChannel(BaseChannel):
             self.logger.error("Failed to load Weixin account state", exc_info=True)
             return False
 
-    def _save_state(self, *, force: bool = False) -> None:
+    def _save_state(self) -> None:
         state_file = self._get_state_dir() / "account.json"
         with suppress(Exception):
-            if not force and state_file.exists():
-                persisted: object = None
-                try:
-                    persisted = json.loads(state_file.read_text())
-                except Exception:
-                    persisted = None
-                persisted_token = ""
-                if isinstance(persisted, dict):
-                    persisted_mapping = cast(dict[str, object], persisted)
-                    persisted_token = str(persisted_mapping.get("token", "") or "")
-                configured_token_is_authoritative: bool = bool(self.config.token) and (
-                    self._token == self.config.token
-                )
-                if (
-                    persisted_token
-                    and persisted_token != self._token
-                    and not configured_token_is_authoritative
-                ):
-                    # A concurrent QR login may have committed a newer token.
-                    # Never let an older runtime snapshot overwrite it.
-                    return
             data = {
                 "token": self._token,
                 "get_updates_buf": self._get_updates_buf,
@@ -297,22 +276,18 @@ class WeixinChannel(BaseChannel):
         if isinstance(err, httpx.TimeoutException | httpx.TransportError):
             return True
         if isinstance(err, httpx.HTTPStatusError):
-            status_code = (
-                err.response.status_code
-                if cast(object, err.response) is not None
-                else 0
-            )
+            status_code = err.response.status_code if err.response is not None else 0
             return status_code >= 500
         return False
 
     async def _api_get(
         self,
         endpoint: str,
-        params: dict[str, Any] | None = None,
+        params: dict | None = None,
         *,
         auth: bool = True,
         extra_headers: dict[str, str] | None = None,
-    ) -> dict[str, Any]:
+    ) -> dict:
         assert self._client is not None
         url = f"{self.config.base_url}/{endpoint}"
         hdrs = self._make_headers(auth=auth)
@@ -320,17 +295,17 @@ class WeixinChannel(BaseChannel):
             hdrs.update(extra_headers)
         resp = await self._client.get(url, params=params, headers=hdrs)
         resp.raise_for_status()
-        return cast(dict[str, Any], resp.json())
+        return resp.json()
 
     async def _api_get_with_base(
         self,
         *,
         base_url: str,
         endpoint: str,
-        params: dict[str, Any] | None = None,
+        params: dict | None = None,
         auth: bool = True,
         extra_headers: dict[str, str] | None = None,
-    ) -> dict[str, Any]:
+    ) -> dict:
         """GET helper that allows overriding base_url for QR redirect polling."""
         assert self._client is not None
         url = f"{base_url.rstrip('/')}/{endpoint}"
@@ -339,15 +314,15 @@ class WeixinChannel(BaseChannel):
             hdrs.update(extra_headers)
         resp = await self._client.get(url, params=params, headers=hdrs)
         resp.raise_for_status()
-        return cast(dict[str, Any], resp.json())
+        return resp.json()
 
     async def _api_post(
         self,
         endpoint: str,
-        body: dict[str, Any] | None = None,
+        body: dict | None = None,
         *,
         auth: bool = True,
-    ) -> dict[str, Any]:
+    ) -> dict:
         assert self._client is not None
         url = f"{self.config.base_url}/{endpoint}"
         payload = body or {}
@@ -355,7 +330,7 @@ class WeixinChannel(BaseChannel):
             payload["base_info"] = BASE_INFO
         resp = await self._client.post(url, json=payload, headers=self._make_headers(auth=auth))
         resp.raise_for_status()
-        return cast(dict[str, Any], resp.json())
+        return resp.json()
 
     # ------------------------------------------------------------------
     # QR Code Login  (matches login-qr.ts)
@@ -368,8 +343,8 @@ class WeixinChannel(BaseChannel):
             params={"bot_type": "3"},
             auth=False,
         )
-        qrcode_img_content = cast(str, data.get("qrcode_img_content", ""))
-        qrcode_id = cast(str, data.get("qrcode", ""))
+        qrcode_img_content = data.get("qrcode_img_content", "")
+        qrcode_id = data.get("qrcode", "")
         if not qrcode_id:
             raise RuntimeError(f"Failed to get QR code from WeChat API: {data}")
         return qrcode_id, (qrcode_img_content or qrcode_id)
@@ -396,7 +371,7 @@ class WeixinChannel(BaseChannel):
                         continue
                     raise
 
-                if not isinstance(cast(object, status_data), dict):
+                if not isinstance(status_data, dict):
                     await asyncio.sleep(1)
                     continue
 
@@ -456,73 +431,15 @@ class WeixinChannel(BaseChannel):
         if isinstance(err, httpx.TimeoutException | httpx.TransportError):
             return True
         if isinstance(err, httpx.HTTPStatusError):
-            status_code = (
-                err.response.status_code
-                if cast(object, err.response) is not None
-                else 0
-            )
+            status_code = err.response.status_code if err.response is not None else 0
             if status_code >= 500:
                 return True
         return False
 
-    @property
-    def connect_base_url(self) -> str:
-        """Base URL currently selected for the interactive connection flow."""
-        return self.config.base_url
-
-    def connect_reset_pending_credentials(self) -> None:
-        """Clear only in-memory credentials while a replacement QR login is pending."""
-        self._token = ""
-        self._get_updates_buf = ""
-
-    def connect_load_state(self) -> bool:
-        """Load an existing account for the interactive connection flow."""
-        return self._load_state()
-
-    def connect_open_client(self) -> None:
-        """Open the short-lived HTTP client used by WebUI QR login."""
-        self._client = httpx.AsyncClient(
-            timeout=httpx.Timeout(60, connect=30),
-            follow_redirects=True,
-        )
-        self._running = True
-
-    async def connect_fetch_qr_code(self) -> tuple[str, str]:
-        return await self._fetch_qr_code()
-
-    async def connect_poll_qr_code(
-        self,
-        *,
-        base_url: str,
-        qrcode_id: str,
-    ) -> dict[str, Any]:
-        return await self._api_get_with_base(
-            base_url=base_url,
-            endpoint="ilink/bot/get_qrcode_status",
-            params={"qrcode": qrcode_id},
-            auth=False,
-        )
-
-    def connect_poll_error_is_retryable(self, err: Exception) -> bool:
-        return self._is_retryable_qr_poll_error(err)
-
-    def connect_commit_account(self, *, token: str, base_url: str) -> None:
-        self._token = token
-        if base_url:
-            self.config.base_url = base_url
-        self._save_state(force=True)
-
-    async def connect_close_client(self) -> None:
-        self._running = False
-        if self._client is not None:
-            with suppress(Exception):
-                await self._client.aclose()
-            self._client = None
-
     @staticmethod
     def _print_qr_code(url: str) -> None:
         try:
-            import qrcode as qr_lib  # pyright: ignore[reportMissingModuleSource]
+            import qrcode as qr_lib
 
             qr = qr_lib.QRCode(border=1)
             qr.add_data(url)
@@ -634,8 +551,6 @@ class WeixinChannel(BaseChannel):
         remaining = self._session_pause_remaining_s()
         if remaining > 0:
             await asyncio.sleep(remaining)
-            if not self.config.token:
-                self._load_state()
             return
 
         body: dict[str, Any] = {
@@ -681,7 +596,7 @@ class WeixinChannel(BaseChannel):
             self._save_state()
 
         # Process messages (WeixinMessage[] from types.ts)
-        msgs = cast(list[dict[str, Any]], data.get("msgs", []) or [])
+        msgs: list[dict] = data.get("msgs", []) or []
         for msg in msgs:
             try:
                 await self._process_message(msg)
@@ -692,7 +607,7 @@ class WeixinChannel(BaseChannel):
     # Inbound message processing  (matches inbound.ts + process-message.ts)
     # ------------------------------------------------------------------
 
-    async def _process_message(self, msg: dict[str, Any]) -> None:
+    async def _process_message(self, msg: dict) -> None:
         """Process a single WeixinMessage from getUpdates."""
         # Skip bot's own messages (message_type 2 = BOT)
         if msg.get("message_type") == MESSAGE_TYPE_BOT:
@@ -764,7 +679,7 @@ class WeixinChannel(BaseChannel):
             self._save_state()
 
         # Parse item_list (WeixinMessage.item_list — types.ts:161)
-        item_list = cast(list[dict[str, Any]], msg.get("item_list") or [])
+        item_list: list[dict] = msg.get("item_list") or []
         content_parts: list[str] = []
         media_paths: list[str] = []
         has_top_level_downloadable_media = False
@@ -773,16 +688,12 @@ class WeixinChannel(BaseChannel):
             item_type = item.get("type", 0)
 
             if item_type == ITEM_TEXT:
-                text_item = cast(dict[str, Any], item.get("text_item") or {})
-                text = cast(str, text_item.get("text", ""))
+                text = (item.get("text_item") or {}).get("text", "")
                 if text:
                     # Handle quoted/ref messages (inbound.ts:86-98)
-                    ref = cast(dict[str, Any] | None, item.get("ref_msg"))
+                    ref = item.get("ref_msg")
                     if ref:
-                        ref_item = cast(
-                            dict[str, Any] | None,
-                            ref.get("message_item"),
-                        )
+                        ref_item = ref.get("message_item")
                         # If quoted message is media, just pass the text
                         if ref_item and ref_item.get("type", 0) in (
                             ITEM_IMAGE,
@@ -794,13 +705,9 @@ class WeixinChannel(BaseChannel):
                         else:
                             parts: list[str] = []
                             if ref.get("title"):
-                                parts.append(cast(str, ref["title"]))
+                                parts.append(ref["title"])
                             if ref_item:
-                                ref_text_item = cast(
-                                    dict[str, Any],
-                                    ref_item.get("text_item") or {},
-                                )
-                                ref_text = cast(str, ref_text_item.get("text", ""))
+                                ref_text = (ref_item.get("text_item") or {}).get("text", "")
                                 if ref_text:
                                     parts.append(ref_text)
                             if parts:
@@ -811,7 +718,7 @@ class WeixinChannel(BaseChannel):
                         content_parts.append(text)
 
             elif item_type == ITEM_IMAGE:
-                image_item = cast(dict[str, Any], item.get("image_item") or {})
+                image_item = item.get("image_item") or {}
                 if _has_downloadable_media_locator(image_item.get("media")):
                     has_top_level_downloadable_media = True
                 file_path = await self._download_media_item(image_item, "image")
@@ -822,9 +729,9 @@ class WeixinChannel(BaseChannel):
                     content_parts.append("[image]")
 
             elif item_type == ITEM_VOICE:
-                voice_item = cast(dict[str, Any], item.get("voice_item") or {})
+                voice_item = item.get("voice_item") or {}
                 # Voice-to-text provided by WeChat (inbound.ts:101-103)
-                voice_text = cast(str, voice_item.get("text", ""))
+                voice_text = voice_item.get("text", "")
                 if voice_text:
                     content_parts.append(f"[voice] {voice_text}")
                 else:
@@ -842,10 +749,10 @@ class WeixinChannel(BaseChannel):
                         content_parts.append("[voice]")
 
             elif item_type == ITEM_FILE:
-                file_item = cast(dict[str, Any], item.get("file_item") or {})
+                file_item = item.get("file_item") or {}
                 if _has_downloadable_media_locator(file_item.get("media")):
                     has_top_level_downloadable_media = True
-                file_name = cast(str, file_item.get("file_name", "unknown"))
+                file_name = file_item.get("file_name", "unknown")
                 file_path = await self._download_media_item(
                     file_item,
                     "file",
@@ -858,7 +765,7 @@ class WeixinChannel(BaseChannel):
                     content_parts.append(f"[file: {file_name}]")
 
             elif item_type == ITEM_VIDEO:
-                video_item = cast(dict[str, Any], item.get("video_item") or {})
+                video_item = item.get("video_item") or {}
                 if _has_downloadable_media_locator(video_item.get("media")):
                     has_top_level_downloadable_media = True
                 file_path = await self._download_media_item(video_item, "video")
@@ -876,8 +783,8 @@ class WeixinChannel(BaseChannel):
             for item in item_list:
                 if item.get("type", 0) != ITEM_TEXT:
                     continue
-                ref = cast(dict[str, Any], item.get("ref_msg") or {})
-                candidate = cast(dict[str, Any], ref.get("message_item") or {})
+                ref = item.get("ref_msg") or {}
+                candidate = ref.get("message_item") or {}
                 if candidate.get("type", 0) in (ITEM_IMAGE, ITEM_VOICE, ITEM_FILE, ITEM_VIDEO):
                     ref_media_item = candidate
                     break
@@ -885,19 +792,13 @@ class WeixinChannel(BaseChannel):
             if ref_media_item:
                 ref_type = ref_media_item.get("type", 0)
                 if ref_type == ITEM_IMAGE:
-                    image_item = cast(
-                        dict[str, Any],
-                        ref_media_item.get("image_item") or {},
-                    )
+                    image_item = ref_media_item.get("image_item") or {}
                     file_path = await self._download_media_item(image_item, "image")
                     if file_path:
                         content_parts.append(f"[image]\n[Image: source: {file_path}]")
                         media_paths.append(file_path)
                 elif ref_type == ITEM_VOICE:
-                    voice_item = cast(
-                        dict[str, Any],
-                        ref_media_item.get("voice_item") or {},
-                    )
+                    voice_item = ref_media_item.get("voice_item") or {}
                     file_path = await self._download_media_item(voice_item, "voice")
                     if file_path:
                         transcription = await self.transcribe_audio(file_path)
@@ -907,20 +808,14 @@ class WeixinChannel(BaseChannel):
                             content_parts.append(f"[voice]\n[Audio: source: {file_path}]")
                         media_paths.append(file_path)
                 elif ref_type == ITEM_FILE:
-                    file_item = cast(
-                        dict[str, Any],
-                        ref_media_item.get("file_item") or {},
-                    )
-                    file_name = cast(str, file_item.get("file_name", "unknown"))
+                    file_item = ref_media_item.get("file_item") or {}
+                    file_name = file_item.get("file_name", "unknown")
                     file_path = await self._download_media_item(file_item, "file", file_name)
                     if file_path:
                         content_parts.append(f"[file: {file_name}]\n[File: source: {file_path}]")
                         media_paths.append(file_path)
                 elif ref_type == ITEM_VIDEO:
-                    video_item = cast(
-                        dict[str, Any],
-                        ref_media_item.get("video_item") or {},
-                    )
+                    video_item = ref_media_item.get("video_item") or {}
                     file_path = await self._download_media_item(video_item, "video")
                     if file_path:
                         content_parts.append(f"[video]\n[Video: source: {file_path}]")
@@ -953,13 +848,13 @@ class WeixinChannel(BaseChannel):
 
     async def _download_media_item(
         self,
-        typed_item: dict[str, Any],
+        typed_item: dict,
         media_type: str,
         filename: str | None = None,
     ) -> str | None:
         """Download + AES-decrypt a media item. Returns local path or None."""
         try:
-            media = cast(dict[str, Any], typed_item.get("media") or {})
+            media = typed_item.get("media") or {}
             encrypt_query_param = str(media.get("encrypt_query_param", "") or "")
             full_url = str(media.get("full_url", "") or "").strip()
 
@@ -970,8 +865,8 @@ class WeixinChannel(BaseChannel):
             # image_item.aeskey is a raw hex string (16 bytes as 32 hex chars).
             # media.aes_key is always base64-encoded.
             # For images, prefer image_item.aeskey; for others use media.aes_key.
-            raw_aeskey_hex = cast(str, typed_item.get("aeskey", ""))
-            media_aes_key_b64 = cast(str, media.get("aes_key", ""))
+            raw_aeskey_hex = typed_item.get("aeskey", "")
+            media_aes_key_b64 = media.get("aes_key", "")
 
             aes_key_b64: str = ""
             if raw_aeskey_hex:
@@ -1265,7 +1160,7 @@ class WeixinChannel(BaseChannel):
                 await self._send_typing(msg.chat_id, typing_ticket, TYPING_STATUS_TYPING)
 
         typing_keepalive_stop = asyncio.Event()
-        typing_keepalive_task: asyncio.Task[None] | None = None
+        typing_keepalive_task: asyncio.Task | None = None
         if typing_ticket:
             typing_keepalive_task = asyncio.create_task(
                 self._typing_keepalive_loop(msg.chat_id, typing_ticket, typing_keepalive_stop)
@@ -1288,7 +1183,7 @@ class WeixinChannel(BaseChannel):
                 except httpx.HTTPStatusError as http_err:
                     status_code = (
                         http_err.response.status_code
-                        if cast(object, http_err.response) is not None
+                        if http_err.response is not None
                         else 0
                     )
                     if status_code >= 500:
@@ -1297,7 +1192,7 @@ class WeixinChannel(BaseChannel):
                             "Server error ({} {}) sending media {}",
                             status_code,
                             http_err.response.reason_phrase
-                            if cast(object, http_err.response) is not None
+                            if http_err.response is not None
                             else "",
                             media_path,
                         )
@@ -1447,7 +1342,7 @@ class WeixinChannel(BaseChannel):
         """Send a text message matching the exact protocol from send.ts."""
         client_id = f"nanobot-{uuid.uuid4().hex[:12]}"
 
-        item_list: list[dict[str, Any]] = []
+        item_list: list[dict] = []
         if text:
             item_list.append({"type": ITEM_TEXT, "text_item": {"text": text}})
 
@@ -1601,9 +1496,7 @@ class WeixinChannel(BaseChannel):
 
         # Send each media item as its own message (matching reference plugin)
         client_id = f"nanobot-{uuid.uuid4().hex[:12]}"
-        item_list: list[dict[str, Any]] = [
-            {"type": item_type, item_key: media_item}
-        ]
+        item_list: list[dict] = [{"type": item_type, item_key: media_item}]
 
         weixin_msg: dict[str, Any] = {
             "from_user_id": "",
@@ -1672,8 +1565,7 @@ def _encrypt_aes_ecb(data: bytes, aes_key_b64: str) -> bytes:
     with suppress(ImportError):
         from Crypto.Cipher import AES
 
-        aes_module = cast(Any, AES)
-        cipher = aes_module.new(key, aes_module.MODE_ECB)
+        cipher = AES.new(key, AES.MODE_ECB)
         return cipher.encrypt(padded)
 
     try:
@@ -1703,8 +1595,7 @@ def _decrypt_aes_ecb(data: bytes, aes_key_b64: str) -> bytes:
     with suppress(ImportError):
         from Crypto.Cipher import AES
 
-        aes_module = cast(Any, AES)
-        cipher = aes_module.new(key, aes_module.MODE_ECB)
+        cipher = AES.new(key, AES.MODE_ECB)
         decrypted = cipher.decrypt(data)
 
     if decrypted is None:

nanobot/channels/weixin/tests/test_weixin_channel.py

@@ -98,80 +98,6 @@ def test_save_and_load_state_persists_context_tokens(tmp_path) -> None:
     assert restored._context_tokens == {"wx-user": "ctx-1"}
 
 
-def test_save_state_preserves_token_committed_by_another_instance(tmp_path) -> None:
-    channel = WeixinChannel(
-        WeixinConfig(enabled=True, allow_from=["*"], state_dir=str(tmp_path)),
-        MessageBus(),
-    )
-    channel._token = "old-token"
-    channel._save_state()
-
-    replacement = {
-        "token": "new-token",
-        "base_url": "https://new.example",
-        "get_updates_buf": "",
-        "context_tokens": {},
-        "typing_tickets": {},
-    }
-    (tmp_path / "account.json").write_text(json.dumps(replacement), encoding="utf-8")
-
-    channel._get_updates_buf = "stale-cursor"
-    channel._save_state()
-
-    assert json.loads((tmp_path / "account.json").read_text()) == replacement
-
-
-def test_save_state_force_overwrites_replaced_token(tmp_path) -> None:
-    channel = WeixinChannel(
-        WeixinConfig(enabled=True, allow_from=["*"], state_dir=str(tmp_path)),
-        MessageBus(),
-    )
-    (tmp_path / "account.json").write_text(json.dumps({"token": "old-token"}), encoding="utf-8")
-
-    channel.connect_commit_account(token="new-token", base_url="https://new.example")
-
-    saved = json.loads((tmp_path / "account.json").read_text())
-    assert saved["token"] == "new-token"
-    assert saved["base_url"] == "https://new.example"
-
-
-def test_save_state_persists_explicit_config_token_over_stale_state(tmp_path) -> None:
-    channel = WeixinChannel(
-        WeixinConfig(
-            enabled=True,
-            allow_from=["*"],
-            token="configured-token",
-            state_dir=str(tmp_path),
-        ),
-        MessageBus(),
-    )
-    channel._token = "configured-token"
-    channel._get_updates_buf = "current-cursor"
-    (tmp_path / "account.json").write_text(
-        json.dumps({"token": "stale-token", "get_updates_buf": "stale-cursor"}),
-        encoding="utf-8",
-    )
-
-    channel._save_state()
-
-    saved = json.loads((tmp_path / "account.json").read_text())
-    assert saved["token"] == "configured-token"
-    assert saved["get_updates_buf"] == "current-cursor"
-
-
-def test_save_state_with_empty_runtime_token_preserves_persisted_account(tmp_path) -> None:
-    channel = WeixinChannel(
-        WeixinConfig(enabled=True, allow_from=["*"], state_dir=str(tmp_path)),
-        MessageBus(),
-    )
-    persisted = {"token": "persisted-token", "get_updates_buf": "persisted-cursor"}
-    (tmp_path / "account.json").write_text(json.dumps(persisted), encoding="utf-8")
-
-    channel._save_state()
-
-    assert json.loads((tmp_path / "account.json").read_text()) == persisted
-
-
 @pytest.mark.asyncio
 async def test_process_message_deduplicates_inbound_ids() -> None:
     channel, bus = _make_channel()
@@ -536,56 +462,6 @@ async def test_poll_once_pauses_session_on_expired_errcode() -> None:
     assert channel._session_pause_remaining_s() > 0
 
 
-@pytest.mark.asyncio
-async def test_poll_once_reloads_refreshed_state_after_session_pause(
-    tmp_path, monkeypatch: pytest.MonkeyPatch
-) -> None:
-    channel = WeixinChannel(
-        WeixinConfig(enabled=True, allow_from=["*"], state_dir=str(tmp_path)),
-        MessageBus(),
-    )
-    channel._token = "old-token"
-    channel._save_state()
-    (tmp_path / "account.json").write_text(
-        json.dumps({"token": "new-token", "base_url": "https://new.example"}),
-        encoding="utf-8",
-    )
-    channel._session_pause_until = time.time() + 10
-    monkeypatch.setattr(weixin_mod.asyncio, "sleep", AsyncMock())
-
-    await channel._poll_once()
-
-    assert channel._token == "new-token"
-    assert channel.config.base_url == "https://new.example"
-
-
-@pytest.mark.asyncio
-async def test_poll_once_keeps_explicit_token_after_session_pause(
-    tmp_path, monkeypatch: pytest.MonkeyPatch
-) -> None:
-    channel = WeixinChannel(
-        WeixinConfig(
-            enabled=True,
-            allow_from=["*"],
-            token="configured-token",
-            state_dir=str(tmp_path),
-        ),
-        MessageBus(),
-    )
-    channel._token = "configured-token"
-    (tmp_path / "account.json").write_text(
-        json.dumps({"token": "stale-token", "base_url": "https://stale.example"}),
-        encoding="utf-8",
-    )
-    channel._session_pause_until = time.time() + 10
-    monkeypatch.setattr(weixin_mod.asyncio, "sleep", AsyncMock())
-
-    await channel._poll_once()
-
-    assert channel._token == "configured-token"
-    assert channel.config.base_url == "https://ilinkai.weixin.qq.com"
-
-
 @pytest.mark.asyncio
 async def test_qr_login_refreshes_expired_qr_and_then_succeeds(
     no_qr_poll_delay,

nanobot/channels/whatsapp/runtime.py

@@ -1,4 +1,3 @@
-# pyright: reportConstantRedefinition=false, reportMissingTypeStubs=false, reportUnusedFunction=false
 """WhatsApp channel implementation using neonize."""
 
 from __future__ import annotations
@@ -11,7 +10,7 @@ import time
 from collections import OrderedDict
 from contextlib import suppress
 from pathlib import Path
-from typing import Any, Literal, NamedTuple, cast
+from typing import Any, Literal, NamedTuple
 
 from pydantic import Field
 
@@ -101,8 +100,7 @@ def _has_field(message: Any, name: str) -> bool:
     list_fields = getattr(message, "ListFields", None)
     if callable(list_fields):
         try:
-            fields = cast(list[tuple[Any, Any]], list_fields())
-            return any(getattr(field, "name", "") == name for field, _ in fields)
+            return any(getattr(field, "name", "") == name for field, _ in list_fields())
         except Exception:
             pass
 
@@ -279,10 +277,7 @@ class WhatsAppChannel(BaseChannel):
         return WhatsAppConfig().model_dump(by_alias=True)
 
     def __init__(self, config: Any, bus: MessageBus):
-        legacy_bridge_fields = (
-            _legacy_bridge_config_fields(cast(dict[str, Any], config))
-            if isinstance(config, dict) else []
-        )
+        legacy_bridge_fields = _legacy_bridge_config_fields(config) if isinstance(config, dict) else []
         if isinstance(config, dict):
             config = WhatsAppConfig.model_validate(config)
         super().__init__(config, bus)
@@ -654,13 +649,12 @@ class WhatsAppChannel(BaseChannel):
         if not self._self_jids:
             return False
         for context in _context_infos(message):
-            raw_mentioned: Any = (
+            mentioned = (
                 _safe_attr(context, "mentionedJID")
                 or _safe_attr(context, "mentionedJid")
                 or _safe_attr(context, "mentioned_jid")
                 or []
             )
-            mentioned: list[Any] = cast(list[Any], raw_mentioned)
             for jid in mentioned:
                 normalized = _normalize_jid(jid)
                 if normalized in self._self_jids or _bare_jid(normalized) in self._self_jids:

nanobot/cli/agent.py

@@ -1,352 +0,0 @@
-"""Direct and interactive agent CLI command."""
-
-import asyncio
-import signal
-import sys
-from collections.abc import Awaitable, Callable
-from types import FrameType
-from typing import Any
-
-import typer
-from rich.console import Console
-
-from nanobot import __logo__
-from nanobot.agent.hooks import create_file_edit_activity_hook
-from nanobot.agent.loop import AgentLoop
-from nanobot.bus.outbound_events import (
-    StreamDeltaEvent,
-    StreamedResponseEvent,
-    StreamEndEvent,
-    outbound_event_from_message,
-)
-from nanobot.cli import terminal as cli_terminal
-from nanobot.cli.log_control import _set_nanobot_logs
-from nanobot.cli.runtime_config import (
-    _load_runtime_config,
-    _migrate_cron_store,
-    _model_display,
-    _print_agent_start_error,
-)
-from nanobot.cli.stream import StreamRenderer, ThinkingSpinner
-from nanobot.config.paths import is_default_workspace
-from nanobot.utils.helpers import (
-    sanitize_surrogates as _sanitize_surrogates,
-)
-from nanobot.utils.helpers import (
-    sync_workspace_templates,
-)
-from nanobot.utils.restart import (
-    consume_restart_notice_from_env,
-    format_restart_completed_message,
-    should_show_cli_restart_notice,
-)
-
-console = Console()
-
-
-def agent(
-    message: str = typer.Option(None, "--message", "-m", help="Message to send to the agent"),
-    session_id: str = typer.Option("cli:direct", "--session", "-s", help="Session ID"),
-    workspace: str | None = typer.Option(None, "--workspace", "-w", help="Workspace directory"),
-    config: str | None = typer.Option(None, "--config", "-c", help="Path to config file"),
-    markdown: bool = typer.Option(
-        True,
-        "--markdown/--no-markdown",
-        help="Render assistant output as Markdown",
-    ),
-    logs: bool = typer.Option(
-        False,
-        "--logs/--no-logs",
-        help="Show nanobot runtime logs during chat",
-    ),
-):
-    """Interact with the agent directly."""
-    from nanobot.bus.queue import MessageBus
-    from nanobot.cron.service import CronService
-    from nanobot.providers.factory import make_provider
-    from nanobot.providers.image_generation import image_gen_provider_configs
-
-    runtime_config = _load_runtime_config(config, workspace)
-    try:
-        provider = make_provider(runtime_config)
-    except ValueError as exc:
-        _print_agent_start_error(exc)
-        raise typer.Exit(1) from exc
-
-    sync_workspace_templates(runtime_config.workspace_path)
-
-    bus = MessageBus()
-
-    # Preserve existing single-workspace installs, but keep custom workspaces clean.
-    if is_default_workspace(runtime_config.workspace_path):
-        _migrate_cron_store(runtime_config)
-
-    # Create cron service with workspace-scoped store
-    cron_store_path = runtime_config.workspace_path / "cron" / "jobs.json"
-    cron = CronService(cron_store_path)
-
-    _set_nanobot_logs(logs)
-
-    try:
-        agent_loop = AgentLoop.from_config(
-            runtime_config,
-            bus,
-            provider=provider,
-            cron_service=cron,
-            image_generation_provider_configs=image_gen_provider_configs(runtime_config),
-            hook_factories=[create_file_edit_activity_hook],
-        )
-    except ValueError as exc:
-        _print_agent_start_error(exc)
-        raise typer.Exit(1) from exc
-    restart_notice = consume_restart_notice_from_env()
-    if restart_notice and should_show_cli_restart_notice(restart_notice, session_id):
-        cli_terminal._print_agent_response(
-            format_restart_completed_message(restart_notice.started_at_raw),
-            render_markdown=False,
-        )
-
-    # Shared reference for progress callbacks
-    _thinking: ThinkingSpinner | None = None
-
-    def _make_progress(
-        renderer: StreamRenderer | None = None,
-    ) -> Callable[..., Awaitable[None]]:
-        reasoning_buffer = cli_terminal._ReasoningBuffer()
-
-        async def _cli_progress(
-            content: str,
-            *,
-            tool_hint: bool = False,
-            reasoning: bool = False,
-            **_kwargs: Any,
-        ) -> None:
-            ch = agent_loop.channels_config
-
-            if _kwargs.get("reasoning_end"):
-                if ch and not ch.show_reasoning:
-                    reasoning_buffer.clear()
-                else:
-                    cli_terminal._flush_cli_reasoning(reasoning_buffer, _thinking, renderer)
-                return
-
-            if reasoning:
-                if ch and not ch.show_reasoning:
-                    reasoning_buffer.clear()
-                    return
-                text = reasoning_buffer.add(content)
-                if text:
-                    cli_terminal._print_cli_reasoning(text, _thinking, renderer)
-                return
-            if ch and tool_hint and not ch.send_tool_hints:
-                return
-            if ch and not tool_hint and not ch.send_progress:
-                return
-            cli_terminal._print_cli_progress_line(content, _thinking, renderer)
-
-        return _cli_progress
-
-    if message:
-        # Single message mode — direct call, no bus needed
-        async def run_once() -> None:
-            renderer = StreamRenderer(
-                render_markdown=markdown,
-                bot_name=runtime_config.agents.defaults.bot_name,
-                bot_icon=runtime_config.agents.defaults.bot_icon,
-            )
-            response = await agent_loop.process_direct(
-                message,
-                session_id,
-                on_progress=_make_progress(renderer),
-                on_stream=renderer.on_delta,
-                on_stream_end=renderer.on_end,
-            )
-            if not renderer.streamed:
-                await renderer.close()
-                print_kwargs: dict[str, Any] = {}
-                if renderer.header_printed:
-                    print_kwargs["show_header"] = False
-                cli_terminal._print_agent_response(
-                    response.content if response else "",
-                    render_markdown=markdown,
-                    metadata=response.metadata if response else None,
-                    **print_kwargs,
-                )
-            await agent_loop.close_mcp()
-
-        asyncio.run(run_once())
-    else:
-        # Interactive mode — route through bus like other channels
-        from nanobot.bus.events import InboundMessage
-
-        cli_terminal._init_prompt_session()
-        _model, _preset_tag = _model_display(runtime_config)
-        _icon = runtime_config.agents.defaults.bot_icon or __logo__
-        console.print(
-            f"{_icon} Interactive mode [bold blue]({_model})[/bold blue]{_preset_tag} "
-            "— type [bold]exit[/bold] or [bold]Ctrl+C[/bold] to quit\n"
-        )
-
-        if ":" in session_id:
-            cli_channel, cli_chat_id = session_id.split(":", 1)
-        else:
-            cli_channel, cli_chat_id = "cli", session_id
-
-        def _handle_signal(signum: int, _frame: FrameType | None) -> None:
-            sig_name = signal.Signals(signum).name
-            cli_terminal._restore_terminal()
-            console.print(f"\nReceived {sig_name}, goodbye!")
-            sys.exit(0)
-
-        signal.signal(signal.SIGINT, _handle_signal)
-        signal.signal(signal.SIGTERM, _handle_signal)
-        # SIGHUP is not available on Windows
-        if hasattr(signal, "SIGHUP"):
-            signal.signal(signal.SIGHUP, _handle_signal)
-        # Ignore SIGPIPE to prevent silent process termination when writing to closed pipes
-        # SIGPIPE is not available on Windows
-        if hasattr(signal, "SIGPIPE"):
-            signal.signal(signal.SIGPIPE, signal.SIG_IGN)
-
-        async def run_interactive() -> None:
-            bus_task = asyncio.create_task(agent_loop.run())
-            turn_done = asyncio.Event()
-            turn_done.set()
-            turn_response: list[Any] = []
-            renderer: StreamRenderer | None = None
-            reasoning_buffer = cli_terminal._ReasoningBuffer()
-
-            async def _consume_outbound() -> None:
-                while True:
-                    try:
-                        msg = await asyncio.wait_for(bus.consume_outbound(), timeout=1.0)
-                        event = outbound_event_from_message(msg)
-
-                        if isinstance(event, StreamDeltaEvent):
-                            if renderer:
-                                await renderer.on_delta(msg.content)
-                            continue
-                        if isinstance(event, StreamEndEvent):
-                            if renderer:
-                                await renderer.on_end(
-                                    resuming=event.resuming,
-                                )
-                            continue
-                        if isinstance(event, StreamedResponseEvent):
-                            if msg.content and renderer and not renderer.streamed:
-                                await renderer.close()
-                                print_kwargs: dict[str, Any] = {}
-                                if renderer.header_printed:
-                                    print_kwargs["show_header"] = False
-                                cli_terminal._print_agent_response(
-                                    msg.content,
-                                    render_markdown=markdown,
-                                    metadata=msg.metadata,
-                                    **print_kwargs,
-                                )
-                            turn_done.set()
-                            continue
-
-                        if await cli_terminal._maybe_print_interactive_progress(
-                            msg,
-                            None,
-                            agent_loop.channels_config,
-                            renderer,
-                            reasoning_buffer,
-                        ):
-                            continue
-
-                        if not turn_done.is_set():
-                            if msg.content:
-                                turn_response.append(msg)
-                            turn_done.set()
-                        elif msg.content:
-                            await cli_terminal._print_interactive_response(
-                                msg.content,
-                                render_markdown=markdown,
-                                metadata=msg.metadata,
-                            )
-
-                    except asyncio.TimeoutError:
-                        continue
-                    except asyncio.CancelledError:
-                        break
-
-            outbound_task = asyncio.create_task(_consume_outbound())
-
-            try:
-                while True:
-                    try:
-                        cli_terminal._flush_pending_tty_input()
-                        # Stop spinner before user input to avoid prompt_toolkit conflicts
-                        if renderer:
-                            renderer.stop_for_input()
-                        user_input = _sanitize_surrogates(
-                            await cli_terminal._read_interactive_input_async()
-                        )
-                        command = user_input.strip()
-                        if not command:
-                            continue
-
-                        if cli_terminal._is_exit_command(command):
-                            cli_terminal._restore_terminal()
-                            console.print("\nGoodbye!")
-                            break
-
-                        turn_done.clear()
-                        turn_response.clear()
-                        reasoning_buffer.clear()
-                        renderer = StreamRenderer(
-                            render_markdown=markdown,
-                            bot_name=runtime_config.agents.defaults.bot_name,
-                            bot_icon=runtime_config.agents.defaults.bot_icon,
-                        )
-
-                        await bus.publish_inbound(
-                            InboundMessage(
-                                channel=cli_channel,
-                                sender_id="user",
-                                chat_id=cli_chat_id,
-                                content=user_input,
-                                metadata={"_wants_stream": True},
-                            )
-                        )
-
-                        await turn_done.wait()
-
-                        if turn_response:
-                            response_msg = turn_response[0]
-                            content = response_msg.content
-                            meta = response_msg.metadata
-                            if content and not isinstance(
-                                response_msg.event,
-                                StreamedResponseEvent,
-                            ):
-                                if renderer:
-                                    await renderer.close()
-                                print_kwargs: dict[str, Any] = {}
-                                if renderer and renderer.header_printed:
-                                    print_kwargs["show_header"] = False
-                                cli_terminal._print_agent_response(
-                                    content,
-                                    render_markdown=markdown,
-                                    metadata=meta,
-                                    **print_kwargs,
-                                )
-                        elif renderer and not renderer.streamed:
-                            await renderer.close()
-                    except KeyboardInterrupt:
-                        cli_terminal._restore_terminal()
-                        console.print("\nGoodbye!")
-                        break
-                    except EOFError:
-                        cli_terminal._restore_terminal()
-                        console.print("\nGoodbye!")
-                        break
-            finally:
-                agent_loop.stop()
-                outbound_task.cancel()
-                await asyncio.gather(bus_task, outbound_task, return_exceptions=True)
-                await agent_loop.close_mcp()
-
-        asyncio.run(run_interactive())

nanobot/cli/gateway.py

@@ -133,9 +133,8 @@ def create_gateway_app(
             console.print()
             console.print(result.content)
 
-    # Typer consumes these callbacks through decorator registration.
     @gateway_app.callback(invoke_without_command=True)
-    def gateway(  # pyright: ignore[reportUnusedFunction]
+    def gateway(
         ctx: typer.Context,
         port: int | None = typer.Option(None, "--port", "-p", help="Gateway port"),
         workspace: str | None = typer.Option(None, "--workspace", "-w", help="Workspace directory"),
@@ -190,7 +189,7 @@ def create_gateway_app(
             )
 
     @gateway_app.command("status")
-    def gateway_status(  # pyright: ignore[reportUnusedFunction]
+    def gateway_status(
         workspace: str | None = typer.Option(None, "--workspace", "-w", help="Workspace directory"),
         config: str | None = typer.Option(None, "--config", "-c", help="Path to config file"),
     ) -> None:
@@ -198,7 +197,7 @@ def create_gateway_app(
         print_status(runtime_for_instance(workspace=workspace, config=config).status())
 
     @gateway_app.command("logs")
-    def gateway_logs(  # pyright: ignore[reportUnusedFunction]
+    def gateway_logs(
         tail: int = typer.Option(200, "--tail", help="Number of recent lines to show"),
         follow: bool = typer.Option(True, "--follow/--no-follow", help="Follow new log output"),
         workspace: str | None = typer.Option(None, "--workspace", "-w", help="Workspace directory"),
@@ -216,7 +215,7 @@ def create_gateway_app(
             console.print(line)
 
     @gateway_app.command("stop")
-    def gateway_stop(  # pyright: ignore[reportUnusedFunction]
+    def gateway_stop(
         timeout: int = typer.Option(20, "--timeout", help="Stop timeout in seconds"),
         workspace: str | None = typer.Option(None, "--workspace", "-w", help="Workspace directory"),
         config: str | None = typer.Option(None, "--config", "-c", help="Path to config file"),
@@ -232,7 +231,7 @@ def create_gateway_app(
             raise typer.Exit(1)
 
     @gateway_app.command("restart")
-    def gateway_restart(  # pyright: ignore[reportUnusedFunction]
+    def gateway_restart(
         port: int | None = typer.Option(None, "--port", "-p", help="Gateway port"),
         workspace: str | None = typer.Option(None, "--workspace", "-w", help="Workspace directory"),
         verbose: bool = typer.Option(False, "--verbose", "-v", help="Verbose output"),
@@ -265,7 +264,7 @@ def create_gateway_app(
         raise typer.Exit(1)
 
     @gateway_app.command("install-service")
-    def gateway_install_service(  # pyright: ignore[reportUnusedFunction]
+    def gateway_install_service(
         port: int | None = typer.Option(None, "--port", "-p", help="Gateway port"),
         workspace: str | None = typer.Option(None, "--workspace", "-w", help="Workspace directory"),
         verbose: bool = typer.Option(False, "--verbose", "-v", help="Verbose output"),
@@ -301,7 +300,7 @@ def create_gateway_app(
         raise typer.Exit(1)
 
     @gateway_app.command("uninstall-service")
-    def gateway_uninstall_service(  # pyright: ignore[reportUnusedFunction]
+    def gateway_uninstall_service(
         name: str = typer.Option("nanobot-gateway", "--name", help="Service name"),
         manager: ServiceManagerKind = typer.Option("auto", "--manager", help="auto, systemd, or launchd"),
         dry_run: bool = typer.Option(False, "--dry-run", help="Print actions without uninstalling"),

nanobot/cli/gateway_runtime.py

@@ -1,829 +0,0 @@
-"""Foreground gateway runtime and lifecycle helpers."""
-
-import asyncio
-import signal
-from collections.abc import Awaitable, Callable, Coroutine, Iterable
-from contextlib import suppress
-from pathlib import Path
-from typing import Any, cast
-
-import typer
-from loguru import logger
-from rich.console import Console
-
-from nanobot import __logo__, __version__
-from nanobot.agent.hooks import create_file_edit_activity_hook
-from nanobot.agent.loop import AgentLoop
-from nanobot.cli import terminal as cli_terminal
-from nanobot.cli.runtime_config import _migrate_cron_store
-from nanobot.cli.webui_support import (
-    _gateway_health_bind_note,
-    _gateway_health_url,
-    _host_for_local_browser,
-    _prepare_webui_bundle_for_gateway,
-    _print_foreground_port_conflict,
-    _tcp_endpoint_reachable,
-    _webui_browser_url,
-    _webui_channel_enabled,
-    _webui_endpoint_reachable,
-)
-from nanobot.config.paths import is_default_workspace
-from nanobot.config.schema import Config
-from nanobot.security.network import is_loopback_host
-from nanobot.session.keys import UNIFIED_SESSION_KEY, last_channel_from_metadata
-from nanobot.utils.evaluator import evaluate_response, resolve_evaluator_prompt
-from nanobot.utils.helpers import sync_workspace_templates
-from nanobot.webui.build import BuildMode
-from nanobot.webui.sidebar_state import read_webui_sidebar_state
-
-__all__ = ["_run_gateway"]
-
-console = Console()
-
-
-def _signal_name(signum: int) -> str:
-    with suppress(ValueError):
-        return signal.Signals(signum).name
-    return f"signal {signum}"
-
-
-def _install_gateway_shutdown_handlers(
-    loop: asyncio.AbstractEventLoop,
-    shutdown_event: asyncio.Event,
-    tasks: list[asyncio.Task[Any]],
-    print_status: Callable[[str], None],
-) -> Callable[[], None]:
-    """Install foreground gateway signal handlers and return a restore callback."""
-    loop_signals: list[int] = []
-    previous_handlers: list[tuple[int, Any]] = []
-    shutdown_requested = False
-
-    def request_shutdown(signum: int) -> None:
-        nonlocal shutdown_requested
-        sig_name = _signal_name(signum)
-        if shutdown_requested:
-            logger.warning("Forcing gateway shutdown after repeated {}", sig_name)
-            for task in tasks:
-                if not task.done():
-                    task.cancel()
-            return
-        shutdown_requested = True
-        logger.info("Gateway shutdown requested by {}", sig_name)
-        print_status("\nShutting down... Press Ctrl+C again to force.")
-        shutdown_event.set()
-
-    for signum in (signal.SIGINT, signal.SIGTERM):
-        try:
-            loop.add_signal_handler(signum, request_shutdown, signum)
-        except (NotImplementedError, RuntimeError, ValueError):
-            try:
-                previous = signal.getsignal(signum)
-                signal.signal(signum, lambda sig, _frame: request_shutdown(sig))
-            except (RuntimeError, ValueError):
-                logger.debug("Could not install gateway handler for {}", _signal_name(signum))
-                continue
-            previous_handlers.append((signum, previous))
-        else:
-            loop_signals.append(signum)
-
-    def restore() -> None:
-        for signum in loop_signals:
-            with suppress(NotImplementedError, RuntimeError, ValueError):
-                loop.remove_signal_handler(signum)
-        for signum, handler in previous_handlers:
-            with suppress(RuntimeError, ValueError):
-                signal.signal(signum, handler)
-
-    return restore
-
-
-def _advance_dream_cursor_if_behind(memory: Any) -> None:
-    latest = memory.get_latest_cursor()
-    if memory.get_last_dream_cursor() < latest:
-        memory.set_last_dream_cursor(latest)
-
-
-def _commit_dream_changes(memory: Any) -> str | None:
-    """Commit durable Dream edits, without entering the commit path for a no-op run."""
-    if not memory.git.is_initialized():
-        return None
-    diff_body = memory.dream_content_diff()
-    if not diff_body:
-        return None
-    message = memory.build_dream_commit_message(
-        "dream: periodic memory consolidation",
-        diff_body,
-    )
-    return memory.git.auto_commit(message)
-
-
-_HEARTBEAT_PREAMBLE = (
-    "[Your response will be delivered directly to the user's messaging app. "
-    "Output ONLY the final user-facing message. Never reference internal "
-    "files (HEARTBEAT.md, AWARENESS.md, etc.), your instructions, or your "
-    "decision process. If nothing needs reporting, respond with just "
-    "'All clear.' and nothing else.]\n\n"
-)
-
-
-def _heartbeat_has_active_tasks(content: str) -> bool:
-    """True if HEARTBEAT.md has task lines, ignoring headers, blanks and comments."""
-    in_comment = False
-    in_active_section: bool = False
-    for line in content.splitlines():
-        stripped = line.strip()
-        if in_comment:
-            if "-->" in stripped:
-                in_comment = False
-            continue
-        if not stripped or stripped.startswith("#"):
-            if stripped.startswith("##") and not stripped.startswith("###"):
-                heading = stripped.lstrip("#").strip().lower()
-                in_active_section = heading.startswith("active tasks")
-            continue
-        if stripped.startswith("<!--"):
-            if "-->" not in stripped[4:]:
-                in_comment = True
-            continue
-        if in_active_section is False:
-            continue
-        return True
-    return False
-
-
-def _pick_heartbeat_target_from_sessions(
-    *,
-    enabled_channels: Iterable[str],
-    sessions: Iterable[dict[str, Any]],
-    archived_keys: Iterable[str],
-    unified_session_metadata: dict[str, Any] | None = None,
-) -> tuple[str, str]:
-    enabled = set(enabled_channels)
-    archived = set(archived_keys)
-    for item in sessions:
-        key = item.get("key") or ""
-        if key in archived:
-            continue
-        if key == UNIFIED_SESSION_KEY:
-            route = last_channel_from_metadata(unified_session_metadata)
-            if route is not None:
-                channel, chat_id = route
-                if channel not in {"cli", "system"} and channel in enabled:
-                    return channel, chat_id
-            continue
-        if ":" not in key:
-            continue
-        channel, chat_id = key.split(":", 1)
-        if channel in {"cli", "system"}:
-            continue
-        if channel in enabled and chat_id:
-            return channel, chat_id
-    return "cli", "direct"
-
-
-_GATEWAY_HEALTH_MAX_CONNECTIONS = 64
-_GATEWAY_HEALTH_READ_TIMEOUT_SECONDS = 2.0
-
-
-def _print_gateway_health_endpoint(host: str, port: int) -> None:
-    """Print a usable health URL and make non-loopback binds explicit."""
-    console.print(
-        f"[green]✓[/green] Health endpoint: {_gateway_health_url(host, port)}"
-        f"{_gateway_health_bind_note(host)}"
-    )
-    if is_loopback_host(host):
-        return
-
-    console.print(
-        "[yellow]Warning: the unauthenticated health endpoint is listening beyond loopback "
-        "and may be reachable from other devices. "
-        f"Keep port {port} private or protect it with a firewall or reverse proxy.[/yellow]"
-    )
-
-
-def _run_gateway(
-    config: Config,
-    *,
-    port: int | None = None,
-    open_browser_url: str | None = None,
-    webui_static_dist: bool = True,
-    webui_bundle_mode: BuildMode = "warn",
-    webui_runtime_surface: str = "browser",
-    webui_runtime_capabilities: dict[str, Any] | None = None,
-    health_server_enabled: bool = True,
-    unconfigured_provider_error: str | None = None,
-) -> None:
-    """Shared gateway runtime; ``open_browser_url`` opens a tab once channels are up."""
-    from nanobot.agent.model_presets import load_model_preset_catalog
-    from nanobot.agent.tools.message import MessageTool
-    from nanobot.agent.turn_delivery import TurnDeliveryFactory
-    from nanobot.bus.queue import MessageBus
-    from nanobot.bus.runtime_events import RuntimeEventBus
-    from nanobot.channels.manager import ChannelManager
-    from nanobot.config.watcher import watch_config_file
-    from nanobot.cron.bound_runner import run_bound_cron_job
-    from nanobot.cron.service import CronJobSkippedError, CronService
-    from nanobot.cron.session_turns import is_bound_cron_job
-    from nanobot.cron.types import CronJob
-    from nanobot.providers.factory import (
-        ProviderSnapshot,
-        build_provider_snapshot,
-        build_unconfigured_provider_snapshot,
-        load_provider_snapshot,
-    )
-    from nanobot.providers.fallback_provider import FallbackProvider
-    from nanobot.providers.image_generation import image_gen_provider_configs
-    from nanobot.session.manager import SessionManager
-    from nanobot.session.webui_turns import (
-        WebuiTurnCoordinator,
-        WebuiTurnRoutePolicy,
-        build_webui_fallback_model_observer,
-    )
-    from nanobot.triggers.local_runner import run_local_trigger_queue
-    from nanobot.triggers.local_store import LocalTriggerStore
-    from nanobot.webui.token_usage import TokenUsageHook
-
-    port = port if port is not None else config.gateway.port
-    webui_url = _webui_browser_url(config)
-    gateway_host_for_browser = _host_for_local_browser(config.gateway.host)
-    if health_server_enabled and _tcp_endpoint_reachable(gateway_host_for_browser, port):
-        _print_foreground_port_conflict(
-            webui_url=webui_url,
-            gateway_host=config.gateway.host,
-            gateway_port=port,
-        )
-        raise typer.Exit(1)
-    if _webui_channel_enabled(config) and _webui_endpoint_reachable(webui_url):
-        _print_foreground_port_conflict(
-            webui_url=webui_url,
-            gateway_host=config.gateway.host,
-            gateway_port=port,
-        )
-        raise typer.Exit(1)
-
-    console.print(f"{__logo__} Starting nanobot gateway version {__version__} on port {port}...")
-    _prepare_webui_bundle_for_gateway(
-        config,
-        mode=webui_bundle_mode,
-        webui_static_dist=webui_static_dist,
-    )
-    sync_workspace_templates(config.workspace_path)
-    bus = MessageBus()
-    runtime_events = RuntimeEventBus()
-    fallback_model_observer = build_webui_fallback_model_observer(bus)
-
-    def _observe_fallback_models(snapshot: ProviderSnapshot) -> ProviderSnapshot:
-        if isinstance(snapshot.provider, FallbackProvider):
-            snapshot.provider.set_fallback_model_observer(fallback_model_observer)
-        return snapshot
-
-    def _load_gateway_provider_snapshot(
-        *args: Any,
-        **kwargs: Any,
-    ) -> ProviderSnapshot:
-        try:
-            return _observe_fallback_models(load_provider_snapshot(*args, **kwargs))
-        except ValueError as exc:
-            if unconfigured_provider_error is None:
-                raise
-            return build_unconfigured_provider_snapshot(config, str(exc))
-
-    if unconfigured_provider_error is not None:
-        provider_snapshot = build_unconfigured_provider_snapshot(
-            config,
-            unconfigured_provider_error,
-        )
-    else:
-        try:
-            provider_snapshot = _observe_fallback_models(build_provider_snapshot(config))
-        except ValueError as exc:
-            console.print(f"[red]Error: {exc}[/red]")
-            raise typer.Exit(1) from exc
-    session_manager = SessionManager(config.workspace_path)
-
-    # Self-heal the gateway state file with the current PID after any restart.
-    from nanobot.config.loader import get_config_path
-    from nanobot.gateway.runtime import GatewayRuntime, GatewayRuntimePaths
-
-    config_path = str(get_config_path().resolve(strict=False))
-    GatewayRuntime.refresh_state_pid(
-        paths=GatewayRuntimePaths.for_instance(
-            workspace=str(config.workspace_path)
-            if not is_default_workspace(config.workspace_path)
-            else None,
-            config_path=config_path,
-        )
-    )
-
-    # Preserve existing single-workspace installs, but keep custom workspaces clean.
-    if is_default_workspace(config.workspace_path):
-        _migrate_cron_store(config)
-
-    # Create cron service with workspace-scoped store
-    cron_store_path = config.workspace_path / "cron" / "jobs.json"
-    cron = CronService(cron_store_path)
-    trigger_store = LocalTriggerStore(config.workspace_path)
-
-    turn_delivery_factory = TurnDeliveryFactory(
-        bus,
-        runtime_events,
-        route_policy=WebuiTurnRoutePolicy(session_manager),
-    )
-
-    # Create agent with cron service
-    agent = AgentLoop.from_config(
-        config, bus,
-        provider=provider_snapshot.provider,
-        model=provider_snapshot.model,
-        context_window_tokens=provider_snapshot.context_window_tokens,
-        cron_service=cron,
-        session_manager=session_manager,
-        image_generation_provider_configs=image_gen_provider_configs(config),
-        provider_snapshot_loader=_load_gateway_provider_snapshot,
-        preset_catalog_loader=load_model_preset_catalog,
-        runtime_events=runtime_events,
-        turn_delivery_factory=turn_delivery_factory,
-        provider_signature=provider_snapshot.signature,
-        hooks=[TokenUsageHook(timezone_name=config.agents.defaults.timezone)],
-        local_trigger_store=trigger_store,
-        hook_factories=[create_file_edit_activity_hook],
-    )
-    def _schedule_webui_background(awaitable: Awaitable[None]) -> None:
-        agent.schedule_background(cast(Coroutine[Any, Any, None], awaitable))
-
-    webui_turn_coordinator = WebuiTurnCoordinator(
-        bus=bus,
-        sessions=session_manager,
-        schedule_background=_schedule_webui_background,
-    )
-    webui_turn_coordinator.subscribe(runtime_events)
-    from nanobot.bus.events import OutboundMessage
-    from nanobot.session.keys import session_key_for_channel
-
-    def _channel_session_key(channel: str, chat_id: str) -> str:
-        return session_key_for_channel(
-            channel,
-            chat_id,
-            unified_session=config.agents.defaults.unified_session,
-        )
-
-    async def _deliver_to_channel(
-        msg: OutboundMessage, *, record: bool = False, session_key: str | None = None,
-    ) -> None:
-        """Publish a user-visible message and mirror it into that channel's session."""
-        metadata = dict(msg.metadata or {})
-        record = record or bool(metadata.pop("_record_channel_delivery", False))
-        if metadata != (msg.metadata or {}):
-            msg = OutboundMessage(
-                channel=msg.channel,
-                chat_id=msg.chat_id,
-                content=msg.content,
-                reply_to=msg.reply_to,
-                media=msg.media,
-                metadata=metadata,
-                buttons=msg.buttons,
-            )
-        if (
-            record
-            and msg.channel != "cli"
-            and msg.content.strip()
-            and hasattr(session_manager, "get_or_create")
-            and hasattr(session_manager, "save")
-        ):
-            key = session_key or _channel_session_key(msg.channel, msg.chat_id)
-            session = session_manager.get_or_create(key)
-            extra: dict[str, Any] = {"_channel_delivery": True}
-            if msg.media:
-                extra["media"] = list(msg.media)
-            session.add_message("assistant", msg.content, **extra)
-            session_manager.save(session)
-        await bus.publish_outbound(msg)
-
-    message_tool = agent.tools.get("message")
-    if isinstance(message_tool, MessageTool):
-        message_tool.set_send_callback(_deliver_to_channel)
-
-    # Set cron callback (needs agent)
-    async def on_cron_job(job: CronJob) -> str | None:
-        """Execute a cron job through the agent."""
-        async def _silent(*_args: Any, **_kwargs: Any) -> None:
-            pass
-
-        # Dream is an internal job — run directly, not through the agent loop.
-        if job.name == "dream":
-            from nanobot.agent.memory import DreamRunProgress, MemoryStore
-
-            dream_session_key = MemoryStore.dream_session_key
-            prune_dream_sessions = MemoryStore.prune_dream_sessions
-
-            store = agent.context.memory
-            progress = DreamRunProgress()
-            resp = None
-            diff_body = ""
-            try:
-                result = store.build_dream_prompt()
-                if result is None:
-                    logger.info("Dream: nothing to process")
-                    return None
-                prompt, last_cursor = result
-                key = dream_session_key()
-                dream_runtime = agent.dream_runtime()
-                resp = await agent.process_direct(
-                    prompt,
-                    session_key=key,
-                    ephemeral=True,
-                    tools=store.build_dream_tools(),
-                    on_progress=progress,
-                    runtime=dream_runtime,
-                )
-                # The real file delta grounds the audit record; clean completion
-                # decides whether this history batch has finished processing.
-                diff_body = store.dream_content_diff()
-                completed = MemoryStore.dream_run_completed(
-                    resp,
-                    had_tool_errors=progress.had_tool_errors,
-                )
-                if completed:
-                    store.set_last_dream_cursor(last_cursor)
-                    if diff_body:
-                        logger.info(
-                            "Dream cron job completed, cursor advanced to {}",
-                            last_cursor,
-                        )
-                    else:
-                        logger.info(
-                            "Dream cron job completed with no memory changes; "
-                            "cursor advanced to {}",
-                            last_cursor,
-                        )
-                else:
-                    logger.warning(
-                        "Dream cron job did not complete; cursor remains at {}",
-                        store.get_last_dream_cursor(),
-                    )
-            except Exception:
-                logger.exception("Dream cron job failed")
-            finally:
-                from nanobot.webui.token_usage import record_response_token_usage
-
-                record_response_token_usage(
-                    resp,
-                    source="dream",
-                    timezone_name=config.agents.defaults.timezone,
-                )
-                sha = _commit_dream_changes(store)
-                if sha:
-                    logger.info("Dream commit: {}", sha)
-                store.compact_history()
-                prune_dream_sessions(agent.sessions.sessions_dir)
-            return None
-
-        # Heartbeat is a system job that checks HEARTBEAT.md for active tasks.
-        if job.name == "heartbeat":
-            heartbeat_file = config.workspace_path / "HEARTBEAT.md"
-            try:
-                content = heartbeat_file.read_text(encoding="utf-8")
-            except OSError:
-                logger.debug("Heartbeat: HEARTBEAT.md missing")
-                return None
-            if not _heartbeat_has_active_tasks(content):
-                logger.debug("Heartbeat: HEARTBEAT.md has no active tasks")
-                return None
-
-            channel, chat_id = _pick_heartbeat_target()
-            if channel == "cli":
-                return None
-
-            prompt = (
-                _HEARTBEAT_PREAMBLE
-                + f"You are executing periodic heartbeat tasks. Read the active tasks below, perform each one, and report what you did:\n\n{content}"
-            )
-
-            # Internal check: funnel all output through the post-run gate so the
-            # turn can't deliver directly via the message tool and skip it.
-            suppress_token = None
-            if isinstance(message_tool, MessageTool):
-                suppress_token = message_tool.set_suppress_delivery(True)
-            try:
-                resp = await agent.process_direct(
-                    prompt,
-                    session_key="heartbeat",
-                    channel=channel,
-                    chat_id=chat_id,
-                    on_progress=_silent,
-                )
-            finally:
-                if isinstance(message_tool, MessageTool) and suppress_token is not None:
-                    message_tool.reset_suppress_delivery(suppress_token)
-
-            # Keep a small tail of heartbeat history so the loop stays bounded.
-            session = agent.sessions.get_or_create("heartbeat")
-            session.retain_recent_legal_suffix(hb_cfg.keep_recent_messages)
-            agent.sessions.save(session)
-
-            if not resp or not resp.content:
-                return
-
-            response = resp.content
-
-            evaluator_prompt = resolve_evaluator_prompt(config.workspace_path)
-
-            # Fail closed: stay silent on evaluator failure instead of notifying.
-            should_notify = await evaluate_response(
-                response=response,
-                task_context=prompt,
-                provider=agent.provider,
-                model=agent.model,
-                evaluator_prompt=evaluator_prompt,
-                default_notify=False,
-            )
-
-            if should_notify:
-                logger.info("Heartbeat: completed, delivering response")
-                await _deliver_to_channel(
-                    OutboundMessage(channel=channel, chat_id=chat_id, content=response),
-                    record=True,
-                )
-            else:
-                logger.info("Heartbeat: silenced by post-run evaluation")
-            return response
-
-        if is_bound_cron_job(job):
-            return await run_bound_cron_job(job, agent=agent, cron=cron)
-
-        reason = "unbound agent cron job must be recreated from a chat session"
-        logger.warning(
-            "Cron: skipped unbound agent job '{}' ({}): {}",
-            job.name,
-            job.id,
-            reason,
-        )
-        raise CronJobSkippedError(reason)
-
-    cron.on_job = on_cron_job
-
-    def _webui_runtime_model_name() -> str | None:
-        return agent.model.strip() or None
-
-    def _webui_skill_state_action(disabled_skills: set[str]) -> None:
-        config.agents.defaults.disabled_skills = sorted(disabled_skills)
-        agent.context.skills.disabled_skills = set(disabled_skills)
-        agent.subagents.disabled_skills = set(disabled_skills)
-
-    # Create channel manager (forwards SessionManager so the WebSocket channel
-    # can serve the embedded webui's REST surface).
-    channels = ChannelManager(
-        config,
-        bus,
-        session_manager=session_manager,
-        cron_service=cron,
-        local_trigger_store=trigger_store,
-        webui_runtime_model_name=_webui_runtime_model_name,
-        webui_cron_pending_job_ids=agent.pending_cron_job_ids_for_session,
-        webui_local_trigger_pending_ids=agent.pending_local_trigger_ids_for_session,
-        webui_cancel_active_turn=getattr(agent, "cancel_active_turn", None),
-        webui_static_dist=webui_static_dist,
-        webui_runtime_surface=webui_runtime_surface,
-        webui_runtime_capabilities=webui_runtime_capabilities,
-        webui_skill_state_action=_webui_skill_state_action,
-    )
-
-    def _pick_heartbeat_target() -> tuple[str, str]:
-        """Pick a routable channel/chat target for heartbeat-triggered messages."""
-        sidebar_state = read_webui_sidebar_state()
-        unified_metadata = None
-        if config.agents.defaults.unified_session:
-            record = session_manager.read_session_metadata(UNIFIED_SESSION_KEY)
-            if isinstance(record, dict) and isinstance(record.get("metadata"), dict):
-                unified_metadata = record["metadata"]
-        return _pick_heartbeat_target_from_sessions(
-            enabled_channels=channels.enabled_channels,
-            sessions=session_manager.list_sessions(),
-            archived_keys=sidebar_state.get("archived_keys", []),
-            unified_session_metadata=unified_metadata,
-        )
-
-    if channels.enabled_channels:
-        console.print(f"[green]✓[/green] Channels enabled: {', '.join(channels.enabled_channels)}")
-    else:
-        console.print("[yellow]Warning: No channels enabled[/yellow]")
-
-    cron_status = cron.status()
-    cron_job_count = cast(int, cron_status["jobs"])
-    if cron_job_count > 0:
-        console.print(f"[green]✓[/green] Cron: {cron_job_count} scheduled jobs")
-
-    hb_cfg = config.gateway.heartbeat
-    if hb_cfg.enabled:
-        console.print(f"[green]✓[/green] Heartbeat: every {hb_cfg.interval_s}s")
-    else:
-        console.print("[yellow]✗[/yellow] Heartbeat: disabled")
-
-    async def _health_server(host: str, health_port: int) -> None:
-        """Lightweight HTTP health endpoint on the gateway port."""
-        import json as _json
-
-        connection_slots = asyncio.Semaphore(_GATEWAY_HEALTH_MAX_CONNECTIONS)
-
-        async def handle(
-            reader: asyncio.StreamReader,
-            writer: asyncio.StreamWriter,
-        ) -> None:
-            if connection_slots.locked():
-                writer.close()
-                return
-
-            async with connection_slots:
-                try:
-                    data = await asyncio.wait_for(
-                        reader.read(4096),
-                        timeout=_GATEWAY_HEALTH_READ_TIMEOUT_SECONDS,
-                    )
-                    request_line = data.split(b"\r\n", 1)[0].decode(
-                        "utf-8", errors="replace",
-                    )
-                    method, path = "", ""
-                    parts = request_line.split(" ")
-                    if len(parts) >= 2:
-                        method, path = parts[0], parts[1]
-
-                    if method == "GET" and path == "/health":
-                        body = _json.dumps({"status": "ok"})
-                        status = "200 OK"
-                        content_type = "application/json"
-                    else:
-                        body = "Not Found"
-                        status = "404 Not Found"
-                        content_type = "text/plain"
-
-                    resp = (
-                        f"HTTP/1.0 {status}\r\n"
-                        f"Content-Type: {content_type}\r\n"
-                        f"Content-Length: {len(body)}\r\n"
-                        "Connection: close\r\n"
-                        f"\r\n{body}"
-                    )
-                    writer.write(resp.encode())
-                    await writer.drain()
-                except (asyncio.TimeoutError, ConnectionError):
-                    pass
-                finally:
-                    writer.close()
-
-        server = await asyncio.start_server(handle, host, health_port)
-        _print_gateway_health_endpoint(host, health_port)
-        async with server:
-            await server.serve_forever()
-    # Register Dream system job (idempotent on restart)
-    from nanobot.cron.types import CronJob, CronPayload, CronSchedule
-    dream_cfg = config.agents.defaults.dream
-    if dream_cfg.enabled:
-        cron.register_system_job(CronJob(
-            id="dream",
-            name="dream",
-            schedule=dream_cfg.build_schedule(config.agents.defaults.timezone),
-            payload=CronPayload(kind="system_event"),
-        ))
-        console.print(f"[green]✓[/green] Dream: {dream_cfg.describe_schedule()}")
-    else:
-        console.print("[yellow]○[/yellow] Dream: disabled")
-        _advance_dream_cursor_if_behind(agent.context.memory)
-
-    # Register Heartbeat system job (idempotent on restart)
-    if hb_cfg.enabled:
-        cron.register_system_job(CronJob(
-            id="heartbeat",
-            name="heartbeat",
-            schedule=CronSchedule(
-                kind="every",
-                every_ms=hb_cfg.interval_s * 1000,
-                tz=config.agents.defaults.timezone,
-            ),
-            payload=CronPayload(kind="system_event"),
-        ))
-
-    async def _open_browser_when_ready() -> None:
-        """Wait for the gateway to bind, then point the user's browser at the webui."""
-        if not open_browser_url:
-            return
-        import webbrowser
-        from urllib.parse import urlparse
-
-        parsed = urlparse(open_browser_url)
-        target_host = parsed.hostname or config.gateway.host or "127.0.0.1"
-        target_port = parsed.port or port
-        # Channels start asynchronously; a short poll lets us avoid racing the bind.
-        for _ in range(40):  # ~4s max
-            try:
-                _reader, writer = await asyncio.open_connection(
-                    target_host,
-                    target_port,
-                )
-                writer.close()
-                with suppress(Exception):
-                    await writer.wait_closed()
-                break
-            except OSError:
-                await asyncio.sleep(0.1)
-        try:
-            webbrowser.open(open_browser_url)
-            console.print(f"[green]✓[/green] Opened browser at {open_browser_url}")
-        except Exception as e:
-            console.print(f"[yellow]Could not open browser ({e}); visit {open_browser_url}[/yellow]")
-
-    async def run() -> None:
-        tasks: list[asyncio.Task[Any]] = []
-        shutdown_task: asyncio.Task[Any] | None = None
-        runtime_tasks: asyncio.Future[list[Any]] | None = None
-        runtime_tasks_drained = False
-        shutdown_event = asyncio.Event()
-        cli_terminal._ensure_interactive_tty_mode()
-        restore_shutdown_handlers = _install_gateway_shutdown_handlers(
-            asyncio.get_running_loop(),
-            shutdown_event,
-            tasks,
-            console.print,
-        )
-        try:
-            await cron.start()
-            # Re-read once on first admission to close the watcher subscription window.
-            agent.runtime_resolver.invalidate()
-            tasks = [
-                asyncio.create_task(
-                    watch_config_file(
-                        Path(config_path),
-                        lambda: agent.invalidate_runtime_config(),
-                    ),
-                    name="nanobot-config-watcher",
-                ),
-                asyncio.create_task(agent.run(), name="nanobot-agent-loop"),
-                asyncio.create_task(channels.start_all(), name="nanobot-channels"),
-                asyncio.create_task(
-                    run_local_trigger_queue(
-                        store=trigger_store,
-                        submit_turn=agent.submit_local_trigger_turn,
-                        is_channel_enabled=lambda name: channels.get_channel(name) is not None,
-                    ),
-                    name="nanobot-local-triggers",
-                ),
-            ]
-            if health_server_enabled:
-                tasks.append(asyncio.create_task(
-                    _health_server(config.gateway.host, port),
-                    name="nanobot-health-server",
-                ))
-            if open_browser_url:
-                tasks.append(asyncio.create_task(
-                    _open_browser_when_ready(),
-                    name="nanobot-open-browser",
-                ))
-            runtime_tasks = asyncio.gather(*tasks)
-            shutdown_task = asyncio.create_task(
-                shutdown_event.wait(),
-                name="nanobot-gateway-shutdown",
-            )
-            done, _pending = await asyncio.wait(
-                {runtime_tasks, shutdown_task},
-                return_when=asyncio.FIRST_COMPLETED,
-            )
-            if runtime_tasks in done:
-                runtime_tasks_drained = True
-                await runtime_tasks
-            else:
-                runtime_tasks.cancel()
-        except KeyboardInterrupt:
-            console.print("\nShutting down...")
-        except Exception:
-            import traceback
-
-            console.print("\n[red]Error: Gateway crashed unexpectedly[/red]")
-            console.print(traceback.format_exc())
-        finally:
-            try:
-                if shutdown_task and not shutdown_task.done():
-                    shutdown_task.cancel()
-                    with suppress(asyncio.CancelledError):
-                        await shutdown_task
-                cron.stop()
-                agent.stop()
-                # Some SDKs swallow task cancellation while attempting to reconnect.
-                # Close channel transports before waiting for their runners to exit.
-                await channels.stop_all()
-                for task in tasks:
-                    if not task.done():
-                        task.cancel()
-                if tasks:
-                    await asyncio.gather(*tasks, return_exceptions=True)
-                if runtime_tasks is not None and not runtime_tasks_drained:
-                    with suppress(asyncio.CancelledError, Exception):
-                        await runtime_tasks
-                # Flush all cached sessions to durable storage before exit.
-                # This prevents data loss on filesystems with write-back
-                # caching (rclone VFS, NFS, FUSE mounts, etc.).
-                flushed = agent.sessions.flush_all()
-                if flushed:
-                    logger.info("Shutdown: flushed {} session(s) to disk", flushed)
-            finally:
-                restore_shutdown_handlers()
-
-    asyncio.run(run())

nanobot/cli/log_control.py

@@ -1,12 +0,0 @@
-"""Runtime log visibility controls shared by CLI commands."""
-
-from loguru import logger
-
-__all__ = ["_set_nanobot_logs"]
-
-
-def _set_nanobot_logs(enabled: bool) -> None:
-    if enabled:
-        logger.enable("nanobot")
-    else:
-        logger.disable("nanobot")

nanobot/cli/onboard.py

@@ -3,23 +3,17 @@
 import asyncio
 import json
 import types
-from collections.abc import Callable, Iterable, Sized
 from contextlib import suppress
 from dataclasses import dataclass
 from functools import lru_cache
-from typing import Any, Literal, NamedTuple, TypeVar, cast, get_args, get_origin
+from typing import Any, Literal, NamedTuple, get_args, get_origin
 
 try:
     import questionary
 except ModuleNotFoundError:  # pragma: no cover - exercised in environments without wizard deps
     questionary = None
 from loguru import logger
-from prompt_toolkit.completion import CompleteEvent, Completer, Completion
-from prompt_toolkit.document import Document
-from prompt_toolkit.key_binding import KeyBindings
-from prompt_toolkit.key_binding.key_processor import KeyPressEvent
 from pydantic import BaseModel
-from pydantic.fields import FieldInfo
 from rich.console import Console
 from rich.markup import escape
 from rich.panel import Panel
@@ -35,8 +29,6 @@ from nanobot.config.schema import Config, ModelPresetConfig
 
 console = Console()
 
-_ModelT = TypeVar("_ModelT", bound=BaseModel)
-
 
 @dataclass
 class OnboardResult:
@@ -127,14 +119,14 @@ _CHANNEL_LOGIN_CHOICE = "Login with QR/link"
 _CHANNEL_ADVANCED_CHOICE = "Edit advanced settings"
 
 
-def _get_questionary() -> Any:
+def _get_questionary():
     """Return questionary or raise a clear error when wizard deps are unavailable."""
     if questionary is None:
         raise RuntimeError(
             "Interactive onboarding requires the optional 'questionary' dependency. "
             "Install project dependencies and rerun with --wizard."
         )
-    return cast(Any, questionary)
+    return questionary
 
 
 def _select_with_back(
@@ -155,6 +147,7 @@ def _select_with_back(
     import shutil
 
     from prompt_toolkit.application import Application
+    from prompt_toolkit.key_binding import KeyBindings
     from prompt_toolkit.keys import Keys
     from prompt_toolkit.layout import Layout
     from prompt_toolkit.layout.containers import HSplit, Window
@@ -177,8 +170,8 @@ def _select_with_back(
     visible_count = min(len(choices), max(1, terminal_lines - 3))
 
     # Build menu items (uses closure over selected_index)
-    def get_menu_text() -> list[tuple[str, str]]:
-        items: list[tuple[str, str]] = []
+    def get_menu_text():
+        items = []
         start, end = _choice_viewport(selected_index, len(choices), visible_count)
         for i in range(start, end):
             choice = choices[i]
@@ -189,14 +182,14 @@ def _select_with_back(
         return items
 
     # Create layout
-    menu_control = FormattedTextControl(cast(Any, get_menu_text), show_cursor=False)
+    menu_control = FormattedTextControl(get_menu_text, show_cursor=False)
     menu_window = Window(content=menu_control, height=visible_count, always_hide_cursor=True)
 
-    def get_prompt_text() -> list[tuple[str, str]]:
+    def get_prompt_text():
         suffix = f" ({selected_index + 1}/{len(choices)})" if len(choices) > visible_count else ""
         return [("class:question", f"{prompt}{suffix}")]
 
-    prompt_control = FormattedTextControl(cast(Any, get_prompt_text), show_cursor=False)
+    prompt_control = FormattedTextControl(get_prompt_text, show_cursor=False)
     prompt_window = Window(content=prompt_control, height=1, always_hide_cursor=True)
 
     layout = Layout(HSplit([prompt_window, menu_window]))
@@ -204,36 +197,35 @@ def _select_with_back(
     # Key bindings
     bindings = KeyBindings()
 
-    # KeyBindings consumes these handlers through decorator registration.
     @bindings.add(Keys.Up)
-    def _up(event: KeyPressEvent) -> None:  # pyright: ignore[reportUnusedFunction]
+    def _up(event):
         nonlocal selected_index
         selected_index = (selected_index - 1) % len(choices)
         event.app.invalidate()
 
     @bindings.add(Keys.Down)
-    def _down(event: KeyPressEvent) -> None:  # pyright: ignore[reportUnusedFunction]
+    def _down(event):
         nonlocal selected_index
         selected_index = (selected_index + 1) % len(choices)
         event.app.invalidate()
 
     @bindings.add(Keys.Enter)
-    def _enter(event: KeyPressEvent) -> None:  # pyright: ignore[reportUnusedFunction]
+    def _enter(event):
         state["result"] = choices[selected_index]
         event.app.exit()
 
     @bindings.add("escape")
-    def _escape(event: KeyPressEvent) -> None:  # pyright: ignore[reportUnusedFunction]
+    def _escape(event):
         state["result"] = _BACK_PRESSED
         event.app.exit()
 
     @bindings.add(Keys.Left)
-    def _left(event: KeyPressEvent) -> None:  # pyright: ignore[reportUnusedFunction]
+    def _left(event):
         state["result"] = _BACK_PRESSED
         event.app.exit()
 
     @bindings.add(Keys.ControlC)
-    def _ctrl_c(event: KeyPressEvent) -> None:  # pyright: ignore[reportUnusedFunction]
+    def _ctrl_c(event):
         state["result"] = None
         event.app.exit()
 
@@ -243,7 +235,7 @@ def _select_with_back(
         "question": f"fg:{_UI_TEXT}",
     })
 
-    app = Application[object](layout=layout, key_bindings=bindings, style=style)
+    app = Application(layout=layout, key_bindings=bindings, style=style)
     app.ttimeoutlen = 0.05
     app.timeoutlen = 0.05
     try:
@@ -276,7 +268,7 @@ class FieldTypeInfo(NamedTuple):
     inner_type: Any
 
 
-def _get_field_type_info(field_info: FieldInfo) -> FieldTypeInfo:
+def _get_field_type_info(field_info) -> FieldTypeInfo:
     """Extract field type info from Pydantic field."""
     annotation = field_info.annotation
     if annotation is None:
@@ -293,11 +285,10 @@ def _get_field_type_info(field_info: FieldInfo) -> FieldTypeInfo:
             args = get_args(annotation)
 
     _simple_types: dict[type, str] = {bool: "bool", int: "int", float: "float"}
-    origin_name = getattr(origin, "__name__", None)
 
-    if origin is list or origin_name == "List":
+    if origin is list or (hasattr(origin, "__name__") and origin.__name__ == "List"):
         return FieldTypeInfo("list", args[0] if args else str)
-    if origin is dict or origin_name == "Dict":
+    if origin is dict or (hasattr(origin, "__name__") and origin.__name__ == "Dict"):
         return FieldTypeInfo("dict", None)
     for py_type, name in _simple_types.items():
         if annotation is py_type:
@@ -309,7 +300,7 @@ def _get_field_type_info(field_info: FieldInfo) -> FieldTypeInfo:
     return FieldTypeInfo("str", None)
 
 
-def _get_field_display_name(field_key: str, field_info: FieldInfo | None) -> str:
+def _get_field_display_name(field_key: str, field_info) -> str:
     """Get display name for a field."""
     if field_info and field_info.description:
         return field_info.description
@@ -358,30 +349,22 @@ def _format_value(value: Any, rich: bool = True, field_name: str = "") -> str:
         masked = _mask_value(value)
         return f"[dim]{masked}[/dim]" if rich else masked
     if isinstance(value, BaseModel):
-        model_parts: list[str] = []
+        parts = []
         for fname, _finfo in type(value).model_fields.items():
             fval = getattr(value, fname, None)
             formatted = _format_value(fval, rich=False, field_name=fname)
             if formatted != "[not set]":
-                model_parts.append(f"{fname}={formatted}")
-        return (
-            ", ".join(model_parts)
-            if model_parts
-            else ("[dim]not set[/dim]" if rich else "[not set]")
-        )
+                parts.append(f"{fname}={formatted}")
+        return ", ".join(parts) if parts else ("[dim]not set[/dim]" if rich else "[not set]")
     if isinstance(value, list):
-        return ", ".join(str(v) for v in cast(list[Any], value))
+        return ", ".join(str(v) for v in value)
     if isinstance(value, dict):
         # Handle dicts containing BaseModel instances
-        mapping_parts: list[str] = []
-        for k, v in cast(dict[Any, Any], value).items():
+        parts = []
+        for k, v in value.items():
             formatted = _format_value(v, rich=False, field_name=str(k))
-            mapping_parts.append(f"{k}: {formatted}")
-        return (
-            ", ".join(mapping_parts)
-            if mapping_parts
-            else ("[dim]not set[/dim]" if rich else "[not set]")
-        )
+            parts.append(f"{k}: {formatted}")
+        return ", ".join(parts) if parts else ("[dim]not set[/dim]" if rich else "[not set]")
     return str(value)
 
 
@@ -390,13 +373,13 @@ def _format_value_for_input(value: Any, field_type: str) -> str:
     if value is None or value == "":
         return ""
     if field_type == "list" and isinstance(value, list):
-        return ",".join(str(v) for v in cast(list[Any], value))
+        return ",".join(str(v) for v in value)
     if field_type == "dict" and isinstance(value, dict):
         return json.dumps(value)
     return str(value)
 
 
-def _validate_field_constraint(value: Any, field_info: FieldInfo | None) -> str | None:
+def _validate_field_constraint(value: Any, field_info) -> str | None:
     """Validate a value against Pydantic Field constraints.
 
     Returns an error message string if validation fails, None if valid.
@@ -405,8 +388,7 @@ def _validate_field_constraint(value: Any, field_info: FieldInfo | None) -> str
     if field_info is None or not hasattr(field_info, "metadata"):
         return None
 
-    for metadata in field_info.metadata:
-        m = metadata
+    for m in field_info.metadata:
         if hasattr(m, "ge") and isinstance(value, (int, float)):
             if value < m.ge:
                 return f"Value must be >= {m.ge}"
@@ -420,16 +402,16 @@ def _validate_field_constraint(value: Any, field_info: FieldInfo | None) -> str
             if value >= m.lt:
                 return f"Value must be < {m.lt}"
         if hasattr(m, "min_length") and hasattr(value, "__len__"):
-            if len(cast(Sized, value)) < m.min_length:
+            if len(value) < m.min_length:
                 return f"Length must be >= {m.min_length}"
         if hasattr(m, "max_length") and hasattr(value, "__len__"):
-            if len(cast(Sized, value)) > m.max_length:
+            if len(value) > m.max_length:
                 return f"Length must be <= {m.max_length}"
 
     return None
 
 
-def _get_constraint_hint(field_info: FieldInfo | None) -> str:
+def _get_constraint_hint(field_info) -> str:
     """Derive a human-readable constraint hint from field metadata.
 
     Returns a string like " - 0-10" or " - >= 0" to append to field display names.
@@ -439,8 +421,7 @@ def _get_constraint_hint(field_info: FieldInfo | None) -> str:
 
     ge_val = None
     le_val = None
-    for metadata in field_info.metadata:
-        m = metadata
+    for m in field_info.metadata:
         if hasattr(m, "ge"):
             ge_val = m.ge
         if hasattr(m, "le"):
@@ -458,11 +439,7 @@ def _get_constraint_hint(field_info: FieldInfo | None) -> str:
 # --- Rich UI Components ---
 
 
-def _show_config_panel(
-    display_name: str,
-    model: BaseModel,
-    fields: list[tuple[str, FieldInfo]],
-) -> None:
+def _show_config_panel(display_name: str, model: BaseModel, fields: list) -> None:
     """Display current configuration as a rich table."""
     table = Table(show_header=False, box=None, padding=(0, 2))
     table.add_column("Field", style=_UI_ACCENT)
@@ -527,19 +504,20 @@ def _input_bool(display_name: str, current: bool | None) -> bool | None:
     ).ask()
 
 
-def _input_back_key_bindings() -> KeyBindings:
+def _input_back_key_bindings():
     """Return key bindings that make Escape behave like a local back action."""
+    from prompt_toolkit.key_binding import KeyBindings
+
     bindings = KeyBindings()
 
-    # KeyBindings consumes this handler through decorator registration.
     @bindings.add("escape")
-    def _escape(event: KeyPressEvent) -> None:  # pyright: ignore[reportUnusedFunction]
+    def _escape(event):
         event.app.exit(result=_BACK_PRESSED)
 
     return bindings
 
 
-def _ask_prompt(prompt: Any) -> Any:
+def _ask_prompt(prompt):
     """Ask a questionary prompt with responsive Escape handling."""
     app = getattr(prompt, "application", None)
     if app is not None:
@@ -550,12 +528,7 @@ def _ask_prompt(prompt: Any) -> Any:
     return prompt.ask()
 
 
-def _input_text(
-    display_name: str,
-    current: Any,
-    field_type: str,
-    field_info: FieldInfo | None = None,
-) -> Any:
+def _input_text(display_name: str, current: Any, field_type: str, field_info=None) -> Any:
     """Get text input and parse based on field type."""
     default = _format_value_for_input(current, field_type)
 
@@ -618,10 +591,7 @@ def _input_secret(display_name: str) -> str | None | object:
 
 
 def _input_with_existing(
-    display_name: str,
-    current: Any,
-    field_type: str,
-    field_info: FieldInfo | None = None,
+    display_name: str, current: Any, field_type: str, field_info=None
 ) -> Any:
     """Handle input with 'keep existing' option for non-empty values."""
     has_existing = current is not None and current != "" and current != {} and current != []
@@ -654,6 +624,8 @@ def _input_model_with_autocomplete(
     """Get model input with autocomplete suggestions.
 
     """
+    from prompt_toolkit.completion import Completer, Completion
+
     default = str(current) if current else ""
 
     class DynamicModelCompleter(Completer):
@@ -662,12 +634,7 @@ def _input_model_with_autocomplete(
         def __init__(self, provider_name: str):
             self.provider = provider_name
 
-        def get_completions(
-            self,
-            document: Document,
-            complete_event: CompleteEvent,
-        ) -> Iterable[Completion]:
-            _ = complete_event
+        def get_completions(self, document, _complete_event):
             text = document.text_before_cursor
             suggestions = get_model_suggestions(text, provider=self.provider, limit=50)
             for model in suggestions:
@@ -768,7 +735,7 @@ def _handle_model_field(
         return
     if new_value is not None and new_value != current_value:
         setattr(working_model, field_name, new_value)
-        _try_auto_fill_context_window(working_model, cast(str, new_value))
+        _try_auto_fill_context_window(working_model, new_value)
 
 
 def _handle_context_window_field(
@@ -788,15 +755,13 @@ def _handle_model_preset_field(
     working_model: BaseModel, field_name: str, field_display: str, current_value: Any
 ) -> None:
     """Handle the 'model_preset' field with a list of existing presets."""
-    preset_names = sorted(_MODEL_PRESET_CACHE)
-    choices = [_CLEAR_CHOICE] + preset_names
-    default_choice = str(current_value) if current_value else _CLEAR_CHOICE
+    preset_names = sorted(_MODEL_PRESET_CACHE) or ["default"]
+    choices = preset_names
+    default_choice = str(current_value) if current_value else "default"
     new_value = _select_with_back(field_display, choices, default=default_choice)
     if new_value is _BACK_PRESSED:
         return
-    if new_value == _CLEAR_CHOICE:
-        setattr(working_model, field_name, None)
-    elif new_value is not None:
+    if new_value is not None:
         setattr(working_model, field_name, new_value)
 
 
@@ -825,13 +790,7 @@ def _handle_fallback_models_field(
     working_model: BaseModel, field_name: str, field_display: str, current_value: Any
 ) -> None:
     """Handle the 'fallback_models' field with preset-aware list management."""
-    from nanobot.config.schema import InlineFallbackConfig
-
-    items: list[Any] = (
-        list(cast(list[Any], current_value))
-        if isinstance(current_value, list)
-        else []
-    )
+    items: list[Any] = list(current_value) if isinstance(current_value, list) else []
     preset_names = sorted(_MODEL_PRESET_CACHE)
 
     while True:
@@ -839,10 +798,7 @@ def _handle_fallback_models_field(
         console.print(f"[bold]{field_display}[/bold]")
         if items:
             for idx, item in enumerate(items, 1):
-                if isinstance(item, InlineFallbackConfig):
-                    console.print(f"  {idx}. {item.model} - {item.provider} inline")
-                else:
-                    console.print(f"  {idx}. {item}")
+                console.print(f"  {idx}. {item}")
         else:
             console.print("  [dim]empty[/dim]")
         console.print()
@@ -925,11 +881,11 @@ def _is_str_or_none(annotation: Any) -> bool:
 
 
 def _configure_pydantic_model(
-    model: _ModelT,
+    model: BaseModel,
     display_name: str,
     *,
     skip_fields: set[str] | None = None,
-) -> _ModelT | None:
+) -> BaseModel | None:
     """Configure a Pydantic model interactively.
 
     Returns the updated model when the user selects "Done" or navigates back.
@@ -938,7 +894,7 @@ def _configure_pydantic_model(
     skip_fields = skip_fields or set()
     working_model = model.model_copy(deep=True)
 
-    fields: list[tuple[str, FieldInfo]] = [
+    fields = [
         (name, info)
         for name, info in type(working_model).model_fields.items()
         if name not in skip_fields
@@ -948,7 +904,7 @@ def _configure_pydantic_model(
         return working_model
 
     def get_choices() -> list[str]:
-        items: list[str] = []
+        items = []
         for fname, finfo in fields:
             value = getattr(working_model, fname, None)
             display = _get_field_display_name(fname, finfo)
@@ -1094,10 +1050,6 @@ def _sync_preset_cache(config: Config) -> None:
     _MODEL_PRESET_CACHE.update(config.model_presets.keys())
 
 
-def _validate_nonempty_name(text: str) -> bool | str:
-    return True if text and text.strip() else "Name cannot be empty"
-
-
 def _configure_model_presets(config: Config) -> None:
     """Configure model presets (CRUD)."""
     _sync_preset_cache(config)
@@ -1140,7 +1092,7 @@ def _configure_model_presets(config: Config) -> None:
             if answer == "[+] Add new preset":
                 name_input = _get_questionary().text(
                     "Preset name:",
-                    validate=_validate_nonempty_name,
+                    validate=lambda t: True if t and t.strip() else "Name cannot be empty",
                 ).ask()
                 if not name_input:
                     continue
@@ -1259,7 +1211,7 @@ def _configure_providers(config: Config) -> None:
 
     def get_provider_choices() -> list[str]:
         """Build provider choices with config status indicators."""
-        choices: list[str] = []
+        choices = []
         for name, display in _get_provider_names().items():
             provider = getattr(config.providers, name, None)
             if provider and provider.api_key:
@@ -1468,7 +1420,7 @@ _SETTINGS_SECTIONS: dict[str, tuple[str, str, set[str] | None]] = {
     "Tools": ("Tools Settings", "Configure web search, shell exec, and other tools", {"mcp_servers"}),
 }
 
-_SETTINGS_GETTER: dict[str, Callable[[Config], BaseModel]] = {
+_SETTINGS_GETTER = {
     "Agent Settings": lambda c: c.agents.defaults,
     "Channel Common": lambda c: c.channels,
     "API Server": lambda c: c.api,
@@ -1476,7 +1428,7 @@ _SETTINGS_GETTER: dict[str, Callable[[Config], BaseModel]] = {
     "Tools": lambda c: c.tools,
 }
 
-_SETTINGS_SETTER: dict[str, Callable[[Config, BaseModel], None]] = {
+_SETTINGS_SETTER = {
     "Agent Settings": lambda c, v: setattr(c.agents, "defaults", v),
     "Channel Common": lambda c, v: setattr(c, "channels", v),
     "API Server": lambda c, v: setattr(c, "api", v),
@@ -1490,7 +1442,7 @@ def _configure_general_settings(config: Config, section: str) -> None:
     meta = _SETTINGS_SECTIONS.get(section)
     if not meta:
         return
-    display_name, _subtitle, skip = meta
+    display_name, subtitle, skip = meta
     model = _SETTINGS_GETTER[section](config)
     updated = _configure_pydantic_model(model, display_name, skip_fields=skip)
     if updated is not None:
@@ -1536,7 +1488,7 @@ def _show_summary(config: Config) -> None:
     console.print()
 
     # Providers
-    provider_rows: list[tuple[str, str]] = []
+    provider_rows = []
     for name, display in _get_provider_names().items():
         provider = getattr(config.providers, name, None)
         status = (
@@ -1548,12 +1500,12 @@ def _show_summary(config: Config) -> None:
     _print_summary_panel(provider_rows, "LLM Providers")
 
     # Channels
-    channel_rows: list[tuple[str, str]] = []
+    channel_rows = []
     for name, display in _get_channel_names().items():
         channel = getattr(config.channels, name, None)
         if channel:
             enabled = (
-                cast(dict[str, Any], channel).get("enabled", False)
+                channel.get("enabled", False)
                 if isinstance(channel, dict)
                 else getattr(channel, "enabled", False)
             )
@@ -1564,7 +1516,7 @@ def _show_summary(config: Config) -> None:
     _print_summary_panel(channel_rows, "Chat Channels")
 
     # Model Presets
-    preset_rows: list[tuple[str, str]] = []
+    preset_rows = []
     for name, preset in config.model_presets.items():
         preset_rows.append((name, f"{preset.model} - ctx {preset.context_window_tokens}"))
     _print_summary_panel(preset_rows, "Model Presets")
@@ -1603,7 +1555,7 @@ def _set_primary_quick_start_preset(config: Config, provider_name: str, model: s
 
 def _show_quick_start_progress(active_step: int) -> None:
     """Render a compact step tracker for Quick Start."""
-    parts: list[str] = []
+    parts = []
     for idx, label in enumerate(_QUICK_START_STEPS, 1):
         if idx < active_step:
             parts.append(f"[{_UI_SUCCESS}]{idx}. {label}[/]")
@@ -1668,11 +1620,7 @@ def _quick_start_oauth_login(config: Config, provider_name: str) -> bool:
         return False
 
     try:
-        # oauth-cli-kit does not publish type information.
-        from oauth_cli_kit import (  # pyright: ignore[reportMissingTypeStubs]
-            get_token,
-            login_oauth_interactive,
-        )
+        from oauth_cli_kit import get_token, login_oauth_interactive
     except ImportError:
         console.print("[red]oauth_cli_kit not installed. Run: pip install oauth-cli-kit[/red]")
         return False
@@ -1713,8 +1661,7 @@ def _quick_start_oauth_is_authenticated(config: Config, provider_name: str) -> b
     if provider_name != "openai_codex":
         return False
     try:
-        # oauth-cli-kit does not publish type information.
-        from oauth_cli_kit import get_token  # pyright: ignore[reportMissingTypeStubs]
+        from oauth_cli_kit import get_token
 
         proxy = _quick_start_codex_proxy(config)
         token = get_token(proxy=proxy)
@@ -1801,10 +1748,7 @@ def _configure_quick_start_provider(config: Config) -> bool | object:
                 continue
             if api_base_result is None:
                 return False
-            api_base, base_was_prompted = cast(
-                tuple[str, bool],
-                api_base_result,
-            )
+            api_base, base_was_prompted = api_base_result
 
         api_key: str | None = None
         if _quick_start_requires_api_key(provider_name, provider_info):
@@ -1827,10 +1771,7 @@ def _configure_quick_start_provider(config: Config) -> bool | object:
                 continue
             if api_base_result is None:
                 return False
-            api_base, base_was_prompted = cast(
-                tuple[str, bool],
-                api_base_result,
-            )
+            api_base, base_was_prompted = api_base_result
 
         provider_config = getattr(config.providers, provider_name, None)
         if provider_config is None:
@@ -1844,7 +1785,7 @@ def _configure_quick_start_provider(config: Config) -> bool | object:
         )
         if model is _BACK_PRESSED:
             continue
-        model = cast(str, model or "").strip()
+        model = (model or "").strip()
         if not model:
             console.print("[yellow]! Model ID is required for Quick Start[/yellow]")
             return False
@@ -1902,7 +1843,7 @@ def _enable_quick_start_websocket_defaults(config: Config) -> bool:
         console.print("[red]No configuration class found for websocket[/red]")
         return False
 
-    current: Any = getattr(config.channels, "websocket", None) or {}
+    current = getattr(config.channels, "websocket", None) or {}
     model = config_cls.model_validate(current)
     if hasattr(model, "enabled"):
         setattr(model, "enabled", True)
@@ -2049,7 +1990,7 @@ def _configure_advanced_settings(config: Config) -> None:
         if answer is _BACK_PRESSED or answer is None or answer == "<- Back":
             break
 
-        _advanced_dispatch: dict[str, Callable[[], None]] = {
+        _advanced_dispatch = {
             "[P] LLM Provider": lambda: _configure_providers(config),
             "[M] Model Presets": lambda: _configure_model_presets(config),
             "[C] Chat Channel": lambda: _configure_channels(config),
@@ -2060,9 +2001,9 @@ def _configure_advanced_settings(config: Config) -> None:
             "[T] Tools": lambda: _configure_general_settings(config, "Tools"),
             "[V] View Configuration Summary": lambda: _show_summary(config),
         }
-        action_fn = _advanced_dispatch.get(cast(str, answer))
+        action_fn = _advanced_dispatch.get(answer)
         if action_fn:
-            last_choice = cast(str, answer)
+            last_choice = answer
             action_fn()
 
 

nanobot/cli/provider.py

@@ -1,372 +0,0 @@
-"""Typer commands for OAuth provider authentication."""
-
-from __future__ import annotations
-
-from collections.abc import Callable
-from contextlib import suppress
-from importlib import import_module
-from pathlib import Path
-from typing import TYPE_CHECKING, Protocol, cast
-
-import typer
-from rich.console import Console
-
-from nanobot import __logo__
-
-if TYPE_CHECKING:
-    from nanobot.providers.registry import ProviderSpec
-
-
-console = Console()
-provider_app = typer.Typer(help="Manage providers")
-
-_PROVIDER_DISPLAY: dict[str, str] = {
-    "openai_codex": "OpenAI Codex",
-    "xai_grok": "xAI Grok",
-    "github_copilot": "GitHub Copilot",
-}
-
-_OAUTH_PROVIDER_DEFAULT_MODELS: dict[str, str] = {
-    "openai_codex": "openai-codex/gpt-5.6-sol",
-    "xai_grok": "xai-grok/grok-4.5",
-    "github_copilot": "github-copilot/gpt-5.4-mini",
-}
-
-
-class _OAuthToken(Protocol):
-    access: str | None
-    account_id: str | None
-
-
-class _GetOAuthToken(Protocol):
-    def __call__(self, *, proxy: str | None = None) -> _OAuthToken | None: ...
-
-
-class _LoginOAuthInteractive(Protocol):
-    def __call__(
-        self,
-        *,
-        print_fn: Callable[[str], None],
-        prompt_fn: Callable[[str], str],
-        proxy: str | None = None,
-    ) -> _OAuthToken | None: ...
-
-
-class _OAuthProviderConfig(Protocol):
-    token_filename: str
-
-
-class _TokenStorage(Protocol):
-    def get_token_path(self) -> Path: ...
-
-
-class _FileTokenStorageFactory(Protocol):
-    def __call__(self, *, token_filename: str) -> _TokenStorage: ...
-
-
-def _required_module_attribute(module_name: str, attribute: str) -> object:
-    """Load an optional dependency attribute with import-compatible errors."""
-    module = import_module(module_name)
-    try:
-        return getattr(module, attribute)
-    except AttributeError as exc:
-        raise ImportError(f"{module_name}.{attribute} is unavailable") from exc
-
-
-def _load_openai_oauth_client() -> tuple[_GetOAuthToken, _LoginOAuthInteractive]:
-    """Load the optional untyped OAuth client behind a typed boundary."""
-    return (
-        cast(_GetOAuthToken, _required_module_attribute("oauth_cli_kit", "get_token")),
-        cast(
-            _LoginOAuthInteractive,
-            _required_module_attribute("oauth_cli_kit", "login_oauth_interactive"),
-        ),
-    )
-
-
-def _load_openai_oauth_storage() -> tuple[_OAuthProviderConfig, _FileTokenStorageFactory]:
-    """Load the optional untyped OAuth storage API behind a typed boundary."""
-    return (
-        cast(
-            _OAuthProviderConfig,
-            _required_module_attribute(
-                "oauth_cli_kit.providers",
-                "OPENAI_CODEX_PROVIDER",
-            ),
-        ),
-        cast(
-            _FileTokenStorageFactory,
-            _required_module_attribute("oauth_cli_kit.storage", "FileTokenStorage"),
-        ),
-    )
-
-
-def _resolve_oauth_provider(provider: str) -> ProviderSpec:
-    """Resolve and validate an OAuth provider configuration."""
-    from nanobot.providers.registry import PROVIDERS
-
-    key = provider.replace("-", "_")
-    spec = next((s for s in PROVIDERS if s.name == key and s.is_oauth), None)
-    if not spec:
-        names = ", ".join(s.name.replace("_", "-") for s in PROVIDERS if s.is_oauth)
-        console.print(f"[red]Unknown OAuth provider: {provider}[/red]  Supported: {names}")
-        raise typer.Exit(1)
-    return spec
-
-
-def _set_oauth_provider_as_main(
-    provider_name: str,
-    *,
-    model: str | None = None,
-    config_path: str | None = None,
-) -> None:
-    """Persist an OAuth provider as the active agent provider."""
-    from nanobot.config.loader import get_config_path, load_config, save_config, set_config_path
-
-    resolved_config_path = Path(config_path).expanduser().resolve() if config_path else None
-    if resolved_config_path is not None and get_config_path() != resolved_config_path:
-        set_config_path(resolved_config_path)
-        console.print(f"[dim]Using config: {resolved_config_path}[/dim]")
-
-    config = load_config(resolved_config_path)
-    selected_model = (model or "").strip() or _OAUTH_PROVIDER_DEFAULT_MODELS[provider_name]
-    config.agents.defaults.model_preset = None
-    config.agents.defaults.provider = provider_name
-    config.agents.defaults.model = selected_model
-    if provider_name == "xai_grok" and selected_model == "xai-grok/grok-4.5":
-        config.agents.defaults.context_window_tokens = 500_000
-    save_config(config, resolved_config_path)
-
-    saved_path = resolved_config_path or get_config_path()
-    console.print(
-        f"[green]✓ Set {provider_name.replace('_', '-')} as the main provider[/green]  "
-        f"[dim]{selected_model}[/dim]"
-    )
-    console.print(f"[dim]Saved: {saved_path}[/dim]")
-
-
-@provider_app.command("login")
-def provider_login(
-    provider: str = typer.Argument(
-        ...,
-        help="OAuth provider (e.g. 'openai-codex', 'xai-grok', 'github-copilot')",
-    ),
-    set_main: bool = typer.Option(
-        False,
-        "--set-main",
-        "--main",
-        help="Set this OAuth provider as the active agent provider after login",
-    ),
-    model: str | None = typer.Option(
-        None,
-        "--model",
-        "-m",
-        help="Model to use when setting this provider as the active provider",
-    ),
-    config: str | None = typer.Option(None, "--config", "-c", help="Path to config file"),
-):
-    """Authenticate with an OAuth provider."""
-    spec = _resolve_oauth_provider(provider)
-
-    handler = _LOGIN_HANDLERS.get(spec.name)
-    if not handler:
-        console.print(f"[red]Login not implemented for {spec.label}[/red]")
-        raise typer.Exit(1)
-
-    if config:
-        from nanobot.config.loader import set_config_path
-
-        resolved_config_path = Path(config).expanduser().resolve()
-        set_config_path(resolved_config_path)
-        console.print(f"[dim]Using config: {resolved_config_path}[/dim]")
-
-    console.print(f"{__logo__} OAuth Login - {spec.label}\n")
-    handler()
-    if set_main or model:
-        _set_oauth_provider_as_main(spec.name, model=model, config_path=config)
-
-
-@provider_app.command("logout")
-def provider_logout(
-    provider: str = typer.Argument(
-        ...,
-        help="OAuth provider (e.g. 'openai-codex', 'xai-grok', 'github-copilot')",
-    ),
-    config: str | None = typer.Option(None, "--config", "-c", help="Path to config file"),
-):
-    """Log out from an OAuth provider."""
-    spec = _resolve_oauth_provider(provider)
-
-    handler = _LOGOUT_HANDLERS.get(spec.name)
-    if not handler:
-        console.print(f"[red]Logout not implemented for {spec.label}[/red]")
-        raise typer.Exit(1)
-
-    if config:
-        from nanobot.config.loader import set_config_path
-
-        resolved_config_path = Path(config).expanduser().resolve()
-        set_config_path(resolved_config_path)
-        console.print(f"[dim]Using config: {resolved_config_path}[/dim]")
-
-    console.print(f"{__logo__} OAuth Logout - {spec.label}\n")
-    handler()
-
-
-def _login_openai_codex() -> None:
-    try:
-        from nanobot.config.loader import load_config, resolve_config_env_vars
-
-        get_token, login_oauth_interactive = _load_openai_oauth_client()
-        proxy = None
-        try:
-            proxy = resolve_config_env_vars(load_config()).providers.openai_codex.proxy or None
-        except ValueError as e:
-            console.print(f"[red]{e}[/red]")
-            raise typer.Exit(1) from e
-        token = None
-        with suppress(Exception):
-            token = get_token(proxy=proxy)
-        if not (token and token.access):
-            console.print("[cyan]Starting interactive OAuth login...[/cyan]\n")
-            token = login_oauth_interactive(
-                print_fn=lambda s: console.print(s),
-                prompt_fn=lambda s: typer.prompt(s),
-                proxy=proxy,
-            )
-        if not (token and token.access):
-            console.print("[red]✗ Authentication failed[/red]")
-            raise typer.Exit(1)
-        console.print(
-            f"[green]✓ Authenticated with OpenAI Codex[/green]  [dim]{token.account_id}[/dim]"
-        )
-    except ImportError:
-        console.print("[red]oauth_cli_kit not installed. Run: pip install oauth-cli-kit[/red]")
-        raise typer.Exit(1)
-
-
-def _logout_openai_codex() -> None:
-    """Clear local OAuth credentials for OpenAI Codex."""
-    try:
-        provider_config, storage_factory = _load_openai_oauth_storage()
-    except ImportError:
-        console.print("[red]oauth_cli_kit not installed. Run: pip install oauth-cli-kit[/red]")
-        raise typer.Exit(1)
-
-    storage = storage_factory(token_filename=provider_config.token_filename)
-    _delete_oauth_files(storage.get_token_path(), _PROVIDER_DISPLAY["openai_codex"])
-
-
-def _login_xai_grok() -> None:
-    """Authenticate with xAI using the Grok subscription OAuth contract."""
-    from nanobot.config.loader import load_config, resolve_config_env_vars
-    from nanobot.providers.xai_oauth import get_xai_oauth_token, login_xai_oauth
-
-    try:
-        proxy = resolve_config_env_vars(load_config()).providers.xai_grok.proxy or None
-    except ValueError as exc:
-        console.print(f"[red]{exc}[/red]")
-        raise typer.Exit(1) from exc
-
-    token = None
-    with suppress(Exception):
-        token = get_xai_oauth_token(proxy=proxy)
-    if not (token and token.access):
-        console.print(
-            "[cyan]Starting xAI browser sign-in for your X Premium / Grok subscription...[/cyan]\n"
-        )
-        try:
-            token = login_xai_oauth(
-                print_fn=lambda message: console.print(message),
-                prompt_fn=lambda prompt: typer.prompt(prompt),
-                proxy=proxy,
-            )
-        except Exception as exc:
-            console.print(f"[red]Authentication error: {exc}[/red]")
-            raise typer.Exit(1) from exc
-    account = token.account_id or "xAI account"
-    console.print(f"[green]✓ Authenticated with xAI[/green]  [dim]{account}[/dim]")
-    console.print(
-        "[dim]Hosted X Search is enabled automatically when the selected model supports it.[/dim]"
-    )
-
-
-def _logout_xai_grok() -> None:
-    """Clear local xAI OAuth credentials for this nanobot instance."""
-    from nanobot.providers.xai_oauth import get_xai_oauth_storage_path, logout_xai_oauth
-
-    token_path = get_xai_oauth_storage_path()
-    provider_label = _PROVIDER_DISPLAY["xai_grok"]
-    if logout_xai_oauth():
-        console.print(f"[green]✓ Logged out from {provider_label}[/green]")
-        console.print(f"[dim]Removed: {token_path}[/dim]")
-    else:
-        console.print(f"[yellow]! No local OAuth credentials found for {provider_label}[/yellow]")
-
-
-def _logout_github_copilot() -> None:
-    """Clear local OAuth credentials for GitHub Copilot."""
-    try:
-        from nanobot.providers.github_copilot_provider import get_storage
-    except ImportError:
-        console.print("[red]oauth_cli_kit not installed. Run: pip install oauth-cli-kit[/red]")
-        raise typer.Exit(1)
-
-    storage = get_storage()
-    _delete_oauth_files(storage.get_token_path(), _PROVIDER_DISPLAY["github_copilot"])
-
-
-def _delete_oauth_files(token_path: Path, provider_label: str) -> None:
-    """Delete OAuth token and lock files, reporting the result."""
-    removed_paths: list[Path] = []
-    skipped: list[tuple[Path, OSError]] = []
-    for path in (token_path, token_path.with_suffix(".lock")):
-        try:
-            path.unlink()
-        except FileNotFoundError:
-            continue
-        except OSError as exc:
-            skipped.append((path, exc))
-            continue
-        removed_paths.append(path)
-
-    if not removed_paths and not skipped:
-        console.print(f"[yellow]! No local OAuth credentials found for {provider_label}[/yellow]")
-        return
-
-    if removed_paths:
-        console.print(f"[green]✓ Logged out from {provider_label}[/green]")
-        for path in removed_paths:
-            console.print(f"[dim]Removed: {path}[/dim]")
-    for path, exc in skipped:
-        console.print(f"[yellow]! Could not remove {path}: {exc}[/yellow]")
-
-
-def _login_github_copilot() -> None:
-    try:
-        from nanobot.providers.github_copilot_provider import login_github_copilot
-
-        console.print("[cyan]Starting GitHub Copilot device flow...[/cyan]\n")
-        token = login_github_copilot(
-            print_fn=lambda s: console.print(s),
-            prompt_fn=lambda s: typer.prompt(s),
-        )
-        account = token.account_id or "GitHub"
-        console.print(
-            f"[green]✓ Authenticated with GitHub Copilot[/green]  [dim]{account}[/dim]"
-        )
-    except Exception as e:
-        console.print(f"[red]Authentication error: {e}[/red]")
-        raise typer.Exit(1)
-
-
-_LOGIN_HANDLERS: dict[str, Callable[[], None]] = {
-    "openai_codex": _login_openai_codex,
-    "xai_grok": _login_xai_grok,
-    "github_copilot": _login_github_copilot,
-}
-_LOGOUT_HANDLERS: dict[str, Callable[[], None]] = {
-    "openai_codex": _logout_openai_codex,
-    "xai_grok": _logout_xai_grok,
-    "github_copilot": _logout_github_copilot,
-}

nanobot/cli/runtime_config.py

@@ -1,185 +0,0 @@
-"""Configuration loading and diagnostics shared by CLI commands."""
-
-from pathlib import Path
-
-import typer
-from pydantic import ValidationError
-from rich.console import Console
-from rich.markup import escape
-from rich.text import Text
-
-from nanobot.config.schema import Config
-
-__all__ = [
-    "_load_config_for_cli",
-    "_load_inspection_config",
-    "_load_runtime_config",
-    "_migrate_cron_store",
-    "_model_display",
-    "_print_agent_start_error",
-    "_print_config_error",
-    "_print_model_setup_steps",
-    "_print_runtime_config_validation_error",
-    "_provider_setup_error",
-]
-
-console = Console()
-
-
-def _model_display(config: Config) -> tuple[str, str]:
-    """Return (resolved_model_name, preset_tag) for display strings."""
-    resolved = config.resolve_preset()
-    name = config.agents.defaults.model_preset
-    tag = f" (preset: {name})" if name else ""
-    return resolved.model, tag
-
-
-def _print_config_error(error: Exception) -> None:
-    """Render a configuration failure without exposing traceback internals."""
-    from nanobot.config.errors import ConfigLoadError
-
-    console.print(Text(str(error), style="red"))
-    if isinstance(error, ConfigLoadError):
-        command = _status_command(error.path)
-        console.print(f"[dim]Check again after editing: {escape(command)}[/dim]")
-
-
-def _print_runtime_config_validation_error(
-    error: ValidationError,
-    *,
-    config_path: Path,
-    summary: str,
-    path_prefix: tuple[str | int, ...],
-    retry_command: str,
-) -> None:
-    """Render a runtime-owned Pydantic config error without exposing input values."""
-    from nanobot.config.errors import ConfigIssue, ConfigLoadError, validation_issues
-
-    issues = tuple(
-        ConfigIssue(
-            path=(*path_prefix, *issue.path),
-            message=issue.message,
-        )
-        for issue in validation_issues(error)
-    )
-    diagnostic = ConfigLoadError(
-        config_path,
-        kind="invalid_schema",
-        summary=summary,
-        issues=issues,
-    )
-    console.print(Text(str(diagnostic), style="red"))
-    console.print(f"[dim]Fix the listed setting, then retry: {escape(retry_command)}[/dim]")
-
-
-def _status_command(config_path: Path) -> str:
-    return f'nanobot status --config "{config_path}"'
-
-
-def _print_model_setup_steps(config_path: Path) -> None:
-    """Show the shortest setup routes shared by Status and Agent startup."""
-    config_arg = f'--config "{config_path}"'
-    console.print(
-        f"  WebUI: run [cyan]nanobot webui {escape(config_arg)}[/cyan], "
-        "then open Settings → Models"
-    )
-    console.print(f"  CLI:   run [cyan]nanobot onboard --wizard {escape(config_arg)}[/cyan]")
-    console.print(f"  Check: [cyan]{escape(_status_command(config_path))}[/cyan]")
-
-
-def _print_agent_start_error(error: ValueError) -> None:
-    from nanobot.config.loader import get_config_path
-
-    console.print(Text(f"Agent cannot start: {error}", style="red"))
-    console.print("Complete provider/model setup:")
-    _print_model_setup_steps(get_config_path())
-
-
-def _load_config_for_cli(
-    config_path: Path | None = None,
-    *,
-    resolve_env: bool = False,
-) -> Config:
-    """Load CLI configuration and turn expected failures into a clean exit."""
-    from nanobot.config.errors import ConfigLoadError
-    from nanobot.config.loader import load_config, resolve_config_env_vars
-
-    try:
-        loaded = load_config(config_path)
-        if resolve_env:
-            loaded = resolve_config_env_vars(loaded)
-        return loaded
-    except ConfigLoadError as exc:
-        _print_config_error(exc)
-        raise typer.Exit(1) from exc
-
-
-def _load_runtime_config(config: str | None = None, workspace: str | None = None) -> Config:
-    """Load config and optionally override the active workspace."""
-    from nanobot.config.loader import set_config_path
-
-    config_path = None
-    if config:
-        config_path = Path(config).expanduser().resolve()
-        if not config_path.exists():
-            console.print(f"[red]Error: Config file not found: {config_path}[/red]")
-            raise typer.Exit(1)
-        set_config_path(config_path)
-        console.print(f"[dim]Using config: {config_path}[/dim]")
-
-    loaded = _load_config_for_cli(config_path, resolve_env=True)
-    if workspace:
-        loaded.agents.defaults.workspace = workspace
-    return loaded
-
-
-def _load_inspection_config(
-    config: str | None = None,
-    workspace: str | None = None,
-) -> tuple[Path, Config]:
-    """Load config for diagnostic commands without resolving secret env refs."""
-    from nanobot.config.errors import ConfigLoadError
-    from nanobot.config.loader import get_config_path, load_config, set_config_path
-
-    config_path = None
-    if config:
-        config_path = Path(config).expanduser().resolve(strict=False)
-        set_config_path(config_path)
-        console.print(f"[dim]Using config: {config_path}[/dim]")
-
-    display_path = config_path or get_config_path()
-    try:
-        loaded = load_config(config_path)
-    except ConfigLoadError as exc:
-        _print_config_error(exc)
-        raise typer.Exit(1) from exc
-    except ValueError as exc:
-        console.print(f"[red]Error: {exc}[/red]")
-        raise typer.Exit(1) from exc
-    if workspace:
-        loaded.agents.defaults.workspace = workspace
-    return display_path, loaded
-
-
-def _migrate_cron_store(config: "Config") -> None:
-    """One-time migration: move legacy global cron store into the workspace."""
-    from nanobot.config.paths import get_cron_dir
-
-    legacy_path = get_cron_dir() / "jobs.json"
-    new_path = config.workspace_path / "cron" / "jobs.json"
-    if legacy_path.is_file() and not new_path.exists():
-        new_path.parent.mkdir(parents=True, exist_ok=True)
-        import shutil
-
-        shutil.move(str(legacy_path), str(new_path))
-
-
-def _provider_setup_error(config: Config) -> str | None:
-    """Return a local provider/model configuration error, or None."""
-    from nanobot.providers.factory import validate_provider_setup
-
-    try:
-        validate_provider_setup(config)
-    except ValueError as exc:
-        return str(exc)
-    return None

nanobot/cli/stream.py

@@ -11,7 +11,6 @@ from __future__ import annotations
 
 import sys
 from contextlib import contextmanager, nullcontext
-from typing import Literal
 
 from rich.console import Console
 from rich.live import Live
@@ -52,12 +51,12 @@ class ThinkingSpinner:
         self._spinner = c.status(f"[dim]{bot_name} is thinking...[/dim]", spinner="dots")
         self._active = False
 
-    def __enter__(self) -> ThinkingSpinner:
+    def __enter__(self):
         self._spinner.start()
         self._active = True
         return self
 
-    def __exit__(self, *exc: object) -> Literal[False]:
+    def __exit__(self, *exc):
         self._active = False
         self._spinner.stop()
         _clear_current_line(self._console)
@@ -111,7 +110,7 @@ class StreamRenderer:
         self._header_printed = False
         self._start_spinner()
 
-    def _renderable(self) -> Markdown | Text:
+    def _renderable(self):
         """Create a renderable from the current buffer."""
         if self._md and self._buf:
             return Markdown(self._buf)

nanobot/cli/terminal.py

@@ -1,428 +0,0 @@
-"""Terminal input and rendering helpers for the interactive CLI."""
-
-from __future__ import annotations
-
-import os
-import select
-import sys
-from collections.abc import Callable
-from contextlib import nullcontext, suppress
-from typing import Any, Literal, cast
-
-from loguru import logger
-from prompt_toolkit import PromptSession, print_formatted_text
-from prompt_toolkit.application import run_in_terminal
-from prompt_toolkit.formatted_text import ANSI, HTML
-from prompt_toolkit.history import FileHistory
-from prompt_toolkit.key_binding import KeyBindings
-from prompt_toolkit.key_binding.key_processor import KeyPressEvent
-from prompt_toolkit.keys import Keys
-from prompt_toolkit.patch_stdout import patch_stdout
-from rich.console import Console
-from rich.markdown import Markdown
-from rich.text import Text
-
-from nanobot import __logo__
-from nanobot.bus.outbound_events import (
-    ProgressEvent,
-    RetryWaitEvent,
-    outbound_event_from_message,
-)
-from nanobot.cli.stream import StreamRenderer, ThinkingSpinner
-from nanobot.utils.helpers import sanitize_surrogates as _sanitize_surrogates
-
-__all__ = [
-    "_ReasoningBuffer",
-    "_ensure_interactive_tty_mode",
-    "_flush_cli_reasoning",
-    "_flush_pending_tty_input",
-    "_init_prompt_session",
-    "_is_exit_command",
-    "_maybe_print_interactive_progress",
-    "_print_agent_response",
-    "_print_cli_progress_line",
-    "_print_cli_reasoning",
-    "_print_interactive_response",
-    "_read_interactive_input_async",
-    "_restore_terminal",
-]
-
-console = Console()
-EXIT_COMMANDS = {"exit", "quit", "/exit", "/quit", ":q"}
-_REASONING_SENTENCE_ENDINGS = (".", "!", "?", "。", "！", "？")
-_REASONING_FLUSH_CHARS = 60
-_prompt_session: PromptSession[str] | None = None
-_saved_term_attrs: list[Any] | None = None
-
-
-def _ensure_interactive_tty_mode() -> None:
-    """Restore interactive line input after a raw-mode TTY leak."""
-    try:
-        fd = sys.stdin.fileno()
-        if not os.isatty(fd):
-            return
-    except Exception:
-        return
-
-    with suppress(Exception):
-        import termios
-
-        attrs = termios.tcgetattr(fd)
-        required_lflag = termios.ISIG | termios.ICANON | termios.ECHO
-        blocked_input_flags = getattr(termios, "IGNCR", 0) | getattr(termios, "INLCR", 0)
-        if (
-            (attrs[3] & required_lflag) == required_lflag
-            and attrs[0] & termios.ICRNL
-            and not attrs[0] & blocked_input_flags
-        ):
-            return
-        attrs[0] = (attrs[0] | termios.ICRNL) & ~blocked_input_flags
-        attrs[3] |= required_lflag
-        termios.tcsetattr(fd, termios.TCSANOW, attrs)
-        termios.tcflush(fd, termios.TCIFLUSH)
-        logger.debug("Restored foreground gateway TTY mode")
-
-
-class SafeFileHistory(FileHistory):
-    """FileHistory subclass that sanitizes surrogate characters on write.
-
-    On Windows, special Unicode input (emoji, mixed-script) can produce
-    surrogate characters that crash prompt_toolkit's file write.
-    See issue #2846.
-    """
-
-    def store_string(self, string: str) -> None:
-        super().store_string(_sanitize_surrogates(string))
-
-
-def _flush_pending_tty_input() -> None:
-    """Drop unread keypresses typed while the model was generating output."""
-    try:
-        fd = sys.stdin.fileno()
-        if not os.isatty(fd):
-            return
-    except Exception:
-        return
-
-    with suppress(Exception):
-        import termios
-
-        termios.tcflush(fd, termios.TCIFLUSH)
-        return
-
-    with suppress(Exception):
-        while True:
-            ready, _, _ = select.select([fd], [], [], 0)
-            if not ready:
-                break
-            if not os.read(fd, 4096):
-                break
-
-
-def _restore_terminal() -> None:
-    """Restore terminal to its original state (echo, line buffering, etc.)."""
-    if _saved_term_attrs is None:
-        return
-    with suppress(Exception):
-        import termios
-
-        termios.tcsetattr(sys.stdin.fileno(), termios.TCSADRAIN, _saved_term_attrs)
-
-
-def _build_cli_key_bindings() -> KeyBindings:
-    """Key bindings for the interactive prompt.
-
-    Behaviour:
-      * Enter       -> submit the current input (keeps the familiar
-                       single-line Enter-to-send feel even though the buffer
-                       is multiline-capable).
-      * Alt+Enter   -> insert a newline for multi-line input.
-      * Shift+Enter -> insert a newline on terminals that emit the CSI-u
-                       (kitty / fixterms) keyboard-protocol encoding for it.
-    """
-    # prompt_toolkit does not recognize CSI-u, so register its Shift+Enter
-    # sequence as a best-effort addition without overriding existing mappings.
-    with suppress(Exception):
-        from prompt_toolkit.input import ansi_escape_sequences as _aes
-
-        _aes.ANSI_SEQUENCES.setdefault("\x1b[13;2u", Keys.ControlF3)
-
-    kb = KeyBindings()
-
-    @kb.add("enter")
-    def _(event: KeyPressEvent) -> None:
-        event.current_buffer.validate_and_handle()
-
-    @kb.add("escape", "enter")  # Alt+Enter / Meta+Enter (ESC + CR, "\x1b\r")
-    def _(event: KeyPressEvent) -> None:
-        event.current_buffer.insert_text("\n")
-
-    # LF-as-Enter terminals send Alt+Enter as ESC + LF rather than ESC + CR.
-    @kb.add("escape", Keys.ControlJ)  # Alt+Enter on LF-as-Enter terminals
-    def _(event: KeyPressEvent) -> None:
-        event.current_buffer.insert_text("\n")
-
-    @kb.add(Keys.ControlF3)  # Shift+Enter on CSI-u capable terminals
-    def _(event: KeyPressEvent) -> None:
-        event.current_buffer.insert_text("\n")
-
-    return kb
-
-
-def _init_prompt_session() -> None:
-    """Create the prompt_toolkit session with persistent file history."""
-    global _prompt_session, _saved_term_attrs
-
-    # Save terminal state so we can restore it on exit
-    with suppress(Exception):
-        import termios
-
-        _saved_term_attrs = termios.tcgetattr(sys.stdin.fileno())
-
-    from nanobot.config.paths import get_cli_history_path
-
-    history_file = get_cli_history_path()
-    history_file.parent.mkdir(parents=True, exist_ok=True)
-
-    _prompt_session = PromptSession(
-        history=SafeFileHistory(str(history_file)),
-        enable_open_in_editor=False,
-        # Multiline-capable buffer; Enter still submits via the custom key
-        # bindings, while Alt+Enter adds a newline.
-        multiline=True,
-        key_bindings=_build_cli_key_bindings(),
-    )
-
-
-def _make_console() -> Console:
-    return Console(file=sys.stdout)
-
-
-def _render_interactive_ansi(render_fn: Callable[[Console], None]) -> str:
-    """Render Rich output to ANSI so prompt_toolkit can print it safely."""
-    ansi_console = Console(
-        force_terminal=sys.stdout.isatty(),
-        color_system=cast(
-            Literal["auto", "standard", "256", "truecolor", "windows"],
-            console.color_system or "standard",
-        ),
-        width=console.width,
-    )
-    with ansi_console.capture() as capture:
-        render_fn(ansi_console)
-    return capture.get()
-
-
-def _print_agent_response(
-    response: str,
-    render_markdown: bool,
-    metadata: dict[str, Any] | None = None,
-    show_header: bool = True,
-) -> None:
-    """Render assistant response with consistent terminal styling."""
-    console = _make_console()
-    content = response or ""
-    body = _response_renderable(content, render_markdown, metadata)
-    if show_header:
-        console.print()
-        console.print(f"[cyan]{__logo__} nanobot[/cyan]")
-    console.print(body)
-    console.print()
-
-
-def _response_renderable(
-    content: str, render_markdown: bool, metadata: dict[str, Any] | None = None
-) -> Text | Markdown:
-    """Render plain-text command output without markdown collapsing newlines."""
-    if not render_markdown:
-        return Text(content)
-    if (metadata or {}).get("render_as") == "text":
-        return Text(content)
-    return Markdown(content)
-
-
-async def _print_interactive_line(text: str) -> None:
-    """Print async interactive updates with prompt_toolkit-safe Rich styling."""
-
-    def _write() -> None:
-        ansi = _render_interactive_ansi(lambda c: c.print(f"  [dim]↳ {text}[/dim]"))
-        print_formatted_text(ANSI(ansi), end="")
-
-    await run_in_terminal(_write)
-
-
-async def _print_interactive_response(
-    response: str,
-    render_markdown: bool,
-    metadata: dict[str, Any] | None = None,
-) -> None:
-    """Print async interactive replies with prompt_toolkit-safe Rich styling."""
-
-    def _write() -> None:
-        content = response or ""
-
-        def _render(target: Console) -> None:
-            target.print()
-            target.print(f"[cyan]{__logo__} nanobot[/cyan]")
-            target.print(_response_renderable(content, render_markdown, metadata))
-            target.print()
-
-        ansi = _render_interactive_ansi(_render)
-        print_formatted_text(ANSI(ansi), end="")
-
-    await run_in_terminal(_write)
-
-
-def _print_cli_progress_line(
-    text: str,
-    thinking: ThinkingSpinner | None,
-    renderer: StreamRenderer | None = None,
-) -> None:
-    """Print a CLI progress line, pausing the spinner if needed."""
-    if not text.strip():
-        return
-    target = renderer.console if renderer else console
-    pause = renderer.pause_spinner() if renderer else (thinking.pause() if thinking else nullcontext())
-    with pause:
-        if renderer:
-            renderer.ensure_header()
-        target.print(f"  [dim]↳ {text}[/dim]")
-
-
-class _ReasoningBuffer:
-    def __init__(self) -> None:
-        self._text = ""
-
-    def add(self, text: str) -> str | None:
-        if not text:
-            return None
-        self._text += text
-        if self._should_flush(text):
-            return self.flush()
-        return None
-
-    def flush(self) -> str | None:
-        text = self._text.strip()
-        self._text = ""
-        return text or None
-
-    def clear(self) -> None:
-        self._text = ""
-
-    def _should_flush(self, text: str) -> bool:
-        stripped = text.rstrip()
-        return (
-            "\n" in text
-            or stripped.endswith(_REASONING_SENTENCE_ENDINGS)
-            or len(self._text) >= _REASONING_FLUSH_CHARS
-        )
-
-
-def _print_cli_reasoning(
-    text: str,
-    thinking: ThinkingSpinner | None,
-    renderer: StreamRenderer | None = None,
-) -> None:
-    """Print reasoning/thinking content in a distinct style."""
-    if not text.strip():
-        return
-    target = renderer.console if renderer else console
-    pause = renderer.pause_spinner() if renderer else (thinking.pause() if thinking else nullcontext())
-    with pause:
-        if renderer:
-            renderer.ensure_header()
-        target.print(f"[dim italic]✻ {text}[/dim italic]")
-
-
-def _flush_cli_reasoning(
-    reasoning_buffer: _ReasoningBuffer,
-    thinking: ThinkingSpinner | None,
-    renderer: StreamRenderer | None = None,
-) -> None:
-    text = reasoning_buffer.flush()
-    if text:
-        _print_cli_reasoning(text, thinking, renderer)
-
-
-async def _print_interactive_progress_line(
-    text: str,
-    thinking: ThinkingSpinner | None,
-    renderer: StreamRenderer | None = None,
-) -> None:
-    """Print an interactive progress line, pausing the spinner if needed."""
-    if not text.strip():
-        return
-    if renderer:
-        with renderer.pause_spinner():
-            renderer.ensure_header()
-            renderer.console.print(f"  [dim]↳ {text}[/dim]")
-    else:
-        with thinking.pause() if thinking else nullcontext():
-            await _print_interactive_line(text)
-
-
-async def _maybe_print_interactive_progress(
-    msg: Any,
-    thinking: ThinkingSpinner | None,
-    channels_config: Any,
-    renderer: StreamRenderer | None = None,
-    reasoning_buffer: _ReasoningBuffer | None = None,
-) -> bool:
-    event = outbound_event_from_message(msg)
-    if isinstance(event, RetryWaitEvent):
-        await _print_interactive_progress_line(msg.content, thinking, renderer)
-        return True
-
-    if not isinstance(event, ProgressEvent):
-        return False
-
-    reasoning_buffer = reasoning_buffer or _ReasoningBuffer()
-
-    if event.reasoning_end:
-        if channels_config and not channels_config.show_reasoning:
-            reasoning_buffer.clear()
-        else:
-            _flush_cli_reasoning(reasoning_buffer, thinking, renderer)
-        return True
-
-    is_tool_hint = event.tool_hint
-    is_reasoning = event.reasoning or event.reasoning_delta
-    if is_reasoning:
-        if channels_config and not channels_config.show_reasoning:
-            reasoning_buffer.clear()
-            return True
-        text = reasoning_buffer.add(msg.content)
-        if text:
-            _print_cli_reasoning(text, thinking, renderer)
-        return True
-    if channels_config and is_tool_hint and not channels_config.send_tool_hints:
-        return True
-    if channels_config and not is_tool_hint and not channels_config.send_progress:
-        return True
-
-    await _print_interactive_progress_line(msg.content, thinking, renderer)
-    return True
-
-
-def _is_exit_command(command: str) -> bool:
-    """Return True when input should end interactive chat."""
-    return command.lower() in EXIT_COMMANDS
-
-
-async def _read_interactive_input_async() -> str:
-    """Read user input using prompt_toolkit (handles paste, history, display).
-
-    prompt_toolkit natively handles:
-    - Multiline paste (bracketed paste mode)
-    - History navigation (up/down arrows)
-    - Clean display (no ghost characters or artifacts)
-    """
-    if _prompt_session is None:
-        raise RuntimeError("Call _init_prompt_session() first")
-    try:
-        with patch_stdout():
-            return await _prompt_session.prompt_async(
-                HTML("<b fg='ansiblue'>You:</b> "),
-            )
-    except EOFError as exc:
-        raise KeyboardInterrupt from exc

nanobot/cli/webui.py

@@ -1,261 +0,0 @@
-"""WebUI CLI command."""
-
-from pathlib import Path
-
-import typer
-from pydantic import ValidationError
-from rich.console import Console
-
-from nanobot.cli import terminal as cli_terminal
-from nanobot.cli.gateway_runtime import _run_gateway
-from nanobot.cli.runtime_config import (
-    _load_runtime_config,
-    _print_config_error,
-    _print_runtime_config_validation_error,
-    _provider_setup_error,
-)
-from nanobot.cli.webui_support import (
-    _attach_to_background_gateway,
-    _confirm_webui_action,
-    _ensure_local_webui_channel,
-    _gateway_health_bind_note,
-    _gateway_health_ready,
-    _gateway_health_url,
-    _gateway_instance_command,
-    _host_for_local_browser,
-    _load_webui_setup_config,
-    _open_webui_browser,
-    _prepare_webui_bundle_for_gateway,
-    _print_foreground_port_conflict,
-    _print_webui_foreground_lifecycle,
-    _resolve_webui_config_path,
-    _run_quick_start_for_webui,
-    _tcp_endpoint_reachable,
-    _warn_webui_bind_scope,
-    _webui_browser_url,
-    _webui_build_mode_for_interactive,
-    _webui_display_url,
-    _webui_endpoint_reachable,
-)
-from nanobot.config.paths import get_workspace_path
-from nanobot.utils.helpers import sync_workspace_templates
-
-console = Console()
-
-
-def webui(
-    port: int | None = typer.Option(None, "--port", "-p", help="WebUI port"),
-    gateway_port: int | None = typer.Option(
-        None,
-        "--gateway-port",
-        help="Gateway health port",
-    ),
-    workspace: str | None = typer.Option(None, "--workspace", "-w", help="Workspace directory"),
-    config: str | None = typer.Option(None, "--config", "-c", help="Path to config file"),
-    background: bool = typer.Option(
-        False,
-        "--background",
-        help="Keep the gateway running after this command exits",
-    ),
-    no_open: bool = typer.Option(False, "--no-open", help="Do not open a browser"),
-    yes: bool = typer.Option(
-        False,
-        "--yes",
-        "-y",
-        help="Apply safe local WebUI defaults without prompting",
-    ),
-) -> None:
-    """Prepare the local WebUI, start the gateway, and open the browser workbench."""
-    from nanobot.config.loader import resolve_config_env_vars, save_config
-    from nanobot.gateway import GatewayRuntime, GatewayRuntimePaths, GatewayStartOptions
-
-    cli_terminal._ensure_interactive_tty_mode()
-    config_path = _resolve_webui_config_path(config)
-    created_config = not config_path.exists()
-    if created_config:
-        console.print(f"[yellow]No config found at {config_path}.[/yellow]")
-        _confirm_webui_action("Create a nanobot config and workspace now?", yes=yes)
-
-    setup_config = _load_webui_setup_config(config_path)
-    if workspace:
-        setup_config.agents.defaults.workspace = workspace
-
-    try:
-        resolved_setup_config = resolve_config_env_vars(
-            setup_config.model_copy(deep=True),
-            config_path=config_path,
-        )
-    except ValueError as exc:
-        _print_config_error(exc)
-        raise typer.Exit(1) from exc
-
-    provider_error = _provider_setup_error(resolved_setup_config)
-    settings_setup_error = provider_error if provider_error and created_config else None
-    if settings_setup_error:
-        console.print(f"[yellow]Model setup is incomplete: {provider_error}[/yellow]")
-        console.print("Configure a provider and model in WebUI Settings → Models.")
-        if background:
-            console.print(
-                "[red]First-time WebUI setup must run in the foreground. "
-                "Run `nanobot webui` without --background.[/red]"
-            )
-            raise typer.Exit(1)
-    elif provider_error:
-        console.print(f"[dim]Provider check: {provider_error}[/dim]")
-        setup_config = _run_quick_start_for_webui(
-            setup_config,
-            yes=yes,
-            config_path=config_path,
-        )
-        if workspace:
-            setup_config.agents.defaults.workspace = workspace
-
-    try:
-        changed_webui, generated_bootstrap_secret = _ensure_local_webui_channel(
-            setup_config,
-            port=port,
-            yes=yes,
-        )
-        _warn_webui_bind_scope(setup_config)
-        webui_url = _webui_browser_url(setup_config)
-    except ValidationError as exc:
-        retry_command = f'nanobot webui --config "{config_path}"'
-        _print_runtime_config_validation_error(
-            exc,
-            config_path=config_path,
-            summary="WebUI configuration is invalid.",
-            path_prefix=("channels", "websocket"),
-            retry_command=retry_command,
-        )
-        raise typer.Exit(1) from exc
-    except ValueError as exc:
-        console.print(f"[red]Error: invalid WebUI channel config: {exc}[/red]")
-        raise typer.Exit(1) from exc
-
-    if created_config or provider_error or changed_webui or workspace:
-        save_config(setup_config, config_path)
-        console.print(f"[green]✓[/green] Saved config: {config_path}")
-
-    workspace_path = get_workspace_path(setup_config.workspace_path)
-    workspace_path.mkdir(parents=True, exist_ok=True)
-    sync_workspace_templates(workspace_path)
-
-    runtime_config = _load_runtime_config(str(config_path), workspace)
-    effective_gateway_port = gateway_port if gateway_port is not None else runtime_config.gateway.port
-
-    console.print()
-    console.print(f"WebUI: [cyan]{_webui_display_url(webui_url)}[/cyan]")
-    gateway_health_url = _gateway_health_url(
-        runtime_config.gateway.host,
-        effective_gateway_port,
-    )
-    console.print(
-        f"Gateway health: [cyan]{gateway_health_url}[/cyan]"
-        f"{_gateway_health_bind_note(runtime_config.gateway.host)}"
-    )
-    if no_open:
-        console.print("[dim]Browser opening disabled by --no-open.[/dim]")
-        if generated_bootstrap_secret:
-            console.print(
-                "[yellow]A WebUI bootstrap secret was generated and saved in this config.[/yellow]"
-            )
-            console.print(
-                "[dim]Open the WebUI and enter channels.websocket.tokenIssueSecret from "
-                f"{config_path}, or rerun without --no-open to open the authenticated URL.[/dim]"
-            )
-
-    webui_bundle_mode = _webui_build_mode_for_interactive(yes=yes)
-
-    config_arg = str(config_path)
-    workspace_arg = str(Path(workspace).expanduser().resolve(strict=False)) if workspace else None
-    runtime = GatewayRuntime(
-        paths=GatewayRuntimePaths.for_instance(
-            data_dir=config_path.parent,
-            workspace=workspace_arg,
-            config_path=config_arg,
-        )
-    )
-    start_options = GatewayStartOptions(
-        port=effective_gateway_port,
-        workspace=workspace_arg,
-        config_path=config_arg,
-    )
-
-    if background:
-        _prepare_webui_bundle_for_gateway(runtime_config, mode=webui_bundle_mode)
-        result = runtime.start_background(start_options)
-        restarted = False
-        restart_attempted = False
-        if not result.ok and result.message == "gateway_already_running" and changed_webui:
-            restart_attempted = True
-            console.print("[yellow]WebUI config changed; restarting the background gateway.[/yellow]")
-            result = runtime.restart(start_options, timeout_s=20)
-            restarted = result.ok
-        if not result.ok and (restart_attempted or result.message != "gateway_already_running"):
-            action = "restarted" if restart_attempted else "started"
-            console.print(f"[yellow]Gateway was not {action}: {result.message}[/yellow]")
-            console.print(f"Logs: {result.status.log_path}")
-            raise typer.Exit(1)
-        if restarted:
-            console.print("[green]Gateway restarted in the background.[/green]")
-        elif result.ok:
-            console.print("[green]Gateway started in the background.[/green]")
-        else:
-            console.print("[yellow]Gateway is already running in the background.[/yellow]")
-        console.print(
-            "Manage this instance: "
-            f"[cyan]{_gateway_instance_command('status', config_path=config_path, workspace=workspace)}[/cyan]"
-        )
-        console.print(
-            "View logs: "
-            f"[cyan]{_gateway_instance_command('logs', config_path=config_path, workspace=workspace)}[/cyan]"
-        )
-        console.print("[dim]Closing the browser does not stop channels or automations.[/dim]")
-        console.print(
-            "Stop nanobot: "
-            f"[cyan]{_gateway_instance_command('stop', config_path=config_path, workspace=workspace)}[/cyan]"
-        )
-        if not no_open:
-            _open_webui_browser(webui_url)
-        return
-
-    gateway_ready = _gateway_health_ready(runtime_config.gateway.host, effective_gateway_port)
-    webui_ready = _webui_endpoint_reachable(webui_url)
-    if gateway_ready and webui_ready:
-        console.print("[yellow]Gateway is already running; attaching to the existing WebUI.[/yellow]")
-        console.print(
-            "Restart the gateway if you need it to pick up local source changes: "
-            f"[cyan]{_gateway_instance_command('restart', config_path=config_path, workspace=workspace)}[/cyan]"
-        )
-        if not no_open:
-            _open_webui_browser(webui_url, wait=False)
-        if runtime.status().running:
-            _attach_to_background_gateway(runtime)
-        else:
-            console.print(
-                "[yellow]This gateway is controlled by another foreground command. "
-                "Stop it from that terminal.[/yellow]"
-            )
-        return
-
-    gateway_port_taken = gateway_ready or _tcp_endpoint_reachable(
-        _host_for_local_browser(runtime_config.gateway.host),
-        effective_gateway_port,
-    )
-    webui_port_taken = webui_ready
-    if gateway_port_taken or webui_port_taken:
-        _print_foreground_port_conflict(
-            webui_url=webui_url,
-            gateway_host=runtime_config.gateway.host,
-            gateway_port=effective_gateway_port,
-        )
-        raise typer.Exit(1)
-
-    _print_webui_foreground_lifecycle(attached=False)
-    _run_gateway(
-        runtime_config,
-        port=effective_gateway_port,
-        open_browser_url=None if no_open else webui_url,
-        webui_bundle_mode=webui_bundle_mode,
-        unconfigured_provider_error=settings_setup_error,
-    )