ur-agent 1.84.0 → 1.84.2

package/docs/AGENT_TRENDS.md

@@ -80,7 +80,7 @@ Inside an interactive session:
 
 | Trend | UR status | Current coverage | Professional next step |
 | --- | --- | --- | --- |
-| Provider-flexible, local-first runtime | Covered | Local Ollama; direct OpenAI, Anthropic, Gemini, OpenRouter, and OpenAI-compatible APIs; authenticated subscription-CLI adapters; explicit provider selection | Normalize capability discovery across providers and make automatic per-step routing opt-in |
+| Provider-flexible, local-first runtime | Covered | Local Ollama; direct OpenAI, Anthropic, Gemini, OpenRouter, NVIDIA NIM, and OpenAI-compatible APIs; authenticated subscription-CLI adapters; explicit provider selection | Normalize capability discovery across providers and make automatic per-step routing opt-in |
 | Model Context Protocol ecosystem | Covered | Stable TypeScript SDK v2 split client/server/core runtime; `ur mcp`, OAuth/XAA, fail-closed bounded tools, final `input_required` continuation, all workspace roots with change notifications, and the opt-in stateless web server | Broaden independent-client interoperability fixtures |
 | Protocol Tasks and Apps | Covered | Negotiated Tasks lifecycle, owner-isolated durable state, and a self-contained Apps resource through `ur mcp serve-web` | Broaden independent-client interoperability fixtures |
 | A2A / Agent Card interoperability | Covered | Stable official v1.1 SDK, native ProtoJSON JSON-RPC/HTTP+JSON, SSE streaming, task resubscription, authenticated push delivery with validated destinations, negotiated cards, tenant isolation, durable artifacts, and explicit v0.3 compatibility | Broaden independent-client/TCK fixtures; keep gRPC and extended cards unadvertised until deployed and tested |
@@ -168,7 +168,7 @@ compatibility transport rather than relabeling either wire schema.
 ## Model Runtime Position
 
 UR is local-first, not local-only. Ollama supports private on-device execution;
-direct adapters support OpenAI, Anthropic, Gemini, OpenRouter, and compatible
+direct adapters support OpenAI, Anthropic, Gemini, OpenRouter, NVIDIA NIM, and compatible
 endpoints; subscription adapters use the provider's authenticated CLI. Provider
 and model selection are explicit, credentials are resolved through the
 credential layer, and the optional fallback setting is diagnostic advice rather

package/docs/CONFIGURATION.md

@@ -88,7 +88,7 @@ receives general-purpose tools through this path.
 
 UR-Nexus supports official provider access paths only:
 
-- Explicit API providers: OpenAI, Anthropic, Gemini, OpenRouter, and
+- Explicit API providers: OpenAI, Anthropic, Gemini, OpenRouter, NVIDIA NIM, and
   OpenAI-compatible endpoints.
 - Local/server providers: Ollama, LM Studio, llama.cpp, vLLM, and Unsloth OpenAI-compatible
   server mode.
@@ -132,6 +132,7 @@ ur config set provider openai-api
 ur config set provider anthropic-api
 ur config set provider gemini-api
 ur config set provider openrouter
+ur config set provider nvidia-nim
 ur config set provider openai-compatible
 ur config set provider unsloth
 ur provider doctor agy
@@ -147,7 +148,7 @@ When the active provider fails, `ur provider doctor` shows the configured
 recovery command; changing providers remains an explicit user action.
 
 Provider values accept canonical IDs and common aliases. Examples:
-`openai-api`, `anthropic-api`, `gemini-api`, `openrouter`, `ollama`,
+`openai-api`, `anthropic-api`, `gemini-api`, `openrouter`, `nvidia-nim` (`NVIDIA Build`), `ollama`,
 `lmstudio`, `LM Studio`, `llama.cpp`, `vllm`, `unsloth` (`Unsloth Studio`), and the subscription CLI
 providers `codex-cli` (`chatgpt`), `claude-code-cli` (`claude`), `gemini-cli`
 (`gemini`), and `antigravity-cli` (`agy`). Values with spaces should be quoted
@@ -162,35 +163,40 @@ saved provider/model pair controls the runtime backend for the next agent
 request; Ollama is only used when `ollama` is the selected provider.
 
 The configured `base_url` is provider-scoped. Setting an address while vLLM is
