pi-nebius 0.3.0

package/src/benchmark/worker.ts

@@ -0,0 +1,150 @@
+import type { ProviderStreams } from "@earendil-works/pi-ai";
+import {
+  createAgentSession,
+  DefaultResourceLoader,
+  ModelRuntime,
+  SessionManager,
+  SettingsManager,
+} from "@earendil-works/pi-coding-agent";
+import { requestSettings } from "../model-settings.ts";
+import { nebiusProvider } from "../provider.ts";
+import { Instrumentation, redactor } from "./instrumentation.ts";
+import type { WorkerInput, WorkerMessage } from "./types.ts";
+
+async function run(input: WorkerInput) {
+  const redact = redactor([input.apiKey]);
+  const send = (message: WorkerMessage) => {
+    if (process.connected) process.send?.(JSON.parse(redact(JSON.stringify(message))), () => {});
+  };
+  const start = performance.now();
+  const observer = new Instrumentation(
+    (observation) => send({ type: "observation", observation }),
+    () => performance.now() - start,
+    redact,
+  );
+  let session: Awaited<ReturnType<typeof createAgentSession>>["session"] | undefined;
+  let cancelled = false;
+  let error: string | null = null;
+  const settings = SettingsManager.inMemory();
+  const requests: Record<string, unknown>[] = [];
+  const effectiveSettings: Record<string, unknown> = {
+    modelOverrides: input.modelSettings ?? {},
+    modelLimits: { contextWindow: input.model.contextWindow, maxTokens: input.model.maxTokens },
+    requestParameters: requests,
+    configuration: settings.getGlobalSettings(),
+    tools: input.definition.tools,
+    compaction: settings.getCompactionSettings(),
+    retry: settings.getRetrySettings(),
+    providerRetry: settings.getProviderRetrySettings(),
+    thinkingLevel: settings.getDefaultThinkingLevel() ?? "medium",
+    resourcePolicy: "no external extensions, skills, context files, prompt templates, or themes",
+    sdkCwd: ".",
+  };
+  const abort = () => {
+    cancelled = true;
+    void session?.abort().catch(() => {});
+  };
+  process.on("message", (message) => {
+    if (message === "abort") abort();
+    if (message === "shutdown") process.exit(0);
+  });
+  process.on("SIGTERM", abort);
+  try {
+    const base = nebiusProvider(
+      [input.model],
+      { [input.model.id]: input.modelSettings ?? {} },
+      (payload) => {
+        requests.push(requestSettings(payload));
+        send({ type: "settings", effectiveSettings });
+      },
+    );
+    const baseStreams: ProviderStreams = base;
+    const provider = {
+      ...base,
+      // Key arrives over IPC, never in argv, config files, or child tool environments.
+      auth: {
+        apiKey: {
+          name: "NEBIUS_API_KEY",
+          async resolve() {
+            return { auth: { apiKey: input.apiKey }, source: "NEBIUS_API_KEY (ephemeral IPC)" };
+          },
+        },
+      },
+      stream: ((model, context, options) =>
+        baseStreams.stream(model, context, {
+          ...options,
+          fetch: observer.observeFetch(options?.fetch ?? globalThis.fetch),
+        })) as typeof base.stream,
+      streamSimple: ((model, context, options) =>
+        base.streamSimple(model, context, {
+          ...options,
+          fetch: observer.observeFetch(options?.fetch ?? globalThis.fetch),
+        })) as typeof base.streamSimple,
+    };
+    const runtime = await ModelRuntime.create({
+      authPath: `${input.agentDir}/auth.json`,
+      modelsPath: null,
+      modelsStorePath: `${input.agentDir}/models-store.json`,
+      allowModelNetwork: false,
+    });
+    const loader = new DefaultResourceLoader({
+      cwd: ".",
+      agentDir: input.agentDir,
+      settingsManager: settings,
+      noExtensions: true,
+      noSkills: true,
+      noPromptTemplates: true,
+      noThemes: true,
+      noContextFiles: true,
+      ...(input.definition.systemPrompt ? { systemPrompt: input.definition.systemPrompt } : {}),
+      extensionFactories: [
+        (pi) => {
+          pi.registerProvider(provider);
+          pi.on("before_agent_start", (event) => {
+            observer.systemPrompt(event.systemPrompt);
+          });
+        },
+      ],
+    });
+    await loader.reload();
+    if (loader.getExtensions().errors.length)
+      throw new Error("Pi could not load benchmark instrumentation");
+    ({ session } = await createAgentSession({
+      cwd: ".",
+      agentDir: input.agentDir,
+      modelRuntime: runtime,
+      model: input.model,
+      settingsManager: settings,
+      resourceLoader: loader,
+      sessionManager: SessionManager.inMemory("."),
+      tools: input.definition.tools,
+    }));
+    session.subscribe((event) => observer.onEvent(event));
+    effectiveSettings.effectiveThinkingLevel = session.thinkingLevel;
+    send({ type: "settings", effectiveSettings });
+    if (cancelled) throw new Error("Cancelled during Pi initialization");
+    await session.prompt(input.definition.task);
+  } catch (caught) {
+    error = redact(String(caught));
+  } finally {
+    session?.dispose();
+    await new Promise<void>((resolve) => {
+      if (!process.connected) {
+        resolve();
+        return;
+      }
+      process.send?.({ type: "done", error, effectiveSettings } satisfies WorkerMessage, () =>
+        resolve(),
+      );
+    });
+    // Parent cleans any detached tool descendants, then requests shutdown.
+  }
+}
+
+if (process.send)
+  process.once("message", (input: WorkerInput) => {
+    void run(input).catch(() => {
+      process.exitCode = 1;
+      process.disconnect?.();
+    });
+  });

