pi-nebius 0.3.0 → 0.3.2

package/CHANGELOG.md

@@ -3,6 +3,22 @@
 Versions use Semantic Versioning. Entries describe changes included in the named version;
 a version is released only when its matching Git tag and GitHub release are published.
 
+## [0.3.2](https://github.com/PeterHdd/pi-nebius/compare/v0.3.1...v0.3.2) (2026-09-17)
+
+
+### Bug Fixes
+
+* launch benchmark workers from installed packages ([f7e717a](https://github.com/PeterHdd/pi-nebius/commit/f7e717a3454ae700451e63f54d78bda1d155d1dd))
+* launch benchmark workers from installed packages ([cf516f7](https://github.com/PeterHdd/pi-nebius/commit/cf516f724d0d85ce921e4b0a6347bdcb6b251493))
+
+## [0.3.1](https://github.com/PeterHdd/pi-nebius/compare/v0.3.0...v0.3.1) (2026-09-17)
+
+
+### Bug Fixes
+
+* enable automated npm publishing and simplify user documentation ([a90b4a4](https://github.com/PeterHdd/pi-nebius/commit/a90b4a40ce7d5bdc8bf8bddb7dc4777c4c68a269))
+* enable automated npm publishing and simplify user documentation ([81b6348](https://github.com/PeterHdd/pi-nebius/commit/81b6348f9710d786ff6f8ae18b56716e8c594e73))
+
 ## [0.3.0](https://github.com/PeterHdd/pi-nebius/compare/v0.2.1...v0.3.0) (2026-09-17)
 
 

package/CONTRIBUTING.md

@@ -17,8 +17,8 @@ with the tested Pi peers. Both require network access. Tests need loopback socke
 and permission to launch/stop subprocesses. Do not provide live API keys to CI.
 
 Keep changes focused and add regression tests for behavior changes. Use a descriptive
-commit message; no special commit syntax or automatic version inference is required.
-Update the changelog for user-visible changes. Report whether a test used mocks or
+Conventional Commit message (`feat:`, `fix:`, `docs:`, or `chore:`). Release Please
+generates the version and changelog; do not bump them manually. Report whether a test used mocks or
 live Nebius; a scripted tool loop is not a hosted-model benchmark.
 
 Never commit credentials, `.env` files, private fixtures, `node_modules`, or generated
@@ -26,7 +26,10 @@ benchmark results. The secret scanner scans Git-visible files and history, so a
 credential committed and later deleted must still be revoked and removed from history.
 
 Release Please generates changelog/version updates in a release PR; merging it publishes
-the GitHub release after CI passes. Changes to workflow permissions,
+the GitHub release after CI passes. The **Publish to npm** workflow then verifies the
+tagged release and publishes the same version to npm with provenance. README updates
+on npm ship with the next package version; pushing documentation alone does not publish.
+Changes to workflow permissions,
 tool checksum pins, dependency lockfiles, and authentication deserve particular review.
 
 PR descriptions are maintained by the **PR description** workflow. Write meaningful
@@ -37,3 +40,24 @@ when CI runs. Add context or live-testing evidence under Notes, outside the
 alone. It uses the built-in GitHub token; no additional secret or AI service is needed.
 It becomes active after the workflow reaches the default branch. For existing PRs
 without markers, it appends its generated section without deleting your description.
+
+
+## npm trusted publishing setup
+
+In the npm settings for `pi-nebius`, add a **GitHub Actions** trusted publisher:
+
+- Organization or user: `PeterHdd`
+- Repository: `pi-nebius`
+- Workflow filename: `publish.yml`
+- Environment: leave blank
+- Allowed actions: enable direct publishing with `npm publish`
+
+No npm token is required. Keep `RELEASE_PLEASE_TOKEN` configured: it allows the
+GitHub release created by Release Please to trigger the publishing workflow.
+See [npm trusted publishing](https://docs.npmjs.com/trusted-publishers/).
+
+After merging a change, wait for CI and merge the generated release PR. Once the
+GitHub release appears, check **Actions → Publish to npm**. If publishing fails,
+fix the configuration and rerun the failed workflow. npm versions are immutable;
+an already published version cannot be replaced. Do not republish `0.3.0` to update
+its README: use the next Release Please version.

package/README.md

@@ -1,30 +1,17 @@
 # pi-nebius
 
-Nebius Token Factory models in Pi's normal model picker, discovered using your API key.
+Use Nebius Token Factory models in Pi and compare them on coding tasks directly inside your session.
 
-This package also includes **benchmarks inside Pi**: run `/nebius-benchmark` to enter your own task prompt and compare models on copies of your current project. Results appear in Pi. A standalone CLI also supports scripted tasks and deterministic validation. See [Benchmarking](docs/benchmarking.md) for the CLI, result schema, metrics, and four ready-to-run fixtures.
+- Discover the models available to your Nebius account.
+- Save per-model temperature, reasoning, and output-token settings.
+- Benchmark models on your own prompt or a bundled coding task.
+- Compare correctness, token usage, completion time, and time to first token.
 
-```bash
-npm ci
-npm run build
-npm run benchmark -- --benchmark benchmarks/fix-auth-bug \
-  --models 'EXACT_MODEL_ID_A,EXACT_MODEL_ID_B' --runs 3 \
-  --output benchmark-results/auth-comparison
-```
-
-Results appear directly in the terminal: each run prints its pass/fail status, followed by a comparison table of success counts, mean input/output tokens, median task duration, observed time to first token (TTFT), end-to-end output throughput, turns, and tool calls. Detailed JSON reports, traces, and workspaces are also saved under `benchmark-results/`; `--output` chooses the directory.
-
-Set `NEBIUS_API_KEY` first. `npm run benchmark:demo` exercises the real Pi runner with scripted model responses, without credentials.
-
-```text
-Pi → pi-nebius → https://api.tokenfactory.nebius.com/v1 → model
-```
+Requires **Node.js 22.19+** and **Pi 0.85.1 or a compatible newer version**.
 
-Requires **Node.js 22.19+ and Pi 0.85.1** (the tested version). This targets the current `@earendil-works` Pi packages, not older `@mariozechner` releases. Pi's package instructions require wildcard peer dependencies; that is not a claim that every Pi version is compatible.
+## Install
 
-## Installation
-
-With Pi already installed:
+With Pi already installed, run in your terminal:
 
 ```bash
 pi install npm:pi-nebius
@@ -32,208 +19,155 @@ export NEBIUS_API_KEY="your-api-key"
 pi
 ```
 
-Run `/model`, search for `nebius`, and select a model.
-
-From this checkout:
+Get your API key from [Nebius Token Factory](https://tokenfactory.nebius.com/).
+Add the export to your shell profile if you want it available in future terminals.
+Restart Pi after changing the key.
 
-```bash
-cd /path/to/pi-nebius
-npm ci
-pi install /absolute/path/to/pi-nebius
-```
+Inside Pi, run `/model`, search for `nebius`, and choose a model.
 
-Or try it without adding it to Pi's settings:
-
-```bash
-pi -e /absolute/path/to/pi-nebius
-```
-
-The provider uses Pi's `pi.extensions` manifest and loads TypeScript directly. Pi installs Git packages with `npm install --omit=dev`; the extension needs no build step. To use the benchmark CLI from a source checkout, run `npm ci` and `npm run build` to generate `dist/`. YAML is the benchmark definition parser; neither component needs a separate server.
-
-GitHub installation is also supported:
+You can also install from GitHub:
 
 ```bash
 pi install git:github.com/PeterHdd/pi-nebius
 ```
 
-Git installs require no compiler or development dependencies. Benchmark development uses a separate source checkout with development dependencies installed. Append a published tag (for example, `@v0.3.0`) to pin a Git installation; install a newer tag explicitly to upgrade.
+## Model settings
 
-See [CONTRIBUTING.md](CONTRIBUTING.md), [CHANGELOG.md](CHANGELOG.md), and [SECURITY.md](SECURITY.md).
+Open the settings menu inside Pi:
 
-## Authentication and usage
-
-```bash
-export NEBIUS_API_KEY="your-key"
-pi
+```text
+/nebius-model
 ```
 
-Inside Pi, run `/model` and search for `nebius`. Choose an exact model from the discovered list. Provider ID: `nebius`; display name: `Nebius Token Factory`. Nebius IDs such as `vendor/model` remain unchanged; Pi identifies the pair as `nebius/vendor/model`.
+Choose a model to configure:
 
-You can also inspect the catalog and select a model explicitly:
+| Setting | What it controls |
+| --- | --- |
+| Temperature | Response variability, from 0 to 2, where supported. |
+| Reasoning effort | The model's reasoning effort, where supported. |
+| Maximum output tokens | The response-length limit. |
+| Advanced: context window | The context limit Pi uses for the model. |
+| Advanced: reasoning support | Whether Pi treats the model as reasoning-capable. |
 
-```bash
-pi --list-models nebius
-pi --provider nebius --model 'EXACT_ID_FROM_THE_LIST'
-```
+You can open a specific model directly with `/nebius-model MODEL_ID`.
 
-`/nebius-refresh` forces discovery again and updates Pi's registered models. If a selected model was removed, use `/model` to choose a current one.
+Settings are saved across restarts and apply to new requests. Choose **Inherit**, clear a numeric
+value, or use **Reset all overrides** to restore defaults. A saved reasoning effort takes precedence
+over Pi's `/thinking` setting.
 
-The extension reads `NEBIUS_API_KEY` at startup for discovery and resolves it through Pi's native authentication interface for inference. It has no `/login` flow and never writes the key to a file. Set the variable in the shell that launches Pi; changing a parent shell's environment cannot change an already-running process. Restart Pi after changing it. Pi's explicit CLI/runtime authentication overrides remain Pi features, but discovery specifically requires `NEBIUS_API_KEY`.
+Use values supported by the chosen model. Advanced settings change Pi's configuration, not the
+model's actual capabilities. The default output limit is up to 4,096 tokens; increase it in the menu
+if your model supports longer responses.
 
 ## Benchmark inside Pi
 
-After installing the extension, run this inside Pi:
+To benchmark your selected Nebius model on your own task:
 
 ```text
 /nebius-benchmark
 ```
 
-An editor asks for your own task prompt. The benchmark uses your selected Nebius model and a copy of the project directory where Pi is running. To compare models, supply their exact IDs:
-
-```text
-/nebius-benchmark --models zai-org/GLM-5.3,moonshotai/Kimi-K2.6 --runs 3
-```
-
-This runs the same prompt three times per model, sequentially, starting from the same project snapshot each time. It shows progress and a comparison of input/output tokens, task duration, observed TTFT, output throughput, turns, and tools directly in Pi. Custom prompts report **correctness not checked**; completion does not prove the task was solved.
+Enter your prompt in the editor. Run Pi from the project directory you want the models to work on.
 
-The snapshot includes current working files, including uncommitted changes, and respects Git ignores. It excludes `.git`, `.pi`, dependency/build folders, prior benchmark results, `.env` files, and `.pem`/`.key` files. Dependencies are not preinstalled; include setup instructions in your task if needed. Links and special files are rejected. Snapshots are limited to 10,000 files / 50 MiB. Run Pi from the project directory you want to benchmark.
-
-Runs use paid inference. Tools have normal host permissions: file copies are not an OS sandbox. Reports and each run's resulting files are retained under `benchmark-results/` in your project.
+To compare two models, once each:
 
 ```text
-/nebius-benchmark cancel
-/nebius-benchmark help
+/nebius-benchmark --models moonshotai/Kimi-K2.6,deepseek-ai/DeepSeek-V4-Flash-0731 --runs 1
 ```
 
-For an optional bundled coding task with automatic correctness tests:
+Use exact model IDs from your `/model` list. Increase `--runs` to repeat the task for each model.
+Runs execute one at a time, each starting from a fresh copy of the same project.
+
+For a bundled task with automatic correctness tests:
 
 ```text
-/nebius-benchmark --task fix-auth-bug --runs 3
+/nebius-benchmark --task fix-auth-bug --models moonshotai/Kimi-K2.6,deepseek-ai/DeepSeek-V4-Flash-0731 --runs 1
 ```
 
-Other bundled tasks: `add-api-endpoint`, `refactor-module`, and `multi-file-feature`. No build step or separate terminal is needed for these Pi commands.
+Available tasks:
 
-## Dynamic model discovery
-
-The async extension factory calls authenticated `GET /v1/models?verbose=true` before Pi finishes startup. This is the documented verbose variant of `/v1/models`, supplying metadata in addition to IDs. There is **no bundled model catalog**.
-
-| Nebius field | Pi mapping |
+| Task | Work to complete |
 | --- | --- |
-| `id` | Exact, case-sensitive `model.id` |
-| `name` | Display name; defaults to ID |
-| `context_length` | `contextWindow`; defaults to 32,768 when absent/invalid |
-| `architecture.modality` | Text/image inputs; known non-text-output models are excluded |
-| `status` | Only `active` or unspecified models are included |
-| `supported_sampling_parameters` contains `reasoning_effort` | Enables reasoning and Pi's standard reasoning-effort control |
-| `supported_features` contains `reasoning` | Marks reasoning support without assuming an effort control |
-| No documented maximum output length | `maxTokens`: 4,096, capped at a quarter of the context window |
-
-Basic responses containing only IDs are supported. Missing capabilities default to text-only with no explicit reasoning control. Without modality metadata, the endpoint may include models unsuitable for chat; discovery cannot prove tool support. Pick a tool-capable model and run the integration test. Duplicate IDs are deduplicated; malformed lists are rejected rather than silently replacing a good cache with partial data.
+| `fix-auth-bug` | Fix refresh-token expiry handling. |
+| `add-api-endpoint` | Add an API endpoint. |
+| `refactor-module` | Refactor an existing module. |
+| `multi-file-feature` | Implement a feature across multiple files. |
 
-### Cache and offline fallback
+Results appear directly in Pi:
 
-The cache is under `getAgentDir()/cache/pi-nebius/` (normally `~/.pi/agent/cache/pi-nebius/`). Pi's `PI_CODING_AGENT_DIR` override is respected. Files contain normalized metadata and a timestamp, never the API key. Names use a SHA-256 fingerprint of the endpoint and key to avoid sharing one account's catalog with another key.
-
-- Fresh metadata is used for 24 hours without a discovery request.
-- Stale/missing metadata triggers one request, with an 8-second timeout and a 4 MiB response limit.
-- Transient failures use stale metadata and display a warning. No cache means no discovered models; Pi continues running.
-- A 401/403 invalidates this key's cache. A fresh cache does not validate credentials; inference can still reject a revoked key.
-- Successful refresh replaces the catalog, including an authoritative empty list. Failed refresh never updates the cache timestamp.
-- Cache writes are atomic and best-effort, with private directory/file permissions. Concurrent Pi processes may each perform discovery; there is no background service or cross-process lock.
-
-Pi now has a shared native model store, but its general provider-level cache is not scoped by the discovery key. This small extension-owned cache makes key isolation explicit and guarantees discovery before model selection. It does not participate in Pi's general remote-catalog refresh; use `/nebius-refresh` or restart Pi.
-
-### Per-model settings
-
-Run `/nebius-model` to choose a discovered model, or `/nebius-model MODEL_ID` to open it directly.
-The menu saves temperature, reasoning effort, and maximum output tokens separately for each model.
-Blank numeric values or **Inherit** restore defaults; **Reset all overrides** clears that model's settings.
-Advanced settings let you override the context window and reasoning capability metadata. These do not
-change the server's capabilities. Use verified limits; the default output limit remains 4,096 tokens
-when the catalog does not provide a documented output limit.
-
-Temperature and reasoning-effort overrides are sent only when discovery advertises support.
-An advertised parameter does not guarantee every value is supported by every model; use its documented values.
-Saved request values take precedence over Pi's generated values (including `/thinking` for reasoning effort).
-Changes apply to new requests immediately and survive restarts in
-`~/.pi/agent/pi-nebius/model-settings.json` (respecting `PI_CODING_AGENT_DIR`).
-`/nebius-refresh` preserves saved overrides. External file edits require `/reload`.
+| Metric | Meaning |
+| --- | --- |
+| Validated success | Runs that passed the task's correctness tests. |
+| Input/output tokens | Average token usage per run, including all model requests. |
+| Task duration | Median time to complete a run. |
+| Observed TTFT | Median time from the first request to the first streamed text, reasoning, or tool content. |
+| Throughput | Output tokens per second across the whole task, including tools and validation. |
+| Agent turns / tool calls | Average number of turns and tool calls per run. |
 
-Both benchmark entry points use saved settings. In-Pi benchmarks snapshot them when the run starts,
-so changing the menu does not change an active comparison. Each run's `effectiveSettings` includes
-saved overrides, model limits, and `requestParameters`: the outgoing temperature, reasoning effort,
-output limit, and top-p where present, without prompt content. Omitted values mean the request did not
-specify them; server defaults are unknown. These parameters are in `results.json`, not the summary table.
+**Mean** means average; **median** means the middle value after sorting (the average of the two
+middle values for an even number of runs). With one run, both show that run's measurement.
+Failed runs contribute to the performance metrics; missing measurements appear as `n/a`.
+Custom prompts have no automatic correctness check, so a completed run does not establish success.
 
-### Metadata overrides and user-defined fallback models
+Detailed results, request settings, and resulting files are saved under `benchmark-results/`.
+Benchmarks use your saved model settings at the start; later changes do not affect an active comparison.
 
-Merge the `nebius` provider entry from [examples/models.json](examples/models.json) into `~/.pi/agent/models.json`, replacing the placeholder ID and limits with verified values. Do not overwrite unrelated providers. The extension must remain installed.
+Project copies include uncommitted changes and respect Git ignores. Dependencies, build output,
+previous results, `.env`, and `.pem`/`.key` files are excluded. Include dependency setup in your prompt
+if needed. Projects are limited to 10,000 files / 50 MiB; symlinks and special files are not supported.
 
-Use `modelOverrides` to adjust discovered models and `models` to add explicit models that remain available when discovery is offline. Native providers are composed beneath these settings by Pi. No `apiKey` field is needed in this configuration. Explicitly configured models remain until you remove them, even if the server no longer lists them.
+Benchmarks use your Nebius account and incur inference charges. Model tools retain normal access to
+your machine; project copies are not a security sandbox.
 
+To stop a benchmark or view help:
 
-For reasoning models, verify the model's Nebius-specific behavior before overriding `reasoning`, `thinkingLevelMap`, or `compat`. Pi supports model-specific template controls, but this extension does not guess them from model names. Always-on reasoning may still appear in Pi even when explicit effort selection is unavailable.
+```text
+/nebius-benchmark cancel
+/nebius-benchmark help
+```
 
-## Architecture and compatibility
+See [Benchmarking](docs/benchmarking.md) for custom validated tasks and scripted CLI usage.
 
-`src/index.ts` is Pi's async extension factory. It registers a native provider with `pi.registerProvider(provider)`, adds `/nebius-refresh`, and supplies provider-specific error guidance through `message_end`.
+## Refresh and update
 
-`src/provider.ts` uses Pi's `createProvider()` and its exported `openAICompletionsApi()` adapter. Pi owns request/message serialization, SSE parsing, multi-turn conversation state, function calls/results, usage accounting, abort handling, retries, and the tool loop. A small fetch decorator retains retry/rate-limit/request-ID headers on HTTP errors; successful response streams pass through unchanged.
+Refresh the list of available Nebius models inside Pi:
 
-Compatibility settings select `system` messages and `max_tokens`, request streamed usage, and disable unsupported assumptions about `store`, strict tools, grammar tools, and reasoning effort. These are model-level properties and can be overridden through Pi.
+```text
+/nebius-refresh
+```
 
+Model lists are cached for up to 24 hours. Refreshing preserves your saved settings.
 
-## Testing
+For an npm installation, update from your terminal:
 
 ```bash
-npm ci
-npm run typecheck
-npm run lint
-npm test
+pi update npm:pi-nebius
 ```
 
-Tests cover model parsing/mapping, discovery errors, missing credentials, cache behavior, native authentication, and Pi's actual extension loader. Adapter tests use Pi itself with mocked HTTP responses. The CLI integration test starts a local HTTP server, loads this package in the real Pi CLI, checks `--list-models`, executes a streamed `write` call, checks the generated file, and verifies that the next request contains the tool result. It also checks cache reuse and `models.json` composition. These tests do not require or use a real Nebius key.
-
-### Manual live integration test
-
-In a scratch directory, start Pi, select a tool-capable Nebius model with `/model`, then ask:
-
-> Create a file called nebius-test.txt containing 'Hello from Nebius'.
-
-Verify that Pi shows a successful write-tool execution, the file contains the expected text, and the model responds after receiving the tool result. Check Token Factory's usage view for the request. Ordinary text claiming the file was created is not sufficient.
-
-An opt-in automated equivalent runs a real Pi CLI in a temporary directory, limits its tools to `write`, requires an actual tool event and final response, checks exact file contents, and cleans up afterward:
+For a GitHub installation:
 
 ```bash
-export NEBIUS_API_KEY="your-key"
-export NEBIUS_MODEL="EXACT_TOOL_CAPABLE_MODEL_ID"
-npm run test:live
+pi update git:github.com/PeterHdd/pi-nebius
 ```
 
-This makes paid inference requests and has a three-minute timeout. It is not part of `npm test`. See [docs/validation.md](docs/validation.md) for what has actually been run.
+Then run `/reload` inside Pi, or restart it.
 
 ## Troubleshooting
 
-| Problem | Action |
+| Problem | What to do |
 | --- | --- |
-| Missing API key | Run `export NEBIUS_API_KEY="..."` in the launching shell and restart Pi. |
-| 401/403 | Token Factory rejected the key or project access. Check the key, permissions, and project; then restart Pi. |
-| Model unavailable / 404 | Run `/nebius-refresh`, then `/model`; remove obsolete explicit entries from `models.json`. |
-| 429 | Respect the preserved `retry-after` / rate-limit details. Pi handles its normal retry policy; discovery itself does not retry automatically. |
-| 5xx | Provider service failure. Retry later; discovery can use stale cached metadata. |
-| Connectivity / timeout | Check access to `api.tokenfactory.nebius.com` and Pi's network/proxy settings. Discovery times out after eight seconds. |
-| No models without a cache | Add an explicit verified model via the example configuration, or retry discovery once connectivity returns. |
-| Model talks but never uses tools | Verify that the chosen model supports functions on Nebius; run the live test or select another model. Discovery alone cannot certify this. |
-| Context/output limit errors | Set verified `contextWindow` and `maxTokens` in `modelOverrides`. Defaults are conservative assumptions, not guaranteed endpoint limits. |
-
-## Current limitations
-
-- Live Nebius inference has not been verified in the development environment because no API key was available. Mocked Pi integration tests prove adapter wiring and the tool loop, not every hosted model's capabilities.
-- Metadata availability and capability vocabulary vary. Reasoning/vision detection is conservative; model-specific thinking templates require explicit configuration and testing.
-- Maximum output limits are defaults; the verbose schema does not expose a documented equivalent of Pi's `maxTokens`.
-- Pi's adapter handles `stop`, `length`, and `tool_calls` finish reasons. Its generic stream options do not expose custom stop sequences; advanced extensions can use Pi's `onPayload` hook if needed. No new stop-sequence API is invented here.
-- The normal picker/listing integration is tested through Pi's CLI and registry. An interactive terminal screenshot/UI test was not performed.
-
-## License
-
-MIT; see [LICENSE](LICENSE).
+| Missing API key | Set `NEBIUS_API_KEY` in the terminal that launches Pi, then restart Pi. |
+| Authentication error (401/403) | Check your Nebius key and project permissions. |
+| Missing or unavailable model | Run `/nebius-refresh`, then choose a model with `/model`. |
+| Rate limit (429) | Wait before retrying or reduce request frequency. |
+| Server error (5xx) | Retry later. |
+| Connection timeout | Check your connection and access to `api.tokenfactory.nebius.com`. |
+| Output cut short | Open `/nebius-model` and adjust maximum output tokens within the model's supported limits. |
+| Model does not use tools | Select a model that supports tool calling. |
+| Benchmark validation failed | Read the failure details: the model's solution did not pass the task's tests. |
+
+## More information
+
+[Changelog](CHANGELOG.md) · [Contributing](CONTRIBUTING.md) · [Security](SECURITY.md)
+
+MIT licensed. See [LICENSE](LICENSE).

package/SECURITY.md

@@ -45,3 +45,11 @@ See [the review record](docs/security-review.md) for findings and residual limit
 The PR-description workflow uses `pull_request_target` and `workflow_run` only to
 read GitHub metadata and update the PR body with a scoped write token. It never
 checks out PR code, installs dependencies, or consumes workflow artifacts.
+
+
+npm publishing runs only for stable, published GitHub releases in this repository.
+The publishing workflow checks that the tagged commit belongs to `main`, verifies
+that the tag matches the package version, and runs tests and package checks before
+publishing. It uses npm trusted publishing with GitHub OIDC (`id-token: write`),
+not a stored npm token, and attaches provenance. Release Please's separate token
+is not passed to the npm publishing job.

package/dist/benchmark/command.js

@@ -5,6 +5,7 @@ import { tmpdir } from "node:os";
 import { dirname, join } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { parseArgs } from "node:util";
+import { Text } from "@earendil-works/pi-tui";
 import { MISSING_KEY } from "../discovery.js";
 import { applyModelSettings } from "../model-settings.js";
 import { loadDefinition, positive } from "./definition.js";
@@ -33,6 +34,15 @@ export async function hostPiEntry() {
     return join(dirname(manifestPath), manifest.main);
 }
 export function registerBenchmarkCommand(pi, getSettings = () => ({})) {
+    pi.registerMessageRenderer("nebius-benchmark", (message, options, theme) => {
+        const content = typeof message.content === "string"
+            ? message.content
+            : message.content
+                .filter((part) => part.type === "text")
+                .map((part) => part.text)
+                .join("\n");
+        return new Text(`${theme.fg("customMessageLabel", "[nebius-benchmark]")}\n\n${content}`, options.outputPad ?? 1, 0);
+    });
     let starting = false;
     let active;
     const show = (content) => pi.sendMessage({ customType: "nebius-benchmark", content, display: true }, { triggerTurn: false });
@@ -149,7 +159,7 @@ export function registerBenchmarkCommand(pi, getSettings = () => ({})) {
                     apiKey: key,
                     signal: controller.signal,
                     piEntry,
-                    workerPath: fileURLToPath(new URL(import.meta.url.endsWith(".ts") ? "./host-worker.ts" : "./host-worker.js", import.meta.url)),
+                    workerPath: fileURLToPath(new URL("./host-worker.mjs", import.meta.url)),
                     workerArgs: [piEntry],
                     onRun: (run) => {
                         ctx.ui.setStatus("nebius-benchmark", `Benchmark: ${task} (${++completed}/${total})`);

package/dist/benchmark/host-worker.mjs

@@ -0,0 +1,28 @@
+import { readFileSync } from "node:fs";
+import { registerHooks, stripTypeScriptTypes } from "node:module";
+import { pathToFileURL } from "node:url";
+// Reuse the installed host's SDK; Git installs intentionally omit Pi dev dependencies.
+const hostEntry = process.argv[2];
+if (!hostEntry)
+    throw new Error("Missing host Pi entry");
+const sourceRoot = new URL("../", import.meta.url).href;
+registerHooks({
+    // Node's automatic type stripping rejects installed sources under node_modules.
+    // This JavaScript bootstrap explicitly strips only this package's own sources.
+    load(url, context, nextLoad) {
+        if (url.startsWith(sourceRoot) && url.endsWith(".ts")) {
+            return {
+                format: "module",
+                source: stripTypeScriptTypes(readFileSync(new URL(url), "utf8"), { sourceUrl: url }),
+                shortCircuit: true,
+            };
+        }
+        return nextLoad(url, context);
+    },
+    resolve(specifier, context, nextResolve) {
+        if (specifier.startsWith("@earendil-works/"))
+            return nextResolve(specifier, { ...context, parentURL: pathToFileURL(hostEntry).href });
+        return nextResolve(specifier, context);
+    },
+});
+await import("./worker.js");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-nebius",
-  "version": "0.3.0",
+  "version": "0.3.2",
   "description": "Nebius Token Factory provider and agentic coding benchmarks for Pi",
   "repository": {
     "type": "git",
@@ -42,13 +42,15 @@
   },
   "peerDependencies": {
     "@earendil-works/pi-ai": "*",
-    "@earendil-works/pi-coding-agent": "*"
+    "@earendil-works/pi-coding-agent": "*",
+    "@earendil-works/pi-tui": "*"
   },
   "devDependencies": {
+    "@biomejs/biome": "^2.2.0",
     "@earendil-works/pi-ai": "0.85.1",
     "@earendil-works/pi-coding-agent": "0.85.1",
+    "@earendil-works/pi-tui": "0.85.1",
     "@types/node": "^22.0.0",
-    "@biomejs/biome": "^2.2.0",
     "tsx": "^4.20.0",
     "typescript": "^5.9.0"
   },

package/src/benchmark/command.ts

@@ -6,6 +6,7 @@ import { dirname, join } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { parseArgs } from "node:util";
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { Text } from "@earendil-works/pi-tui";
 import { MISSING_KEY } from "../discovery.ts";
 import { applyModelSettings, type ModelSettingsMap } from "../model-settings.ts";
 import type { NebiusModel } from "../models.ts";
@@ -42,6 +43,20 @@ export function registerBenchmarkCommand(
   pi: ExtensionAPI,
   getSettings: () => ModelSettingsMap = () => ({}),
 ) {
+  pi.registerMessageRenderer("nebius-benchmark", (message, options, theme) => {
+    const content =
+      typeof message.content === "string"
+        ? message.content
+        : message.content
+            .filter((part) => part.type === "text")
+            .map((part) => part.text)
+            .join("\n");
+    return new Text(
+      `${theme.fg("customMessageLabel", "[nebius-benchmark]")}\n\n${content}`,
+      options.outputPad ?? 1,
+      0,
+    );
+  });
   let starting = false;
   let active: { controller: AbortController; done: Promise<void> } | undefined;
   const show = (content: string) =>
@@ -168,12 +183,7 @@ export function registerBenchmarkCommand(
           apiKey: key,
           signal: controller.signal,
           piEntry,
-          workerPath: fileURLToPath(
-            new URL(
-              import.meta.url.endsWith(".ts") ? "./host-worker.ts" : "./host-worker.js",
-              import.meta.url,
-            ),
-          ),
+          workerPath: fileURLToPath(new URL("./host-worker.mjs", import.meta.url)),
           workerArgs: [piEntry],
           onRun: (run) => {
             ctx.ui.setStatus("nebius-benchmark", `Benchmark: ${task} (${++completed}/${total})`);

package/src/benchmark/host-worker.mjs

@@ -0,0 +1,28 @@
+import { readFileSync } from "node:fs";
+import { registerHooks, stripTypeScriptTypes } from "node:module";
+import { pathToFileURL } from "node:url";
+
+// Reuse the installed host's SDK; Git installs intentionally omit Pi dev dependencies.
+const hostEntry = process.argv[2];
+if (!hostEntry) throw new Error("Missing host Pi entry");
+const sourceRoot = new URL("../", import.meta.url).href;
+registerHooks({
+  // Node's automatic type stripping rejects installed sources under node_modules.
+  // This JavaScript bootstrap explicitly strips only this package's own sources.
+  load(url, context, nextLoad) {
+    if (url.startsWith(sourceRoot) && url.endsWith(".ts")) {
+      return {
+        format: "module",
+        source: stripTypeScriptTypes(readFileSync(new URL(url), "utf8"), { sourceUrl: url }),
+        shortCircuit: true,
+      };
+    }
+    return nextLoad(url, context);
+  },
+  resolve(specifier, context, nextResolve) {
+    if (specifier.startsWith("@earendil-works/"))
+      return nextResolve(specifier, { ...context, parentURL: pathToFileURL(hostEntry).href });
+    return nextResolve(specifier, context);
+  },
+});
+await import("./worker.ts");

package/dist/benchmark/host-worker.js

@@ -1,14 +0,0 @@
-import { registerHooks } from "node:module";
-import { pathToFileURL } from "node:url";
-// Reuse the installed host's SDK; Git installs intentionally omit Pi dev dependencies.
-const hostEntry = process.argv[2];
-if (!hostEntry)
-    throw new Error("Missing host Pi entry");
-registerHooks({
-    resolve(specifier, context, nextResolve) {
-        if (specifier.startsWith("@earendil-works/"))
-            return nextResolve(specifier, { ...context, parentURL: pathToFileURL(hostEntry).href });
-        return nextResolve(specifier, context);
-    },
-});
-await import("./worker.js");

package/src/benchmark/host-worker.ts

@@ -1,14 +0,0 @@
-import { registerHooks } from "node:module";
-import { pathToFileURL } from "node:url";
-
-// Reuse the installed host's SDK; Git installs intentionally omit Pi dev dependencies.
-const hostEntry = process.argv[2];
-if (!hostEntry) throw new Error("Missing host Pi entry");
-registerHooks({
-  resolve(specifier, context, nextResolve) {
-    if (specifier.startsWith("@earendil-works/"))
-      return nextResolve(specifier, { ...context, parentURL: pathToFileURL(hostEntry).href });
-    return nextResolve(specifier, context);
-  },
-});
-await import("./worker.ts");