-active does not replace the saved Ollama, llama.cpp, or Unsloth address;
+active does not replace the saved Ollama, llama.cpp, Unsloth, or NVIDIA NIM address;
 returning to any provider restores its own URL. Legacy `provider.baseUrl`
 settings are migrated to the old active provider on the first provider switch
 or scoped base-URL write.
 To configure a provider that is not active, use
 `ur config set base_url <provider> <url>`; the success message names the target
 provider. This applies to direct API providers and gateways (OpenAI, Anthropic,
-Gemini, and OpenRouter) as well as local/server providers; built-in vendor URLs
+Gemini, OpenRouter, and NVIDIA NIM) as well as local/server providers; built-in vendor URLs
 are fallbacks only. Discovery, doctor output, and request dispatch all resolve
 the same per-provider override. `/model` also opens an endpoint field when a
 disconnected local/server provider is selected.
 
 In the model step, Up/Down browses, Left/Right changes the focused model's
-supported effort level, Enter confirms, Ctrl+R refreshes the catalog, and Esc
-returns to providers. OpenRouter entries show pricing tier, context size,
+supported effort level, Enter confirms, Ctrl+R refreshes the catalog, `E`
+edits the provider endpoint, `K` adds or replaces its API key, and Esc returns
+to providers. OpenRouter entries show pricing tier, context size,
 tool/reasoning capability, compact names, and the exact ID for the focused
 entry. Its endpoint-scoped catalog is reused for five minutes, while Ctrl+R
 forces an immediate live refresh; a failed forced refresh never silently
 displays cached entries. API-provider secret
 entry stays on one masked row and stores the value through the keychain flow.
-Ollama and llama.cpp capabilities are loaded lazily for the focused model from
-`/api/show` and `/props`, respectively, so the arrow selector reflects the
-actual model rather than a provider-wide guess.
+Ollama, llama.cpp, and vLLM capabilities are loaded lazily for the focused
+model from `/api/show`, `/props`, and `/server_info?config_format=json`,
+respectively, so the arrow selector reflects live runtime evidence rather than
+a provider-wide guess. llama.cpp's current boolean support flag does not name
+accepted levels, while a configured vLLM reasoning parser exposes its
+documented `minimal→none|low|medium|high` mapping.
 
 The effort row contains only capability-backed selectors UR can map to native
 provider values. Ultra appears only when metadata advertises `ultra`, `max`,
 `xhigh`, or an explicit alias; mappings such as `ultra→max` are shown and sent
