@psnext/slingcli 2.5.20260710-1 → 2.5.20260718-2

package/node_modules/@earendil-works/pi-coding-agent/dist/extensions/llama/provider.js

@@ -0,0 +1,102 @@
+import { stream, streamSimple } from "@earendil-works/pi-ai/compat";
+import { LlamaClient, llamaInferenceUrl, normalizeLlamaServerUrl } from "./client.js";
+export const LLAMA_PROVIDER_ID = "llama.cpp";
+export const DEFAULT_LLAMA_SERVER_URL = "http://127.0.0.1:8080";
+const DEFAULT_MAX_TOKENS = 16384;
+function credentialServerUrl(credential) {
+    const value = credential?.env?.LLAMA_BASE_URL;
+    return typeof value === "string" && value.trim() ? normalizeLlamaServerUrl(value) : undefined;
+}
+async function resolveServerUrl(ctx, credential) {
+    const configured = credentialServerUrl(credential) ?? (await ctx.env("LLAMA_BASE_URL"))?.trim();
+    return configured ? normalizeLlamaServerUrl(configured) : undefined;
+}
+function toPiModel(model, serverUrl) {
+    const reportedContextWindow = model.meta?.n_ctx ?? model.meta?.n_ctx_train;
+    const contextWindow = reportedContextWindow && reportedContextWindow > 0 ? reportedContextWindow : 128000;
+    return {
+        id: model.id,
+        name: model.id,
+        api: "openai-completions",
+        provider: LLAMA_PROVIDER_ID,
+        baseUrl: llamaInferenceUrl(serverUrl),
+        reasoning: false,
+        input: model.architecture?.input_modalities?.includes("image") ? ["text", "image"] : ["text"],
+        cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+        contextWindow,
+        maxTokens: Math.min(DEFAULT_MAX_TOKENS, contextWindow),
+        compat: {
+            supportsStore: false,
+            supportsDeveloperRole: false,
+            supportsReasoningEffort: false,
+            supportsUsageInStreaming: false,
+            supportsStrictMode: false,
+            maxTokensField: "max_tokens",
+        },
+    };
+}
+export function createLlamaProvider() {
+    let models = [];
+    const setCatalog = (catalog, serverUrl) => {
+        models = catalog.filter((model) => model.status.value === "loaded").map((model) => toPiModel(model, serverUrl));
+    };
+    const provider = {
+        id: LLAMA_PROVIDER_ID,
+        name: "llama.cpp",
+        baseUrl: llamaInferenceUrl(DEFAULT_LLAMA_SERVER_URL),
+        auth: {
+            apiKey: {
+                name: "llama.cpp server",
+                login: async (interaction) => {
+                    const enteredUrl = await interaction.prompt({
+                        type: "text",
+                        message: "llama.cpp server URL",
+                        placeholder: process.env.LLAMA_BASE_URL ?? DEFAULT_LLAMA_SERVER_URL,
+                    });
+                    const serverUrl = normalizeLlamaServerUrl(enteredUrl.trim() || process.env.LLAMA_BASE_URL || DEFAULT_LLAMA_SERVER_URL);
+                    const apiKey = (await interaction.prompt({
+                        type: "secret",
+                        message: "API key (optional)",
+                    })).trim();
+                    await new LlamaClient(serverUrl, apiKey || undefined).list({ signal: interaction.signal });
+                    return {
+                        type: "api_key",
+                        key: apiKey || undefined,
+                        env: { LLAMA_BASE_URL: serverUrl },
+                    };
+                },
+                check: async ({ ctx, credential }) => {
+                    const serverUrl = await resolveServerUrl(ctx, credential);
+                    return serverUrl
+                        ? { type: "api_key", source: credential ? "stored credential" : "LLAMA_BASE_URL" }
+                        : undefined;
+                },
+                resolve: async ({ ctx, credential }) => {
+                    const serverUrl = await resolveServerUrl(ctx, credential);
+                    if (!serverUrl)
+                        return undefined;
+                    const apiKey = credential?.key ?? (await ctx.env("LLAMA_API_KEY")) ?? "local";
+                    return {
+                        auth: { apiKey, baseUrl: llamaInferenceUrl(serverUrl) },
+                        env: { ...credential?.env, LLAMA_BASE_URL: serverUrl },
+                        source: credential ? "stored credential" : "LLAMA_BASE_URL",
+                    };
+                },
+            },
+        },
+        getModels: () => models,
+        refreshModels: async (context) => {
+            if (!context.allowNetwork || context.signal?.aborted || context.credential?.type !== "api_key")
+                return;
+            const serverUrl = credentialServerUrl(context.credential);
+            if (!serverUrl)
+                return;
+            const catalog = await new LlamaClient(serverUrl, context.credential.key).list({ signal: context.signal });
+            setCatalog(catalog, serverUrl);
+        },
+        stream: (model, context, options) => stream(model, context, options),
+        streamSimple: (model, context, options) => streamSimple(model, context, options),
+    };
+    return { provider, setCatalog };
+}
+//# sourceMappingURL=provider.js.map

