ur-agent 1.84.3 → 1.84.5

package/docs/CONFIGURATION.md

@@ -143,6 +143,46 @@ ur config set base_url <url>
 ur config set base_url <provider> <url>
 ```
 
+OpenRouter's default `auto` policy keeps its current Auto Exacto ordering for
+tool turns and prioritizes end-to-end throughput for ordinary text turns.
+Every performance choice is explicit and editable:
+
+```sh
+ur config set openrouter.routing auto          # auto | throughput | latency | price
+ur config set openrouter.allow_fallbacks true    # true | false | auto
+ur config set openrouter.require_parameters true # true | false | auto
+ur config set openrouter.preferred_min_throughput 40
+ur config set openrouter.preferred_max_latency 3
+ur config set openrouter.service_tier priority # auto | default | flex | priority | fast
+ur config set openrouter.speed fast            # standard | fast
+ur config set model <openrouter-model>:nitro   # or :floor / :exacto
+```
+
+Thresholds are preferences, not exclusions. `priority` and `fast` can increase
+price and apply only where OpenRouter advertises upstream support; their
+default `auto`/`standard` values add no premium request. Explicit request-level
+provider preferences still win. Set either performance threshold to `auto` to
+remove it and return to OpenRouter's own routing data.
+
+Direct Anthropic requests preserve UR's prompt-cache breakpoints using
+Anthropic's supported cache-control shape. Streaming requests also set
+`eager_input_streaming: true` on user-defined tools, so large tool arguments
+arrive as Claude generates them instead of waiting for server-side buffering.
+Both behaviors use Anthropic's documented native fields and require no setting.
+
+Anthropic fast mode is a separate, premium research-preview tier. It is off by
+default and can be requested explicitly:
+
+```sh
+ur config set anthropic.speed fast             # standard | fast
+```
+
+UR adds `speed: "fast"` and Anthropic's required
+`fast-mode-2026-02-01` beta only for Claude Opus 5 and Opus 4.8. The account
+must be enabled by Anthropic. Other Claude models remain on standard speed;
+UR does not send a field the selected model does not support. Return to normal
+billing with `ur config set anthropic.speed standard`.
+
 `provider.fallback` is diagnostic recovery metadata, not automatic routing.
 When the active provider fails, `ur provider doctor` shows the configured
 recovery command; changing providers remains an explicit user action.
@@ -242,11 +282,21 @@ UNSLOTH_API_KEY=...
 
 NVIDIA NIM defaults to `https://integrate.api.nvidia.com/v1`, discovers the
 connected account's models live, and accepts a provider-scoped override for an
-enterprise or self-hosted NIM. Generic `openai-compatible` authentication is
+enterprise or self-hosted NIM. On NVIDIA's hosted endpoint, UR treats the
+documented `/v1/models` response as authoritative and omits non-agent utility
+endpoints. It does not narrow hosted models using the separate NVCF deployment
+inventory; a configured NIM gateway uses its own model feed. Generic
+`openai-compatible` authentication is
 optional: `ur connect openai-compatible` or the picker's `K` key stores a
 credential when the chosen gateway needs one, without breaking anonymous
 local endpoints.
 
