agentsw 0.3.0

package/dist/targets/omp.js

@@ -0,0 +1,170 @@
+import fs from "node:fs";
+import path from "node:path";
+import YAML from "yaml";
+import { backupFile, home, readTextIfExists, writeFileAtomic } from "../fsutil.js";
+import { looksLikeEnvName } from "../slug.js";
+import { apiValue, classifyApi, entryApi, mergeModels, stripConflictingOverrides } from "./wire.js";
+/** Per-model keys this adapter writes; one that stops being emitted is cleared, not inherited. */
+const OWNED_MODEL_KEYS = ["id", "name", "reasoning", "input", "contextWindow", "maxTokens", "cost"];
+const agentDir = path.join(home, ".omp", "agent");
+const modelsYml = path.join(agentDir, "models.yml");
+const modelsYaml = path.join(agentDir, "models.yaml");
+/**
+ * Oh My Pi: providers live in ~/.omp/agent/models.yml (models.yaml fallback).
+ * YAML Document round-trip preserves existing comments and unrelated providers.
+ */
+export const omp = {
+    id: "omp",
+    name: "Oh My Pi",
+    protocols: ["openai", "anthropic"],
+    configPaths: [modelsYml],
+    detect: () => fs.existsSync(path.join(home, ".omp")),
+    async apply(provider) {
+        const notes = [];
+        // Respect an existing models.yaml if models.yml is absent (omp precedence: yml then yaml).
+        const file = !fs.existsSync(modelsYml) && fs.existsSync(modelsYaml) ? modelsYaml : modelsYml;
+        const text = readTextIfExists(file);
+        const doc = text ? YAML.parseDocument(text) : new YAML.Document({});
+        if (doc.errors.length) {
+            throw new Error(`${file} has YAML errors; refusing to rewrite: ${doc.errors[0]?.message}`);
+        }
+        if (doc.contents == null)
+            doc.contents = doc.createNode({});
+        const prev = doc.getIn(["providers", provider.id])?.toJSON?.();
+        const anthropic = provider.protocol === "anthropic";
+        const api = apiValue(provider.protocol, provider.openaiApi, entryApi(prev ?? {}));
+        const models = mergeModels(prev?.models, provider.models.map((m) => ({
+            id: m.id,
+            ...(m.name ? { name: m.name } : {}),
+            ...(m.reasoning !== undefined ? { reasoning: m.reasoning } : {}),
+            input: m.imageInput ? ["text", "image"] : ["text"],
+            ...(m.contextWindow ? { contextWindow: m.contextWindow } : {}),
+            ...(m.maxOutput ? { maxTokens: m.maxOutput } : {}),
+            ...(m.cost
+                ? {
+                    cost: {
+                        input: m.cost.input ?? 0,
+                        output: m.cost.output ?? 0,
+                        cacheRead: m.cost.cacheRead ?? 0,
+                        cacheWrite: m.cost.cacheWrite ?? 0,
+                    },
+                }
+                : {}),
+        })), OWNED_MODEL_KEYS);
+        const conflicts = stripConflictingOverrides(models, api, provider.baseUrl);
+        if (conflicts.length)
+            notes.push(`dropped model overrides pointing elsewhere: ${conflicts.join(", ")}`);
+        const entry = {
+            baseUrl: provider.baseUrl,
+            apiKey: provider.apiKey, // omp treats value as env-var name first, then literal
+            api,
+            models,
+        };
+        if (anthropic) {
+            // Most Anthropic-fronted proxies reject the strict tool field.
+            entry.disableStrictTools = true;
+        }
+        // Key-by-key when the entry already exists: provider-level keys agentsw does not
+        // model (authHeader, headers, compat, auth, discovery, modelOverrides, ...) and their
+        // comments belong to the user; a sync must not drop them.
+        const at = ["providers", provider.id];
+        if (YAML.isMap(doc.getIn(at))) {
+            for (const [key, value] of Object.entries(entry))
+                doc.setIn([...at, key], doc.createNode(value));
+            // an anthropic-only key must not outlive a switch to an openai wire
+            if (!anthropic)
+                doc.deleteIn([...at, "disableStrictTools"]);
+        }
+        else {
+            doc.setIn(at, doc.createNode(entry));
+        }
+        const backup = backupFile(file);
+        if (backup)
+            notes.push(`backup: ${backup}`);
+        writeFileAtomic(file, doc.toString());
+        notes.push(`select in omp with: omp --model ${provider.id}/${provider.defaultModel}`);
+        return { app: this.id, changed: [file], notes };
+    },
+    async prune(provider) {
+        const file = fs.existsSync(modelsYml) ? modelsYml : fs.existsSync(modelsYaml) ? modelsYaml : undefined;
+        if (!file)
+            return { app: this.id, changed: [], notes: [], skipped: "no models.yml" };
+        const doc = YAML.parseDocument(readTextIfExists(file) ?? "");
+        if (doc.errors.length) {
+            throw new Error(`${file} has YAML errors; refusing to rewrite: ${doc.errors[0]?.message}`);
+        }
+        if (!doc.hasIn(["providers", provider.id])) {
+            return { app: this.id, changed: [], notes: [], skipped: `no providers.${provider.id} entry` };
+        }
+        doc.deleteIn(["providers", provider.id]);
+        const notes = [];
+        const backup = backupFile(file);
+        if (backup)
+            notes.push(`backup: ${backup}`);
+        writeFileAtomic(file, doc.toString());
+        return { app: this.id, changed: [file], notes };
+    },
+    current() {
+        const file = fs.existsSync(modelsYml) ? modelsYml : fs.existsSync(modelsYaml) ? modelsYaml : undefined;
+        if (!file)
+            return undefined;
+        try {
+            const parsed = YAML.parse(readTextIfExists(file) ?? "");
+            const ids = Object.keys(parsed?.providers ?? {});
+            return ids.length ? `providers: ${ids.join(", ")}` : undefined;
+        }
+        catch {
+            return undefined;
+        }
+    },
+    candidates() {
+        const file = fs.existsSync(modelsYml) ? modelsYml : fs.existsSync(modelsYaml) ? modelsYaml : undefined;
+        if (!file)
+            return [];
+        let parsed;
+        try {
+            parsed = YAML.parse(readTextIfExists(file) ?? "");
+        }
+        catch {
+            return [];
+        }
+        if (!parsed?.providers)
+            return [];
+        const self = this.id;
+        return Object.entries(parsed.providers).flatMap(([id, entry]) => {
+            if (!entry || typeof entry.baseUrl !== "string")
+                return [];
+            const modelEntries = Array.isArray(entry.models) ? entry.models : [];
+            // omp takes `api` at provider level or on every model; a mixed-protocol entry is skipped.
+            const wire = classifyApi(entryApi(entry));
+            if (!wire)
+                return [];
+            let apiKey;
+            let keyEnv;
+            if (typeof entry.apiKey === "string" && entry.apiKey) {
+                if (looksLikeEnvName(entry.apiKey) && process.env[entry.apiKey]) {
+                    keyEnv = entry.apiKey;
+                    apiKey = process.env[entry.apiKey];
+                }
+                else {
+                    // omp resolves env-var names first, then uses the value as a literal key
+                    apiKey = entry.apiKey;
+                }
+            }
+            const models = modelEntries.map((m) => (typeof m?.id === "string" ? m.id : "")).filter(Boolean);
+            return [
+                {
+                    id,
+                    name: typeof entry.name === "string" ? entry.name : id,
+                    protocol: wire.protocol,
+                    openaiApi: wire.openaiApi,
+                    baseUrl: entry.baseUrl,
+                    apiKey,
+                    keyEnv,
+                    models,
+                    source: self,
+                },
+            ];
+        });
+    },
+};