package/node_modules/@earendil-works/pi-coding-agent/dist/extensions/llama/ui.js

@@ -0,0 +1,416 @@
+import { Container, fuzzyFilter, Input, SelectList, Spacer, Text, truncateToWidth, visibleWidth, } from "@earendil-works/pi-tui";
+import { DynamicBorder } from "../../modes/interactive/components/dynamic-border.js";
+import { keyHint } from "../../modes/interactive/components/keybinding-hints.js";
+const DOWNLOAD_VALUE = "\0download";
+function contextLabel(model) {
+    const context = model.meta?.n_ctx ?? model.meta?.n_ctx_train;
+    if (context)
+        return context >= 1000 ? `${Math.round(context / 1000)}k` : String(context);
+    const args = model.status.args ?? [];
+    for (let index = 0; index < args.length - 1; index++) {
+        if (args[index] !== "--ctx-size" && args[index] !== "-c" && args[index] !== "-ctx")
+            continue;
+        const value = Number(args[index + 1]);
+        if (Number.isFinite(value) && value > 0)
+            return value >= 1000 ? `${Math.round(value / 1000)}k` : String(value);
+    }
+    return undefined;
+}
+function modelDescription(model) {
+    const details = [];
+    const loaded = model.status.value === "loaded" || model.status.value === "sleeping";
+    if (loaded)
+        details.push("loaded");
+    else if (model.status.value !== "unloaded")
+        details.push(model.status.value);
+    const context = loaded ? contextLabel(model) : undefined;
+    if (context)
+        details.push(`${context} context`);
+    return details.join(" · ");
+}
+function selectTheme(theme) {
+    return {
+        selectedPrefix: (text) => theme.fg("accent", text),
+        selectedText: (text) => theme.fg("accent", text),
+        description: (text) => theme.fg("muted", text),
+        scrollInfo: (text) => theme.fg("dim", text),
+        noMatch: (text) => theme.fg("warning", text),
+    };
+}
+function frame(theme, title, body, footer) {
+    const container = new Container();
+    container.addChild(new DynamicBorder((text) => theme.fg("accent", text)));
+    container.addChild(new Text(theme.fg("accent", theme.bold(title)), 1, 0));
+    for (const child of body)
+        container.addChild(child);
+    if (footer) {
+        container.addChild(new Spacer(1));
+        container.addChild(new Text(theme.fg("dim", footer), 1, 0));
+    }
+    container.addChild(new DynamicBorder((text) => theme.fg("accent", text)));
+    return container;
+}
+function compactCount(value) {
+    if (value >= 1_000_000)
+        return `${(value / 1_000_000).toFixed(value >= 10_000_000 ? 0 : 1)}M`;
+    if (value >= 1_000)
+        return `${(value / 1_000).toFixed(value >= 100_000 ? 0 : 1)}k`;
+    return String(value);
+}
+class HuggingFaceSearch extends Container {
+    tui;
+    theme;
+    keybindings;
+    search;
+    cache;
+    onSelectModel;
+    input = new Input();
+    resultsContainer = new Container();
+    results = [];
+    filteredResults = [];
+    selectedIndex = 0;
+    query = "";
+    status = "Type at least 2 characters";
+    debounce;
+    request;
+    closed = false;
+    _focused = false;
+    constructor(tui, theme, keybindings, search, cache, onSelectModel) {
+        super();
+        this.tui = tui;
+        this.theme = theme;
+        this.keybindings = keybindings;
+        this.search = search;
+        this.cache = cache;
+        this.onSelectModel = onSelectModel;
+        this.addChild(new Text(theme.fg("dim", "Model name or owner/repository[:quant]"), 1, 0));
+        this.addChild(this.input);
+        this.addChild(new Spacer(1));
+        this.addChild(this.resultsContainer);
+        this.updateResults();
+    }
+    get focused() {
+        return this._focused;
+    }
+    set focused(value) {
+        this._focused = value;
+        this.input.focused = value;
+    }
+    updateResults() {
+        this.resultsContainer.clear();
+        const maxVisible = 10;
+        const start = Math.max(0, Math.min(this.selectedIndex - Math.floor(maxVisible / 2), this.filteredResults.length - maxVisible));
+        const end = Math.min(start + maxVisible, this.filteredResults.length);
+        for (let index = start; index < end; index++) {
+            const model = this.filteredResults[index];
+            if (!model)
+                continue;
+            const prefix = index === this.selectedIndex ? "→ " : "  ";
+            const details = `${compactCount(model.downloads)} downloads`;
+            this.resultsContainer.addChild(new Text(index === this.selectedIndex
+                ? this.theme.fg("accent", `${prefix}${model.id}  ${details}`)
+                : `${prefix}${model.id}${this.theme.fg("muted", `  ${details}`)}`, 0, 0));
+        }
+        if (start > 0 || end < this.filteredResults.length) {
+            this.resultsContainer.addChild(new Text(this.theme.fg("dim", `  (${this.selectedIndex + 1}/${this.filteredResults.length})`), 0, 0));
+        }
+        if (this.filteredResults.length === 0) {
+            this.resultsContainer.addChild(new Text(this.theme.fg("dim", `  ${this.status}`), 0, 0));
+        }
+        else if (this.status === "Searching Hugging Face…") {
+            this.resultsContainer.addChild(new Text(this.theme.fg("dim", `  ${this.status}`), 0, 0));
+        }
+        this.tui.requestRender();
+    }
+    filterResults() {
+        if (this.query) {
+            const matches = new Set(fuzzyFilter(this.results, this.query, (model) => model.id).map((model) => model.id));
+            this.filteredResults = this.results.filter((model) => matches.has(model.id));
+        }
+        else {
+            this.filteredResults = this.results;
+        }
+        this.selectedIndex = Math.min(this.selectedIndex, Math.max(0, this.filteredResults.length - 1));
+        this.updateResults();
+    }
+    scheduleSearch() {
+        if (this.debounce)
+            clearTimeout(this.debounce);
+        this.request?.abort();
+        this.request = undefined;
+        if (this.query.length < 2) {
+            this.status = "Type at least 2 characters";
+            this.filterResults();
+            return;
+        }
+        const cached = this.cache.get(this.query.toLowerCase());
+        if (cached) {
+            this.results = cached;
+            this.status = cached.length === 0 ? "No GGUF models found" : "";
+            this.filterResults();
+            return;
+        }
+        this.status = "Searching Hugging Face…";
+        this.filterResults();
+        this.debounce = setTimeout(() => void this.runSearch(this.query), 500);
+    }
+    async runSearch(query) {
+        const request = new AbortController();
+        this.request = request;
+        try {
+            const results = await this.search(query, request.signal);
+            this.cache.set(query.toLowerCase(), results);
+            if (this.closed || request.signal.aborted || this.query !== query)
+                return;
+            this.results = results;
+            this.selectedIndex = 0;
+            this.status = results.length === 0 ? "No GGUF models found" : "";
+            this.filterResults();
+        }
+        catch (error) {
+            if (this.closed || request.signal.aborted || this.query !== query)
+                return;
+            this.results = [];
+            this.status = error instanceof Error ? error.message : String(error);
+            this.filterResults();
+        }
+        finally {
+            if (this.request === request)
+                this.request = undefined;
+        }
+    }
+    close(model) {
+        if (this.closed)
+            return;
+        this.closed = true;
+        if (this.debounce)
+            clearTimeout(this.debounce);
+        this.request?.abort();
+        this.onSelectModel(model);
+    }
+    handleInput(data) {
+        if (this.keybindings.matches(data, "tui.select.up")) {
+            if (this.filteredResults.length > 0) {
+                this.selectedIndex = this.selectedIndex === 0 ? this.filteredResults.length - 1 : this.selectedIndex - 1;
+                this.updateResults();
+            }
+            return;
+        }
+        if (this.keybindings.matches(data, "tui.select.down")) {
+            if (this.filteredResults.length > 0) {
+                this.selectedIndex = this.selectedIndex === this.filteredResults.length - 1 ? 0 : this.selectedIndex + 1;
+                this.updateResults();
+            }
+            return;
+        }
+        if (this.keybindings.matches(data, "tui.select.confirm")) {
+            const exact = /^[^/\s]+\/[^:\s]+(?::[^\s:]+)?$/u.test(this.query) ? this.query : undefined;
+            const selected = exact ?? this.filteredResults[this.selectedIndex]?.id;
+            if (selected)
+                this.close(selected);
+            return;
+        }
+        if (this.keybindings.matches(data, "tui.select.cancel")) {
+            this.close(undefined);
+            return;
+        }
+        this.input.handleInput(data);
+        const query = this.input.getValue().trim();
+        if (query === this.query)
+            return;
+        this.query = query;
+        this.scheduleSearch();
+    }
+}
+class LlamaView {
+    tui;
+    theme;
+    keybindings;
+    searchCache = new Map();
+    content;
+    inputHandler;
+    inputTarget;
+    progressPromise;
+    progressResolver;
+    showingProgress = false;
+    _focused = false;
+    constructor(tui, theme, keybindings) {
+        this.tui = tui;
+        this.theme = theme;
+        this.keybindings = keybindings;
+        this.content = frame(theme, "llama.cpp models", [new Text(theme.fg("muted", "Loading…"), 1, 1)]);
+    }
+    get focused() {
+        return this._focused;
+    }
+    set focused(value) {
+        this._focused = value;
+        if (this.inputTarget)
+            this.inputTarget.focused = value;
+    }
+    setContent(content, inputHandler, inputTarget) {
+        if (this.inputTarget)
+            this.inputTarget.focused = false;
+        this.progressPromise = undefined;
+        this.progressResolver = undefined;
+        this.showingProgress = false;
+        this.content = content;
+        this.inputHandler = inputHandler;
+        this.inputTarget = inputTarget;
+        if (this.inputTarget)
+            this.inputTarget.focused = this._focused;
+        this.tui.requestRender();
+    }
+    showModels(serverUrl, models) {
+        const sorted = [...models].sort((left, right) => {
+            const loaded = Number(right.status.value === "loaded") - Number(left.status.value === "loaded");
+            return loaded || left.id.localeCompare(right.id);
+        });
+        const byId = new Map(sorted.map((model) => [model.id, model]));
+        const items = [
+            ...sorted.map((model) => ({
+                value: model.id,
+                label: model.id,
+                description: modelDescription(model),
+            })),
+            { value: DOWNLOAD_VALUE, label: "Download model…", description: "Hugging Face owner/repository[:quant]" },
+        ];
+        return new Promise((resolve) => {
+            const list = new SelectList(items, Math.min(items.length, 12), selectTheme(this.theme), {
+                minPrimaryColumnWidth: 36,
+                maxPrimaryColumnWidth: 56,
+            });
+            list.onSelect = (item) => {
+                if (item.value === DOWNLOAD_VALUE)
+                    resolve({ type: "download" });
+                else {
+                    const model = byId.get(item.value);
+                    if (model)
+                        resolve({ type: "model", model });
+                }
+            };
+            list.onCancel = () => resolve({ type: "close" });
+            this.setContent(frame(this.theme, "llama.cpp models", [new Text(this.theme.fg("dim", serverUrl), 1, 0), new Spacer(1), list], `${keyHint("tui.select.confirm", "load/unload/download")} • ${keyHint("tui.select.cancel", "close")}`), list);
+        });
+    }
+    select(title, options) {
+        return new Promise((resolve) => {
+            const list = new SelectList(options.map((option) => ({ value: option, label: option })), Math.min(options.length, 12), selectTheme(this.theme));
+            list.onSelect = (item) => resolve(item.value);
+            list.onCancel = () => resolve(undefined);
+            this.setContent(frame(this.theme, title, [new Spacer(1), list], `${keyHint("tui.select.confirm", "select")} • ${keyHint("tui.select.cancel", "cancel")}`), list);
+        });
+    }
+    async confirm(title, message) {
+        return (await this.select(`${title}\n${message}`, ["Yes", "No"])) === "Yes";
+    }
+    async connectionError(serverUrl, message) {
+        const choice = await this.select(`llama.cpp unavailable\n${serverUrl}\n\n${message}`, ["Retry", "Close"]);
+        return choice === "Retry" ? "retry" : "close";
+    }
+    searchModels(search) {
+        return new Promise((resolve) => {
+            const component = new HuggingFaceSearch(this.tui, this.theme, this.keybindings, search, this.searchCache, resolve);
+            this.setContent(frame(this.theme, "Download model", [new Spacer(1), component], `${keyHint("tui.select.confirm", "select")} • ${keyHint("tui.select.cancel", "back")}`), component, component);
+        });
+    }
+    showStatus(title, message) {
+        this.setContent(frame(this.theme, title, [new Spacer(1), new Text(this.theme.fg("muted", message), 1, 0)]));
+    }
+    progress(state) {
+        if (!this.progressPromise) {
+            this.progressPromise = new Promise((resolve) => {
+                this.progressResolver = resolve;
+            });
+        }
+        this.showingProgress = true;
+        this.updateProgress(state);
+        return this.progressPromise;
+    }
+    updateProgress(state) {
+        if (!this.showingProgress)
+            return;
+        const body = [
+            new Text(this.theme.fg("text", state.model), 1, 0),
+            new Spacer(1),
+            new Text(this.theme.fg("muted", state.message), 1, 0),
+        ];
+        if (state.ratio !== undefined) {
+            const available = 40;
+            const filled = Math.round(Math.max(0, Math.min(1, state.ratio)) * available);
+            body.push(new Text(this.theme.fg("accent", `${"█".repeat(filled)}${"─".repeat(available - filled)} ${Math.round(state.ratio * 100)}%`), 1, 0));
+        }
+        if (state.detail)
+            body.push(new Text(this.theme.fg("dim", state.detail), 1, 0));
+        this.content = frame(this.theme, state.title, body, keyHint("tui.select.cancel", "stop"));
+        this.inputHandler = undefined;
+        this.tui.requestRender();
+    }
+    handleInput(data) {
+        if (this.progressResolver && this.keybindings.matches(data, "tui.select.cancel")) {
+            const resolve = this.progressResolver;
+            this.progressPromise = undefined;
+            this.progressResolver = undefined;
+            resolve();
+            return;
+        }
+        this.inputHandler?.handleInput?.(data);
+        this.tui.requestRender();
+    }
+    render(width) {
+        return this.content
+            .render(width)
+            .map((line) => (visibleWidth(line) > width ? truncateToWidth(line, width, "") : line));
+    }
+    invalidate() {
+        this.content.invalidate();
+    }
+}
+export async function showLlamaUi(ctx, run) {
+    await ctx.ui.custom((tui, theme, keybindings, done) => {
+        const view = new LlamaView(tui, theme, keybindings);
+        void run(view).then(() => done(), (error) => {
+            ctx.ui.notify(error instanceof Error ? error.message : String(error), "error");
+            done();
+        });
+        return view;
+    });
+}
+export async function runWithProgress(ui, options) {
+    const controller = new AbortController();
+    const state = { title: options.title, model: options.model, message: options.initialMessage };
+    const settled = options
+        .run(controller.signal, (progress) => {
+        Object.assign(state, progress);
+        ui.updateProgress(state);
+    })
+        .then((value) => ({ ok: true, value }), (error) => ({ ok: false, error }));
+    let completed = false;
+    settled.finally(() => {
+        completed = true;
+    });
+    while (!completed) {
+        const outcome = await Promise.race([
+            settled.then(() => "settled"),
+            ui.progress(state).then(() => "stop"),
+        ]);
+        if (outcome === "settled")
+            break;
+        const stop = await ui.confirm(options.cancelTitle, options.cancelMessage);
+        if (!stop || completed)
+            continue;
+        try {
+            await options.cancel();
+        }
+        finally {
+            controller.abort(new Error("Cancelled"));
+        }
+        await settled;
+        return { cancelled: true };
+    }
+    const result = await settled;
+    if (!result.ok)
+        throw result.error;
+    return { cancelled: false, value: result.value };
+}
+//# sourceMappingURL=ui.js.map

