@lunchbox-labs/opencode-model-profiles 0.0.0-stage → 0.1.1

package/dist/server.js

@@ -0,0 +1,280 @@
+import { modelsFilePath, resolveModelProfiles, stripModelRefs, } from "./apply.js";
+import { assignmentsAreStale, availabilityKey, availableModels, fallbackModel, knownAvailableModels, knownRefModels, readConnectedProviders, recentModels, rememberAvailableModels, } from "./fallback.js";
+import { isRecord } from "./models-file.js";
+import { publishReport } from "./report.js";
+import { selectionFilePath, stateDirectory, worktreeRoot, } from "./selection.js";
+const logService = "model-profiles";
+/** Availability each directory was last reloaded for, so a reload that changes nothing is never repeated. */
+const reloadedFor = new Map();
+function modelName(value) {
+    if (isRecord(value) &&
+        typeof value.providerID === "string" &&
+        typeof value.modelID === "string") {
+        return `${value.providerID}/${value.modelID}`;
+    }
+    // OpenCode stores a session's model as { providerID, id }.
+    if (isRecord(value) &&
+        typeof value.providerID === "string" &&
+        typeof value.id === "string") {
+        return `${value.providerID}/${value.id}`;
+    }
+    return undefined;
+}
+/**
+ * Keeps agents usable when a ref names a model no connected provider offers. The config hook runs before
+ * providers load, so it cannot check models itself: it uses the availability saved by an earlier check, and until
+ * there is one, a prompt to such a model is moved to the model OpenCode would use without the ref. When the
+ * applied refs no longer match what is available, the project reloads once nothing is running, so the config hook
+ * leaves those refs unapplied (which also covers built-in agents such as compaction that never pass through a
+ * prompt).
+ */
+function createFallbacks(input, getApplied) {
+    const { client, directory } = input;
+    /** Each session's model after this hook, for subagents that inherit their parent's. */
+    const sessionModels = new Map();
+    let reloadWanted = false;
+    let reloading = false;
+    let checkedOnce = false;
+    let lastAvailable;
+    const log = (message) => client.app
+        .log({
+        body: { service: logService, level: "warn", message },
+        query: { directory },
+    })
+        .catch(() => undefined);
+    const check = async () => {
+        const response = await client.config.providers({ query: { directory } });
+        const connected = response.error === undefined
+            ? readConnectedProviders(response.data)
+            : undefined;
+        if (connected === undefined) {
+            return undefined;
+        }
+        const available = availableModels(connected);
+        lastAvailable = available;
+        await rememberAvailableModels(stateDirectory(), directory, available, getApplied().assignments.map((assignment) => assignment.model));
+        if (assignmentsAreStale(getApplied().assignments, available) &&
+            reloadedFor.get(directory) !== availabilityKey(available)) {
+            reloadWanted = true;
+        }
+        return { connected, available };
+    };
+    const parentModel = async (sessionID) => {
+        const session = await client.session.get({
+            path: { id: sessionID },
+            query: { directory },
+        });
+        const parentID = isRecord(session.data) ? session.data.parentID : undefined;
+        if (typeof parentID !== "string") {
+            return undefined;
+        }
+        const remembered = sessionModels.get(parentID);
+        if (remembered !== undefined) {
+            return remembered;
+        }
+        const parent = await client.session.get({
+            path: { id: parentID },
+            query: { directory },
+        });
+        // OpenCode 1.19 includes the session's model, which the SDK's type does not list yet.
+        const data = parent.data;
+        return isRecord(data) ? modelName(data.model) : undefined;
+    };
+    const checkMessage = async (hookInput, message) => {
+        const applied = getApplied();
+        const requested = modelName(message.model);
+        const sessionID = typeof hookInput.sessionID === "string" ? hookInput.sessionID : undefined;
+        const result = await check();
+        if (result === undefined || requested === undefined) {
+            return;
+        }
+        const { connected, available } = result;
+        const remember = (model) => {
+            if (sessionID !== undefined) {
+                sessionModels.set(sessionID, model);
+            }
+        };
+        if (available.has(requested)) {
+            remember(requested);
+            return;
+        }
+        // A model the caller chose (as the task tool does for a subagent) is moved only when a ref put it there. One
+        // OpenCode took from the agent or the session is moved either way, because OpenCode stores a session's model
+        // before this hook runs, so a session keeps asking for it after the ref is fixed or left out.
+        const assignment = applied.assignments.find((candidate) => candidate.agent === message.agent && candidate.model === requested) ??
+            applied.assignments.find((candidate) => candidate.model === requested);
+        if (assignment === undefined &&
+            (hookInput.model !== undefined ||
+                !knownRefModels(directory).has(requested))) {
+            return;
+        }
+        const own = assignment !== undefined &&
+            assignment.agent === message.agent &&
+            assignment.ownModel !== undefined
+            ? {
+                model: assignment.ownModel,
+                ...(assignment.ownVariant === undefined
+                    ? {}
+                    : { variant: assignment.ownVariant }),
+            }
+            : undefined;
+        const inherited = sessionID === undefined
+            ? undefined
+            : await parentModel(sessionID).catch(() => undefined);
+        const fallback = fallbackModel({
+            ...(own === undefined ? {} : { own }),
+            ...(inherited === undefined ? {} : { parentModel: inherited }),
+            available,
+            connected,
+            ...(applied.configuredModel === undefined
+                ? {}
+                : { configuredModel: applied.configuredModel }),
+            configuredProviders: applied.configuredProviders,
+            recent: await recentModels(stateDirectory()),
+        });
+        if (fallback === undefined) {
+            return;
+        }
+        message.model = fallback;
+        remember(`${fallback.providerID}/${fallback.modelID}`);
+        const agent = typeof message.agent === "string" ? message.agent : "the agent";
+        await log(assignment === undefined
+            ? `${agent} asked for ${requested}, which no connected provider offers; it uses ${fallback.providerID}/${fallback.modelID} instead.`
+            : `Ref "${assignment.ref}" uses ${requested}, which no connected provider offers; ${agent} uses ${fallback.providerID}/${fallback.modelID} instead.`);
+    };
+    /** Reloads only while no session is busy and no terminal is open, since a reload ends running terminals. */
+    const reloadWhenIdle = async () => {
+        const status = await client.session.status({ query: { directory } });
+        if (status.error !== undefined ||
+            !isRecord(status.data) ||
+            Object.values(status.data).some((session) => !isRecord(session) || session.type !== "idle")) {
+            return;
+        }
+        const terminals = await client.pty.list({ query: { directory } });
+        if (terminals.error !== undefined ||
+            !Array.isArray(terminals.data) ||
+            terminals.data.length > 0) {
+            return;
+        }
+        const available = lastAvailable;
+        const disposed = await client.instance.dispose({ query: { directory } });
+        if (disposed.error === undefined) {
+            reloadWanted = false;
+            if (available !== undefined) {
+                reloadedFor.set(directory, availabilityKey(available));
+            }
+        }
+    };
+    const scheduleReload = () => {
+        if (!reloadWanted || reloading) {
+            return;
+        }
+        reloading = true;
+        // Disposing from inside the event that reports idleness would wait on this very hook.
+        setTimeout(() => {
+            reloadWhenIdle()
+                .catch(() => undefined)
+                .finally(() => {
+                reloading = false;
+            });
+        }, 0);
+    };
+    return {
+        message: async (hookInput, message) => {
+            if (isRecord(message)) {
+                await checkMessage(hookInput, message);
+            }
+        },
+        forget: (sessionID) => {
+            sessionModels.delete(sessionID);
+        },
+        event: (type) => {
+            if (!checkedOnce) {
+                // Saves availability before the first prompt too, so the next start leaves unavailable refs out. Reloading
+                // waits for an idle session, since the project may still be starting.
+                checkedOnce = true;
+                setTimeout(() => {
+                    check().catch(() => undefined);
+                }, 0);
+            }
+            if (type === "session.idle") {
+                scheduleReload();
+            }
+        },
+    };
+}
+const ModelProfilesServer = (input, options) => {
+    const worktree = worktreeRoot(input.worktree, input.directory);
+    let applied = { assignments: [], configuredProviders: [] };
+    const fallbacks = createFallbacks(input, () => applied);
+    return Promise.resolve({
+        config: async (config) => {
+            const target = config;
+            const configFile = modelsFilePath(options);
+            try {
+                const available = await knownAvailableModels(stateDirectory(), input.directory);
+                const resolved = await resolveModelProfiles(target, {
+                    configFile,
+                    worktree,
+                    ...(available === undefined ? {} : { availableModels: available }),
+                });
+                applied = {
+                    assignments: resolved.assignments,
+                    ...(typeof target.model === "string"
+                        ? { configuredModel: target.model }
+                        : {}),
+                    configuredProviders: isRecord(target.provider)
+                        ? Object.keys(target.provider)
+                        : [],
+                };
+                publishReport(target, options, resolved.report);
+            }
+            catch (error) {
+                try {
+                    applied = { assignments: [], configuredProviders: [] };
+                    stripModelRefs(target);
+                    publishReport(target, options, {
+                        version: 1,
+                        configFile,
+                        selectionFile: selectionFilePath(stateDirectory(), worktree),
+                        worktree,
+                        profiles: [],
+                        profile: null,
+                        profileSource: "none",
+                        refs: [],
+                        notices: [
+                            `Model refs were not applied (${error instanceof Error ? error.message : String(error)}); agents keep OpenCode's models.`,
+                        ],
+                    });
+                }
+                catch {
+                    // A failing config hook must never stop OpenCode; agents then keep OpenCode's models.
+                }
+            }
+        },
+        "chat.message": async (hookInput, output) => {
+            try {
+                await fallbacks.message(hookInput, output.message);
+            }
+            catch {
+                // A failed check leaves the prompt as OpenCode built it.
+            }
+        },
+        event: ({ event }) => {
+            try {
+                fallbacks.event(event.type);
+                if (event.type === "session.deleted") {
+                    fallbacks.forget(event.properties.info.id);
+                }
+            }
+            catch {
+                // Fallback checks never stop OpenCode's events.
+            }
+            return Promise.resolve();
+        },
+    });
+};
+export default {
+    id: "model-profiles",
+    server: ModelProfilesServer,
+};