package/src/benchmark/workspace.ts

@@ -0,0 +1,64 @@
+import { createHash } from "node:crypto";
+import { chmod, copyFile, lstat, mkdir, readdir, readFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+
+interface Entry {
+  path: string;
+  directory: boolean;
+  executable: number;
+}
+
+/** Reject links/special files rather than risk a copy retaining access to the source fixture. */
+async function treeEntries(root: string, prefix = ""): Promise<Entry[]> {
+  const rootInfo = await lstat(root);
+  if (rootInfo.isSymbolicLink() || !rootInfo.isDirectory())
+    throw new Error("Fixture root must be a real directory, not a symbolic link");
+  const files: Entry[] = [];
+  for (const name of (await readdir(join(root, prefix))).sort()) {
+    if (name === ".git") continue;
+    if (name === ".env" || name.startsWith(".env."))
+      throw new Error("Fixtures must not contain .env credential files");
+    const relative = prefix ? `${prefix}/${name}` : name;
+    const info = await lstat(join(root, relative));
+    if (info.isSymbolicLink() || (!info.isDirectory() && !info.isFile()))
+      throw new Error(
+        `Unsupported fixture entry: ${relative} (links/special files are not allowed)`,
+      );
+    files.push({ path: relative, directory: info.isDirectory(), executable: info.mode & 0o111 });
+    if (info.isDirectory()) files.push(...(await treeEntries(root, relative)));
+  }
+  return files;
+}
+export async function treeFiles(root: string): Promise<string[]> {
+  return (await treeEntries(root)).filter((entry) => !entry.directory).map((entry) => entry.path);
+}
+export async function hashTree(root: string): Promise<string> {
+  const digest = createHash("sha256");
+  for (const entry of await treeEntries(root)) {
+    const content = entry.directory ? Buffer.alloc(0) : await readFile(join(root, entry.path));
+    digest.update(
+      JSON.stringify([
+        entry.path,
+        entry.directory,
+        entry.directory ? 0 : entry.executable,
+        content.length,
+      ]),
+    );
+    digest.update(content);
+  }
+  return digest.digest("hex");
+}
+export async function copyTree(source: string, target: string) {
+  await mkdir(target, { recursive: true, mode: 0o700 });
+  for (const entry of await treeEntries(source)) {
+    const sourcePath = join(source, entry.path);
+    const targetPath = join(target, entry.path);
+    if (entry.directory) {
+      await mkdir(targetPath, { recursive: true, mode: 0o700 });
+      continue;
+    }
+    await mkdir(dirname(targetPath), { recursive: true, mode: 0o700 });
+    await copyFile(sourcePath, targetPath);
+    await chmod(targetPath, 0o600 | entry.executable);
+  }
+}

package/src/discovery.ts

@@ -0,0 +1,176 @@
+import { createHash, randomUUID } from "node:crypto";
+import { mkdir, readFile, rename, unlink, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { BASE_URL, isRecord, type NebiusModel, parseModels } from "./models.ts";
+
+export const MISSING_KEY = 'Nebius Token Factory: set export NEBIUS_API_KEY="..." and restart Pi.';
+const TTL_MS = 24 * 60 * 60 * 1000;
+const MAX_BYTES = 4 * 1024 * 1024;
+
+export class DiscoveryError extends Error {
+  constructor(
+    message: string,
+    readonly status?: number,
+  ) {
+    super(message);
+  }
+}
+
+export interface DiscoveryOptions {
+  apiKey?: string;
+  agentDir: string;
+  fetch?: typeof globalThis.fetch;
+  now?: number;
+  force?: boolean;
+  signal?: AbortSignal;
+}
+
+export interface DiscoveryResult {
+  models: NebiusModel[];
+  source: "network" | "cache" | "stale" | "none";
+  warning?: string;
+}
+
+export function cachePath(agentDir: string, apiKey: string): string {
+  const fingerprint = createHash("sha256").update(`${BASE_URL}\0${apiKey}`).digest("hex");
+  return join(agentDir, "cache", "pi-nebius", `${fingerprint}.json`);
+}
+
+async function readCache(
+  path: string,
+): Promise<{ checkedAt: number; models: NebiusModel[] } | undefined> {
+  try {
+    const raw = await readFile(path, "utf8");
+    if (Buffer.byteLength(raw) > MAX_BYTES) return undefined;
+    const value: unknown = JSON.parse(raw);
+    if (
+      !isRecord(value) ||
+      value.version !== 1 ||
+      typeof value.checkedAt !== "number" ||
+      !Number.isFinite(value.checkedAt) ||
+      !Array.isArray(value.models)
+    )
+      return undefined;
+    // Cache only normalized discovery fields, and remap through the same validation path.
+    return {
+      checkedAt: value.checkedAt,
+      models: parseModels({ object: "list", data: value.models }),
+    };
+  } catch {
+    return undefined;
+  }
+}
+
+async function writeCache(path: string, models: NebiusModel[], checkedAt: number): Promise<void> {
+  const temp = `${path}.${randomUUID()}.tmp`;
+  try {
+    await mkdir(dirname(path), { recursive: true, mode: 0o700 });
+    await writeFile(
+      temp,
+      JSON.stringify({
+        version: 1,
+        checkedAt,
+        models: models.map((model) => ({
+          id: model.id,
+          name: model.name,
+          context_length: model.contextWindow,
+          architecture: {
+            modality: model.input.includes("image") ? "text+image->text" : "text->text",
+          },
+          supported_features: model.reasoning ? ["reasoning"] : [],
+          supported_sampling_parameters: model.nebiusSupportedParameters ?? [],
+        })),
+      }),
+      { mode: 0o600, flag: "wx" },
+    );
+    await rename(temp, path);
+  } finally {
+    await unlink(temp).catch(() => {});
+  }
+}
+
+export async function discoverModels(options: DiscoveryOptions): Promise<DiscoveryResult> {
+  const key = options.apiKey?.trim();
+  if (!key) return { models: [], source: "none", warning: MISSING_KEY };
+  const path = cachePath(options.agentDir, key);
+  const cached = await readCache(path);
+  const now = options.now ?? Date.now();
+  if (!options.force && cached && now >= cached.checkedAt && now - cached.checkedAt < TTL_MS) {
+    return { models: cached.models, source: "cache" };
+  }
+  try {
+    const signal = AbortSignal.any([
+      AbortSignal.timeout(8000),
+      ...(options.signal ? [options.signal] : []),
+    ]);
+    const response = await (options.fetch ?? globalThis.fetch)(`${BASE_URL}/models?verbose=true`, {
+      headers: { Authorization: `Bearer ${key}`, Accept: "application/json" },
+      signal,
+      redirect: "error",
+    });
+    if (!response.ok) {
+      await response.body?.cancel();
+      const detail =
+        response.status === 401 || response.status === 403
+          ? "Token Factory rejected the credentials; check NEBIUS_API_KEY and project access."
+          : response.status === 429
+            ? "Token Factory rate limit reached."
+            : response.status >= 500
+              ? "Token Factory is temporarily unavailable."
+              : "Token Factory model discovery failed.";
+      const retry = response.headers.get("retry-after");
+      // Do not log arbitrary error bodies: they may echo credentials/request headers.
+      const safeRetry = retry && /^[\w ,:+.-]{1,100}$/.test(retry) ? ` Retry-After: ${retry}.` : "";
+      throw new DiscoveryError(`HTTP ${response.status}: ${detail}${safeRetry}`, response.status);
+    }
+    const reader = response.body?.getReader();
+    if (!reader) throw new DiscoveryError("Empty Token Factory model response.");
+    const chunks: Uint8Array[] = [];
+    let size = 0;
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        size += value.byteLength;
+        if (size > MAX_BYTES)
+          throw new DiscoveryError("Token Factory model response exceeds 4 MiB.");
+        chunks.push(value);
+      }
+    } finally {
+      await reader.cancel().catch(() => {});
+    }
+    let payload: unknown;
+    try {
+      payload = JSON.parse(Buffer.concat(chunks).toString("utf8"));
+    } catch {
+      throw new DiscoveryError("Malformed JSON in Token Factory model response.");
+    }
+    const models = parseModels(payload);
+    try {
+      await writeCache(path, models, now);
+    } catch {
+      return {
+        models,
+        source: "network",
+        warning: "Nebius models loaded, but the metadata cache could not be written.",
+      };
+    }
+    return { models, source: "network" };
+  } catch (error) {
+    const authFailure =
+      error instanceof DiscoveryError && (error.status === 401 || error.status === 403);
+    if (authFailure) await unlink(path).catch(() => {});
+    const fallback = !authFailure && !options.signal?.aborted ? cached : undefined;
+    const detail =
+      error instanceof DiscoveryError
+        ? error.message
+        : error instanceof Error && error.message.startsWith("Malformed Token Factory")
+          ? error.message
+          : "Token Factory model discovery could not complete (connectivity, timeout, or cancellation).";
+    return {
+      models: fallback?.models ?? [],
+      source: fallback ? "stale" : "none",
+      warning: `Nebius: ${detail} ${fallback ? "Using stale cached models." : "Use models.json for an offline model definition, then retry with /nebius-refresh."}`,
+    };
+  }
+}

