Your lightweight open-source personal agent.
Python agent-frameworkai-agentai-agentschatbotchatopsdiscord-botllm-agentsllmslocal-llmmcpmodel-context-protocolmulti-agentopenai-compatibleopenclawpersonal-ai-assistantpythonself-hostedtelegram-bot-ai-assistantwebuiworkflow-automation
feat(providers): support provider-scoped proxy config
chengyongru44a5ed1bc0d3
diff --git a/docs/configuration.md b/docs/configuration.mdindex dbe03c601..8b309ecb8 100644--- a/docs/configuration.md+++ b/docs/configuration.md@@ -240,6 +240,7 @@ Tracing covers the providers that go through nanobot's OpenAI-compatible client> - **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 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 and `openai_codex`. Native provider backends such as `anthropic`, `bedrock`, `azure_openai`, and `github_copilot` reject `proxy`.| Provider | Purpose | Get API Key ||----------|---------|-------------|@@ -632,20 +633,37 @@ nanobot agent -m "Reply with one short sentence."<details><summary><b>OpenAI Codex (OAuth)</b></summary>-Codex uses OAuth instead of API keys. Requires a ChatGPT Plus or Pro account. No `providers.openaiCodex` block is needed in `config.json`; `nanobot provider login` stores the OAuth session outside config.+Codex uses OAuth instead of API keys. Requires a ChatGPT Plus or Pro account. `nanobot provider login` stores the OAuth session outside config. A `providers.openai_codex` block is optional and is only needed for provider-specific settings such as a proxy.**1. Login:**```bashnanobot provider login openai-codex```-**2. Set model** (merge into `~/.nanobot/config.json`):+If the machine running nanobot cannot open a graphical browser, copy the printed URL into a real browser. For remote SSH login, open the URL locally, then paste the final `http://localhost:1455/auth/callback?...` redirect URL back into the terminal when prompted.++**2. Optional proxy** (merge into `~/.nanobot/config.json` if Codex OAuth or Codex API traffic must use a proxy):++```json+{+ "providers": {+ "openai_codex": {+ "proxy": "http://127.0.0.1:7890"+ }+ }+}+```++The proxy applies to Codex OAuth token refresh, interactive token exchange, and Codex Responses API requests. It does not affect other providers; configure `proxy` separately on each supported provider that needs it.++**3. Set model** (merge into `~/.nanobot/config.json`):```json{"modelPresets": {"codex": {"provider": "openai_codex",- "model": "openai-codex/gpt-5.1-codex"+ "model": "gpt-5.1-codex",+ "reasoningEffort": "high"}},"agents": {@@ -656,7 +674,9 @@ nanobot provider login openai-codex}```-**3. Chat:**+Use `reasoningEffort` in the preset to send a Codex reasoning effort such as `"low"`, `"medium"`, `"high"`, or another value supported by the selected model. When `provider` is explicitly `openai_codex`, the model name does not need the `openai-codex/` prefix.++**4. Chat:**```bashnanobot agent -m "Hello!"@@ -675,7 +695,7 @@ nanobot agent -c ~/.nanobot-telegram/config.json -w /tmp/nanobot-telegram-test -<details><summary><b>GitHub Copilot (OAuth)</b></summary>-GitHub Copilot uses OAuth instead of API keys. Requires a [GitHub account with a plan](https://github.com/features/copilot/plans) configured. No `providers.githubCopilot` block is needed in `config.json`; `nanobot provider login` stores the OAuth session outside config.+GitHub Copilot uses OAuth instead of API keys. Requires a [GitHub account with a plan](https://github.com/features/copilot/plans) configured. No `providers.github_copilot` block is needed in `config.json`; `nanobot provider login` stores the OAuth session outside config.For GitHub Enterprise / Copilot for Business, set the endpoint overrides you need before login:```bashdiff --git a/docs/providers.md b/docs/providers.mdindex 697173fb8..028d92b23 100644--- a/docs/providers.md+++ b/docs/providers.md@@ -61,9 +61,12 @@ These fields answer different questions:| `model` | `modelPresets.<name>.model` | The model ID expected by that provider or gateway. || `apiKey` | `providers.<provider>.apiKey` | Credential for that provider. Use `${ENV_VAR}` for secrets. || `apiBase` | `providers.<provider>.apiBase` | HTTP base URL of the provider endpoint. |+| `proxy` | `providers.<provider>.proxy` | Optional HTTP proxy for this provider only. Supported for OpenAI-compatible providers and OpenAI Codex. |You usually omit `apiBase` for hosted built-in providers such as OpenRouter, Anthropic direct, OpenAI direct, Groq, or Bedrock because nanobot knows their default endpoints. Set `apiBase` for `custom`, local OpenAI-compatible servers, provider proxies, regional endpoints, or subscription endpoints. Include the API version path when the endpoint requires it, for example `https://api.example.com/v1` or `http://localhost:11434/v1`.+Use `proxy` when one provider must send HTTP traffic through a proxy without changing process-wide `HTTP_PROXY` / `HTTPS_PROXY`. This is supported for providers that use nanobot's OpenAI-compatible client, including `openai`, `custom`, named custom providers, OpenRouter-style gateways, local OpenAI-compatible servers, and similar registry entries. It is also supported for `openai_codex`, including Codex OAuth token exchange/refresh and Codex Responses API requests. Native provider backends such as `anthropic`, `bedrock`, `azure_openai`, and `github_copilot` reject `proxy`; use their endpoint-specific configuration instead.+## Common Provider Patterns### OpenRouter Gateway@@ -422,6 +425,32 @@ nanobot provider login github-copilotThen explicitly select the provider and model in a preset. OAuth providers are not valid automatic fallbacks.+For OpenAI Codex, add `providers.openai_codex.proxy` only when Codex OAuth/token refresh or Codex API requests must use a proxy:++```json+{+ "providers": {+ "openai_codex": {+ "proxy": "http://127.0.0.1:7890"+ }+ },+ "modelPresets": {+ "codex": {+ "provider": "openai_codex",+ "model": "gpt-5.1-codex",+ "reasoningEffort": "high"+ }+ },+ "agents": {+ "defaults": {+ "modelPreset": "codex"+ }+ }+}+```++If you run the login command on a remote/headless machine and open the authorization URL in a local browser, paste the final `http://localhost:1455/auth/callback?...` redirect URL back into the terminal when prompted. See [`configuration.md#providers`](./configuration.md#providers) for the full OAuth provider notes.+## Provider ResolutionThe recommended path is a named preset selected by `agents.defaults.modelPreset`. The effective model parameters come from:diff --git a/nanobot/cli/commands.py b/nanobot/cli/commands.pyindex 67d70dbd3..499c97539 100644--- a/nanobot/cli/commands.py+++ b/nanobot/cli/commands.py@@ -1812,14 +1812,23 @@ def _login_openai_codex() -> None:try:from oauth_cli_kit import get_token, login_oauth_interactive+ from nanobot.config.loader import load_config, resolve_config_env_vars++ 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 etoken = Nonewith suppress(Exception):- token = get_token()+ 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]")diff --git a/nanobot/config/loader.py b/nanobot/config/loader.pyindex 0addc842e..384f0f5a6 100644--- a/nanobot/config/loader.py+++ b/nanobot/config/loader.py@@ -80,6 +80,10 @@ def save_config(config: Config, config_path: Path | None = None) -> None:path.parent.mkdir(parents=True, exist_ok=True)data = config.model_dump(mode="json", by_alias=True)+ if config.providers.openai_codex.proxy is not None:+ data.setdefault("providers", {})["openaiCodex"] = {+ "proxy": config.providers.openai_codex.proxy,+ }with open(path, "w", encoding="utf-8") as f:json.dump(data, f, indent=2, ensure_ascii=False)diff --git a/nanobot/config/schema.py b/nanobot/config/schema.pyindex 9e8b0ce46..5b50407e4 100644--- a/nanobot/config/schema.py+++ b/nanobot/config/schema.py@@ -179,6 +179,7 @@ class ProviderConfig(Base):extra_headers: dict[str, str] | None = None # Custom headers (e.g. APP-Code for AiHubMix)extra_body: dict[str, Any] | None = None # Extra provider request fields; shape depends on provider/API surfaceextra_query: dict[str, str] | None = None # Extra query params (e.g. api-version for Azure-style gateways)+ proxy: str | None = None # OpenAI-compatible/Codex HTTP proxy URLthinking_style: str | None = None # Thinking/reasoning style for custom providers# Valid values mirror the keys of _THINKING_STYLE_MAP indiff --git a/nanobot/providers/factory.py b/nanobot/providers/factory.pyindex 4fd75cdd0..756eadc54 100644--- a/nanobot/providers/factory.py+++ b/nanobot/providers/factory.py@@ -58,6 +58,11 @@ def _make_provider_core(if spec and spec.is_transcription_only:raise ValueError(f"Provider '{provider_name}' only supports transcription.")backend = spec.backend if spec else "openai_compat"+ if p and p.proxy and backend not in {"openai_compat", "openai_codex"}:+ raise ValueError(+ f"providers.{provider_name}.proxy is only supported for "+ "OpenAI-compatible providers and OpenAI Codex."+ )if backend == "azure_openai":if not p or not p.api_base:@@ -79,7 +84,10 @@ def _make_provider_core(if backend == "openai_codex":from nanobot.providers.openai_codex_provider import OpenAICodexProvider- provider = OpenAICodexProvider(default_model=model)+ provider = OpenAICodexProvider(+ default_model=model,+ proxy=getattr(p, "proxy", None) if p else None,+ )elif backend == "azure_openai":from nanobot.providers.azure_openai_provider import AzureOpenAIProvider@@ -124,6 +132,7 @@ def _make_provider_core(extra_body=p.extra_body if p else None,api_type=p.api_type if p and provider_name == "openai" else "auto",extra_query=p.extra_query if p else None,+ proxy=p.proxy if p else None,)provider.generation = resolved.to_generation_settings()@@ -218,6 +227,7 @@ def provider_signature(fallback.temperature,fallback.reasoning_effort,fallback.context_window_tokens,+ getattr(fp, "proxy", None) if fp else None,)provider_name = config.get_provider_name(resolved.model, preset=resolved)@@ -237,6 +247,7 @@ def provider_signature(resolved.temperature,resolved.reasoning_effort,resolved.context_window_tokens,+ getattr(p, "proxy", None) if p else None,tuple(_fallback_signature(fallback) for fallback in fallback_presets),)diff --git a/nanobot/providers/openai_codex_provider.py b/nanobot/providers/openai_codex_provider.pyindex 64430cdc4..b544bad46 100644--- a/nanobot/providers/openai_codex_provider.py+++ b/nanobot/providers/openai_codex_provider.py@@ -33,9 +33,14 @@ class OpenAICodexProvider(LLMProvider):supports_progress_deltas = True- def __init__(self, default_model: str = "openai-codex/gpt-5.1-codex"):+ def __init__(+ self,+ default_model: str = "openai-codex/gpt-5.1-codex",+ proxy: str | None = None,+ ):super().__init__(api_key=None, api_base=None)self.default_model = default_model+ self.proxy = proxy or Noneasync def _call_codex(self,@@ -52,9 +57,6 @@ class OpenAICodexProvider(LLMProvider):model = model or self.default_modelsystem_prompt, input_items = convert_messages(messages)- token = await asyncio.to_thread(get_codex_token)- headers = _build_headers(token.account_id, token.access)-body: dict[str, Any] = {"model": _strip_model_prefix(model),"store": False,@@ -74,9 +76,13 @@ class OpenAICodexProvider(LLMProvider):body["tools"] = convert_tools(tools)try:+ token = await asyncio.to_thread(get_codex_token, proxy=self.proxy)+ headers = _build_headers(token.account_id, token.access)+try:content, tool_calls, finish_reason, usage, reasoning_content = await _request_codex(DEFAULT_CODEX_URL, headers, body, verify=True,+ proxy=self.proxy,on_content_delta=on_content_delta,on_thinking_delta=on_thinking_delta,on_tool_call_delta=on_tool_call_delta,@@ -87,6 +93,7 @@ class OpenAICodexProvider(LLMProvider):logger.warning("SSL verification failed for Codex API; retrying with verify=False")content, tool_calls, finish_reason, usage, reasoning_content = await _request_codex(DEFAULT_CODEX_URL, headers, body, verify=False,+ proxy=self.proxy,on_content_delta=on_content_delta,on_thinking_delta=on_thinking_delta,on_tool_call_delta=on_tool_call_delta,@@ -199,12 +206,17 @@ async def _request_codex(headers: dict[str, str],body: dict[str, Any],verify: bool,+ proxy: str | None = None,on_content_delta: Callable[[str], Awaitable[None]] | None = None,on_thinking_delta: Callable[[str], Awaitable[None]] | None = None,on_tool_call_delta: Callable[[dict[str, Any]], Awaitable[None]] | None = None,) -> tuple[str, list[ToolCallRequest], str, dict[str, int], str | None]:idle_timeout_s = resolve_stream_idle_timeout_s()- async with httpx.AsyncClient(timeout=idle_timeout_s, verify=verify) as client:+ client_kwargs: dict[str, Any] = {"timeout": idle_timeout_s, "verify": verify}+ if proxy:+ client_kwargs["proxy"] = proxy+ client_kwargs["trust_env"] = False+ async with httpx.AsyncClient(**client_kwargs) as client:async with client.stream("POST", url, headers=headers, json=body) as response:if response.status_code != 200:text = await response.aread()diff --git a/nanobot/providers/openai_compat_provider.py b/nanobot/providers/openai_compat_provider.pyindex 7aec961c8..57eccdb6b 100644--- a/nanobot/providers/openai_compat_provider.py+++ b/nanobot/providers/openai_compat_provider.py@@ -358,6 +358,7 @@ class OpenAICompatProvider(LLMProvider):extra_body: dict[str, Any] | None = None,api_type: str = "auto",extra_query: dict[str, str] | None = None,+ proxy: str | None = None,):super().__init__(api_key, api_base)self.default_model = default_model@@ -366,6 +367,7 @@ class OpenAICompatProvider(LLMProvider):self._extra_body = extra_body or {}self._api_type = api_type if spec and spec.name == "openai" else "auto"self._extra_query = extra_query or {}+ self._proxy = proxy or Noneif api_key and spec and spec.env_key:self._setup_env(api_key, api_base)@@ -396,7 +398,14 @@ class OpenAICompatProvider(LLMProvider):timeout_s = _openai_compat_timeout_s()http_client: httpx.AsyncClient | None = None- if self._is_local:+ if self._proxy:+ http_client = httpx.AsyncClient(+ timeout=timeout_s,+ proxy=self._proxy,+ trust_env=False,+ follow_redirects=True,+ )+ elif self._is_local:# Local model servers (Ollama, llama.cpp, vLLM) often close idle# HTTP connections before the client-side keepalive expires. When# two LLM calls happen seconds apart (e.g. heartbeat _decide thendiff --git a/nanobot/webui/settings_api.py b/nanobot/webui/settings_api.pyindex 8d378b156..5b1f9bb44 100644--- a/nanobot/webui/settings_api.py+++ b/nanobot/webui/settings_api.py@@ -22,7 +22,7 @@ from nanobot.audio.transcription_registry import (resolve_transcription_provider,transcription_provider_names,)-from nanobot.config.loader import get_config_path, load_config, save_config+from nanobot.config.loader import get_config_path, load_config, resolve_config_env_vars, save_configfrom nanobot.config.schema import ModelPresetConfig, ProviderConfigfrom nanobot.providers.image_generation import (get_image_gen_provider,@@ -1166,14 +1166,19 @@ def login_oauth_provider(query: QueryParams) -> dict[str, Any]:except ImportError:raise WebUISettingsError("oauth_cli_kit is not installed", status=500) from None+ try:+ proxy = resolve_config_env_vars(load_config()).providers.openai_codex.proxy or None+ except ValueError as e:+ raise WebUISettingsError(str(e), status=400) from etoken = Nonewith suppress(Exception):- token = get_token()+ token = get_token(proxy=proxy)if not (token and token.access):messages: list[str] = []token = login_oauth_interactive(print_fn=lambda message: messages.append(str(message)),prompt_fn=lambda _prompt: "",+ proxy=proxy,)if not (token and token.access):raise WebUISettingsError("OAuth login failed", status=401)diff --git a/pyproject.toml b/pyproject.tomlindex 285078b5c..cdc6cc0f8 100644--- a/pyproject.toml+++ b/pyproject.toml@@ -31,7 +31,7 @@ dependencies = ["websocket-client>=1.9.0,<2.0.0","httpx>=0.28.0,<1.0.0","ddgs>=9.5.5,<10.0.0",- "oauth-cli-kit>=0.1.3,<1.0.0",+ "oauth-cli-kit>=0.1.6,<1.0.0","loguru>=0.7.3,<1.0.0","readability-lxml>=0.8.4,<1.0.0","lxml-html-clean>=0.4.0,<1.0.0",diff --git a/tests/cli/test_commands.py b/tests/cli/test_commands.pyindex 3d9e79c61..e265d1c27 100644--- a/tests/cli/test_commands.py+++ b/tests/cli/test_commands.py@@ -5,6 +5,7 @@ import shutilimport signalfrom contextlib import suppressfrom pathlib import Path+from types import SimpleNamespacefrom unittest.mock import AsyncMock, MagicMock, patchimport pytest@@ -19,7 +20,7 @@ from nanobot.cron.service import CronJobSkippedErrorfrom nanobot.cron.session_turns import CRON_DEFER_UNTIL_IDLE_META, CRON_TRIGGER_METAfrom nanobot.cron.types import CronJob, CronPayloadfrom nanobot.cron.webui_metadata import cron_proactive_delivery_metadata-from nanobot.providers.factory import ProviderSnapshot, make_provider+from nanobot.providers.factory import ProviderSnapshot, make_provider, provider_signaturefrom nanobot.providers.openai_codex_provider import _strip_model_prefixfrom nanobot.providers.registry import find_by_namefrom nanobot.webui.metadata import (@@ -434,6 +435,60 @@ def test_provider_login_rejects_unknown_provider():assert "Unknown OAuth provider" in result.stdout+def test_provider_login_openai_codex_passes_configured_proxy(monkeypatch):+ proxy = "http://127.0.0.1:23458"+ monkeypatch.setattr(+ "nanobot.config.loader.load_config",+ lambda: Config.model_validate({"providers": {"openaiCodex": {"proxy": proxy}}}),+ )++ import oauth_cli_kit++ def fake_get_token(**_kwargs):+ raise RuntimeError("no-token")++ monkeypatch.setattr(oauth_cli_kit, "get_token", fake_get_token)++ captured: dict[str, str | None] = {}++ def fake_login(*, print_fn, prompt_fn, proxy=None):+ captured["proxy"] = proxy+ return SimpleNamespace(access="access-token", account_id="acct-test")++ monkeypatch.setattr(oauth_cli_kit, "login_oauth_interactive", fake_login)++ result = runner.invoke(app, ["provider", "login", "openai-codex"])++ assert result.exit_code == 0+ assert captured["proxy"] == proxy+++def test_provider_login_openai_codex_resolves_proxy_env_ref(monkeypatch):+ proxy = "http://127.0.0.1:23458"+ monkeypatch.setenv("CODEX_PROXY_FOR_TEST", proxy)+ monkeypatch.setattr(+ "nanobot.config.loader.load_config",+ lambda: Config.model_validate(+ {"providers": {"openaiCodex": {"proxy": "${CODEX_PROXY_FOR_TEST}"}}}+ ),+ )++ import oauth_cli_kit++ captured: dict[str, str | None] = {}++ def fake_get_token(*, proxy=None):+ captured["proxy"] = proxy+ return SimpleNamespace(access="access-token", account_id="acct-test")++ monkeypatch.setattr(oauth_cli_kit, "get_token", fake_get_token)++ result = runner.invoke(app, ["provider", "login", "openai-codex"])++ assert result.exit_code == 0+ assert captured["proxy"] == proxy++def test_config_matches_explicit_ollama_prefix_without_api_key():config = Config()config.agents.defaults.model = "ollama/llama3.2"@@ -685,6 +740,54 @@ def test_make_provider_uses_github_copilot_backend():assert provider.__class__.__name__ == "GitHubCopilotProvider"+def test_openai_codex_proxy_config_affects_provider_and_signature():+ def config_with_proxy(proxy: str) -> Config:+ return Config.model_validate(+ {+ "agents": {+ "defaults": {+ "provider": "openai-codex",+ "model": "openai-codex/gpt-5.5",+ }+ },+ "providers": {"openaiCodex": {"proxy": proxy}},+ }+ )++ proxy = "http://127.0.0.1:23458"+ config = config_with_proxy(proxy)++ provider = make_provider(config)++ assert provider.__class__.__name__ == "OpenAICodexProvider"+ assert provider.proxy == proxy+ assert provider_signature(config) != provider_signature(+ config_with_proxy("http://127.0.0.1:23459")+ )+++def test_provider_proxy_rejects_unsupported_backend():+ config = Config.model_validate(+ {+ "agents": {+ "defaults": {+ "provider": "anthropic",+ "model": "anthropic/claude-opus-4-5",+ }+ },+ "providers": {+ "anthropic": {+ "apiKey": "sk-test",+ "proxy": "http://127.0.0.1:23458",+ }+ },+ }+ )++ with pytest.raises(ValueError, match=r"providers\.anthropic\.proxy"):+ make_provider(config)++def test_github_copilot_provider_strips_prefixed_model_name():from nanobot.providers.github_copilot_provider import GitHubCopilotProvider@@ -752,7 +855,7 @@ def test_make_provider_passes_extra_headers_to_custom_provider():"x-session-affinity": "sticky-session",},}- },+ }})diff --git a/tests/config/test_env_interpolation.py b/tests/config/test_env_interpolation.pyindex dad443824..329010cc1 100644--- a/tests/config/test_env_interpolation.py+++ b/tests/config/test_env_interpolation.py@@ -8,6 +8,7 @@ from nanobot.config.loader import (resolve_config_env_vars,save_config,)+from nanobot.config.schema import Configclass TestResolveEnvVars:@@ -127,6 +128,31 @@ class TestResolveConfig:assert "githubCopilot" not in saved["providers"]assert saved["providers"]["groq"]["apiKey"] == "groq-secret"+ def test_save_preserves_openai_codex_proxy_config(self, tmp_path):+ config_path = tmp_path / "config.json"+ proxy = "http://127.0.0.1:23458"+ config = Config.model_validate(+ {+ "providers": {+ "openaiCodex": {+ "apiKey": "codex-secret",+ "proxy": proxy,+ },+ "groq": {"apiKey": "groq-secret"},+ }+ }+ )++ save_config(config, config_path)++ saved = json.loads(config_path.read_text(encoding="utf-8"))+ assert saved["providers"]["openaiCodex"] == {"proxy": proxy}+ assert saved["providers"]["groq"]["apiKey"] == "groq-secret"++ reloaded = load_config(config_path)+ assert reloaded.providers.openai_codex.proxy == proxy+ assert reloaded.providers.openai_codex.api_key is None+def test_preserves_excluded_fields_when_no_env_refs(self, tmp_path):"""Regression: fields with ``exclude=True`` (e.g. ProviderConfig.openai_codex)must survive ``resolve_config_env_vars`` when the config has nodiff --git a/tests/providers/test_openai_codex_provider.py b/tests/providers/test_openai_codex_provider.pyindex cbd3ed488..8cba9df00 100644--- a/tests/providers/test_openai_codex_provider.py+++ b/tests/providers/test_openai_codex_provider.py@@ -21,9 +21,12 @@ from nanobot.providers.openai_codex_provider import (def _mock_codex_token(monkeypatch: pytest.MonkeyPatch) -> None:+ def fake_token(**_kwargs):+ return SimpleNamespace(account_id="acct", access="token")+monkeypatch.setattr("nanobot.providers.openai_codex_provider.get_codex_token",- lambda: SimpleNamespace(account_id="acct", access="token"),+ fake_token,)@@ -77,7 +80,12 @@ async def test_codex_request_non_200_populates_http_metadata(monkeypatch) -> Nonrequest=request,)- def fake_client(*, timeout: int, verify: bool) -> httpx.AsyncClient:+ def fake_client(+ *,+ timeout: int,+ verify: bool,+ **_kwargs: object,+ ) -> httpx.AsyncClient:assert timeout == 90assert verify is Truereturn original_client(transport=httpx.MockTransport(handler), timeout=timeout)@@ -106,7 +114,12 @@ async def test_codex_request_honors_stream_idle_timeout_env(monkeypatch) -> Nonedef handler(request: httpx.Request) -> httpx.Response:return httpx.Response(200, request=request)- def fake_client(*, timeout: int, verify: bool) -> httpx.AsyncClient:+ def fake_client(+ *,+ timeout: int,+ verify: bool,+ **_kwargs: object,+ ) -> httpx.AsyncClient:seen["timeout"] = timeoutreturn original_client(transport=httpx.MockTransport(handler), timeout=timeout)@@ -117,6 +130,39 @@ async def test_codex_request_honors_stream_idle_timeout_env(monkeypatch) -> Noneassert seen["timeout"] == 5+async def test_codex_request_uses_configured_proxy(monkeypatch) -> None:+ original_client = httpx.AsyncClient+ seen: dict[str, object] = {}+ proxy = "http://127.0.0.1:23458"++ def handler(request: httpx.Request) -> httpx.Response:+ return httpx.Response(200, request=request)++ def fake_client(+ *,+ timeout: int,+ verify: bool,+ proxy: str | None = None,+ trust_env: bool = True,+ ) -> httpx.AsyncClient:+ seen["proxy"] = proxy+ seen["trust_env"] = trust_env+ return original_client(transport=httpx.MockTransport(handler), timeout=timeout)++ monkeypatch.setattr("nanobot.providers.openai_codex_provider.httpx.AsyncClient", fake_client)++ await _request_codex(+ "https://codex.example/responses",+ {},+ {"input": []},+ verify=True,+ proxy=proxy,+ )++ assert seen == {"proxy": proxy, "trust_env": False}++@pytest.mark.asyncioasync def test_codex_prompt_cache_key_uses_stable_conversation_prefix(monkeypatch) -> None:bodies: list[dict] = []@@ -128,11 +174,12 @@ async def test_codex_prompt_cache_key_uses_stable_conversation_prefix(monkeypatcheaders,body,verify,+ proxy=None,on_content_delta=None,on_thinking_delta=None,on_tool_call_delta=None,):- _ = on_thinking_delta, on_tool_call_delta+ _ = proxy, on_thinking_delta, on_tool_call_deltabodies.append(body)return "ok", [], "stop", {}, None@@ -186,6 +233,40 @@ async def test_codex_timeout_error_is_typed_and_retryable(monkeypatch) -> None:assert response.error_should_retry is True+async def test_codex_provider_passes_proxy_to_oauth_and_response_request(monkeypatch) -> None:+ proxy = "http://127.0.0.1:23458"+ seen: dict[str, object] = {}++ def fake_token(*, proxy=None):+ seen["token_proxy"] = proxy+ return SimpleNamespace(account_id="acct", access="token")++ async def fake_request(+ url,+ headers,+ body,+ verify,+ proxy=None,+ on_content_delta=None,+ on_thinking_delta=None,+ on_tool_call_delta=None,+ ):+ _ = url, headers, body, verify, on_content_delta, on_thinking_delta, on_tool_call_delta+ seen["request_proxy"] = proxy+ return "ok", [], "stop", {}, None++ monkeypatch.setattr("nanobot.providers.openai_codex_provider.get_codex_token", fake_token)+ monkeypatch.setattr("nanobot.providers.openai_codex_provider._request_codex", fake_request)++ provider = OpenAICodexProvider(proxy=proxy)+ response = await provider.chat([{"role": "user", "content": "hello"}])++ assert response.content == "ok"+ assert seen["token_proxy"] == proxy+ assert seen["request_proxy"] == proxy++@pytest.mark.asyncioasync def test_codex_timeout_error_writes_diagnostic_log(monkeypatch) -> None:log_capture = _capture_codex_warnings(monkeypatch)@@ -409,9 +490,12 @@ def test_codex_reasoning_options_request_summary_without_forcing_effort() -> Non@pytest.mark.asyncioasync def test_codex_stream_surfaces_reasoning_summary(monkeypatch) -> None:+ def fake_token(**_kwargs):+ return SimpleNamespace(account_id="acct", access="token")+monkeypatch.setattr("nanobot.providers.openai_codex_provider.get_codex_token",- lambda: SimpleNamespace(account_id="acct", access="token"),+ fake_token,)async def fake_request(@@ -419,11 +503,12 @@ async def test_codex_stream_surfaces_reasoning_summary(monkeypatch) -> None:headers,body,verify,+ proxy=None,on_content_delta=None,on_thinking_delta=None,on_tool_call_delta=None,):- _ = url, headers, verify, on_tool_call_delta+ _ = url, headers, verify, proxy, on_tool_call_deltaassert body["reasoning"] == {"summary": "auto", "effort": "medium"}if on_content_delta:await on_content_delta("answer")diff --git a/tests/providers/test_proxy_env.py b/tests/providers/test_proxy_env.pyindex 640c9dfb2..340d1bc5d 100644--- a/tests/providers/test_proxy_env.py+++ b/tests/providers/test_proxy_env.py@@ -4,6 +4,7 @@ from unittest.mock import MagicMockimport httpx+import nanobot.providers.openai_compat_provider as openai_compat_providerfrom nanobot.providers.openai_compat_provider import OpenAICompatProvider@@ -54,3 +55,32 @@ class TestCloudEndpointProxyEnabled:client = provider._client._client# trust_env should be True so httpx reads HTTP_PROXY etc.assert client._trust_env is True++ async def test_explicit_provider_proxy_overrides_env(self, monkeypatch):+ spec = _make_spec(is_local=False)+ spec.env_key = ""+ spec.default_api_base = "https://api.openai.com/v1"+ proxy = "http://127.0.0.1:23458"+ monkeypatch.delenv("NANOBOT_OPENAI_COMPAT_TIMEOUT_S", raising=False)++ http_client = MagicMock()+ async_client = MagicMock(return_value=http_client)+ openai_client = MagicMock(return_value=object())+ monkeypatch.setattr(httpx, "AsyncClient", async_client)+ monkeypatch.setattr(openai_compat_provider, "AsyncOpenAI", openai_client)++ provider = OpenAICompatProvider(+ api_key="test",+ api_base=None,+ spec=spec,+ proxy=proxy,+ )+ provider._build_client()++ async_client.assert_called_once_with(+ timeout=120.0,+ proxy=proxy,+ trust_env=False,+ follow_redirects=True,+ )+ assert openai_client.call_args.kwargs["http_client"] is http_clientdiff --git a/tests/webui/test_settings_api.py b/tests/webui/test_settings_api.pyindex 4a41328f6..f772ce5ac 100644--- a/tests/webui/test_settings_api.py+++ b/tests/webui/test_settings_api.py@@ -1,6 +1,7 @@from __future__ import annotationsimport json+from types import SimpleNamespaceimport httpximport pytest@@ -12,6 +13,7 @@ from nanobot.webui.settings_api import (WebUISettingsError,_oauth_provider_status,create_model_configuration,+ login_oauth_provider,provider_models_payload,settings_payload,settings_usage_payload,@@ -844,6 +846,39 @@ def test_openai_codex_oauth_status_rejects_unavailable_token(assert status["account"] is None+def test_openai_codex_oauth_login_passes_configured_proxy(+ tmp_path,+ monkeypatch: pytest.MonkeyPatch,+) -> None:+ proxy = "http://127.0.0.1:23458"+ config_path = tmp_path / "config.json"+ save_config(+ Config.model_validate({"providers": {"openaiCodex": {"proxy": "${CODEX_PROXY_TEST}"}}}),+ config_path,+ )+ monkeypatch.setenv("CODEX_PROXY_TEST", proxy)+ monkeypatch.setattr("nanobot.config.loader._current_config_path", config_path)++ import oauth_cli_kit++ captured: dict[str, str | None] = {}++ def fake_get_token(*, proxy=None):+ captured["get_proxy"] = proxy+ raise RuntimeError("no-token")++ def fake_login(*, print_fn, prompt_fn, proxy=None):+ captured["login_proxy"] = proxy+ return SimpleNamespace(access="access-token", account_id="acct-test")++ monkeypatch.setattr(oauth_cli_kit, "get_token", fake_get_token)+ monkeypatch.setattr(oauth_cli_kit, "login_oauth_interactive", fake_login)++ login_oauth_provider({"provider": ["openai-codex"]})++ assert captured == {"get_proxy": proxy, "login_proxy": proxy}++def test_provider_models_payload_fetches_openai_compatible_models(tmp_path,monkeypatch: pytest.MonkeyPatch,