package/dist/targets/opencode.js

@@ -0,0 +1,135 @@
+import fs from "node:fs";
+import path from "node:path";
+import { backupFile, home, readJsonIfExists, writeFileAtomic } from "../fsutil.js";
+const configFile = path.join(home, ".config", "opencode", "opencode.json");
+/**
+ * opencode: custom providers in ~/.config/opencode/opencode.json "provider" map,
+ * backed by @ai-sdk/openai-compatible or @ai-sdk/anthropic npm loaders.
+ */
+export const opencode = {
+    id: "opencode",
+    name: "opencode",
+    protocols: ["openai", "anthropic"],
+    configPaths: [configFile],
+    detect: () => fs.existsSync(path.dirname(configFile)),
+    async apply(provider) {
+        const notes = [];
+        const config = readJsonIfExists(configFile) ?? {
+            $schema: "https://opencode.ai/config.json",
+        };
+        const anthropic = provider.protocol === "anthropic";
+        const providerMap = { ...config.provider };
+        // Keys agentsw does not model (custom options, per-model extras) are the user's,
+        // but a key it owns and no longer emits is cleared rather than inherited from last sync.
+        const existing = providerMap[provider.id];
+        const prev = (existing && typeof existing === "object" && !Array.isArray(existing)
+            ? existing
+            : {});
+        const prevModels = (prev.models ?? {});
+        const models = {};
+        for (const m of provider.models) {
+            const old = { ...prevModels[m.id] };
+            for (const key of ["name", "reasoning", "attachment", "cost", "limit"])
+                delete old[key];
+            models[m.id] = {
+                ...old,
+                ...(m.name ? { name: m.name } : {}),
+                ...(m.reasoning !== undefined ? { reasoning: m.reasoning } : {}),
+                ...(m.imageInput ? { attachment: true } : {}),
+                ...(m.cost
+                    ? {
+                        cost: {
+                            input: m.cost.input ?? 0,
+                            output: m.cost.output ?? 0,
+                            ...(m.cost.cacheRead !== undefined ? { cache_read: m.cost.cacheRead } : {}),
+                            ...(m.cost.cacheWrite !== undefined ? { cache_write: m.cost.cacheWrite } : {}),
+                        },
+                    }
+                    : {}),
+                ...(m.contextWindow || m.maxOutput
+                    ? {
+                        limit: {
+                            ...(m.contextWindow ? { context: m.contextWindow } : {}),
+                            ...(m.maxOutput ? { output: m.maxOutput } : {}),
+                        },
+                    }
+                    : {}),
+            };
+        }
+        providerMap[provider.id] = {
+            ...prev,
+            npm: anthropic ? "@ai-sdk/anthropic" : "@ai-sdk/openai-compatible",
+            name: provider.name,
+            options: {
+                ...prev.options,
+                baseURL: provider.baseUrl,
+                apiKey: provider.apiKey,
+            },
+            models,
+        };
+        config.provider = providerMap;
+        config.model = `${provider.id}/${provider.defaultModel}`;
+        if (provider.smallModel)
+            config.small_model = `${provider.id}/${provider.smallModel}`;
+        const backup = backupFile(configFile);
+        if (backup)
+            notes.push(`backup: ${backup}`);
+        writeFileAtomic(configFile, JSON.stringify(config, null, 2) + "\n");
+        return { app: this.id, changed: [configFile], notes };
+    },
+    async prune(provider) {
+        const config = readJsonIfExists(configFile);
+        const providerMap = config?.provider;
+        if (!config || !providerMap?.[provider.id]) {
+            return { app: this.id, changed: [], notes: [], skipped: `no provider.${provider.id} entry` };
+        }
+        delete providerMap[provider.id];
+        if (Object.keys(providerMap).length === 0)
+            delete config.provider;
+        const notes = [];
+        if (typeof config.model === "string" && config.model.startsWith(`${provider.id}/`)) {
+            delete config.model;
+            notes.push("default model reset (was pointing at this provider)");
+        }
+        if (typeof config.small_model === "string" && config.small_model.startsWith(`${provider.id}/`)) {
+            delete config.small_model;
+        }
+        const backup = backupFile(configFile);
+        if (backup)
+            notes.push(`backup: ${backup}`);
+        writeFileAtomic(configFile, JSON.stringify(config, null, 2) + "\n");
+        return { app: this.id, changed: [configFile], notes };
+    },
+    current() {
+        const config = readJsonIfExists(configFile);
+        return config?.model;
+    },
+    candidates() {
+        const config = readJsonIfExists(configFile);
+        if (!config?.provider)
+            return [];
+        const activeProvider = config.model?.includes("/") ? config.model.split("/")[0] : undefined;
+        const activeModel = activeProvider && config.model && config.model.includes("/") ? config.model.split("/").slice(1).join("/") : undefined;
+        const self = this.id;
+        return Object.entries(config.provider).flatMap(([id, entry]) => {
+            const baseUrl = entry?.options?.baseURL;
+            if (!entry || !baseUrl || baseUrl.startsWith("{"))
+                return [];
+            if (!entry.npm)
+                return []; // built-in provider without a custom npm loader
+            const protocol = entry.npm.includes("anthropic") ? "anthropic" : "openai";
+            let apiKey = entry.options?.apiKey;
+            let keyEnv;
+            const ref = apiKey?.match(/^\{env:([A-Za-z0-9_]+)\}$/);
+            if (ref?.[1]) {
+                keyEnv = ref[1];
+                apiKey = process.env[ref[1]];
+            }
+            const models = Object.keys(entry.models ?? {});
+            const defaultModel = activeProvider === id ? activeModel : undefined;
+            if (defaultModel && !models.includes(defaultModel))
+                models.unshift(defaultModel);
+            return [{ id, name: entry.name ?? id, protocol, baseUrl, apiKey, keyEnv, models, defaultModel, source: self }];
+        });
+    },
+};