package/src/errors.ts

@@ -0,0 +1,32 @@
+/** Preserve retry diagnostics that Pi's SDK error-to-string conversion otherwise drops. */
+export function withErrorDetails(fetcher: typeof fetch): typeof fetch {
+  return async (input, init) => {
+    const response = await fetcher(input, init);
+    if (response.ok) return response; // Successful SSE bodies remain completely untouched.
+    const details: string[] = [];
+    for (const [name, value] of response.headers) {
+      if (
+        name === "retry-after" ||
+        name === "retry-after-ms" ||
+        name === "x-request-id" ||
+        name.startsWith("x-ratelimit-") ||
+        name.startsWith("ratelimit-")
+      ) {
+        details.push(`${name}: ${value}`);
+      }
+    }
+    if (details.length === 0) return response;
+    const body = await response.text();
+    const headers = new Headers(response.headers);
+    headers.delete("content-length");
+    headers.delete("content-encoding");
+    headers.set("content-type", "text/plain; charset=utf-8");
+    // Headers come first so Pi's error-body truncation keeps retry diagnostics.
+    // The original body is retained verbatim, including context-overflow markers.
+    return new Response(`${details.join("\n")}\n${body}`, {
+      status: response.status,
+      statusText: response.statusText,
+      headers,
+    });
+  };
+}