package/dist/tui.d.ts

@@ -0,0 +1,6 @@
+import type { TuiPlugin } from "@opencode-ai/plugin/tui";
+declare const _default: {
+    id: string;
+    tui: TuiPlugin;
+};
+export default _default;

package/dist/tui.js

@@ -0,0 +1,204 @@
+import { fallbackToastLines, modelConfigOptions, profileLabel, selectedChoice, selectedNotice, unavailableModelNotices, } from "./model-config-view.js";
+import { loadModelsDocument } from "./models-file.js";
+import { readReport } from "./report.js";
+import { clearSelection, processProfileVariable, readSavedSelection, saveSelection, } from "./selection.js";
+const toastTitle = "Model Profiles";
+function errorText(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function registerModelConfig(api) {
+    const directory = () => api.state.path.directory;
+    let shownNotices = new Set();
+    let reading = Promise.resolve();
+    let reloadsInFlight = 0;
+    const toast = (variant, lines) => {
+        api.ui.toast({
+            variant,
+            title: toastTitle,
+            message: lines.join("\n"),
+            duration: variant === "warning" ? 10_000 : 5_000,
+        });
+    };
+    /** Reads what the server applied; a fallback is new until it disappears from a later report. */
+    const readApplied = () => {
+        const next = reading.then(async () => {
+            const response = await api.client.config.get({ directory: directory() });
+            const report = response.error === undefined ? readReport(response.data) : undefined;
+            if (report === undefined) {
+                return undefined;
+            }
+            const notices = [
+                ...unavailableModelNotices(report.refs, api.state.provider),
+                ...report.notices,
+            ];
+            const newNotices = notices.filter((notice) => !shownNotices.has(notice));
+            shownNotices = new Set(notices);
+            return { report, notices, newNotices };
+        });
+        reading = next.catch(() => undefined);
+        return next;
+    };
+    const announceFallbacks = async () => {
+        const applied = await readApplied();
+        if (applied !== undefined && applied.newNotices.length > 0) {
+            toast("warning", fallbackToastLines(applied.newNotices));
+        }
+    };
+    const reload = async (label) => {
+        const status = await api.client.session.status({ directory: directory() });
+        if (status.error !== undefined) {
+            toast("warning", [
+                `Saved ${label} for this worktree, but OpenCode could not report whether a session is busy, so it did not reload. It applies on the next reload.`,
+            ]);
+            return;
+        }
+        if (Object.values(status.data).some((session) => session.type !== "idle")) {
+            toast("info", [
+                `Saved ${label} for this worktree. A session is busy, so it applies the next time OpenCode reloads this project, or pick it again in /model-config once the session is idle.`,
+            ]);
+            return;
+        }
+        reloadsInFlight += 1;
+        const disposed = await api.client.instance
+            .dispose({ directory: directory() })
+            .finally(() => {
+            reloadsInFlight -= 1;
+        });
+        if (disposed.error !== undefined) {
+            toast("warning", [
+                `Saved ${label}, but OpenCode did not reload. It applies on the next reload.`,
+            ]);
+            return;
+        }
+        const applied = await readApplied();
+        if (applied === undefined) {
+            toast("success", [`Saved ${label}.`]);
+            return;
+        }
+        toast(applied.newNotices.length > 0 ? "warning" : "success", [
+            `Using ${profileLabel(applied.report.profile)}.`,
+            ...fallbackToastLines(applied.newNotices),
+        ]);
+    };
+    const choose = async (report, choice, defaultProfile) => {
+        const label = choice.kind === "save"
+            ? profileLabel(choice.profile)
+            : `defaultProfile (${defaultProfile ?? "none"})`;
+        try {
+            await (choice.kind === "save"
+                ? saveSelection(report.selectionFile, report.worktree, choice.profile)
+                : clearSelection(report.selectionFile));
+        }
+        catch (error) {
+            toast("warning", [`Could not save ${label}: ${errorText(error)}`]);
+            return;
+        }
+        if (report.environmentProfile !== undefined) {
+            toast("info", [
+                `Saved ${label} for this worktree. ${processProfileVariable}=${report.environmentProfile} still applies to this OpenCode process.`,
+            ]);
+            return;
+        }
+        try {
+            await reload(label);
+        }
+        catch (error) {
+            toast("warning", [
+                `Saved ${label}, but could not reload OpenCode (${errorText(error)}). It applies on the next reload.`,
+            ]);
+        }
+    };
+    const open = async () => {
+        const applied = await readApplied().catch(() => undefined);
+        if (applied === undefined) {
+            toast("warning", [
+                "The server plugin has not reported model refs. Add @lunchbox-labs/opencode-model-profiles to plugin in opencode.jsonc.",
+            ]);
+            return;
+        }
+        const { report, notices } = applied;
+        const [current, saved] = await Promise.all([
+            loadModelsDocument(report.configFile),
+            readSavedSelection(report.selectionFile),
+        ]);
+        const loaded = current.status === "loaded";
+        const defaultProfile = loaded ? current.document.defaultProfile : undefined;
+        api.ui.dialog.replace(() => api.ui.DialogSelect({
+            title: "Model config",
+            options: modelConfigOptions({
+                report,
+                profiles: loaded
+                    ? Object.keys(current.document.profiles)
+                    : report.profiles,
+                savedProfile: saved.profile,
+                defaultProfile,
+                notices,
+            }),
+            current: report.profile === null ? "defaults" : `profile:${report.profile}`,
+            onSelect: (option) => {
+                const notice = selectedNotice(option.value, notices);
+                if (notice !== undefined) {
+                    toast("warning", [notice]);
+                    return;
+                }
+                const choice = selectedChoice(option.value);
+                if (choice === undefined) {
+                    return;
+                }
+                api.ui.dialog.clear();
+                choose(report, choice, defaultProfile).catch(() => undefined);
+            },
+        }));
+        api.ui.dialog.setSize("large");
+    };
+    const unregister = api.keymap.registerLayer({
+        commands: [
+            {
+                name: "model-profiles.config",
+                title: "Model config",
+                category: "Model",
+                namespace: "palette",
+                slashName: "model-config",
+                run: () => {
+                    open().catch(() => undefined);
+                },
+            },
+        ],
+    });
+    const unsubscribeInstance = api.event.on("server.instance.disposed", (event) => {
+        if (reloadsInFlight === 0 && event.properties.directory === directory()) {
+            announceFallbacks().catch(() => undefined);
+        }
+    });
+    const unsubscribeGlobal = api.event.on("global.disposed", () => {
+        announceFallbacks().catch(() => undefined);
+    });
+    /** Models are checked against connected providers, which may not have loaded when the TUI starts. */
+    let providerChecks = 0;
+    const providerTimer = setInterval(() => {
+        providerChecks += 1;
+        if (api.state.provider.length > 0) {
+            clearInterval(providerTimer);
+            announceFallbacks().catch(() => undefined);
+        }
+        else if (providerChecks >= 60) {
+            clearInterval(providerTimer);
+        }
+    }, 500);
+    providerTimer.unref();
+    api.lifecycle.onDispose(() => {
+        clearInterval(providerTimer);
+        unregister();
+        unsubscribeInstance();
+        unsubscribeGlobal();
+    });
+    announceFallbacks().catch(() => undefined);
+}
+const ModelProfilesTui = (api) => {
+    registerModelConfig(api);
+    return Promise.resolve();
+};
+export default {
+    id: "model-profiles",
+    tui: ModelProfilesTui,
+};

package/package.json

@@ -1,6 +1,75 @@
 {
   "name": "@lunchbox-labs/opencode-model-profiles",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.1",
+  "description": "Pick agent models by name, with defaults and per-worktree profiles",
+  "license": "MIT",
+  "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/lunchbox-labs/opencode-model-profiles.git"
+  },
+  "engines": {
+    "node": ">=22.18.0"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/server.d.ts",
+      "default": "./dist/server.js"
+    },
+    "./server": {
+      "types": "./dist/server.d.ts",
+      "default": "./dist/server.js"
+    },
+    "./tui": {
+      "types": "./dist/tui.d.ts",
+      "default": "./dist/tui.js"
+    },
+    "./schema.json": "./schema.json"
+  },
+  "files": [
+    "dist",
+    "schema.json",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "typecheck": "tsc -p tsconfig.json",
+    "test": "node --experimental-strip-types --test tests/*.test.ts tests/*.test.mjs",
+    "lint": "eslint . --max-warnings 0",
+    "format": "prettier --write src tests scripts package.json tsconfig*.json *.config.mjs schema.json",
+    "format:check": "prettier --check src tests scripts package.json tsconfig*.json *.config.mjs schema.json",
+    "check": "npm run check:static && npm test",
+    "prepack": "npm run build",
+    "test:package": "npm run build && node --experimental-strip-types --test tests/package.integration.ts",
+    "check:static": "concurrently --names typecheck,lint,format --kill-others-on-fail \"npm run typecheck\" \"npm run lint\" \"npm run format:check\"",
+    "prebuild": "node --input-type=module -e \"import { rm } from 'node:fs/promises'; await rm('dist', { recursive: true, force: true });\""
+  },
+  "devDependencies": {
+    "@eslint-community/eslint-plugin-eslint-comments": "4.8.1",
+    "@eslint/js": "10.0.1",
+    "@opencode-ai/plugin": "1.19.5",
+    "@opencode-ai/sdk": "1.19.5",
+    "@opentui/core": "0.4.5",
+    "@opentui/keymap": "0.4.5",
+    "@opentui/solid": "0.4.5",
+    "@types/node": "24.19.2",
+    "concurrently": "10.0.6",
+    "eslint": "10.14.0",
+    "eslint-config-prettier": "10.1.8",
+    "eslint-plugin-regexp": "3.3.3",
+    "globals": "17.14.0",
+    "prettier": "3.9.10",
+    "solid-js": "1.9.12",
+    "typescript": "6.0.3",
+    "typescript-eslint": "8.72.1",
+    "yaml": "2.9.1"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org"
+  },
+  "dependencies": {
+    "jsonc-parser": "3.3.1"
+  }
+}