-exactly. Models that top out at `high`, boolean-thinking models, and unknown
-capabilities omit Ultra. See [Reasoning effort](providers.md#reasoning-effort).
+exactly. Models that top out at `high`, models without an advertised
+beyond-high value, and unknown capabilities omit Ultra. See
+[Reasoning effort](providers.md#reasoning-effort).
 
 Boolean-thinking models on runtimes with a native toggle expose a two-state
 control instead: Left selects off, Right selects on, and `t` toggles in
@@ -226,6 +232,7 @@ OPENAI_COMPATIBLE_API_KEY=...
 ANTHROPIC_API_KEY=...
 GEMINI_API_KEY=...
 OPENROUTER_API_KEY=...
+NVIDIA_API_KEY=...
 OLLAMA_API_KEY=...             # optional for authenticated Ollama gateways
 LMSTUDIO_API_KEY=...           # optional when required by the endpoint
 LLAMA_CPP_API_KEY=...          # optional when required by the endpoint
@@ -233,6 +240,13 @@ VLLM_API_KEY=...               # optional when required by the endpoint
 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
+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.
+
 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
@@ -500,6 +514,15 @@ before the agent can declare the task complete. A failing command surfaces
 to the model as a structured reminder with the command name and the trimmed
 stdout/stderr.
 
+## Shell command deadlines
+
+Set the Bash tool's `timeout` input in milliseconds for a whole-command
+deadline. If a generated command uses the common Linux form `timeout 60 cmd`,
+UR also makes that command work on macOS: it uses Homebrew `gtimeout` when
+installed, otherwise supplies an in-process compatibility implementation with
+process-group cleanup and GNU-style status 124 on expiry. No package install or
+shell-profile change is required. Native Linux `timeout` remains untouched.
+
 ## Project Safety Policy
 
 `ur safety` exposes the project shell safety policy:

package/docs/TROUBLESHOOTING.md

@@ -200,10 +200,16 @@ ur provider doctor <provider-id>
 curl http://localhost:11434/api/tags        # Ollama
 curl http://localhost:1234/v1/models        # LM Studio (llama.cpp: 8080, vLLM: 8000)
 curl -H "Authorization: Bearer $UNSLOTH_API_KEY" http://localhost:8888/v1/models
+curl -H "Authorization: Bearer $NVIDIA_API_KEY" https://integrate.api.nvidia.com/v1/models
 ur connect openai-api                       # store an API key securely
 ur provider doctor
 ```
 
+For an authenticated generic gateway, run `ur connect openai-compatible` or
+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.
+
 ### Unsloth is selected but unavailable
 
 - Likely cause: Studio is not running, no model is loaded, its generated API

package/docs/USAGE.md

@@ -207,7 +207,7 @@ Use `ur provider status` or `ur provider doctor <provider>` to see provider
 kind, external CLI usage, native tool/streaming support, and the boundary text.
 
 Provider values accept canonical IDs and common aliases. For example,
-`openai-api`, `anthropic-api`, `gemini-api`, `openrouter`, `ollama`,
+`openai-api`, `anthropic-api`, `gemini-api`, `openrouter`, `nvidia-nim`, `ollama`,
 `lmstudio`, `llama.cpp`, `vllm`, and `unsloth` are UR-native runtime providers, and
 `codex-cli` (`chatgpt`), `claude-code-cli` (`claude`), `gemini-cli` (`gemini`),
 and `antigravity-cli` (`agy`) are subscription CLI providers.
@@ -215,7 +215,7 @@ and `antigravity-cli` (`agy`) are subscription CLI providers.
 API modes are explicit. Keys are read from a key stored via
 `ur connect <provider>` (OS keychain) or from the environment variables
 `OPENAI_API_KEY`, `ANTHROPIC_API_KEY`, `GEMINI_API_KEY`,
-`OPENROUTER_API_KEY`, and `UNSLOTH_API_KEY`. Subscription CLIs are optional, never required
+`OPENROUTER_API_KEY`, `NVIDIA_API_KEY`, and `UNSLOTH_API_KEY`. Subscription CLIs are optional, never required
 dependencies, and never used as a silent fallback. UR-Nexus never scrapes
 browser sessions, extracts OAuth tokens, or bypasses provider restrictions.
 OpenAI-compatible local or cloud endpoints use `base_url` plus `model`.
@@ -224,7 +224,7 @@ and is inference-only: UR does not manage Unsloth and disables its server-side
 tools while retaining standard function calls inside UR's guarded tool loop.
 
 UR stores `base_url` per provider. You can set different addresses for
-Ollama, LM Studio, llama.cpp, vLLM, and Unsloth once, then switch providers without
+Ollama, LM Studio, llama.cpp, vLLM, Unsloth, and NVIDIA NIM once, then switch providers without
 re-entering any of them. `ur config get base_url` reports the active provider's
 saved scoped override when one exists; use `ur provider status` or
 `ur provider doctor <provider>` to inspect the effective endpoint.
@@ -233,10 +233,17 @@ without making it active first. The `/model` picker offers the same endpoint
 entry flow for a disconnected local/server provider.
 
 Use `/model` in an interactive session to select provider first and model
-second. OpenAI API, Claude API, Gemini API, OpenRouter, Ollama, and
+second. OpenAI API, Claude API, Gemini API, OpenRouter, NVIDIA NIM, Ollama, and
 OpenAI-compatible endpoints stay separate; a subscription login does not grant
 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
+provider API key and `E` edits its endpoint. This also makes optional
+authentication practical for generic OpenAI-compatible gateways.
+
 ## Project Instructions
 
 Add a `UR.md` file to the repository root for team-shared instructions. UR loads it as project context.

package/docs/VALIDATION.md

@@ -19,7 +19,7 @@ You need:
 
 ```sh
 ur --version
-# expected for this release: "1.84.0 (UR-Nexus)"
+# expected for this release: "1.84.2 (UR-Nexus)"
 ```
 
 ### 0.0 Redteam mode and Reverse Skills (1.81.0)
@@ -82,15 +82,18 @@ between models that top out at high, xhigh, max, and native-ultra models; the le
 selected ceiling must update immediately. Models that top out at high must omit Ultra, while
 xhigh/max entries must show `ultra→xhigh` or `ultra→max`, and the
 confirmation must match `/effort status` and the request wire value. For
-an Ollama model that advertises boolean thinking without a ladder, verify that
+an Ollama model that advertises thinking without a model-specific ladder, verify that
 Left selects off, Right selects on, `t` toggles, and `/effort max` reports that
 max was not sent while enabling `think: true`; `/thinking off` must produce
 `think: false`. For
-llama.cpp, verify focus requests
-`/props?model=<focused-id>` and that a template reporting
-`supports_reasoning_effort: false` has no graded selector. Open the OpenAI API or Claude
-API connection flow and verify the masked `API key` label and entry remain on
-one horizontal row.
+llama.cpp, verify focus requests `/props?model=<focused-id>` and that both an
+unsupported template and a bare `supports_reasoning_effort: true` flag have no
+graded selector unless exact levels are also returned. For vLLM, verify one
+focus request to `/server_info?config_format=json`; a non-empty reasoning parser
+must expose `minimal→none`, `low`, `medium`, and `high`, serialize
+`minimal` as `reasoning_effort: "none"`, and omit Ultra. Open the OpenAI API or
+Claude API connection flow and verify the masked `API key` label and entry
+remain on one horizontal row.
 
 Then ask UR to research a current topic with WebSearch and WebFetch. Expected:
 the auxiliary request stays on the active OpenRouter model, no `modelH` error
@@ -176,6 +179,29 @@ file. Expected: UR asks once whether to run the detected compile/test/lint
 commands. After answering, the same approval question is not shown again. A
 separate user task that edits files may ask once for its own verification.
 
+### 0.1.3 Portable deadlines and provider tool images (1.84.2)
+
+Run the deterministic adapter and shell coverage:
+
+```sh
+bun test test/bashCommandExecution.test.ts \
+  test/providerNvidiaNim.test.ts \
+  test/providerMultimodal.test.ts \
+  test/openaiResponses.test.ts \
+  test/ollamaToolResultImages.test.ts
+```
+
+Expected: macOS can execute `timeout 0.1 …` without GNU coreutils and reports
+124 when the deadline expires. Image-bearing tool results retain their text and
+image bytes across OpenAI Chat/Responses, Anthropic, Gemini, OpenRouter,
+NVIDIA NIM, Ollama, LM Studio, llama.cpp, vLLM, Unsloth, and generic OpenAI-compatible
+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
+add or replace its optional key while `E` continues to edit only its endpoint.
+
 ## 0.2 Permission safety and context pack (1.19.0)
 
 In a project checkout:

package/docs/providers.md

@@ -37,6 +37,7 @@ multimodal input, external CLI boundary, and sandbox scope:
 | Claude API | API | UR-native | no | yes | yes | yes | UR Bash/File sandbox | `api:anthropic` | `ANTHROPIC_API_KEY` |
 | Gemini API | API | UR-native | no | yes | yes | yes | UR Bash/File sandbox | `api:gemini` | `GEMINI_API_KEY` |
 | OpenRouter | API/router | UR-native | no | yes | yes | yes | UR Bash/File sandbox | `api:openrouter` | `OPENROUTER_API_KEY` |
+| NVIDIA NIM | hosted/server API | UR-native | no | yes | yes | model-dependent | UR Bash/File sandbox | `api:nvidia-nim` | `NVIDIA_API_KEY`; configurable NIM endpoint |
 | OpenAI-compatible | server/API | UR-native | no | yes | yes | endpoint-dependent | UR Bash/File sandbox | `openai-compatible` | optional `OPENAI_COMPATIBLE_API_KEY`; never reuses `OPENAI_API_KEY` |
 | Ollama | local/server | UR-native | no | yes | yes | yes* | UR Bash/File sandbox | `ollama` | configured local, LAN, or hosted endpoint; optional `OLLAMA_API_KEY` |
 | LM Studio | local/server | UR-native | no | yes | yes | yes | UR Bash/File sandbox | `openai-compatible:lmstudio` | configured endpoint; optional `LMSTUDIO_API_KEY` |
@@ -69,6 +70,17 @@ or `ollama show <model>`.
 official CLI, so image blocks are not forwarded, and UR-native tool/streaming/
 sandbox guarantees stop at UR-run tools and final UR output.
 
+All UR-native adapters preserve images returned by tools without putting image
+content into a wire field that rejects it. Anthropic keeps the image inside its
+native `tool_result`; OpenAI Responses uses rich function-call output; Gemini
+nests `inlineData` in the matching function response; Ollama uses the
+following native user message; and OpenAI Chat Completions, OpenRouter, NVIDIA
+NIM, LM Studio, llama.cpp, vLLM, Unsloth, and generic compatible endpoints emit the
+required textual `role: tool` message followed immediately by a multimodal
+`role: user` message. This preserves tool-call ordering and every image byte.
+It does not turn a text-only model into a vision model: select a model whose
+live provider metadata or runtime supports image input.
+
 Tool search (deferred tool loading) is disabled on every provider above. It
 depends on `tool_reference` content blocks being expanded into tool definitions
 by the API, which is a URHQ-native beta feature with no equivalent on a local
@@ -149,7 +161,7 @@ migrated to the previously active provider on the first provider switch or
 scoped base-URL write.
 
 The override is not limited to local runtimes. OpenAI API, Anthropic API,
-Gemini API, and OpenRouter can each target a separate compatible gateway using
+Gemini API, OpenRouter, and NVIDIA NIM can each target a separate compatible gateway using
 the same command. Their official URLs are defaults, not hardcoded dispatch
 destinations; model discovery and inference use the selected provider's saved
 URL. Subscription CLI providers remain vendor-managed and do not accept a base
@@ -182,8 +194,9 @@ For OpenRouter, UR preserves the live `/models` reasoning metadata and sends
 the unified `reasoning.effort` request. OpenAI-compatible servers receive the
 resolved value as `reasoning_effort`. The command confirmation, status
 indicator, active-work spinner, SDK settings response, and provider request all
-use the same resolved value. If a provider advertises only boolean thinking and
-its runtime has a real native on/off mapping, UR does not invent a graded effort
+use the same resolved value. If a provider advertises thinking without a
+model-specific graded ladder and its runtime has a real native on/off mapping,
+UR does not invent a graded effort
 selector. Use `/thinking on|off` directly;
 in `/model`, Left selects off, Right selects on, and `t` toggles. A graded
 `/effort` request on that model enables boolean thinking while clearly reporting
@@ -194,10 +207,17 @@ so metadata alone does not make this toggle appear and UR sends no invented para
 when the provider/model advertises `ultra`, `max`, `xhigh`, or an explicit
 provider-authored equivalent. UR shows the native mapping (for example,
 `ultra→max`) and sends that exact wire value; it never enables Ultra for a model
-whose graded ladder tops out at `high`, boolean thinking, or unknown capability metadata. Arbitrary
+whose graded ladder tops out at `high`, lacks an advertised beyond-high value,
+or has unknown capability metadata. Arbitrary
 labels such as `deep` still require an explicit provider alias because UR
 cannot infer their rank.
 
+NVIDIA NIM is live-discovery first. UR enriches a discovered model only when
+NVIDIA's current model API reference documents that exact model's
+`reasoning_effort` values. Documented `none` appears as Minimal and `max`
+appears as Ultra while the request preserves NVIDIA's wire values. An unknown
+NIM model never inherits an invented graded ladder.
+
 For an unknown or newly released model, UR waits for provider-authored model
 metadata or a supported model-scoped probe before adding thinking parameters.
 If the provider does not establish support, thinking stays off for request
@@ -209,16 +229,30 @@ the model advertises `supports_max_tokens`.
 
 For Ollama, UR lazily reads the focused model's `/api/show` capabilities and
 sends the resolved control through native `think`. A generic `thinking`
-capability means boolean thinking only. GPT-OSS uses Ollama's documented
+capability proves thinking support but does not identify a model-specific
+graded ladder; UR therefore exposes the verified native on/off control without
+claiming that the model cannot also support levels. GPT-OSS uses Ollama's documented
 `low|medium|high` ladder and does not expose Ultra. Other graded ladders and
 Ultra aliases are used only when the endpoint explicitly returns them in model
-reasoning metadata. Direct OpenAI,
+reasoning metadata.
+
+For vLLM, UR lazily reads the non-generating
+`/server_info?config_format=json` endpoint for the focused model. A configured
+reasoning parser establishes vLLM's documented Chat Completions contract:
+`none|low|medium|high`, displayed as `minimal→none|low|medium|high` and sent
+through `reasoning_effort`. This discovery never launches a completion and
+does not add Ultra. A richer provider-authored model record can add exact
+levels or aliases. For llama.cpp, `/props` can establish that the active chat
+template consumes reasoning effort, but the current capability flag does not
+publish its finite accepted values; UR does not fabricate a ladder from that
+boolean. Direct OpenAI,
 Anthropic, and Gemini models use curated model-specific ladders from their
 official documentation; live discovery rows are merged with those contracts.
 See [Ollama thinking](https://docs.ollama.com/capabilities/thinking),
 [OpenAI model guidance](https://developers.openai.com/api/docs/guides/latest-model),
 [Claude effort](https://platform.claude.com/docs/en/build-with-claude/effort),
-and [Gemini thinking](https://ai.google.dev/gemini-api/docs/thinking).
+[Gemini thinking](https://ai.google.dev/gemini-api/docs/thinking), and
+[vLLM reasoning outputs](https://docs.vllm.ai/en/latest/features/reasoning_outputs/).
 
 The provider-first `/model` picker supports the same control directly: use
 Left/Right to move through the capability-backed selectors UR can map to a
@@ -233,15 +267,18 @@ 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
-OpenAI, Claude, Gemini, and OpenRouter is a single aligned masked row; the key
-is stored in the OS keychain flow and is never written to settings.
+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
+replaces the selected HTTP provider's key and `E` edits its endpoint. Generic
+OpenAI-compatible endpoints may remain anonymous.
 
 ### Token counting
 
 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 Messages token
-counting. Ollama, OpenRouter, LM Studio, Unsloth, and subscription CLIs use a
+Gemini `countTokens`, llama.cpp chat input tokens, and vLLM/NVIDIA NIM Messages
+token counting. 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,
@@ -249,12 +286,13 @@ file and MCP size checks retain the local estimate rather than disabling their
 limits.
 
 For llama.cpp, `/v1/models` metadata is preserved when the server supplies it.
-Because stock llama.cpp exposes chat-template effort support per loaded model,
 UR also resolves the model currently under the Up/Down cursor through
-`/props?model=<id>`. Left/Right is enabled only after that focused template
-advertises `supports_reasoning_effort`; the selected value is then sent
-unchanged in `reasoning_effort`. This works with llama.cpp router/cluster mode
-and does not assume that port 8080 limits UR to one worker.
+`/props?model=<id>`. `supports_reasoning_effort` establishes template support,
+but current llama.cpp does not expose the accepted value set through that flag,
+so it does not by itself enable Left/Right. Exact effort metadata from the
+model endpoint still enables the corresponding selectors and is sent unchanged
+as `reasoning_effort`. This works with llama.cpp router/cluster mode and does
+not assume that port 8080 limits UR to one worker.
 
 ### Provider-aware research calls
 
@@ -271,7 +309,7 @@ error, not a successful `Did 0 searches` result.
 When you select a UR-native provider and model, every agent request is routed
 through that provider's backend:
 
-- **API providers** make direct HTTP calls in each provider's native wire format: Anthropic uses `x-api-key` + `anthropic-version` against `/v1/messages`; OpenAI uses `Authorization: Bearer` against `/v1/chat/completions` by default or `/v1/responses` when explicitly selected; Gemini uses `x-goog-api-key` against `…:generateContent`; OpenRouter uses its OpenAI-compatible chat endpoint.
+- **API providers** make direct HTTP calls in each provider's native wire format: Anthropic uses `x-api-key` + `anthropic-version` against `/v1/messages`; OpenAI uses `Authorization: Bearer` against `/v1/chat/completions` by default or `/v1/responses` when explicitly selected; Gemini uses `x-goog-api-key` against `…:generateContent`; OpenRouter and NVIDIA NIM use their OpenAI-compatible chat endpoints.
 - **Local/server providers** connect to the configured local or OpenAI-compatible endpoint (`/v1/chat/completions` for LM Studio, llama.cpp and vLLM; the native tags/chat API for Ollama)
 - **Subscription CLI providers** (Codex CLI, Claude Code, Gemini CLI,
   Antigravity) dispatch the turn through the vendor's official CLI using your
@@ -382,6 +420,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 |
 | 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 |
@@ -408,6 +447,7 @@ provider's successful live catalog remains authoritative for that account.
 - `anthropic-api` — requires `ANTHROPIC_API_KEY`
 - `gemini-api` — requires `GEMINI_API_KEY`
 - `openrouter` — requires `OPENROUTER_API_KEY`
+- `nvidia-nim` — requires `NVIDIA_API_KEY` for build.nvidia.com; endpoint is configurable
 
 **Local/server providers** require local runtime or endpoint:
 - `ollama` — configurable local, LAN, or hosted Ollama server
@@ -540,6 +580,7 @@ Provider config and doctor commands accept canonical IDs and common aliases:
 | `anthropic-api` | `anthropic`, `claude api` |
 | `gemini-api` | `gemini api`, `google gemini api` |
 | `openrouter` | `openrouter api` |
+| `nvidia-nim` | `nvidia`, `NVIDIA Build`, `nvidia api`, `nim` |
 | `openai-compatible` | `compatible`, `openai compatible` |
 | `ollama` | `ollama local` |
 | `lmstudio` | `LM Studio`, `lm-studio` |
@@ -580,6 +621,7 @@ OPENAI_COMPATIBLE_API_KEY=...
 ANTHROPIC_API_KEY=...
 GEMINI_API_KEY=...
 OPENROUTER_API_KEY=...
+NVIDIA_API_KEY=...
 OLLAMA_API_KEY=...             # optional for authenticated Ollama gateways
 LMSTUDIO_API_KEY=...           # optional when the endpoint requires it
 LLAMA_CPP_API_KEY=...          # optional when the endpoint requires it
@@ -599,6 +641,32 @@ ur config set model local-model-name
 `OPENAI_API_KEY`; selecting an arbitrary compatible base URL never forwards
 the OpenAI credential to that host.
 
+The compatible provider's key is optional and provider-scoped. Add or replace
+it with `ur connect openai-compatible`, `/connect openai-compatible`, or `K`
+in the `/model` model screen. Anonymous endpoints continue to work without it.
+
+### NVIDIA NIM / build.nvidia.com
+
+NVIDIA NIM is a UR-native, OpenAI-compatible provider with live discovery:
+
+```sh
+echo "$NVIDIA_API_KEY" | ur connect nvidia-nim
+ur config set provider nvidia-nim
+ur provider doctor nvidia-nim
+# Optional self-hosted/enterprise gateway:
+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
+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).
+
 Local/server providers use their normal endpoints:
 
 - Ollama: `http://localhost:11434`
@@ -655,6 +723,7 @@ Required variables:
 | --- | --- | --- |
 | OpenAI-compatible | `OPENAI_COMPATIBLE_BASE_URL`, `OPENAI_COMPATIBLE_MODEL` | `OPENAI_COMPATIBLE_API_KEY` |
 | Unsloth | `UNSLOTH_API_KEY`, `UNSLOTH_MODEL` | `UNSLOTH_BASE_URL` (defaults to `http://localhost:8888/v1`) |
+| NVIDIA NIM | `NVIDIA_API_KEY`, `NVIDIA_MODEL` | `NVIDIA_BASE_URL` (defaults to `https://integrate.api.nvidia.com/v1`) |
 | OpenAI | `OPENAI_API_KEY`, `OPENAI_MODEL` | `OPENAI_BASE_URL` |
 | OpenRouter | `OPENROUTER_API_KEY`, `OPENROUTER_MODEL` | `OPENROUTER_BASE_URL` |
 | Anthropic | `ANTHROPIC_API_KEY`, `ANTHROPIC_MODEL` | `ANTHROPIC_BASE_URL` |

package/documentation/app.js

@@ -68,8 +68,8 @@ const featureGroups = [
   {
     title: 'Providers and auth',
     tags: ['subscription', 'API', 'local', 'effort', 'status bar'],
-    text: 'UR-native API/local/OpenAI-compatible runtimes, provider-scoped endpoints, provider-only Unsloth inference, capability-driven reasoning effort, responsive OpenRouter routing, first-class subscription CLI providers dispatched through the official vendor CLIs, provider doctor checks, secure API-key connect, non-secret config, fallback hints, and provider-aware status-bar output.',
-    commands: ['ur provider list', 'ur provider status', 'ur provider doctor agy', 'ur connect status', 'ur config set provider openai-api', 'ur config set provider ollama', 'ur config set base_url llama.cpp http://localhost:9931/v1', '/effort ultra', '/thinking on'],
+    text: 'UR-native API/local/OpenAI-compatible runtimes, provider-scoped endpoints, live NVIDIA NIM and provider-only Unsloth inference, optional compatible-gateway keys, capability-driven reasoning effort, responsive OpenRouter routing, first-class subscription CLI providers dispatched through the official vendor CLIs, provider doctor checks, secure API-key connect, non-secret config, fallback hints, and provider-aware status-bar output.',
+    commands: ['ur provider list', 'ur provider status', 'ur provider doctor agy', 'ur connect status', 'ur config set provider nvidia-nim', 'ur config set provider openai-api', 'ur config set provider ollama', 'ur config set base_url llama.cpp http://localhost:9931/v1', '/effort ultra', '/thinking on'],
   },
   {
     title: 'Security and operations',
@@ -548,7 +548,7 @@ const slashGroups = [
   {
     title: 'Models, tools, and interop',
     items: ['/model', '/provider', '/effort', '/thinking', '/fast', '/model-doctor', '/model-route', '/escalate', '/mcp', '/plugin', '/skills', '/skill', '/sdk', '/a2a-card'],
-    text: 'Pick providers and models, cycle only capability-backed effort selectors or provider-native boolean thinking, inspect capabilities, manage MCP/plugin extensions, browse prompt skills with /skills, run executable workflows with /skill, and expose interop surfaces.',
+    text: 'Pick providers and models, cycle only capability-backed effort selectors or a verified provider-native thinking toggle, inspect capabilities, manage MCP/plugin extensions, browse prompt skills with /skills, run executable workflows with /skill, and expose interop surfaces.',
   },
   {
     title: 'Security operations',

package/documentation/index.html

@@ -45,7 +45,7 @@
     <main id="content" class="content">
       <header class="topbar">
         <div>
-          <p class="eyebrow">Version 1.84.0</p>
+          <p class="eyebrow">Version 1.84.2</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>
@@ -165,6 +165,7 @@ ur provider doctor agy</code></pre>
             <h3>API and local providers</h3>
             <pre><code>ur config set provider openai-compatible
 ur config set provider openai-api
+ur config set provider nvidia-nim
 ur config set base_url ollama http://localhost:11434
 ur config set base_url llama.cpp http://localhost:9931/v1
 ur config set provider unsloth
@@ -172,15 +173,15 @@ 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, and API gateways restores the matching address. OpenAI Responses is opt-in and privacy-first; Chat Completions remains the default. Unsloth is an authenticated inference provider only.</p>
+            <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>
           </article>
           <article>
             <h3>Capability-driven reasoning effort</h3>
             <pre><code>/effort ultra
 /thinking on
 ur --model kimi-k3:cloud --effort high
-/model  # Up/Down model · Left/Right effort or boolean thinking · Enter apply</code></pre>
-            <p>The normalized vocabulary is <code>minimal</code>, <code>low</code>, <code>medium</code>, <code>high</code>, <code>xhigh</code>, <code>max</code>, and <code>ultra</code>; <code>/effort auto</code> clears an explicit choice. UR lists only capability-backed selectors it can map to the focused model's provider-native levels. <code>max</code> resolves to the highest supported non-Ultra tier. Ultra appears only for native <code>ultra</code>, advertised <code>max</code>/<code>xhigh</code>, or an explicit provider alias; the picker shows translations such as <code>ultra→max</code> and sends that exact provider value. Models that top out at <code>high</code>, boolean-thinking models, and unknown capabilities do not get Ultra. For boolean-thinking models on runtimes with a native toggle, Left selects off, Right selects on, and <code>t</code> toggles; <code>/thinking on|off</code> is the direct control. A graded <code>/effort</code> request on such a model enables thinking while reporting that no graded value was sent. Generic OpenAI-compatible runtimes receive no invented boolean field.</p>
+/model  # Up/Down model · Left/Right effort or thinking on/off · Enter apply</code></pre>
+            <p>The normalized vocabulary is <code>minimal</code>, <code>low</code>, <code>medium</code>, <code>high</code>, <code>xhigh</code>, <code>max</code>, and <code>ultra</code>; <code>/effort auto</code> clears an explicit choice. UR lists only capability-backed selectors it can map to the focused model's provider-native levels. <code>max</code> resolves to the highest supported non-Ultra tier. Ultra appears only for native <code>ultra</code>, advertised <code>max</code>/<code>xhigh</code>, or an explicit provider alias; the picker shows translations such as <code>ultra→max</code> and sends that exact provider value. Models that top out at <code>high</code>, lack an advertised beyond-high value, or have unknown capabilities do not get Ultra. For models with thinking but no advertised graded ladder on runtimes with a native toggle, Left selects off, Right selects on, and <code>t</code> toggles; <code>/thinking on|off</code> is the direct control. A graded <code>/effort</code> request on such a model enables thinking while reporting that no graded value was sent. Focused vLLM models use non-generating <code>/server_info</code> discovery for the documented <code>minimal→none|low|medium|high</code> mapping; llama.cpp's bare support flag creates no invented ladder. Generic OpenAI-compatible runtimes receive no invented boolean field.</p>
           </article>
           <article>
             <h3>OpenRouter responsive routing</h3>
@@ -188,6 +189,25 @@ ur --model kimi-k3:cloud --effort high
 /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>
           </article>
+          <article>
+            <h3>NVIDIA NIM and compatible API keys</h3>
+            <pre><code>ur connect nvidia-nim
+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>
+          </article>
+          <article>
+            <h3>Portable shell deadlines</h3>
+            <pre><code>timeout 60 long-command
+# or use the Bash tool timeout field in milliseconds</code></pre>
+            <p>Generated Linux-style timeout commands also work on macOS. UR uses Homebrew <code>gtimeout</code> when present or supplies a process-group-aware compatibility command with status 124 on expiry; it does not modify your shell profile.</p>
+          </article>
+          <article>
+            <h3>Tool images across providers</h3>
+            <pre><code>Computer screenshot → tool result → vision model</code></pre>
+            <p>Every UR-native provider preserves image-bearing tool output in its valid wire shape. OpenRouter, NVIDIA NIM, and other Chat-Completions backends keep the tool result textual and send the image in the next multimodal user turn; Gemini, OpenAI Responses, Anthropic, and Ollama use their native rich forms. Vision still depends on the selected model.</p>
+          </article>
           <article>
             <h3>Status bar and updates</h3>
             <pre><code>Ollama | llama3 | ask | main | update available</code></pre>

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

@@ -7,7 +7,7 @@ plugins {
 }
 
 group = "dev.urnexus"
-version = "1.84.0"
+version = "1.84.2"
 
 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.0",
+  "version": "1.84.2",
   "publisher": "ur-nexus",
   "engines": {
     "vscode": "^1.92.0"

package/package.json

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