+The broader Build web page includes download-only NIMs; those are not valid
+hosted choices unless the authenticated `/v1/models` endpoint returns them.
+For the hosted service, UR focuses NVIDIA's documented fastest 30B agent model,
+`nvidia/nemotron-3.5-lightning-30b-a3b`, first. Its thinking toggle maps to
+NVIDIA's model-specific `chat_template_kwargs.enable_thinking` field.
+
 Unsloth is an inference-provider integration only. Start Unsloth Studio and
 load the model outside UR, connect its generated key with `ur connect unsloth`,
 then select a model discovered from `http://localhost:8888/v1` (or your

package/docs/TROUBLESHOOTING.md

@@ -210,6 +210,54 @@ press `K` on its `/model` screen; the key is optional and stored separately
 from `OPENAI_API_KEY`. NVIDIA NIM uses `ur connect nvidia-nim` and keeps any
 custom `base_url` scoped to that provider.
 
+### NVIDIA lists a model but inference returns `Function … Not found for account`
+
+- Cause: NVIDIA's hosted `/v1/models` feed can change, or a listed model's
+  backing function can become unavailable for the connected account.
+- Fix: upgrade UR, run `ur provider doctor nvidia-nim`, then open `/model` and
+  press `Ctrl+R`. Hosted discovery uses NVIDIA's documented `/v1/models`
+  endpoint and excludes non-agent utility endpoints. It does not intersect the
+  catalog with the separate NVCF deployment-function inventory. A definitive
+  runtime 404 removes only that model from the current endpoint-scoped session
+  catalog until the next explicit refresh.
+- Privacy: UR does not display or retain the internal NVIDIA function UUID and
+  account identifier from this error response.
+
+If `chat_models` fails, reconnect a current build.nvidia.com key with
+`ur connect nvidia-nim`. A configured enterprise/self-hosted NIM endpoint is
+validated only against that gateway's own `/models` response.
+
+### A provider says the previous answer was empty after successful tool calls
+
+Some OpenAI-compatible models scope generated tool-call IDs to one response
+and reuse values such as `TaskCreate:0` on a later response. Older UR releases
+mistook the later completed pair for transcript corruption, removed it before
+the next API request, and could make the model believe that the user sent an
+empty continuation.
+
+Upgrade UR and retry the turn. UR now canonicalizes only later, independently
+completed call/result pairs before provider dispatch. Same-message duplicates,
+unmatched calls, and orphaned results still go through normal transcript
+repair. The saved transcript remains faithful to the provider response; only
+the API-bound copy receives conversation-unique IDs.
+
+### `The provider reported that model … reached its per-response output boundary`
+
+This is not an input-context overflow and does not mean UR counted the text
+incorrectly. The provider ended the generation with its `max_tokens`/`length`
+finish reason on a response chunk whose boundary was the displayed value. The
+normal query loop silently continues from the exact cutoff with no fixed total
+continuation ceiling while every capped response adds novel work. It stops only
+after two consecutive empty or replayed capped responses, which indicates a
+stalled model loop rather than a long task.
+
+`UR_CODE_MAX_OUTPUT_TOKENS` changes only the per-response chunk, up to the
+model's discovered limit; it does not impose or remove a total task limit.
+Cloud requests use a practical chunk so routers retain fast endpoint choices,
+and local runtimes use a smaller reservation to avoid unnecessary KV-memory
+allocation. If the stalled-loop message appears, inspect the prompt/model for
+repetition before retrying.
+
 ### Unsloth is selected but unavailable
 
 - Likely cause: Studio is not running, no model is loaded, its generated API

package/docs/USAGE.md

@@ -173,6 +173,36 @@ ur config set responses.compact_threshold 20000
 ur config set responses.tool_search hosted
 ```
 
+For OpenRouter, UR preserves Auto Exacto on tool turns and uses throughput
+routing on non-tool turns. Tune that provider without hardcoded endpoints or
+request patches:
+
+```sh
+ur config set openrouter.routing auto
+ur config set openrouter.preferred_min_throughput 40
+ur config set openrouter.preferred_max_latency 3
+ur config set openrouter.service_tier priority
+ur config set openrouter.speed fast
+```
+
+`auto` is the recommended default. `priority`/`fast` are optional paid upstream
+features and are effective only for models that OpenRouter supports. Append
+`:nitro`, `:floor`, or `:exacto` to an OpenRouter model ID for its native
+throughput-, price-, or tool-quality-first virtual route.
+
+Direct Anthropic sessions preserve prompt-cache breakpoints and stream large
+tool arguments with Anthropic's per-tool `eager_input_streaming` control.
+Accounts admitted to Anthropic's premium fast-mode research preview can opt in
+for its supported Opus models:
+
+```sh
+ur config set anthropic.speed fast
+```
+
+UR sends that tier only to Claude Opus 5 and Opus 4.8; all other Claude models
+remain on standard speed. Use `ur config set anthropic.speed standard` to turn
+the premium tier off.
+
 `provider.fallback` only controls the recovery suggestion printed by provider
 diagnostics. UR does not switch or retry across providers automatically; use
 `ur config set provider <id>` after reviewing the failure.
@@ -240,7 +270,16 @@ API-key access, and an API key does not grant subscription CLI access.
 NVIDIA NIM uses the build.nvidia.com key and hosted
 `https://integrate.api.nvidia.com/v1` endpoint by default. Connect it with
 `ur connect nvidia-nim`; use `ur config set base_url nvidia-nim <url>` for a
-different NIM deployment. On the `/model` model screen, `K` adds or replaces a
+different NIM deployment. For the hosted endpoint, `/model` shows only models
+returned by NVIDIA's authoritative `/v1/models` feed, excluding non-agent
+utility endpoints such as embeddings, guards, and parsers. NVCF deployment
+functions are a separate API and do not narrow this hosted catalog. A custom
+NIM gateway retains its own independent catalog.
+Download-only cards from the Build web catalog are not inserted into the
+hosted picker. NVIDIA's live `nemotron-3.5-lightning-30b-a3b` endpoint is
+focused first as its documented fastest 30B agent model; Left/Right controls
+that model's advertised on/off thinking switch.
+On the `/model` model screen, `K` adds or replaces a
 provider API key and `E` edits its endpoint. This also makes optional
 authentication practical for generic OpenAI-compatible gateways.
 

package/docs/VALIDATION.md

@@ -19,7 +19,7 @@ You need:
 
 ```sh
 ur --version
-# expected for this release: "1.84.3 (UR-Nexus)"
+# expected for this release: "1.84.5 (UR-Nexus)"
 ```
 
 ### 0.0 Redteam mode and Reverse Skills (1.81.0)
@@ -72,7 +72,7 @@ changes must remain blocked. The deterministic regressions are:
 bun test test/taskListGate.test.ts test/toolExecutionFinalInput.test.ts
 ```
 
-### 0.0.0 OpenRouter research routing and provider UI (1.81.3; Ultra mapping updated 1.83.1)
+### 0.0.0 OpenRouter research routing and provider UI (routing updated 1.84.4)
 
 Connect OpenRouter, run `/model`, select OpenRouter, and verify that its model
 step shows catalog freshness plus pricing/context/tool/reasoning details. Focus
@@ -100,13 +100,76 @@ the auxiliary request stays on the active OpenRouter model, no `modelH` error
 appears, a real provider search count is shown, and a response that did not
 perform a search fails clearly instead of saying `Did 0 searches`.
 
+Inspect the OpenRouter request body. A turn containing tools must not contain a
+default `provider.sort`, leaving Auto Exacto active; a text-only request must
+contain `provider.sort="throughput"`. Both retain the stable `session_id`.
+Then verify explicit controls and native virtual variants:
+
+```sh
+ur config set openrouter.routing latency
+ur config set openrouter.allow_fallbacks true
+ur config set openrouter.require_parameters true
+ur config set openrouter.preferred_min_throughput 40
+ur config set openrouter.preferred_max_latency 3
+ur config set openrouter.service_tier priority
+ur config set openrouter.speed fast
+ur config set model <discovered-openrouter-model>:nitro
+```
+
+The forced routing value must appear on both tool and non-tool requests;
+fallback/threshold settings must use OpenRouter's snake-case wire keys;
+`priority`/`fast` must appear only when explicitly selected. `:nitro` must
+validate against the discovered base model and inherit its context, output,
+tool, and reasoning metadata.
+
+For direct Anthropic, inspect one streaming request with tools. Valid
+`cache_control` markers must remain while URHQ-only `scope` is absent, each user
+tool must include `eager_input_streaming: true`, and no legacy fine-grained
+streaming beta header is required. Then run:
+
+```sh
+ur config set anthropic.speed fast
+```
+
+Opus 5/4.8 must receive `speed="fast"` and
+`anthropic-beta: fast-mode-2026-02-01`; Sonnet, Fable, Haiku, and unsupported
+Opus versions must receive neither. A non-stream response must retain
+`usage.speed`.
+
 Deterministic coverage:
 
 ```sh
 bun test test/providerPickerPresentation.test.ts \
   test/openRouterEffort.test.ts test/providerModelDiscovery.test.ts \
   test/secondaryModelFallback.test.ts test/providerToolCalls.test.ts \
-  test/usageAccounting.test.ts test/providerRouting.test.ts
+  test/providerContextWindow.test.ts test/outputLimitRecovery.test.ts \
+  test/usageAccounting.test.ts test/providerRouting.test.ts \
+  test/reusedToolUseIds.test.ts
+```
+
+The repeated-ID fixture contains two sequential completed calls that both
+arrive as `TaskCreate:0`. Both call/results must survive the provider-bound
+history pass with the later pair renamed deterministically; same-message or
+unmatched duplicates must remain visible to corruption repair.
+
+### 0.0.0a Provider output-boundary continuation (1.84.4)
+
+Use a provider fixture that returns `max_tokens`/`length` after non-empty
+partial output. UR must withhold the intermediate API error, add a continuation
+turn that requests only novel work from the exact cutoff, and continue for more
+than three responses while every response progresses. The original prompt,
+tool state, and completed output remain in context. Two consecutive empty or
+exact-replay capped responses must stop with the stalled-loop diagnostic.
+
+The per-request `max_tokens` value remains bounded by live/static model
+metadata. A model with a 128K advertised output ceiling uses a practical 32K
+default response chunk; `UR_CODE_MAX_OUTPUT_TOKENS` may raise that chunk to
+128K, but neither value creates a total task-output ceiling. Local/user-hosted
+runtimes use their conservative 4K reservation and the same continuation path.
+
+```sh
+bun test test/outputLimitRecovery.test.ts \
+  test/providerRequestTuning.test.ts test/providerContextWindow.test.ts
 ```
 
 ### 0.0.1 Unavailable Ollama tools recover (1.80.7)
@@ -198,8 +261,12 @@ NVIDIA NIM, Ollama, LM Studio, llama.cpp, vLLM, Unsloth, and generic OpenAI-comp
 request shapes.
 
 The NVIDIA fixture also verifies hosted/default and overridden endpoints,
-Bearer discovery, native dispatch, documented effort aliases, and no Ultra on
-an unknown model. In `/model`, select `openai-compatible` and verify `K` can
+Bearer discovery from NVIDIA's authoritative `/v1/models` endpoint, removal
+of non-agent utility models, selected-model doctor diagnostics, redaction of
+internal NVIDIA account/function IDs, endpoint-scoped runtime invalidation,
+native dispatch, the preferred Lightning endpoint and its model-scoped
+`enable_thinking` switch, documented effort aliases, and no Ultra on an unknown model. In
+`/model`, select `openai-compatible` and verify `K` can
 add or replace its optional key while `E` continues to edit only its endpoint.
 
 ## 0.2 Permission safety and context pack (1.19.0)

package/docs/providers.md

@@ -263,10 +263,40 @@ shows pricing tier, context size, tool capability, reasoning capability, and
 the full, untruncated model ID immediately below the focused entry. Opening the
 OpenRouter catalog reuses its endpoint-scoped five-minute cache; Ctrl+R forces
 the current `/models` endpoint and never substitutes a cached list when that
-forced refresh fails. Interactive requests default to OpenRouter's latency
-sorting, promote UR's stable session ID for sticky routing, and preserve safe
-provider prompt-cache markers. Explicit routing preferences and the `:nitro`,
-`:floor`, and `:exacto` model variants remain authoritative. API-key entry for
+forced refresh fails. Tool requests preserve OpenRouter Auto Exacto so its live
+throughput, tool-call reliability, and benchmark signals choose the route;
+non-tool requests default to throughput sorting rather than TTFT-only latency
+sorting. UR promotes its stable session ID for prompt-cache affinity while
+retaining router fallback. Explicit request preferences, the `openrouter.*`
+configuration controls, and the `:nitro`, `:floor`, and `:exacto` model variants
+remain authoritative. See OpenRouter's
+[provider routing](https://openrouter.ai/docs/guides/routing/provider-selection),
+[Auto Exacto](https://openrouter.ai/docs/guides/routing/auto-exacto), and
+[prompt caching](https://openrouter.ai/docs/guides/best-practices/prompt-caching).
+
+Direct Anthropic requests retain supported prompt-cache breakpoints and enable
+per-tool `eager_input_streaming` on streaming turns. This reduces repeated
+prefill work and avoids waiting for a complete large tool argument before its
+deltas arrive. Anthropic's premium fast tier remains explicit:
+
+```sh
+ur config set anthropic.speed fast
+```
+
+UR sends `speed: "fast"` with the `fast-mode-2026-02-01` beta only for Claude
+Opus 5 and Opus 4.8, and retains `usage.speed` so accounting can distinguish the
+tier actually served. Enabled account access is still required. Unsupported
+models stay on standard speed. See Anthropic's
+[prompt caching](https://platform.claude.com/docs/en/build-with-claude/prompt-caching),
+[fine-grained tool streaming](https://platform.claude.com/docs/en/agents-and-tools/tool-use/fine-grained-tool-streaming),
+and [fast mode](https://platform.claude.com/docs/en/build-with-claude/fast-mode).
+
+UR uses only provider-documented acceleration controls. OpenAI Responses
+already has native streaming and WebSocket continuation; Gemini 2.5+ implicit
+caching is automatic. Google's Priority tier requires the Interactions API and
+is not a valid `generateContent` option. NVIDIA NIM and local servers publish
+no universal OpenRouter-style routing field, so UR does not invent one.
+API-key entry for
 OpenAI, Claude, Gemini, OpenRouter, NVIDIA NIM, and authenticated compatible
 endpoints is a single aligned masked row; the key is stored in the OS keychain
 flow and is never written to settings. On the model screen, `K` adds or
@@ -277,8 +307,9 @@ OpenAI-compatible endpoints may remain anonymous.
 
 UR uses each provider's non-generating count endpoint when one covers the full
 request: OpenAI Responses input tokens, Anthropic Messages token counting,
-Gemini `countTokens`, llama.cpp chat input tokens, and vLLM/NVIDIA NIM Messages
-token counting. Ollama, OpenRouter, LM Studio, Unsloth, and subscription CLIs use a
+Gemini `countTokens`, llama.cpp chat input tokens, and vLLM Messages token
+counting. NVIDIA's hosted NIM API has no documented token-count route;
+NVIDIA NIM, Ollama, OpenRouter, LM Studio, Unsloth, and subscription CLIs use a
 provider-wire local estimate because those runtimes do not share a dependable
 preflight tokenizer for complete chat history plus tools. UR never launches a
 hidden completion for token counting. If a native count call is unavailable,
@@ -420,7 +451,7 @@ ur config set provider anthropic-api
 | --- | --- | --- |
 | API providers (openai-api, anthropic-api, gemini-api) | Live discovery from the provider's `/models` endpoint using your connected key (curated fallback until connected) | live |
 | OpenRouter | Live `/models` discovery with an endpoint-scoped five-minute cache; Ctrl+R forces a fresh request with no stale fallback | live/cache |
-| NVIDIA NIM | Live `/models` discovery from the hosted or configured NIM endpoint; no stale offline model catalog | live |
+| NVIDIA NIM | Hosted: authoritative live `/models`, restricted to agent/chat endpoints. Configured NIM gateway: its own live `/models` catalog | live |
 | Local/server providers (ollama, lmstudio, llama.cpp, vllm, unsloth) | Dynamic discovery from the selected provider endpoint | live |
 | OpenAI-compatible | Dynamic discovery from configured endpoint | live |
 | Subscription CLIs (codex-cli, claude-code-cli, gemini-cli, antigravity-cli) | Curated list (the official CLIs expose no models API); first-class in `/model`, dispatched via the official CLI. External CLI behavior depends on the vendor CLI. Log in with `ur auth <provider>` | static |
@@ -657,15 +688,38 @@ ur provider doctor nvidia-nim
 ur config set base_url nvidia-nim https://nim-gateway.example/v1
 ```
 
-The default is `https://integrate.api.nvidia.com/v1`. UR calls `/models`,
-`/chat/completions`, and, when available, `/messages/count_tokens`; native
-count failure falls back to a provider-wire estimate and never launches a
-hidden completion. Streaming, standard tool calls, and image input use the
+The default is `https://integrate.api.nvidia.com/v1`. NVIDIA documents
+`/v1/models` as the management endpoint for models available for inference, so
+UR uses that authenticated response as the live hosted catalog. It removes
+embedding, guard, parser, translation, reward, and similar non-agent endpoints,
+but does not intersect the result with NVCF's separate deployment-function
+inventory. A custom enterprise or self-hosted NIM remains independent and uses
+only that configured gateway's `/models` response.
+
+The Build web catalog also contains download-only NIMs. UR does not add those
+cards to the hosted picker: only IDs returned by the authenticated hosted
+`/v1/models` endpoint can appear. UR focuses
+`nvidia/nemotron-3.5-lightning-30b-a3b` first because NVIDIA documents it as
+its fastest 30B model for long-running agents. Left/Right can turn that exact
+model's thinking off/on through NVIDIA's documented
+`chat_template_kwargs.enable_thinking`; other NIM models receive only their
+own advertised reasoning contract.
+
+UR calls `/models` and `/chat/completions`. It counts NVIDIA requests with a
+provider-wire local estimate instead of first calling the unsupported hosted
+`/messages/count_tokens` route, and never launches a hidden completion.
+Streaming, standard tool calls, and image input use the
 same OpenAI-compatible adapter. Vision and tools remain model-dependent. For
 documented Nemotron coding-agent models, UR includes NVIDIA's
 `force_nonempty_content` template option when tools are present. See NVIDIA's
 [NIM LLM API reference](https://docs.api.nvidia.com/nim/reference/llm-apis)
-and [NIM function-calling API](https://docs.nvidia.com/nim/large-language-models/latest/function-calling.html).
+and [NIM endpoint guide](https://docs.nvidia.com/nim/large-language-models/latest/tutorials.html).
+
+`ur provider doctor nvidia-nim` verifies the hosted catalog and selected model
+against the live `/v1/models` response. If NVIDIA rejects a listed model after
+selection, UR redacts NVIDIA's internal function/account IDs, removes that
+model from the current endpoint-scoped session catalog, and asks the user to
+select another model. `Ctrl+R` explicitly retries discovery.
 
 Local/server providers use their normal endpoints:
 

package/documentation/index.html

@@ -45,7 +45,7 @@
     <main id="content" class="content">
       <header class="topbar">
         <div>
-          <p class="eyebrow">Version 1.84.3</p>
+          <p class="eyebrow">Version 1.84.5</p>
           <h1>UR-Nexus Documentation</h1>
           <p class="lead">A practical, tutorial-style reference for installing, configuring, automating, extending, and operating UR-Nexus.</p>
         </div>
@@ -172,8 +172,9 @@ ur config set provider unsloth
 ur config set model qwen3-coder:480b-cloud
 ur config set provider.fallback ollama
 ur config set openai_transport responses
-ur config set responses.store false</code></pre>
-            <p>API providers require explicit selection and read keys from a key stored via <code>ur connect</code> (OS keychain) or from environment variables. Each configurable provider keeps its own <code>base_url</code>, so switching among Ollama, LM Studio, llama.cpp, vLLM, Unsloth, NVIDIA NIM, and API gateways restores the matching address. NVIDIA NIM uses live discovery from build.nvidia.com's official OpenAI-compatible API. OpenAI Responses is opt-in and privacy-first; Chat Completions remains the default. Unsloth is an authenticated inference provider only.</p>
+ur config set responses.store false
+ur config set anthropic.speed fast</code></pre>
+            <p>API providers require explicit selection and read keys from a key stored via <code>ur connect</code> (OS keychain) or from environment variables. Each configurable provider keeps its own <code>base_url</code>, so switching among Ollama, LM Studio, llama.cpp, vLLM, Unsloth, NVIDIA NIM, and API gateways restores the matching address. OpenAI Responses is opt-in and privacy-first; Chat Completions remains the default. Direct Anthropic preserves prompt-cache breakpoints, streams tool inputs with its per-tool control, and enables the documented premium fast tier only when explicitly configured for a supported model. Unsloth is an authenticated inference provider only.</p>
           </article>
           <article>
             <h3>Capability-driven reasoning effort</h3>
@@ -187,7 +188,7 @@ ur --model kimi-k3:cloud --effort high
             <h3>OpenRouter responsive routing</h3>
             <pre><code>ur config set provider openrouter
 /model  # cached catalog; Ctrl+R forces live refresh</code></pre>
-            <p>The endpoint-scoped model catalog is reused for five minutes, while forced refresh never substitutes stale data. Interactive requests prefer OpenRouter latency routing, a stable session ID, and provider-authored prompt-cache markers; explicit routing preferences and model variants still win.</p>
+            <p>The endpoint-scoped model catalog is reused for five minutes, while forced refresh never substitutes stale data. Tool turns preserve OpenRouter Auto Exacto for live throughput and tool-call reliability; non-tool turns prefer end-to-end throughput. Stable session affinity keeps prompt caches warm, while configurable routing preferences and the <code>:nitro</code>, <code>:floor</code>, and <code>:exacto</code> variants remain authoritative.</p>
           </article>
           <article>
             <h3>NVIDIA NIM and compatible API keys</h3>
@@ -195,7 +196,7 @@ ur --model kimi-k3:cloud --effort high
 ur config set provider nvidia-nim
 ur config set base_url nvidia-nim https://integrate.api.nvidia.com/v1
 /model  # K API key · E endpoint</code></pre>
-            <p>NVIDIA NIM is a UR-native provider with live models, streaming, tools, images, configurable endpoints, and only NVIDIA-documented effort ladders. Generic OpenAI-compatible endpoints can also store an optional dedicated key; anonymous endpoints remain valid.</p>
+            <p>NVIDIA NIM is a UR-native provider with live models, streaming, tools, images, configurable endpoints, and only NVIDIA-documented effort ladders. Its authenticated hosted <code>/v1/models</code> response is authoritative: UR filters utility endpoints but does not narrow the catalog through the unrelated NVCF deployment inventory, and download-only Build cards are not presented as hosted endpoints. Nemotron 3.5 Lightning is preferred when live and receives its documented on/off thinking field; unknown models inherit no fabricated effort. Generic OpenAI-compatible endpoints can store an optional dedicated key, while anonymous endpoints remain valid.</p>
           </article>
           <article>
             <h3>Portable shell deadlines</h3>

package/extensions/jetbrains-ur/build.gradle.kts

@@ -7,7 +7,7 @@ plugins {
 }
 
 group = "dev.urnexus"
-version = "1.84.3"
+version = "1.84.5"
 
 repositories {
     mavenCentral()

package/extensions/vscode-ur-inline-diffs/package.json

@@ -2,7 +2,7 @@
   "name": "ur-inline-diffs",
   "displayName": "UR Inline Diffs",
   "description": "Review, apply, and reject UR inline diff bundles from .ur/ide/diffs inside VS Code.",
-  "version": "1.84.3",
+  "version": "1.84.5",
   "publisher": "ur-nexus",
   "engines": {
     "vscode": "^1.92.0"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ur-agent",
-  "version": "1.84.3",
+  "version": "1.84.5",
   "description": "UR-Nexus — autonomous engineering workflow engine (plan, execute, test, verify, document, benchmark, reproduce)",
   "type": "module",
   "packageManager": "bun@1.3.14",