package/src/index.ts

@@ -0,0 +1,96 @@
+import { type ExtensionAPI, getAgentDir } from "@earendil-works/pi-coding-agent";
+import { registerBenchmarkCommand } from "./benchmark/command.ts";
+import { discoverModels, MISSING_KEY } from "./discovery.ts";
+import {
+  applyModelSettings,
+  loadSettings,
+  type ModelSettingsMap,
+  settingsPath,
+} from "./model-settings.ts";
+import { registerModelSettingsCommand } from "./model-settings-command.ts";
+import type { NebiusModel } from "./models.ts";
+import { nebiusProvider } from "./provider.ts";
+
+export default async function nebius(pi: ExtensionAPI) {
+  const path = settingsPath(getAgentDir());
+  let settings: ModelSettingsMap = {};
+  try {
+    settings = await loadSettings(path);
+  } catch (error) {
+    process.stderr.write(`Nebius settings were not loaded: ${String(error)}\n`);
+  }
+  let catalog: NebiusModel[] = [];
+  const register = () =>
+    pi.registerProvider(
+      nebiusProvider(
+        catalog.map((model) => applyModelSettings(model, settings[model.id])),
+        settings,
+      ),
+    );
+  registerBenchmarkCommand(pi, () => settings);
+  registerModelSettingsCommand(pi, {
+    path,
+    models: () => catalog,
+    settings: () => settings,
+    update: (updated) => {
+      settings = updated;
+      register();
+    },
+  });
+  let pending: Promise<Awaited<ReturnType<typeof discoverModels>>> | undefined;
+  const initialize = (force = false) => {
+    pending ??= discoverModels({
+      apiKey: process.env.NEBIUS_API_KEY,
+      agentDir: getAgentDir(),
+      force,
+    })
+      .then((result) => {
+        catalog = result.models;
+        register();
+        return result;
+      })
+      .finally(() => {
+        pending = undefined;
+      });
+    return pending;
+  };
+  const initial = await initialize();
+  if (initial.warning) process.stderr.write(`${initial.warning}\n`);
+
+  pi.on("session_start", async (_event, ctx) => {
+    if (initial.warning && ctx.hasUI) ctx.ui.notify(initial.warning, "warning");
+  });
+  pi.registerCommand("nebius-refresh", {
+    description: "Refresh the Nebius Token Factory model catalog",
+    handler: async (_args, ctx) => {
+      const result = await initialize(true);
+      const message = result.warning ?? `Nebius: loaded ${result.models.length} models.`;
+      if (ctx.hasUI) ctx.ui.notify(message, result.warning ? "warning" : "info");
+      else process.stderr.write(`${message}\n`);
+    },
+  });
+  pi.on("message_end", async (event) => {
+    const message = event.message;
+    if (
+      message.role !== "assistant" ||
+      message.provider !== "nebius" ||
+      message.stopReason !== "error"
+    )
+      return;
+    const original = message.errorMessage ?? "Unknown provider error";
+    if (original.startsWith("Nebius Token Factory:")) return;
+    const hint = /\b(?:401|403)\b/.test(original)
+      ? "Token Factory rejected the credentials; check NEBIUS_API_KEY and project access."
+      : /\b429\b|rate.?limit/i.test(original)
+        ? "Rate limited; retry after the server's requested delay."
+        : /\b404\b|model.*(?:not found|unavailable|does not exist)/i.test(original)
+          ? "Model unavailable; run /nebius-refresh and select a current model with /model."
+          : /\b5\d\d\b/.test(original)
+            ? "Token Factory is temporarily unavailable; retry later."
+            : /no.*(?:api.?key|auth)|not configured/i.test(original)
+              ? MISSING_KEY
+              : "Request failed.";
+    // Preserve Pi's normalized error, including status, retry hints, and overflow markers.
+    return { message: { ...message, errorMessage: `Nebius Token Factory: ${hint}\n${original}` } };
+  });
+}