package/dist/targets/pistyle.js

@@ -0,0 +1,208 @@
+import fs from "node:fs";
+import path from "node:path";
+import { backupFile, home, readJsonIfExists, writeFileAtomic } from "../fsutil.js";
+import { looksLikeEnvName } from "../slug.js";
+import { apiValue, classifyApi, entryApi, mergeModels, stripConflictingOverrides } from "./wire.js";
+/** Per-model keys this adapter writes; one that stops being emitted is cleared, not inherited. */
+const OWNED_MODEL_KEYS = [
+    "id",
+    "name",
+    "reasoning",
+    "thinkingLevelMap",
+    "input",
+    "contextWindow",
+    "maxTokens",
+    "cost",
+];
+/**
+ * pi-family agents (pi, prime-agent) share the same config layout:
+ *   <dir>/models.json   — { providers: { <id>: { baseUrl, apiKey, api, models[] } } }
+ *   <dir>/settings.json — { defaultProvider, defaultModel }
+ * prime-agent is a pi fork with configDir ".prime/agent" instead of ".pi/agent".
+ */
+/**
+ * Map models.dev reasoning-effort values onto pi thinking levels.
+ * pi grammar: value string = provider value, null = level unsupported.
+ */
+function thinkingLevelMap(efforts) {
+    const map = {};
+    map.off = efforts.includes("none") ? "none" : null;
+    for (const level of ["minimal", "low", "medium", "high", "xhigh", "max"]) {
+        map[level] = efforts.includes(level) ? level : null;
+    }
+    return map;
+}
+export function piStyleTarget(opts) {
+    const resolveDir = () => {
+        const env = process.env[opts.dirEnvVar];
+        if (env)
+            return env.startsWith("~") ? path.join(home, env.slice(1)) : env;
+        return path.join(home, opts.configDirName);
+    };
+    return {
+        id: opts.id,
+        name: opts.name,
+        protocols: ["openai", "anthropic"],
+        configPaths: [path.join(resolveDir(), "models.json"), path.join(resolveDir(), "settings.json")],
+        detect: () => fs.existsSync(path.dirname(resolveDir())),
+        async apply(provider) {
+            const dir = resolveDir();
+            const modelsFile = path.join(dir, "models.json");
+            const settingsFile = path.join(dir, "settings.json");
+            const notes = [];
+            const modelsConfig = readJsonIfExists(modelsFile) ?? {};
+            const providers = { ...modelsConfig.providers };
+            // Keys agentsw does not model (headers, authHeader, oauth, ...) and per-model extras
+            // are the user's; a re-sync overwrites only the fields it owns.
+            const existing = providers[provider.id];
+            const prev = (existing && typeof existing === "object" && !Array.isArray(existing)
+                ? existing
+                : {});
+            const api = apiValue(provider.protocol, provider.openaiApi, entryApi(prev));
+            const models = mergeModels(prev.models, provider.models.map((m) => ({
+                id: m.id,
+                ...(m.name ? { name: m.name } : {}),
+                ...(m.reasoning !== undefined ? { reasoning: m.reasoning } : {}),
+                ...(m.reasoning && m.reasoningEfforts?.length
+                    ? { thinkingLevelMap: thinkingLevelMap(m.reasoningEfforts) }
+                    : {}),
+                input: m.imageInput ? ["text", "image"] : ["text"],
+                ...(m.contextWindow ? { contextWindow: m.contextWindow } : {}),
+                ...(m.maxOutput ? { maxTokens: m.maxOutput } : {}),
+                ...(m.cost
+                    ? {
+                        cost: {
+                            input: m.cost.input ?? 0,
+                            output: m.cost.output ?? 0,
+                            cacheRead: m.cost.cacheRead ?? 0,
+                            cacheWrite: m.cost.cacheWrite ?? 0,
+                        },
+                    }
+                    : {}),
+            })), OWNED_MODEL_KEYS);
+            const conflicts = stripConflictingOverrides(models, api, provider.baseUrl);
+            if (conflicts.length)
+                notes.push(`dropped model overrides pointing elsewhere: ${conflicts.join(", ")}`);
+            providers[provider.id] = {
+                ...prev,
+                name: provider.name,
+                baseUrl: provider.baseUrl,
+                apiKey: provider.apiKey, // literal key; pi treats "$VAR"/"!cmd" as indirection, prime also accepts bare env names
+                api,
+                models,
+            };
+            modelsConfig.providers = providers;
+            const modelsBackup = backupFile(modelsFile);
+            if (modelsBackup)
+                notes.push(`backup: ${modelsBackup}`);
+            writeFileAtomic(modelsFile, JSON.stringify(modelsConfig, null, 2) + "\n");
+            const settings = readJsonIfExists(settingsFile) ?? {};
+            settings.defaultProvider = provider.id;
+            settings.defaultModel = provider.defaultModel;
+            const settingsBackup = backupFile(settingsFile);
+            if (settingsBackup)
+                notes.push(`backup: ${settingsBackup}`);
+            writeFileAtomic(settingsFile, JSON.stringify(settings, null, 2) + "\n");
+            return { app: opts.id, changed: [modelsFile, settingsFile], notes };
+        },
+        async prune(provider) {
+            const dir = resolveDir();
+            const modelsFile = path.join(dir, "models.json");
+            const settingsFile = path.join(dir, "settings.json");
+            const modelsConfig = readJsonIfExists(modelsFile);
+            const providers = modelsConfig?.providers;
+            if (!modelsConfig || !providers?.[provider.id]) {
+                return { app: opts.id, changed: [], notes: [], skipped: `no providers.${provider.id} entry` };
+            }
+            delete providers[provider.id];
+            const notes = [];
+            const changed = [modelsFile];
+            const modelsBackup = backupFile(modelsFile);
+            if (modelsBackup)
+                notes.push(`backup: ${modelsBackup}`);
+            writeFileAtomic(modelsFile, JSON.stringify(modelsConfig, null, 2) + "\n");
+            const settings = readJsonIfExists(settingsFile);
+            if (settings?.defaultProvider === provider.id) {
+                delete settings.defaultProvider;
+                delete settings.defaultModel;
+                const settingsBackup = backupFile(settingsFile);
+                if (settingsBackup)
+                    notes.push(`backup: ${settingsBackup}`);
+                writeFileAtomic(settingsFile, JSON.stringify(settings, null, 2) + "\n");
+                changed.push(settingsFile);
+                notes.push("default model reset (was pointing at this provider)");
+            }
+            return { app: opts.id, changed, notes };
+        },
+        current() {
+            const settings = readJsonIfExists(path.join(resolveDir(), "settings.json"));
+            if (!settings?.defaultProvider)
+                return undefined;
+            return `${settings.defaultProvider} · ${settings.defaultModel ?? "?"}`;
+        },
+        candidates() {
+            const dir = resolveDir();
+            const mc = readJsonIfExists(path.join(dir, "models.json"));
+            if (!mc?.providers)
+                return [];
+            const settings = readJsonIfExists(path.join(dir, "settings.json"));
+            const self = opts.id;
+            return Object.entries(mc.providers).flatMap(([id, entry]) => {
+                if (!entry || typeof entry.baseUrl !== "string")
+                    return [];
+                const modelEntries = Array.isArray(entry.models) ? entry.models : [];
+                // pi takes `api` at provider level or on every model; a mixed-protocol entry is skipped.
+                const wire = classifyApi(entryApi(entry));
+                if (!wire)
+                    return [];
+                let apiKey;
+                let keyEnv;
+                const raw = typeof entry.apiKey === "string" && entry.apiKey ? entry.apiKey : undefined;
+                if (raw) {
+                    if (raw.startsWith("$") && raw.length > 1) {
+                        keyEnv = raw.slice(1);
+                        apiKey = process.env[keyEnv];
+                    }
+                    else if (opts.id === "prime" && looksLikeEnvName(raw)) {
+                        // prime resolves bare env names; falls back to the literal string
+                        keyEnv = raw;
+                        apiKey = process.env[raw] ?? raw;
+                    }
+                    else {
+                        apiKey = raw;
+                    }
+                }
+                const models = modelEntries.map((m) => (typeof m?.id === "string" ? m.id : "")).filter(Boolean);
+                const defaultModel = settings?.defaultProvider === id && settings?.defaultModel ? settings.defaultModel : undefined;
+                if (defaultModel && !models.includes(defaultModel))
+                    models.unshift(defaultModel);
+                return [
+                    {
+                        id,
+                        name: typeof entry.name === "string" ? entry.name : id,
+                        protocol: wire.protocol,
+                        openaiApi: wire.openaiApi,
+                        baseUrl: entry.baseUrl,
+                        apiKey,
+                        keyEnv,
+                        models,
+                        defaultModel,
+                        source: self,
+                    },
+                ];
+            });
+        },
+    };
+}
+export const pi = piStyleTarget({
+    id: "pi",
+    name: "pi",
+    configDirName: ".pi/agent",
+    dirEnvVar: "PI_CODING_AGENT_DIR",
+});
+export const prime = piStyleTarget({
+    id: "prime",
+    name: "prime-agent",
+    configDirName: ".prime/agent",
+    dirEnvVar: "PRIME_AGENT_CODING_AGENT_DIR",
+});

