@lunchbox-labs/opencode-model-profiles 0.1.0 → 0.1.1

package/README.md

@@ -86,6 +86,6 @@ Precedence: `OPENCODE_MODEL_PROFILE`, then the saved worktree choice, then `defa
 
 Problems in the configuration never stop OpenCode. A missing or unparsable `models.jsonc`, an invalid entry or a ref that resolves nowhere leaves the affected agents as OpenCode would configure them; invalid entries are skipped one by one, so the rest of the file still applies. An undefined profile is skipped as described above.
 
-The plugin does not check that a model exists when it applies a ref, so an agent whose ref names a model no connected provider offers fails when used. The TUI warns about such refs.
+A ref whose model no connected provider offers falls back too, to the model OpenCode would use without the ref: the agent's own `model`, a subagent's parent model, else OpenCode's default. The plugin applies refs before OpenCode loads providers, so it saves which models were available in OpenCode's state directory and leaves unavailable refs out from the next start. Until it has checked once, prompts to such a model are moved to the fallback, and once no session is busy and no terminal is open the plugin reloads the project, which restarts its MCP and LSP servers. That covers built-in agents such as `compaction` and `title` that never receive a prompt of their own; in the first process that meets a broken ref they, and commands that name the agent, can still fail until that reload. A prompt that reuses a ref's unavailable model after the ref is fixed falls back too, while a model you set on an agent yourself is left as OpenCode would use it. If a provider connects after the last check, its refs apply again after the first reload.
 
 The TUI shows a warning toast with the first new problem and how many more there are. A problem is toasted once per OpenCode launch, and again after it changes; `/model-config` lists all current ones.

package/dist/apply.d.ts

@@ -1,11 +1,18 @@
 import type { ModelProfilesReport } from "./report.ts";
+import { type RefAssignment } from "./resolution.ts";
 export declare function modelsFilePath(options: unknown, environment?: NodeJS.ProcessEnv): string;
 export interface ResolveInput {
     configFile: string;
     worktree: string;
     environment?: NodeJS.ProcessEnv;
+    /** Models connected providers offered when last checked; refs to others are not applied. Unknown until checked. */
+    availableModels?: ReadonlySet<string>;
+}
+export interface ResolvedModelProfiles {
+    report: ModelProfilesReport;
+    assignments: RefAssignment[];
 }
 /** Replaces `config.agent` with resolved copies and returns what was applied; never throws for bad input files. */
-export declare function resolveModelProfiles(config: Record<string, unknown>, input: ResolveInput): Promise<ModelProfilesReport>;
+export declare function resolveModelProfiles(config: Record<string, unknown>, input: ResolveInput): Promise<ResolvedModelProfiles>;
 /** The last resort when resolution fails unexpectedly: OpenCode's models stay, and modelRef never reaches a provider. */
 export declare function stripModelRefs(config: Record<string, unknown>): void;

package/dist/apply.js

@@ -1,6 +1,6 @@
 import path from "node:path";
 import { isRecord, loadModelsDocument, } from "./models-file.js";
-import { applyModelRefs, selectProfile } from "./resolution.js";
+import { applyModelRefs, selectProfile, } from "./resolution.js";
 import { configurationDirectory, processProfile, readSavedSelection, selectionFilePath, stateDirectory, } from "./selection.js";
 export function modelsFilePath(options, environment = process.env) {
     const directory = configurationDirectory(environment);
@@ -31,14 +31,14 @@ export async function resolveModelProfiles(config, input) {
         notices.push(saved.notice);
     }
     const selection = selectProfile(loaded.document, environmentProfile, saved.profile);
-    const applied = applyModelRefs(config.agent, loaded.document, selection.profile);
+    const applied = applyModelRefs(config.agent, loaded.document, selection.profile, input.availableModels);
     if (loaded.status === "loaded") {
         notices.push(...selection.notices, ...applied.notices);
     }
     if (isRecord(config.agent) || Object.keys(applied.agents).length > 0) {
         config.agent = applied.agents;
     }
-    return {
+    const report = {
         version: 1,
         configFile: input.configFile,
         selectionFile,
@@ -50,6 +50,7 @@ export async function resolveModelProfiles(config, input) {
         refs: applied.refs,
         notices,
     };
+    return { report, assignments: applied.assignments };
 }
 /** The last resort when resolution fails unexpectedly: OpenCode's models stay, and modelRef never reaches a provider. */
 export function stripModelRefs(config) {

package/dist/fallback.d.ts

@@ -0,0 +1,49 @@
+import type { RefAssignment } from "./resolution.ts";
+export declare function knownRefModels(directory: string): ReadonlySet<string>;
+export declare function availabilityFilePath(state: string, directory: string): string;
+/** The models last seen for this directory, from memory or the state file; undefined when never checked. */
+export declare function knownAvailableModels(state: string, directory: string): Promise<ReadonlySet<string> | undefined>;
+export declare function availabilityKey(models: ReadonlySet<string>): string;
+/** Remembers the models for this directory and the ref models seen, saving them when they changed; best-effort. */
+export declare function rememberAvailableModels(state: string, directory: string, models: ReadonlySet<string>, assigned?: Iterable<string>): Promise<void>;
+export interface ConnectedProviders {
+    providers: {
+        id: string;
+        models: Record<string, unknown>;
+    }[];
+    default: Record<string, string>;
+}
+/** Reads OpenCode's provider list response; anything unexpected yields undefined so nothing changes. */
+export declare function readConnectedProviders(data: unknown): ConnectedProviders | undefined;
+export declare function availableModels(connected: ConnectedProviders): ReadonlySet<string>;
+/** True when the agents the config hook built no longer match what is available, so a reload would change them. */
+export declare function assignmentsAreStale(assignments: readonly RefAssignment[], available: ReadonlySet<string>): boolean;
+/** OpenCode's recently used models, which it tries before a provider's default when no `model` is set. */
+export declare function recentModels(state: string): Promise<string[]>;
+export interface FallbackInput {
+    /** The agent's own model and variant, when it had one besides its ref. */
+    own?: {
+        model: string;
+        variant?: string;
+    };
+    /** The model of the session that started this subagent, which OpenCode gives a subagent without a model. */
+    parentModel?: string;
+    available: ReadonlySet<string>;
+    connected: ConnectedProviders;
+    /** The top-level `model` from OpenCode's config. */
+    configuredModel?: string;
+    /** Provider ids configured under `provider`, which OpenCode prefers for its default. */
+    configuredProviders: readonly string[];
+    recent: readonly string[];
+}
+export interface FallbackModel {
+    providerID: string;
+    modelID: string;
+    variant?: string;
+}
+/**
+ * The model OpenCode would use for the agent without its ref: the agent's own `model`, else for a subagent its
+ * parent's model, else OpenCode's default (the configured `model`, a recently used model, then a connected
+ * provider's default), skipping unavailable ones.
+ */
+export declare function fallbackModel(input: FallbackInput): FallbackModel | undefined;

package/dist/fallback.js

@@ -0,0 +1,169 @@
+import { createHash, randomUUID } from "node:crypto";
+import { mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { isRecord } from "./models-file.js";
+/**
+ * Models connected providers offered when last checked, per instance directory. OpenCode keeps the plugin module
+ * loaded when it reloads a project, so this outlives the reload that lets the config hook leave unavailable refs
+ * unapplied. It is also saved in OpenCode's state directory, so a new process (such as `opencode run`) leaves them
+ * out from the start.
+ */
+const availability = new Map();
+/**
+ * Every model a ref has put on an agent, per directory, also saved. A session can keep asking for one after its ref
+ * is fixed or left out, and only those are moved when OpenCode took the model from the agent or the session, so a
+ * model the user set by hand still fails as OpenCode would.
+ */
+const refModels = new Map();
+export function knownRefModels(directory) {
+    return refModels.get(directory) ?? new Set();
+}
+export function availabilityFilePath(state, directory) {
+    const key = createHash("sha256")
+        .update(process.platform === "win32"
+        ? path.resolve(directory).toLowerCase()
+        : path.resolve(directory))
+        .digest("hex")
+        .slice(0, 32);
+    return path.join(state, "model-profiles", "available", `${key}.json`);
+}
+/** The models last seen for this directory, from memory or the state file; undefined when never checked. */
+export async function knownAvailableModels(state, directory) {
+    const known = availability.get(directory);
+    if (known !== undefined) {
+        return known;
+    }
+    try {
+        const value = JSON.parse(await readFile(availabilityFilePath(state, directory), "utf8"));
+        if (isRecord(value) &&
+            value.version === 1 &&
+            Array.isArray(value.models) &&
+            value.models.every((model) => typeof model === "string")) {
+            const models = new Set(value.models);
+            availability.set(directory, models);
+            if (!refModels.has(directory) &&
+                Array.isArray(value.refModels) &&
+                value.refModels.every((model) => typeof model === "string")) {
+                refModels.set(directory, new Set(value.refModels));
+            }
+            return models;
+        }
+    }
+    catch {
+        // A missing or unreadable file means availability is not known yet.
+    }
+    return undefined;
+}
+export function availabilityKey(models) {
+    return [...models].sort().join("\n");
+}
+/** Remembers the models for this directory and the ref models seen, saving them when they changed; best-effort. */
+export async function rememberAvailableModels(state, directory, models, assigned = []) {
+    const previous = availability.get(directory);
+    const previousRefs = knownRefModels(directory);
+    const refs = new Set([...previousRefs, ...assigned]);
+    availability.set(directory, models);
+    refModels.set(directory, refs);
+    if (previous !== undefined &&
+        availabilityKey(previous) === availabilityKey(models) &&
+        refs.size === previousRefs.size) {
+        return;
+    }
+    const file = availabilityFilePath(state, directory);
+    const temporary = `${file}.${randomUUID()}.tmp`;
+    try {
+        await mkdir(path.dirname(file), { recursive: true });
+        await writeFile(temporary, `${JSON.stringify({ version: 1, directory, models: [...models].sort(), refModels: [...refs].sort() })}\n`, "utf8");
+        await rename(temporary, file);
+    }
+    catch {
+        // Without the file the next process learns availability on its first prompt instead.
+    }
+    finally {
+        await rm(temporary, { force: true }).catch(() => undefined);
+    }
+}
+/** Reads OpenCode's provider list response; anything unexpected yields undefined so nothing changes. */
+export function readConnectedProviders(data) {
+    if (!isRecord(data) || !Array.isArray(data.providers)) {
+        return undefined;
+    }
+    const providers = data.providers.flatMap((provider) => isRecord(provider) &&
+        typeof provider.id === "string" &&
+        isRecord(provider.models)
+        ? [{ id: provider.id, models: provider.models }]
+        : []);
+    const defaults = isRecord(data.default)
+        ? Object.fromEntries(Object.entries(data.default).filter((entry) => typeof entry[1] === "string"))
+        : {};
+    return { providers, default: defaults };
+}
+export function availableModels(connected) {
+    return new Set(connected.providers.flatMap((provider) => Object.keys(provider.models).map((model) => `${provider.id}/${model}`)));
+}
+/** True when the agents the config hook built no longer match what is available, so a reload would change them. */
+export function assignmentsAreStale(assignments, available) {
+    return assignments.some((assignment) => assignment.applied !== available.has(assignment.model));
+}
+/** OpenCode's recently used models, which it tries before a provider's default when no `model` is set. */
+export async function recentModels(state) {
+    try {
+        const value = JSON.parse(await readFile(path.join(state, "model.json"), "utf8"));
+        if (!isRecord(value) || !Array.isArray(value.recent)) {
+            return [];
+        }
+        return value.recent.flatMap((entry) => isRecord(entry) &&
+            typeof entry.providerID === "string" &&
+            typeof entry.modelID === "string"
+            ? [`${entry.providerID}/${entry.modelID}`]
+            : []);
+    }
+    catch {
+        return [];
+    }
+}
+function split(model) {
+    const separator = model.indexOf("/");
+    return {
+        providerID: model.slice(0, separator),
+        modelID: model.slice(separator + 1),
+    };
+}
+function hasVariant(connected, model, variant) {
+    const { providerID, modelID } = split(model);
+    const info = connected.providers.find((provider) => provider.id === providerID)?.models[modelID];
+    // Only a model that lists its variants can be known not to offer one.
+    return (!isRecord(info) ||
+        !isRecord(info.variants) ||
+        Object.hasOwn(info.variants, variant));
+}
+/**
+ * The model OpenCode would use for the agent without its ref: the agent's own `model`, else for a subagent its
+ * parent's model, else OpenCode's default (the configured `model`, a recently used model, then a connected
+ * provider's default), skipping unavailable ones.
+ */
+export function fallbackModel(input) {
+    const { own, available, connected } = input;
+    if (own !== undefined && available.has(own.model)) {
+        return {
+            ...split(own.model),
+            ...(own.variant !== undefined &&
+                hasVariant(connected, own.model, own.variant)
+                ? { variant: own.variant }
+                : {}),
+        };
+    }
+    const provider = connected.providers.find((candidate) => input.configuredProviders.length === 0 ||
+        input.configuredProviders.includes(candidate.id));
+    const providerDefault = provider === undefined ? undefined : connected.default[provider.id];
+    const candidates = [
+        input.parentModel,
+        input.configuredModel,
+        ...input.recent,
+        provider === undefined || providerDefault === undefined
+            ? undefined
+            : `${provider.id}/${providerDefault}`,
+    ];
+    const model = candidates.find((candidate) => candidate !== undefined && available.has(candidate));
+    return model === undefined ? undefined : split(model);
+}

package/dist/model-config-view.d.ts

@@ -8,8 +8,8 @@ export interface ConnectedProvider {
     models: Record<string, unknown>;
 }
 /**
- * The server cannot see which providers are connected, so the TUI checks resolved models against them.
- * With no provider list (not loaded yet) nothing is reported, rather than every ref.
+ * The server's config hook runs before providers load, so the TUI checks resolved models against them until
+ * the server has marked a ref unavailable itself. With no provider list (not loaded yet) nothing is reported.
  */
 export declare function unavailableModelNotices(refs: readonly RefResolution[], providers: readonly ConnectedProvider[]): string[];
 export interface ModelConfigViewInput {

package/dist/model-config-view.js

@@ -1,3 +1,4 @@
+import { unavailableModelNotice } from "./resolution.js";
 import { processProfileVariable } from "./selection.js";
 export function profileLabel(profile) {
     return profile ?? "Defaults only";
@@ -6,20 +7,23 @@ function modelLabel(ref) {
     if (ref.model === undefined) {
         return "not defined, OpenCode's model";
     }
-    return ref.variant === undefined
-        ? ref.model
-        : `${ref.model} (${ref.variant})`;
+    const model = ref.variant === undefined ? ref.model : `${ref.model} (${ref.variant})`;
+    return ref.unavailable === true
+        ? `${model}, unavailable, OpenCode's model`
+        : model;
 }
 /**
- * The server cannot see which providers are connected, so the TUI checks resolved models against them.
- * With no provider list (not loaded yet) nothing is reported, rather than every ref.
+ * The server's config hook runs before providers load, so the TUI checks resolved models against them until
+ * the server has marked a ref unavailable itself. With no provider list (not loaded yet) nothing is reported.
  */
 export function unavailableModelNotices(refs, providers) {
     if (providers.length === 0) {
         return [];
     }
     return refs.flatMap((ref) => {
-        if (ref.model === undefined || ref.agents.length === 0) {
+        if (ref.model === undefined ||
+            ref.unavailable === true ||
+            ref.agents.length === 0) {
             return [];
         }
         const separator = ref.model.indexOf("/");
@@ -29,11 +33,8 @@ export function unavailableModelNotices(refs, providers) {
         if (provider !== undefined && Object.hasOwn(provider.models, modelId)) {
             return [];
         }
-        const reason = provider === undefined
-            ? `provider "${providerId}" is not connected`
-            : `"${providerId}" has no model "${modelId}"`;
         return [
-            `Ref "${ref.ref}" uses ${ref.model}, but ${reason}; ${ref.agents.join(", ")} will fail until you fix the ref or pick another profile.`,
+            unavailableModelNotice(ref.ref, ref.model, ref.agents, provider !== undefined),
         ];
     });
 }
@@ -90,7 +91,9 @@ export function modelConfigOptions(input) {
             value: `ref:${ref.ref}`,
             category: "Model refs",
             description: ref.agents.length === 0 ? "No agents" : ref.agents.join(", "),
-            footer: ref.source === "unresolved" ? "fallback" : ref.source,
+            footer: ref.source === "unresolved" || ref.unavailable === true
+                ? "fallback"
+                : ref.source,
         })),
         ...input.notices.map((notice, index) => ({
             title: notice,

package/dist/resolution.d.ts

@@ -8,20 +8,39 @@ export interface ProfileSelection {
 }
 /** Takes the first choice that names a defined profile (or "defaults only"); undefined profiles fall through to the next. */
 export declare function selectProfile(document: ModelsDocument, environmentProfile: string | undefined, savedProfile: SavedProfile): ProfileSelection;
+/**
+ * The fallback notice for a ref whose model no connected provider offers. The server and the TUI word it the same
+ * way, so the TUI does not toast it again when the reload that drops the ref replaces its own check with the server's.
+ */
+export declare function unavailableModelNotice(ref: string, model: string, agents: readonly string[], providerConnected: boolean): string;
 export interface RefResolution {
     ref: string;
     model?: string;
     variant?: string;
     source: "profile" | "defaults" | "unresolved";
+    /** Set when no connected provider offers the model, so agents keep OpenCode's model. */
+    unavailable?: true;
     agents: string[];
 }
+/** A ref that resolved for an agent, and the model the agent had without it, for falling back at runtime. */
+export interface RefAssignment {
+    agent: string;
+    ref: string;
+    model: string;
+    variant?: string;
+    ownModel?: string;
+    ownVariant?: string;
+    /** False when the model was known to be unavailable, so the agent kept its own model. */
+    applied: boolean;
+}
 export interface AppliedModelRefs {
     agents: Record<string, unknown>;
     refs: RefResolution[];
+    assignments: RefAssignment[];
     notices: string[];
 }
 /**
  * Returns a new agent map and leaves the given one untouched: OpenCode keeps the global config's
  * agent objects for the whole process, so mutating them would lose each modelRef on the next reload.
  */
-export declare function applyModelRefs(configuredAgents: unknown, document: ModelsDocument, profile: string | null): AppliedModelRefs;
+export declare function applyModelRefs(configuredAgents: unknown, document: ModelsDocument, profile: string | null, availableModels?: ReadonlySet<string>): AppliedModelRefs;

package/dist/resolution.js

@@ -34,6 +34,20 @@ export function selectProfile(document, environmentProfile, savedProfile) {
         notices: skipped.map(([requested, source]) => `Profile "${requested}" from ${profileOrigins[source]} is not defined in models.jsonc; using ${using}.`),
     };
 }
+function providerOf(model) {
+    return model.slice(0, model.indexOf("/"));
+}
+/**
+ * The fallback notice for a ref whose model no connected provider offers. The server and the TUI word it the same
+ * way, so the TUI does not toast it again when the reload that drops the ref replaces its own check with the server's.
+ */
+export function unavailableModelNotice(ref, model, agents, providerConnected) {
+    const providerId = providerOf(model);
+    const reason = providerConnected
+        ? `"${providerId}" has no model "${model.slice(providerId.length + 1)}"`
+        : `provider "${providerId}" is not connected`;
+    return `Ref "${ref}" uses ${model}, but ${reason}; ${agents.join(", ")} ${agents.length === 1 ? "falls" : "fall"} back to OpenCode's model until you fix the ref or pick another profile.`;
+}
 function resolveRef(document, profile, ref) {
     const profileRefs = profile === null ? undefined : ownValue(document.profiles, profile);
     const profileChoice = profileRefs === undefined ? undefined : ownValue(profileRefs, ref);
@@ -59,8 +73,10 @@ function withoutModelRef(agent) {
  * Returns a new agent map and leaves the given one untouched: OpenCode keeps the global config's
  * agent objects for the whole process, so mutating them would lose each modelRef on the next reload.
  */
-export function applyModelRefs(configuredAgents, document, profile) {
+export function applyModelRefs(configuredAgents, document, profile, availableModels) {
     const notices = [];
+    const assignments = [];
+    const isAvailable = (model) => availableModels === undefined || availableModels.has(model);
     const agents = {};
     const refAgents = new Map();
     const builtIns = builtInAgentNames;
@@ -100,12 +116,29 @@ export function applyModelRefs(configuredAgents, document, profile) {
         refAgents.set(ref, [...(refAgents.get(ref) ?? []), name]);
         const resolved = resolveRef(document, profile, ref);
         if (resolved !== undefined) {
-            agent.model = resolved.choice.model;
-            if (resolved.choice.variant !== undefined) {
-                agent.variant = resolved.choice.variant;
+            const applied = isAvailable(resolved.choice.model);
+            assignments.push({
+                agent: name,
+                ref,
+                model: resolved.choice.model,
+                ...(resolved.choice.variant === undefined
+                    ? {}
+                    : { variant: resolved.choice.variant }),
+                ...(typeof agent.model === "string" ? { ownModel: agent.model } : {}),
+                ...(typeof agent.variant === "string"
+                    ? { ownVariant: agent.variant }
+                    : {}),
+                applied,
+            });
+            if (applied) {
+                agent.model = resolved.choice.model;
+                if (resolved.choice.variant !== undefined) {
+                    agent.variant = resolved.choice.variant;
+                }
             }
         }
-        if (original !== undefined || resolved !== undefined) {
+        if (original !== undefined ||
+            (resolved !== undefined && isAvailable(resolved.choice.model))) {
             agents[name] = agent;
         }
     }
@@ -126,6 +159,11 @@ export function applyModelRefs(configuredAgents, document, profile) {
             notices.push(`Ref "${ref}" is not defined in ${where}; ${users.join(", ")} ${users.length === 1 ? "keeps" : "keep"} OpenCode's model.`);
             return { ref, source: "unresolved", agents: users };
         }
+        const unavailable = !isAvailable(resolved.choice.model);
+        if (unavailable && users.length > 0) {
+            notices.push(unavailableModelNotice(ref, resolved.choice.model, users, availableModels !== undefined &&
+                [...availableModels].some((model) => model.startsWith(`${providerOf(resolved.choice.model)}/`))));
+        }
         return {
             ref,
             model: resolved.choice.model,
@@ -133,8 +171,9 @@ export function applyModelRefs(configuredAgents, document, profile) {
                 ? {}
                 : { variant: resolved.choice.variant }),
             source: resolved.source,
+            ...(unavailable ? { unavailable: true } : {}),
             agents: users,
         };
     });
-    return { agents, refs, notices };
+    return { agents, refs, assignments, notices };
 }

package/dist/server.js

@@ -1,17 +1,237 @@
 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 {
-                publishReport(target, options, await resolveModelProfiles(target, { configFile, worktree }));
+                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,
@@ -32,6 +252,26 @@ const ModelProfilesServer = (input, options) => {
                 }
             }
         },
+        "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 {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lunchbox-labs/opencode-model-profiles",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Pick agent models by name, with defaults and per-worktree profiles",
   "license": "MIT",
   "type": "module",