package/node_modules/@earendil-works/pi-coding-agent/dist/index.js

@@ -3,8 +3,7 @@ export { parseArgs } from "./cli/args.js";
 // Config paths
 export { CONFIG_DIR_NAME, getAgentDir, getDocsPath, getExamplesPath, getPackageDir, getReadmePath, VERSION, } from "./config.js";
 export { AgentSession, parseSkillBlock, } from "./core/agent-session.js";
-// Auth and model registry
-export { AuthStorage, FileAuthStorageBackend, InMemoryAuthStorageBackend, } from "./core/auth-storage.js";
+export { readStoredCredential } from "./core/auth-storage.js";
 // Compaction
 export { calculateContextTokens, collectEntriesForBranchSummary, compact, DEFAULT_COMPACTION_SETTINGS, estimateTokens, findCutPoint, findTurnStartIndex, generateBranchSummary, generateSummary, getLastAssistantUsage, prepareBranchEntries, serializeConversation, shouldCompact, } from "./core/compaction/index.js";
 export { createEventBus } from "./core/event-bus.js";
@@ -12,6 +11,7 @@ export { createExtensionRuntime, defineTool, discoverAndLoadExtensions, Extensio
 export { convertToLlm } from "./core/messages.js";
 export { ModelRegistry } from "./core/model-registry.js";
 export { resolveCliModel, resolveModelScopeWithDiagnostics, } from "./core/model-resolver.js";
+export { ModelRuntime, } from "./core/model-runtime.js";
 export { DefaultPackageManager } from "./core/package-manager.js";
 export { DefaultResourceLoader, loadProjectContextFiles } from "./core/resource-loader.js";
 // SDK for programmatic usage

package/node_modules/@earendil-works/pi-coding-agent/dist/main.js

@@ -18,7 +18,6 @@ import { ENV_SESSION_DIR, expandTildePath, getAgentDir, getPackageDir, VERSION }
 import { createAgentSessionRuntime } from "./core/agent-session-runtime.js";
 import { createAgentSessionFromServices, createAgentSessionServices, } from "./core/agent-session-services.js";
 import { formatNoModelsAvailableMessage } from "./core/auth-guidance.js";
-import { AuthStorage } from "./core/auth-storage.js";
 import { exportFromFile } from "./core/export-html/index.js";
 import { applyHttpProxySettings, configureHttpDispatcher } from "./core/http-dispatcher.js";
 import { resolveCliModel, resolveModelScope } from "./core/model-resolver.js";
@@ -29,6 +28,7 @@ import { assertValidSessionId, SessionManager } from "./core/session-manager.js"
 import { SettingsManager } from "./core/settings-manager.js";
 import { printTimings, resetTimings, time } from "./core/timings.js";
 import { hasTrustRequiringProjectResources, ProjectTrustStore } from "./core/trust-manager.js";
+import { builtInExtensions } from "./extensions/index.js";
 import { runMigrations, showDeprecationWarnings } from "./migrations.js";
 import { InteractiveMode, runPrintMode, runRpcMode } from "./modes/index.js";
 import { initTheme, stopThemeWatcher } from "./modes/interactive/theme/theme.js";
@@ -266,10 +266,11 @@ async function createSessionManager(parsed, cwd, sessionDir, settingsManager) {
         if (existingSession) {
             return SessionManager.open(existingSession.path, sessionDir);
         }
+        console.error(chalk.yellow(`Warning: No project session found with id '${parsed.sessionId}'; creating a new session with that id.`));
     }
     return SessionManager.create(cwd, sessionDir, { id: parsed.sessionId });
 }