package/dist/targets/types.js

@@ -0,0 +1 @@
+export {};

package/dist/targets/wire.js

@@ -0,0 +1,109 @@
+/**
+ * pi-family `api` values (pi, prime-agent, omp share the enum) that speak the
+ * OpenAI Responses wire: `openai-responses` plus the Azure/Codex variants.
+ */
+const RESPONSES_APIS = {
+    "openai-responses": true,
+    "azure-openai-responses": true,
+    "openai-codex-responses": true,
+};
+/**
+ * Classify a pi-family `api` value. Returns undefined for wires agentsw
+ * cannot drive (bedrock, google, ...) so importers skip those providers.
+ */
+export function classifyApi(api) {
+    if (typeof api !== "string")
+        return undefined;
+    if (api === "anthropic-messages")
+        return { protocol: "anthropic" };
+    if (api === "openai-completions")
+        return { protocol: "openai", openaiApi: "completions" };
+    if (RESPONSES_APIS[api])
+        return { protocol: "openai", openaiApi: "responses" };
+    return undefined;
+}
+/**
+ * `api` value to write for a provider. An existing openai-family value is kept
+ * whenever it matches the flavor being written, so a sync never rewrites
+ * `azure-openai-responses` into plain `openai-responses` — or, when the store
+ * carries no flavor at all, downgrades a working `/v1/responses` endpoint to
+ * chat completions.
+ */
+export function apiValue(protocol, openaiApi, existing) {
+    if (protocol === "anthropic")
+        return "anthropic-messages";
+    const prev = classifyApi(existing);
+    const flavor = openaiApi ?? prev?.openaiApi ?? "completions";
+    if (prev?.protocol === "openai" && prev.openaiApi === flavor)
+        return existing;
+    return flavor === "responses" ? "openai-responses" : "openai-completions";
+}
+/**
+ * The `api` a pi-family entry declares: provider-level, or its models' own when
+ * they agree. A mixed-protocol entry has no single answer — one agentsw
+ * provider cannot represent it — so importers skip it rather than guess.
+ */
+export function entryApi(entry) {
+    if (typeof entry.api === "string")
+        return entry.api;
+    if (!Array.isArray(entry.models))
+        return undefined;
+    let single;
+    for (const model of entry.models) {
+        const api = model?.api;
+        if (typeof api !== "string")
+            continue;
+        if (single === undefined)
+            single = api;
+        else if (single !== api)
+            return undefined;
+    }
+    return single;
+}
+/**
+ * Merge the model entries agentsw owns over the ones already in an app
+ * config: per-model keys the adapter does not model (`compat`, per-model wire
+ * overrides, ...) survive a re-sync, while an `owned` key the new entry no
+ * longer carries is cleared instead of lingering as last sync's value — a
+ * stale `thinkingLevelMap` beside `reasoning: false` is a state no fresh write
+ * produces.
+ */
+export function mergeModels(previous, written, owned) {
+    const prev = new Map();
+    if (Array.isArray(previous)) {
+        for (const m of previous) {
+            if (m && typeof m.id === "string")
+                prev.set(m.id, m);
+        }
+    }
+    return written.map((m) => {
+        const old = prev.get(m.id);
+        if (!old)
+            return m;
+        const kept = { ...old };
+        for (const key of owned)
+            if (!(key in m))
+                delete kept[key];
+        return { ...kept, ...m };
+    });
+}
+/**
+ * Drop per-model `api`/`baseUrl` overrides that contradict the route being
+ * written. A model-level override wins over the provider entry in omp and pi,
+ * so a preserved one would silently keep sending requests to the endpoint or
+ * wire the switch just replaced. Returns the dropped `<model>.<key>` labels.
+ */
+export function stripConflictingOverrides(models, api, baseUrl) {
+    const dropped = [];
+    for (const model of models) {
+        if (typeof model.api === "string" && model.api !== api) {
+            dropped.push(`${String(model.id)}.api`);
+            delete model.api;
+        }
+        if (typeof model.baseUrl === "string" && model.baseUrl !== baseUrl) {
+            dropped.push(`${String(model.id)}.baseUrl`);
+            delete model.baseUrl;
+        }
+    }
+    return dropped;
+}