agentsw 0.6.0 → 0.6.2

package/dist/jsonc.js

@@ -0,0 +1,111 @@
+import fs from "node:fs";
+import { applyEdits, createScanner, getNodeValue, modify, parseTree, printParseErrorCode, } from "jsonc-parser";
+export function isJsonObject(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function parseJsoncObject(file, text) {
+    const source = text.startsWith("\uFEFF") ? text.slice(1) : text;
+    const errors = [];
+    const root = parseTree(source, errors, { allowTrailingComma: true });
+    const error = errors[0];
+    if (error) {
+        // Do not quote source text: config files can contain credentials.
+        throw new Error(`${file}: invalid JSONC (${printParseErrorCode(error.error)} at offset ${error.offset})`);
+    }
+    if (root?.type !== "object")
+        throw new Error(`${file}: expected a JSON object at the document root`);
+    // Parsing resolves duplicate keys last-wins, but modify edits the first occurrence.
+    // Reject that ambiguity at any depth rather than syncing a value the agent will not read.
+    const checkDuplicates = (node) => {
+        const names = node.type === "object" ? new Set() : undefined;
+        for (const child of node.children ?? []) {
+            if (names) {
+                const name = child.children[0].value;
+                if (names.has(name)) {
+                    throw new Error(`${file}: invalid JSONC (duplicate object property at offset ${child.offset})`);
+                }
+                names.add(name);
+            }
+            checkDuplicates(child);
+        }
+    };
+    checkDuplicates(root);
+    return getNodeValue(root);
+}
+/** Only missing files initialize to an empty object; unreadable or invalid files must not be replaced. */
+export function readJsoncObject(file) {
+    let text;
+    try {
+        text = fs.readFileSync(file, "utf8");
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return { file, text: "{}\n", value: {} };
+        throw error;
+    }
+    return { file, text, value: parseJsoncObject(file, text) };
+}
+function comments(text) {
+    const result = [];
+    const scanner = createScanner(text);
+    for (let token = scanner.scan(); token !== 17 /* SyntaxKind.EOF */; token = scanner.scan()) {
+        if (token === 12 /* SyntaxKind.LineCommentTrivia */ || token === 13 /* SyntaxKind.BlockCommentTrivia */) {
+            result.push(text.slice(scanner.getTokenOffset(), scanner.getTokenOffset() + scanner.getTokenLength()));
+        }
+    }
+    return result;
+}
+/** modify() may include adjacent comments in deletion ranges; retain them as detached comments. */
+function retainComments(text, edit, eol) {
+    const remaining = new Map();
+    for (const comment of comments(edit.content))
+        remaining.set(comment, (remaining.get(comment) ?? 0) + 1);
+    const removed = [];
+    for (const comment of comments(text.slice(edit.offset, edit.offset + edit.length))) {
+        const count = remaining.get(comment) ?? 0;
+        if (count)
+            remaining.set(comment, count - 1);
+        else
+            removed.push(comment);
+    }
+    return removed.length ? { ...edit, content: eol + removed.join(eol) + eol + edit.content } : edit;
+}
+/** Change only differing values, leaving unrelated fields, comments, and string literals intact. */
+export function editJsoncObject(document, value) {
+    const bom = document.text.startsWith("\uFEFF") ? "\uFEFF" : "";
+    let text = bom ? document.text.slice(1) : document.text;
+    const eol = text.includes("\r\n") ? "\r\n" : "\n";
+    const update = (location, previous, next) => {
+        if (previous === next)
+            return;
+        if (isJsonObject(previous) && isJsonObject(next)) {
+            const keys = Object.keys(next);
+            if (keys.length || !Object.keys(previous).length) {
+                // Add before deleting, so a trailing-comma object never temporarily loses its last property.
+                for (const key of keys)
+                    update([...location, key], previous[key], next[key]);
+                for (const key of Object.keys(previous)) {
+                    if (!Object.hasOwn(next, key))
+                        update([...location, key], previous[key], undefined);
+                }
+                return;
+            }
+            // Replacing an emptying object also removes its trailing comma (modify's last-property
+            // deletion otherwise leaves `{,}`). retainComments keeps comments from the removed subtree.
+        }
+        // Replace shrinking arrays whole: modify's last-element deletion can truncate a compact
+        // value incorrectly. Equal-length/growing arrays still get incremental, comment-safe edits.
+        if (Array.isArray(previous) && Array.isArray(next) && next.length >= previous.length) {
+            for (let index = 0; index < next.length; index++) {
+                update([...location, index], previous[index], next[index]);
+            }
+            return;
+        }
+        const edits = modify(text, location, next, { formattingOptions: { insertSpaces: true, tabSize: 2, eol } });
+        text = applyEdits(text, edits.map((edit) => retainComments(text, edit, eol)));
+    };
+    update([], document.value, value);
+    // Never let a library edit boundary or comment relocation write malformed output.
+    parseJsoncObject(document.file, text);
+    return bom + text;
+}

package/dist/targets/dsh.js

@@ -2,7 +2,7 @@ import fs from "node:fs";
 import path from "node:path";
 import YAML from "yaml";
 import { backupFile, expandHome, home, localAppDataDir, readTextIfExists, writeFileAtomic } from "../fsutil.js";
-import { apiValue, classifyApi, mergeModels, stripApiVersion } from "./wire.js";
+import { apiValue, classifyApi, mergeModels, sdkBaseUrl } from "./wire.js";
 /** `$DSH_HOME`, or `~/.dsh` (packages/util/home-paths `resolveDshHome`). */
 function dshHome() {
     const env = process.env.DSH_HOME?.trim();
@@ -91,7 +91,7 @@ export const dsh = {
             displayName: provider.name,
             apiKeyEnv: ref, // credential reference, never the secret
             api: apiValue(provider.protocol, provider.openaiApi, prev?.api),
-            baseURL: stripApiVersion(provider.baseUrl),
+            baseURL: sdkBaseUrl(provider.protocol, provider.baseUrl),
             models: mergeModels(prev?.models, provider.models.map(modelEntry), OWNED_MODEL_KEYS),
         };
         if (YAML.isMap(doc.getIn(at))) {

package/dist/targets/hermes.js

@@ -2,7 +2,7 @@ import fs from "node:fs";
 import path from "node:path";
 import YAML from "yaml";
 import { backupFile, home, localAppDataDir, readTextIfExists, writeFileAtomic } from "../fsutil.js";
-import { stripApiVersion } from "./wire.js";
+import { sdkBaseUrl } from "./wire.js";
 function hermesHome() {
     const env = process.env.HERMES_HOME?.trim();
     if (env)
@@ -47,9 +47,13 @@ export const hermes = {
         }
         const entry = {
             name: provider.name,
-            api: stripApiVersion(provider.baseUrl),
+            api: sdkBaseUrl(provider.protocol, provider.baseUrl),
             key_env: keyVar,
-            transport: provider.protocol === "anthropic" ? "anthropic_messages" : "chat_completions",
+            transport: provider.protocol === "anthropic"
+                ? "anthropic_messages"
+                : provider.openaiApi === "responses"
+                    ? "codex_responses"
+                    : "chat_completions",
             default_model: provider.defaultModel,
             models,
         };
@@ -158,9 +162,14 @@ export const hermes = {
         return Object.entries(parsed.providers).flatMap(([id, entry]) => {
             if (!entry || typeof entry.api !== "string" || !entry.api)
                 return [];
-            const protocol = entry.transport === "anthropic_messages" ? "anthropic" : entry.transport === "chat_completions" ? "openai" : undefined;
+            const protocol = entry.transport === "anthropic_messages"
+                ? "anthropic"
+                : ["chat_completions", "codex_responses"].includes(entry.transport ?? "")
+                    ? "openai"
+                    : undefined;
             if (!protocol)
                 return [];
+            const openaiApi = protocol === "openai" ? (entry.transport === "codex_responses" ? "responses" : "completions") : undefined;
             const keyEnv = typeof entry.key_env === "string" && entry.key_env ? entry.key_env : undefined;
             const apiKey = keyEnv ? readEnv(keyEnv) : undefined;
             const models = Object.keys(entry.models ?? {});
@@ -168,7 +177,7 @@ export const hermes = {
             const defaultModel = entry.default_model ?? active;
             if (defaultModel && !models.includes(defaultModel))
                 models.unshift(defaultModel);
-            return [{ id, name: entry.name ?? id, protocol, baseUrl: entry.api, apiKey, keyEnv, models, defaultModel, source: self }];
+            return [{ id, name: entry.name ?? id, protocol, openaiApi, baseUrl: entry.api, apiKey, keyEnv, models, defaultModel, source: self }];
         });
     },
 };

package/dist/targets/omp.js

@@ -3,13 +3,57 @@ import path from "node:path";
 import YAML from "yaml";
 import { backupFile, home, readTextIfExists, writeFileAtomic } from "../fsutil.js";
 import { looksLikeEnvName } from "../slug.js";
-import { stripApiVersion } from "./wire.js";
-import { apiValue, classifyApi, entryApi, mergeModels, stripConflictingOverrides } from "./wire.js";
+import { apiValue, classifyApi, entryApi, mergeModels, sdkBaseUrl, 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");
+/** Resolve references before edits can remove their anchors or mutate shared providers. */
+function parseModelsDocument(file, text) {
+    try {
+        const doc = text ? YAML.parseDocument(text) : new YAML.Document({});
+        if (doc.errors.length)
+            throw doc.errors[0];
+        if (doc.contents == null)
+            doc.contents = doc.createNode({});
+        // Validate references with the full document context and the default alias limit.
+        // Cycles are valid YAML, but not a usable model configuration; reject before expansion.
+        JSON.stringify(doc.toJS());
+        const expanded = new Map();
+        YAML.visit(doc, {
+            Alias(_key, alias) {
+                const node = doc.createNode(alias.toJS(doc), { aliasDuplicateObjects: false });
+                node.comment = alias.comment;
+                node.commentBefore = alias.commentBefore;
+                node.spaceBefore = alias.spaceBefore;
+                expanded.set(alias, node);
+            },
+        });
+        // Resolve all references before replacing any nodes (anchors may be reused).
+        YAML.visit(doc, { Alias: (_key, alias) => expanded.get(alias) });
+        if (!YAML.isMap(doc.contents))
+            throw new Error("expected a configuration mapping");
+        if (doc.hasIn(["providers"]) && !YAML.isMap(doc.getIn(["providers"]))) {
+            throw new Error("expected providers to be a mapping");
+        }
+        return doc;
+    }
+    catch (error) {
+        throw new Error(`${file} has invalid YAML: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+/** Validate the emitted document before any backup or write. */
+function serializeModelsDocument(file, doc) {
+    try {
+        const text = doc.toString();
+        YAML.parse(text);
+        return text;
+    }
+    catch (error) {
+        throw new Error(`${file} has invalid YAML: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
 /**
  * Oh My Pi: providers live in ~/.omp/agent/models.yml (models.yaml fallback).
  * YAML Document round-trip preserves existing comments and unrelated providers.
@@ -25,15 +69,11 @@ export const omp = {
         // 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 doc = parseModelsDocument(file, text);
+        const prev = doc.getIn(["providers", provider.id])?.toJS(doc);
         const anthropic = provider.protocol === "anthropic";
         const api = apiValue(provider.protocol, provider.openaiApi, entryApi(prev ?? {}));
+        const baseUrl = sdkBaseUrl(provider.protocol, provider.baseUrl);
         const models = mergeModels(prev?.models, provider.models.map((m) => ({
             id: m.id,
             ...(m.name ? { name: m.name } : {}),
@@ -52,11 +92,11 @@ export const omp = {
                 }
                 : {}),
         })), OWNED_MODEL_KEYS);
-        const conflicts = stripConflictingOverrides(models, api, provider.baseUrl);
+        const conflicts = stripConflictingOverrides(models, api, baseUrl);
         if (conflicts.length)
             notes.push(`dropped model overrides pointing elsewhere: ${conflicts.join(", ")}`);
         const entry = {
-            baseUrl: stripApiVersion(provider.baseUrl),
+            baseUrl,
             apiKey: provider.apiKey, // omp treats value as env-var name first, then literal
             api,
             models,
@@ -79,10 +119,11 @@ export const omp = {
         else {
             doc.setIn(at, doc.createNode(entry));
         }
+        const output = serializeModelsDocument(file, doc);
         const backup = backupFile(file);
         if (backup)
             notes.push(`backup: ${backup}`);
-        writeFileAtomic(file, doc.toString());
+        writeFileAtomic(file, output);
         notes.push(`select in omp with: omp --model ${provider.id}/${provider.defaultModel}`);
         return { app: this.id, changed: [file], notes };
     },
@@ -90,19 +131,17 @@ export const omp = {
         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}`);
-        }
+        const doc = parseModelsDocument(file, readTextIfExists(file));
         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 output = serializeModelsDocument(file, doc);
         const backup = backupFile(file);
         if (backup)
             notes.push(`backup: ${backup}`);
-        writeFileAtomic(file, doc.toString());
+        writeFileAtomic(file, output);
         return { app: this.id, changed: [file], notes };
     },
     current() {

package/dist/targets/opencode.js

@@ -1,9 +1,10 @@
 import fs from "node:fs";
 import path from "node:path";
-import { appDataDir, backupFile, readJsonIfExists, writeFileAtomic } from "../fsutil.js";
-import { stripApiVersion } from "./wire.js";
-const configDir = process.env.OPENCODE_CONFIG_DIR?.trim() || appDataDir("opencode");
-const configFile = path.join(configDir, "opencode.json");
+import { appDataDir, backupFile, expandHome, readJsonIfExists, writeFileAtomic } from "../fsutil.js";
+const customDir = process.env.OPENCODE_CONFIG_DIR?.trim();
+const configFile = customDir
+    ? path.join(expandHome(customDir), "opencode.json")
+    : path.join(appDataDir("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.
@@ -48,11 +49,11 @@ export const opencode = {
                         },
                     }
                     : {}),
-                ...(m.contextWindow || m.maxOutput
+                ...(m.contextWindow && m.maxOutput
                     ? {
                         limit: {
-                            ...(m.contextWindow ? { context: m.contextWindow } : {}),
-                            ...(m.maxOutput ? { output: m.maxOutput } : {}),
+                            context: m.contextWindow,
+                            output: m.maxOutput,
                         },
                     }
                     : {}),
@@ -60,11 +61,11 @@ export const opencode = {
         }
         providerMap[provider.id] = {
             ...prev,
-            npm: anthropic ? "@ai-sdk/anthropic" : "@ai-sdk/openai-compatible",
+            npm: anthropic ? "@ai-sdk/anthropic" : provider.openaiApi === "responses" ? "@ai-sdk/openai" : "@ai-sdk/openai-compatible",
             name: provider.name,
             options: {
                 ...prev.options,
-                baseURL: stripApiVersion(provider.baseUrl),
+                baseURL: provider.baseUrl.replace(/\/+$/, ""),
                 apiKey: provider.apiKey,
             },
             models,
@@ -120,6 +121,7 @@ export const opencode = {
             if (!entry.npm)
                 return []; // built-in provider without a custom npm loader
             const protocol = entry.npm.includes("anthropic") ? "anthropic" : "openai";
+            const openaiApi = protocol === "openai" ? (entry.npm === "@ai-sdk/openai" ? "responses" : "completions") : undefined;
             let apiKey = entry.options?.apiKey;
             let keyEnv;
             const ref = apiKey?.match(/^\{env:([A-Za-z0-9_]+)\}$/);
@@ -131,7 +133,7 @@ export const opencode = {
             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 }];
+            return [{ id, name: entry.name ?? id, protocol, openaiApi, baseUrl, apiKey, keyEnv, models, defaultModel, source: self }];
         });
     },
 };

package/dist/targets/pistyle.js

@@ -1,9 +1,9 @@
 import fs from "node:fs";
 import path from "node:path";
-import { backupFile, home, readJsonIfExists, writeFileAtomic } from "../fsutil.js";
+import { backupFile, home, writeFileAtomic } from "../fsutil.js";
+import { editJsoncObject, isJsonObject, readJsoncObject } from "../jsonc.js";
 import { looksLikeEnvName } from "../slug.js";
-import { stripApiVersion } from "./wire.js";
-import { apiValue, classifyApi, entryApi, mergeModels, stripConflictingOverrides } from "./wire.js";
+import { apiValue, classifyApi, entryApi, mergeModels, sdkBaseUrl, stripConflictingOverrides } from "./wire.js";
 /** Per-model keys this adapter writes; one that stops being emitted is cleared, not inherited. */
 const OWNED_MODEL_KEYS = [
     "id",
@@ -15,6 +15,28 @@ const OWNED_MODEL_KEYS = [
     "maxTokens",
     "cost",
 ];
+function readModels(file) {
+    const document = readJsoncObject(file);
+    const providers = document.value.providers;
+    if (providers !== undefined) {
+        if (!isJsonObject(providers))
+            throw new Error(`${file}: expected providers to be a JSON object`);
+        for (const entry of Object.values(providers)) {
+            if (!isJsonObject(entry))
+                throw new Error(`${file}: expected every provider entry to be a JSON object`);
+        }
+    }
+    return { ...document, value: document.value };
+}
+function readSettings(file) {
+    const document = readJsoncObject(file);
+    for (const key of ["defaultProvider", "defaultModel"]) {
+        if (document.value[key] !== undefined && typeof document.value[key] !== "string") {
+            throw new Error(`${file}: expected ${key} to be a string`);
+        }
+    }
+    return { ...document, value: document.value };
+}
 /**
  * pi-family agents (pi, prime-agent) share the same config layout:
  *   <dir>/models.json   — { providers: { <id>: { baseUrl, apiKey, api, models[] } } }
@@ -51,15 +73,16 @@ export function piStyleTarget(opts) {
             const modelsFile = path.join(dir, "models.json");
             const settingsFile = path.join(dir, "settings.json");
             const notes = [];
-            const modelsConfig = readJsonIfExists(modelsFile) ?? {};
+            // Validate both files before preparing any writes, including a malformed settings file.
+            const modelsDocument = readModels(modelsFile);
+            const settingsDocument = readSettings(settingsFile);
+            const modelsConfig = { ...modelsDocument.value };
             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 prev = providers[provider.id] ?? {};
             const api = apiValue(provider.protocol, provider.openaiApi, entryApi(prev));
+            const baseUrl = sdkBaseUrl(provider.protocol, provider.baseUrl);
             const models = mergeModels(prev.models, provider.models.map((m) => ({
                 id: m.id,
                 ...(m.name ? { name: m.name } : {}),
@@ -81,72 +104,82 @@ export function piStyleTarget(opts) {
                     }
                     : {}),
             })), OWNED_MODEL_KEYS);
-            const conflicts = stripConflictingOverrides(models, api, provider.baseUrl);
+            const conflicts = stripConflictingOverrides(models, api, baseUrl);
             if (conflicts.length)
                 notes.push(`dropped model overrides pointing elsewhere: ${conflicts.join(", ")}`);
             providers[provider.id] = {
                 ...prev,
                 name: provider.name,
-                baseUrl: stripApiVersion(provider.baseUrl),
+                baseUrl,
                 apiKey: provider.apiKey, // literal key; pi treats "$VAR"/"!cmd" as indirection, prime also accepts bare env names
                 api,
                 models,
             };
             modelsConfig.providers = providers;
+            const settings = {
+                ...settingsDocument.value,
+                defaultProvider: provider.id,
+                defaultModel: provider.defaultModel,
+            };
+            const modelsText = editJsoncObject(modelsDocument, modelsConfig);
+            const settingsText = editJsoncObject(settingsDocument, settings);
             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;
+            writeFileAtomic(modelsFile, modelsText);
             const settingsBackup = backupFile(settingsFile);
             if (settingsBackup)
                 notes.push(`backup: ${settingsBackup}`);
-            writeFileAtomic(settingsFile, JSON.stringify(settings, null, 2) + "\n");
+            writeFileAtomic(settingsFile, settingsText);
             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]) {
+            const modelsDocument = readModels(modelsFile);
+            const settingsDocument = readSettings(settingsFile);
+            const providers = { ...modelsDocument.value.providers };
+            if (!Object.hasOwn(providers, provider.id)) {
                 return { app: opts.id, changed: [], notes: [], skipped: `no providers.${provider.id} entry` };
             }
             delete providers[provider.id];
+            const settings = { ...settingsDocument.value };
+            const resetDefault = settings.defaultProvider === provider.id;
+            if (resetDefault) {
+                delete settings.defaultProvider;
+                delete settings.defaultModel;
+            }
+            const modelsText = editJsoncObject(modelsDocument, { ...modelsDocument.value, providers });
+            const settingsText = resetDefault ? editJsoncObject(settingsDocument, settings) : undefined;
             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;
+            writeFileAtomic(modelsFile, modelsText);
+            if (settingsText !== undefined) {
                 const settingsBackup = backupFile(settingsFile);
                 if (settingsBackup)
                     notes.push(`backup: ${settingsBackup}`);
-                writeFileAtomic(settingsFile, JSON.stringify(settings, null, 2) + "\n");
+                writeFileAtomic(settingsFile, settingsText);
                 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"));
+            const settings = readSettings(path.join(resolveDir(), "settings.json")).value;
             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)
+            const mc = readModels(path.join(dir, "models.json")).value;
+            const settings = readSettings(path.join(dir, "settings.json")).value;
+            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")

package/dist/targets/wire.js

@@ -108,11 +108,14 @@ export function stripConflictingOverrides(models, api, baseUrl) {
     return dropped;
 }
 /**
- * Strip a trailing API version segment (e.g. `/v1`, `/v2beta`) from a base URL.
- * Use this when writing to apps whose own SDK appends `/v1/...` to the base URL
- * (Anthropic SDK, OpenAI SDK, omp, pi, hermes, dsh). Codex is the exception —
- * it appends `/responses` directly, so it keeps the `/v1` segment.
+ * Return the base URL expected by SDK-backed clients. Anthropic SDK methods
+ * append `/v1/...`, while OpenAI-compatible clients append only the operation
+ * path (`/responses` or `/chat/completions`) and therefore keep `/v1`.
  */
+export function sdkBaseUrl(protocol, baseUrl) {
+    return protocol === "anthropic" ? stripApiVersion(baseUrl) : baseUrl.replace(/\/+$/, "");
+}
+/** Strip a trailing API version segment (e.g. `/v1`, `/v2beta`). */
 export function stripApiVersion(baseUrl) {
     return baseUrl.replace(/\/v\d+(?:beta\d*)?\/?$/i, "");
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentsw",
-  "version": "0.6.0",
+  "version": "0.6.2",
   "description": "CLI provider switcher for coding agents: manage OpenAI/Anthropic-protocol providers in one place and sync them, with models.dev metadata, into Claude Code, Codex, omp, pi, prime-agent, opencode, Hermes, WorkBuddy and DeepSeek Harness",
   "type": "module",
   "repository": {
@@ -41,6 +41,7 @@
   },
   "dependencies": {
     "commander": "^15.0.0",
+    "jsonc-parser": "^3.3.1",
     "picocolors": "^1.1.1",
     "prompts": "^2.4.2",
     "smol-toml": "^1.8.0",