package/src/model-settings-command.ts

@@ -0,0 +1,151 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import {
+  applyModelSettings,
+  efforts,
+  type ModelSettings,
+  type ModelSettingsMap,
+  saveModelSettings,
+  validateSettings,
+} from "./model-settings.ts";
+import type { NebiusModel } from "./models.ts";
+
+export function registerModelSettingsCommand(
+  pi: ExtensionAPI,
+  options: {
+    path: string;
+    models: () => NebiusModel[];
+    settings: () => ModelSettingsMap;
+    update: (settings: ModelSettingsMap) => void;
+  },
+) {
+  pi.registerCommand("nebius-model", {
+    description: "Configure saved per-model Nebius settings",
+    handler: async (args, ctx) => {
+      if (!ctx.hasUI) {
+        ctx.ui.notify("/nebius-model requires interactive Pi.", "warning");
+        return;
+      }
+      if (!ctx.isIdle()) {
+        ctx.ui.notify("Wait for the current response before changing model settings.", "warning");
+        return;
+      }
+      const models = options.models();
+      const id =
+        args.trim() ||
+        (await ctx.ui.select(
+          "Nebius model settings",
+          models.map((model) => model.id),
+        ));
+      if (!id) return;
+      const base = models.find((model) => model.id === id);
+      if (!base) {
+        ctx.ui.notify("Unknown model. Run /nebius-refresh first.", "error");
+        return;
+      }
+      try {
+        while (true) {
+          const current = options.settings()[id] ?? {};
+          const effective = applyModelSettings(base, current);
+          const choices = [
+            `Temperature: ${current.temperature ?? "inherit"}`,
+            `Reasoning effort: ${current.reasoningEffort ?? "inherit"}`,
+            `Maximum output tokens: ${current.maxTokens ?? `inherit (${base.maxTokens})`}`,
+            "Advanced metadata settings",
+            "Reset all overrides",
+            "Done",
+          ];
+          const action = await ctx.ui.select(id, choices);
+          if (!action || action === "Done") return;
+          const next: ModelSettings = { ...current };
+          if (action === "Reset all overrides") {
+            for (const key of Object.keys(next)) delete next[key as keyof ModelSettings];
+          } else if (action === "Advanced metadata settings") {
+            const advanced = await ctx.ui.select(
+              "Local metadata only; does not change server capabilities",
+              ["Context window", "Reasoning support", "Back"],
+            );
+            if (!advanced || advanced === "Back") continue;
+            if (advanced === "Context window") {
+              const value = await ctx.ui.input(
+                "Context window: positive integer; blank to inherit",
+                String(current.contextWindow ?? ""),
+              );
+              if (value === undefined) continue;
+              if (!value.trim()) delete next.contextWindow;
+              else next.contextWindow = Number(value);
+            } else {
+              const value = await ctx.ui.select("Reasoning support", [
+                "Inherit",
+                "Enabled",
+                "Disabled",
+              ]);
+              if (!value) continue;
+              if (value === "Inherit") delete next.reasoning;
+              else next.reasoning = value === "Enabled";
+              if (value === "Disabled") delete next.reasoningEffort;
+            }
+          } else if (action === choices[1]) {
+            if (!effective.reasoning || !effective.compat?.supportsReasoningEffort) {
+              ctx.ui.notify(
+                "The catalog does not advertise reasoning-effort control for this model. No override will be sent.",
+                "warning",
+              );
+              continue;
+            }
+            const value = await ctx.ui.select(
+              "Reasoning effort (saved value overrides Pi's thinking setting)",
+              ["Inherit", ...efforts],
+            );
+            if (!value) continue;
+            if (value === "Inherit") delete next.reasoningEffort;
+            else next.reasoningEffort = value as ModelSettings["reasoningEffort"];
+          } else {
+            const temperature = action === choices[0];
+            if (temperature && !base.nebiusSupportedParameters?.includes("temperature")) {
+              ctx.ui.notify(
+                "The catalog does not advertise temperature control for this model. No override will be sent.",
+                "warning",
+              );
+              continue;
+            }
+            const key = temperature ? "temperature" : "maxTokens";
+            const value = await ctx.ui.input(
+              temperature
+                ? "Temperature: 0–2; blank to inherit"
+                : "Maximum output tokens: positive integer; blank to inherit",
+              String(current[key] ?? ""),
+            );
+            if (value === undefined) continue;
+            if (!value.trim()) delete next[key];
+            else next[key] = Number(value);
+          }
+          try {
+            validateSettings(next);
+            if (
+              next.maxTokens !== undefined &&
+              next.maxTokens > (next.contextWindow ?? base.contextWindow)
+            )
+              throw new Error("Maximum output tokens cannot exceed the context window.");
+          } catch (error) {
+            ctx.ui.notify(String(error), "error");
+            continue;
+          }
+          const saved = await saveModelSettings(options.path, id, next);
+          options.update(saved);
+          if (ctx.model?.provider === "nebius" && ctx.model.id === id) {
+            const model = ctx.modelRegistry
+              .getAll()
+              .find((candidate) => candidate.provider === "nebius" && candidate.id === id);
+            if (model) await pi.setModel(model);
+          }
+          ctx.ui.notify(
+            "Saved. New requests use these settings; running benchmarks keep their starting settings.",
+            "info",
+          );
+        }
+      } catch (error) {
+        ctx.ui.notify(`Could not update Nebius settings: ${String(error)}`, "error");
+      }
+    },
+  });
+}