-function buildSessionOptions(parsed, scopedModels, hasExistingSession, modelRegistry, settingsManager) {
+function buildSessionOptions(parsed, scopedModels, hasExistingSession, modelRuntime, settingsManager) {
     const options = {};
     const diagnostics = [];
     let cliThinkingFromModel = false;
@@ -281,7 +282,7 @@ function buildSessionOptions(parsed, scopedModels, hasExistingSession, modelRegi
             cliProvider: parsed.provider,
             cliModel: parsed.model,
             cliThinking: parsed.thinking,
-            modelRegistry,
+            modelRuntime,
         });
         if (resolved.warning) {
             diagnostics.push({ type: "warning", message: resolved.warning });
@@ -303,7 +304,7 @@ function buildSessionOptions(parsed, scopedModels, hasExistingSession, modelRegi
         // Check if saved default is in scoped models - use it if so, otherwise first scoped model
         const savedProvider = settingsManager.getDefaultProvider();
         const savedModelId = settingsManager.getDefaultModel();
-        const savedModel = savedProvider && savedModelId ? modelRegistry.find(savedProvider, savedModelId) : undefined;
+        const savedModel = savedProvider && savedModelId ? modelRuntime.getModel(savedProvider, savedModelId) : undefined;
         const savedInScope = savedModel ? scopedModels.find((sm) => modelsAreEqual(sm.model, savedModel)) : undefined;
         if (savedInScope) {
             options.model = savedInScope.model;
@@ -333,7 +334,7 @@ function buildSessionOptions(parsed, scopedModels, hasExistingSession, modelRegi
             thinkingLevel: sm.thinkingLevel,
         }));
     }
-    // API key from CLI - set in authStorage
+    // API key from CLI - set as a non-persistent runtime override
     // (handled by caller before createAgentSession)
     // Tools
     if (parsed.noTools) {
@@ -361,6 +362,7 @@ async function promptForMissingSessionCwd(issue, settingsManager) {
 }
 export async function main(args, options) {
     resetTimings();
+    const extensionFactories = [...builtInExtensions, ...(options?.extensionFactories ?? [])];
     const offlineMode = args.includes("--offline") || isTruthyEnvFlag(process.env.PI_OFFLINE);
     if (offlineMode) {
         process.env.PI_OFFLINE = "1";
@@ -374,7 +376,7 @@ export async function main(args, options) {
     const bootstrapSettingsManager = SettingsManager.create(cwd, agentDir, { projectTrusted: false });
     applyHttpProxySettings(bootstrapSettingsManager.getGlobalSettings().httpProxy);
     configureHttpDispatcher();
-    if (await handlePackageCommand(args, { extensionFactories: options?.extensionFactories })) {
+    if (await handlePackageCommand(args, { extensionFactories })) {
         const exitCode = process.exitCode ?? 0;
         if (process.platform === "win32" && exitCode === 0 && args[0] === "update") {
             // We normally prefer process.exit(0) for package commands so bad extensions cannot keep
@@ -386,7 +388,7 @@ export async function main(args, options) {
         process.exit(exitCode);
         return;
     }
-    if (await handleConfigCommand(args, { extensionFactories: options?.extensionFactories })) {
+    if (await handleConfigCommand(args, { extensionFactories })) {
         return;
     }
     const parsed = parseArgs(args);
@@ -484,7 +486,6 @@ export async function main(args, options) {
     const resolvedSkillPaths = resolveCliPaths(cwd, parsed.skills);
     const resolvedPromptTemplatePaths = resolveCliPaths(cwd, parsed.promptTemplates);
     const resolvedThemePaths = resolveCliPaths(cwd, parsed.themes);
-    const authStorage = AuthStorage.create();
     const createRuntime = async ({ cwd, agentDir, sessionManager, sessionStartEvent, projectTrustContext, }) => {
         const isInitialRuntime = sessionStartEvent === undefined;
         const projectTrustDiagnostics = [];
@@ -500,7 +501,6 @@ export async function main(args, options) {
         const services = await createAgentSessionServices({
             cwd,
             agentDir,
-            authStorage,
             settingsManager: runtimeSettingsManager,
             extensionFlagValues: parsed.unknownFlags,
             resourceLoaderReloadOptions: shouldResolveProjectTrust
@@ -538,10 +538,10 @@ export async function main(args, options) {
                 noContextFiles: parsed.noContextFiles,
                 systemPrompt: parsed.systemPrompt,
                 appendSystemPrompt: parsed.appendSystemPrompt,
-                extensionFactories: options?.extensionFactories,
+                extensionFactories,
             },
         });
-        const { settingsManager, modelRegistry, resourceLoader } = services;
+        const { settingsManager, modelRuntime, resourceLoader } = services;
         const diagnostics = [
             ...projectTrustDiagnostics,
             ...services.diagnostics,
@@ -552,8 +552,8 @@ export async function main(args, options) {
             })),
         ];
         const modelPatterns = parsed.models ?? settingsManager.getEnabledModels();
-        const scopedModels = modelPatterns && modelPatterns.length > 0 ? await resolveModelScope(modelPatterns, modelRegistry) : [];
-        const { options: sessionOptions, cliThinkingFromModel, diagnostics: sessionOptionDiagnostics, } = buildSessionOptions(parsed, scopedModels, sessionManager.buildSessionContext().messages.length > 0, modelRegistry, settingsManager);
+        const scopedModels = modelPatterns && modelPatterns.length > 0 ? await resolveModelScope(modelPatterns, modelRuntime) : [];
+        const { options: sessionOptions, cliThinkingFromModel, diagnostics: sessionOptionDiagnostics, } = buildSessionOptions(parsed, scopedModels, sessionManager.buildSessionContext().messages.length > 0, modelRuntime, settingsManager);
         diagnostics.push(...sessionOptionDiagnostics);
         if (parsed.apiKey) {
             if (!sessionOptions.model) {
@@ -563,7 +563,8 @@ export async function main(args, options) {
                 });
             }
             else {
-                authStorage.setRuntimeApiKey(sessionOptions.model.provider, parsed.apiKey);
+                await modelRuntime.setRuntimeApiKey(sessionOptions.model.provider, parsed.apiKey);
+                await services.modelRuntime.getAvailable();
             }
         }
         const created = await createAgentSessionFromServices({
@@ -596,7 +597,7 @@ export async function main(args, options) {
     });
     time("createAgentSessionRuntime");
     const { services, session, modelFallbackMessage } = runtime;
-    const { settingsManager, modelRegistry, resourceLoader } = services;
+    const { settingsManager, modelRuntime, resourceLoader } = services;
     applyHttpProxySettings(settingsManager.getGlobalSettings().httpProxy);
     configureHttpDispatcher(settingsManager.getHttpIdleTimeoutMs());
     if (parsed.help) {
@@ -608,7 +609,7 @@ export async function main(args, options) {
     }
     if (parsed.listModels !== undefined) {
         const searchPattern = typeof parsed.listModels === "string" ? parsed.listModels : undefined;
-        await listModels(modelRegistry, searchPattern);
+        await listModels(modelRuntime, searchPattern);
         process.exit(0);
     }
     // Read piped stdin content (if any) - skip for RPC mode which uses stdin for JSON-RPC