package/schema.json

@@ -0,0 +1,97 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://cdn.jsdelivr.net/npm/@lunchbox-labs/opencode-model-profiles/schema.json",
+  "title": "OpenCode Model Profiles",
+  "description": "Named model refs for OpenCode agents: defaults, per-worktree profiles and built-in agent refs.",
+  "type": "object",
+  "additionalProperties": false,
+  "properties": {
+    "$schema": {
+      "type": "string"
+    },
+    "defaultProfile": {
+      "description": "Profile used when no profile is saved for the worktree and OPENCODE_MODEL_PROFILE is unset.",
+      "type": "string",
+      "minLength": 1
+    },
+    "defaults": {
+      "description": "Model for each ref when the selected profile does not define it.",
+      "$ref": "#/$defs/refs"
+    },
+    "profiles": {
+      "description": "Profiles by name, each mapping ref names to models.",
+      "type": "object",
+      "propertyNames": {
+        "minLength": 1
+      },
+      "additionalProperties": {
+        "$ref": "#/$defs/refs"
+      }
+    },
+    "builtins": {
+      "description": "Ref for each built-in OpenCode agent. Built-in agents without a ref keep OpenCode's default model.",
+      "type": "object",
+      "additionalProperties": false,
+      "properties": {
+        "build": {
+          "$ref": "#/$defs/refName"
+        },
+        "plan": {
+          "$ref": "#/$defs/refName"
+        },
+        "general": {
+          "$ref": "#/$defs/refName"
+        },
+        "explore": {
+          "$ref": "#/$defs/refName"
+        },
+        "compaction": {
+          "$ref": "#/$defs/refName"
+        },
+        "title": {
+          "$ref": "#/$defs/refName"
+        },
+        "summary": {
+          "$ref": "#/$defs/refName"
+        }
+      }
+    }
+  },
+  "$defs": {
+    "refName": {
+      "type": "string",
+      "minLength": 1
+    },
+    "modelIdentifier": {
+      "type": "string",
+      "pattern": "^[^\\s/]+/\\S+$"
+    },
+    "refs": {
+      "type": "object",
+      "propertyNames": {
+        "minLength": 1
+      },
+      "additionalProperties": {
+        "oneOf": [
+          {
+            "$ref": "#/$defs/modelIdentifier"
+          },
+          {
+            "type": "object",
+            "additionalProperties": false,
+            "required": ["model"],
+            "properties": {
+              "model": {
+                "$ref": "#/$defs/modelIdentifier"
+              },
+              "variant": {
+                "type": "string",
+                "minLength": 1
+              }
+            }
+          }
+        ]
+      }
+    }
+  }
+}