@undefineds.co/xpod 0.4.3 → 0.4.5

package/node_modules/@undefineds.co/ai-connections/dist/client-config/index.cjs

@@ -52,6 +52,7 @@ __export(exports_client_config, {
   normalizeClientProfile: () => normalizeClientProfile,
   looksLikePreviousXpodValue: () => looksLikePreviousXpodValue,
   hashWebId: () => hashWebId,
+  contentFingerprint: () => contentFingerprint,
   activeModelReferences: () => activeModelReferences,
   PiConfigAdapter: () => PiConfigAdapter,
   CodexConfigAdapter: () => CodexConfigAdapter,
@@ -90,7 +91,11 @@ class AiClientConfigTransaction {
       }
     }
     const snapshots = await Promise.all(writes.map((write) => this.snapshot(write.path)));
+    for (const write of writes) {
+      this.assertExpectedContent(write, snapshots.find((snapshot) => snapshot.path === write.path).content);
+    }
     const staged = new Map;
+    const applied = [];
     try {
       for (const write of writes) {
         const snapshot = snapshots.find((candidate) => candidate.path === write.path);
@@ -105,16 +110,21 @@ class AiClientConfigTransaction {
         }
       }
       for (const write of writes) {
+        if (write.expectedContentHash !== undefined) {
+          this.assertExpectedContent(write, (await this.snapshot(write.path)).content);
+        }
         if (write.content === null) {
           await fs.promises.rm(write.path, { force: true });
+          applied.push(write);
         } else {
           await this.rename(staged.get(write.path), write.path);
+          applied.push(write);
           await fs.promises.chmod(write.path, 384);
           await this.syncDirectory(path.dirname(write.path));
         }
       }
     } catch (error) {
-      await this.rollback(snapshots);
+      await this.rollback(snapshots, applied);
       throw error;
     } finally {
       await Promise.all([...staged.values()].map((tempPath) => fs.promises.rm(tempPath, { force: true }).catch(() => {
@@ -178,20 +188,43 @@ class AiClientConfigTransaction {
     await fs.promises.chmod(filePath, 384);
     await this.syncDirectory(path.dirname(filePath));
   }
-  async rollback(snapshots) {
-    for (const snapshot of [...snapshots].reverse()) {
+  assertExpectedContent(write, content) {
+    if (write.expectedContentHash === undefined)
+      return;
+    const hash = content === undefined ? undefined : crypto.createHash("sha256").update(content).digest("hex");
+    if (hash !== write.expectedContentHash) {
+      throw new Error(`AI client configuration changed since planning: ${write.path}; retry with a fresh plan`);
+    }
+  }
+  async rollback(snapshots, applied) {
+    for (const write of [...applied].reverse()) {
+      const snapshot = snapshots.find((candidate) => candidate.path === write.path);
+      let tempPath;
       try {
+        if (!await this.stillContainsWrite(write))
+          continue;
         if (!snapshot.existed) {
           await fs.promises.rm(snapshot.path, { force: true });
           continue;
         }
-        const tempPath = await this.stage(snapshot.path, snapshot.content.toString("utf8"));
+        tempPath = await this.stage(snapshot.path, snapshot.content.toString("utf8"));
+        if (!await this.stillContainsWrite(write))
+          continue;
         await this.rename(tempPath, snapshot.path);
         await fs.promises.chmod(snapshot.path, snapshot.mode ?? 384);
         await this.syncDirectory(path.dirname(snapshot.path));
-      } catch {}
+      } catch {} finally {
+        if (tempPath)
+          await fs.promises.rm(tempPath, { force: true }).catch(() => {
+            return;
+          });
+      }
     }
   }
+  async stillContainsWrite(write) {
+    const current = await this.snapshot(write.path);
+    return write.content === null ? !current.existed : current.content?.equals(Buffer.from(write.content, "utf8")) === true;
+  }
   async syncDirectory(directory) {
     let handle;
     try {
@@ -227,6 +260,10 @@ class AiClientConfigError extends Error {
 function hashWebId(webId) {
   return crypto2.createHash("sha256").update(webId.trim(), "utf8").digest("hex");
 }
+function contentHash(value) {
+  return crypto2.createHash("sha256").update(value, "utf8").digest("hex");
+}
+var contentFingerprint = contentHash;
 function normalizeV1Endpoint(endpoint) {
   const normalized = endpoint.trim().replace(/\/+$/, "");
   return normalized.endsWith("/v1") ? normalized : `${normalized}/v1`;
@@ -314,7 +351,7 @@ function normalizeActiveModels(models) {
 function normalizeClientProfile(profile) {
   return {
     ...profile,
-    model: resolveActiveModel(profile)
+    model: profile.activeModels?.length ? resolveActiveModel(profile) : profile.model?.trim() || undefined
   };
 }
 function stripLegacyXpodObject(value) {
@@ -346,9 +383,22 @@ class BaseAiClientConfigAdapter {
   }
   async inspect() {
     const state = await this.readState();
+    let projectionMatches;
+    if (state?.projectionHashes) {
+      projectionMatches = true;
+      for (const filePath of this.configPaths) {
+        await this.rejectSymlink(filePath);
+        const content = await this.readOptional(filePath);
+        if (content === undefined || contentHash(content) !== state.projectionHashes[filePath]) {
+          projectionMatches = false;
+        }
+      }
+    }
     return {
       ownership: state ? "owned" : "unowned",
       ...state ? { webIdHash: state.webIdHash } : {},
+      ...projectionMatches === undefined ? {} : { projectionMatches },
+      ...projectionMatches && /^[a-f0-9]{64}$/u.test(state?.apiKeyFingerprint ?? "") ? { apiKeyFingerprint: state.apiKeyFingerprint } : {},
       configPaths: [...this.configPaths]
     };
   }
@@ -365,8 +415,14 @@ class BaseAiClientConfigAdapter {
       contents.set(filePath, await this.readOptional(filePath));
     }
     const projected = await this.project(normalizedProfile, contents);
+    for (const filePath of projected.keys()) {
+      if (!contents.has(filePath)) {
+        await this.rejectSymlink(filePath);
+        contents.set(filePath, await this.readOptional(filePath));
+      }
+    }
     const timestamp = Date.now();
-    const files = this.configPaths.map((filePath) => {
+    const files = [...projected.keys()].map((filePath) => {
       const prior = currentState?.files.find((file) => file.path === filePath);
       const existed = contents.get(filePath) !== undefined;
       return prior ?? {
@@ -379,12 +435,14 @@ class BaseAiClientConfigAdapter {
       path: filePath,
       content,
       backupPath: files.find((file) => file.path === filePath)?.backupPath,
-      createBackup: !currentState && contents.get(filePath) !== undefined
+      createBackup: !currentState?.files.some((file) => file.path === filePath) && contents.get(filePath) !== undefined
     }));
     const state = {
       version: 1,
       client: this.client,
       webIdHash: ownerHash,
+      apiKeyFingerprint: contentHash(profileApiKey(normalizedProfile)),
+      projectionHashes: Object.fromEntries([...projected].map(([filePath, content]) => [filePath, contentHash(content)])),
       files
     };
     writes.push({ path: this.statePath, content: stringifyJson(state) });
@@ -411,10 +469,17 @@ class BaseAiClientConfigAdapter {
     if (state.webIdHash !== hashWebId(webId)) {
       throw new Error(`${this.client} AI Connection projection is owned by another WebID`);
     }
-    const writes = [];
+    const current = new Map;
     for (const file of state.files) {
       await this.rejectSymlink(file.path);
-      const current = await this.readOptional(file.path);
+      current.set(file.path, await this.readOptional(file.path));
+    }
+    const currentFingerprint = await this.currentApiKeyFingerprint(current);
+    if (state.apiKeyFingerprint && currentFingerprint && currentFingerprint !== state.apiKeyFingerprint) {
+      throw new Error(`${this.client} API key changed since projection was applied; refusing restore to avoid data loss`);
+    }
+    const writes = [];
+    for (const file of state.files) {
       let original;
       if (file.existed) {
         if (!file.backupPath) {
@@ -428,7 +493,7 @@ class BaseAiClientConfigAdapter {
       }
       writes.push({
         path: file.path,
-        content: await this.restoreFile(file.path, current, original, file.existed)
+        content: await this.restoreFile(file.path, current.get(file.path), original, file.existed)
       });
     }
     writes.push({ path: this.statePath, content: null });
@@ -437,6 +502,9 @@ class BaseAiClientConfigAdapter {
   normalizeProfile(profile) {
     return normalizeClientProfile(profile);
   }
+  async currentApiKeyFingerprint(_current) {
+    return;
+  }
   async readOptional(filePath) {
     try {
       return await fs2.promises.readFile(filePath, "utf8");
@@ -506,67 +574,154 @@ var END = "# <<< xpod-ai-connections managed";
 class CodexConfigAdapter extends BaseAiClientConfigAdapter {
   configPath;
   authPath;
+  catalogPath;
+  nativeModelsPath;
   constructor(options = {}) {
     const codexHome = path3.join(options.homeDir ?? os.homedir(), ".codex");
     const configPath = path3.join(codexHome, "config.toml");
     const authPath = path3.join(codexHome, "auth.json");
-    super("codex", "codex", [configPath, authPath], codexHome);
+    super("codex", "codex", [configPath], codexHome);
     this.configPath = configPath;
     this.authPath = authPath;
+    this.catalogPath = path3.join(codexHome, "xpod-model-catalog.json");
+    this.nativeModelsPath = path3.join(codexHome, "models_cache.json");
   }
   normalizeProfile(profile) {
-    if (!profile.model?.trim() && (!profile.activeModels || profile.activeModels.length === 0)) {
-      return { ...profile, model: undefined };
+    return profile.model?.trim() ? super.normalizeProfile(profile) : { ...profile, model: undefined };
+  }
+  async inspect() {
+    const inspection = await super.inspect();
+    const state = await this.readState();
+    if (!state?.files.some((file) => file.path === this.catalogPath))
+      return inspection;
+    await this.rejectSymlink(this.catalogPath);
+    const catalog = await this.readOptional(this.catalogPath);
+    if (catalog !== undefined && contentFingerprint(catalog) === state.projectionHashes?.[this.catalogPath]) {
+      return { ...inspection, configPaths: [...inspection.configPaths, this.catalogPath] };
     }
-    return super.normalizeProfile(profile);
+    const withoutFingerprint = { ...inspection };
+    delete withoutFingerprint.apiKeyFingerprint;
+    return { ...withoutFingerprint, projectionMatches: false, configPaths: [...inspection.configPaths, this.catalogPath] };
+  }
+  async plan(profile) {
+    const plan = await super.plan(profile);
+    const state = await this.readState();
+    const legacyAuth = state?.files.find((file) => file.path === this.authPath);
+    if (!legacyAuth)
+      return plan;
+    await this.rejectSymlink(this.authPath);
+    const current = await this.readOptional(this.authPath);
+    if (!this.ownsLegacyAuth(current, state?.apiKeyFingerprint))
+      return plan;
+    let original;
+    if (legacyAuth.existed) {
+      if (!legacyAuth.backupPath)
+        throw new Error("Missing Codex auth.json backup metadata");
+      await this.rejectSymlink(legacyAuth.backupPath);
+      original = await this.readOptional(legacyAuth.backupPath);
+      if (original === undefined)
+        throw new Error("Missing Codex auth.json backup; refusing to guess login state");
+    }
+    plan.writes.splice(plan.writes.length - 1, 0, {
+      path: this.authPath,
+      content: restoreLegacyAuth(current, original, legacyAuth.existed),
+      expectedContentHash: contentFingerprint(current)
+    });
+    return plan;
+  }
+  ownsLegacyAuth(current, fingerprint) {
+    if (!fingerprint || current === undefined)
+      return false;
+    const auth = parseJsonObject(current, "Codex auth.json");
+    return typeof auth.OPENAI_API_KEY === "string" && contentFingerprint(auth.OPENAI_API_KEY) === fingerprint;
   }
   async project(profile, current) {
-    const config = stripRootLevelModelKeys(this.removeManagedBlock(current.get(this.configPath) ?? "")).trimEnd();
+    const baseContent = current.get(this.configPath) ?? "";
+    let nativeModels = [];
+    if (profile.activeModels?.length) {
+      const nativeCatalog = await this.readOptional(this.nativeModelsPath);
+      if (nativeCatalog !== undefined)
+        nativeModels = readCatalogModels(nativeCatalog, "Codex native model cache");
+    }
+    let catalog = codexModelCatalog(profile.activeModels, nativeModels);
+    const state = await this.readState();
+    const ownsCatalog = state?.files.some((file) => file.path === this.catalogPath);
+    if (catalog !== undefined || ownsCatalog) {
+      await this.rejectSymlink(this.catalogPath);
+      const existingCatalog = await this.readOptional(this.catalogPath);
+      current.set(this.catalogPath, existingCatalog);
+      catalog ??= existingCatalog;
+      if (catalog === undefined)
+        throw new Error("Codex model catalog is missing; refresh with the current Gateway models");
+    }
+    const unmanagedConfig = this.removeManagedBlock(baseContent);
+    if (hasUnmanagedModelProviderTable(unmanagedConfig)) {
+      throw new Error("Codex config.toml already defines [model_providers.xpod] outside managed block");
+    }
+    const config = stripRootLevelModelKeys(unmanagedConfig).trim();
     const model = profile.model?.trim();
-    const block = [
+    const rootBlock = [
       START,
       'model_provider = "xpod"',
-      ...model ? [`model = ${JSON.stringify(model)}`] : [],
+      ...model ? [`model = ${JSON.stringify(model)}`] : rootLevelLines(baseContent, "model"),
+      ...catalog !== undefined ? [`model_catalog_json = ${JSON.stringify(this.catalogPath)}`] : rootLevelLines(baseContent, "model_catalog_json"),
+      END
+    ].join(`
+`);
+    const providerBlock = [
+      START,
       "",
       "[model_providers.xpod]",
       'name = "Xpod AI Connection"',
       `base_url = ${JSON.stringify(normalizeV1Endpoint(profile.endpoint))}`,
       'wire_api = "responses"',
-      "requires_openai_auth = true",
+      "requires_openai_auth = false",
+      `experimental_bearer_token = ${JSON.stringify(profileApiKey(profile))}`,
       END,
       ""
     ].join(`
 `);
-    const auth = parseJsonObject(current.get(this.authPath), "Codex auth.json");
-    auth.OPENAI_API_KEY = profileApiKey(profile);
-    return new Map([
-      [this.configPath, `${config}${config ? `
+    const projected = new Map([[this.configPath, `${rootBlock}
 
-` : ""}${block}`],
-      [this.authPath, stringifyJson(auth)]
-    ]);
+${config}${config ? `
+
+` : ""}${providerBlock}`]]);
+    if (catalog !== undefined)
+      projected.set(this.catalogPath, catalog);
+    return projected;
   }
   async verifyProjection(profile) {
     try {
       const config = await fs3.promises.readFile(this.configPath, "utf8");
-      const auth = parseJsonObject(await fs3.promises.readFile(this.authPath, "utf8"), "Codex auth.json");
-      const modelMatches = profile.model ? config.includes(`model = ${JSON.stringify(profile.model)}`) : !hasRootLevelKey(config, "model");
-      const ok = config.includes('model_provider = "xpod"') && modelMatches && config.includes(`base_url = ${JSON.stringify(normalizeV1Endpoint(profile.endpoint))}`) && auth.OPENAI_API_KEY === profileApiKey(profile);
+      const modelMatches = profile.model ? rootLevelLines(config, "model").some((line) => line.trim() === `model = ${JSON.stringify(profile.model)}`) : true;
+      const provider = tableLines(config, "model_providers.xpod");
+      const state = await this.readState();
+      const ownsCatalog = state?.files.some((file) => file.path === this.catalogPath);
+      let catalogMatches = true;
+      if (profile.activeModels !== undefined || ownsCatalog) {
+        const catalog = await fs3.promises.readFile(this.catalogPath, "utf8");
+        const expectedCatalog = codexModelCatalog(profile.activeModels, readCatalogModels(catalog, "Codex model catalog"));
+        catalogMatches = rootLevelLines(config, "model_catalog_json").includes(`model_catalog_json = ${JSON.stringify(this.catalogPath)}`) && contentFingerprint(catalog) === state?.projectionHashes?.[this.catalogPath] && (expectedCatalog === undefined || catalog === expectedCatalog);
+      }
+      const ok = rootLevelLines(config, "model_provider").some((line) => line.trim() === 'model_provider = "xpod"') && modelMatches && catalogMatches && provider.includes(`base_url = ${JSON.stringify(normalizeV1Endpoint(profile.endpoint))}`) && provider.includes('wire_api = "responses"') && provider.includes("requires_openai_auth = false") && provider.includes(`experimental_bearer_token = ${JSON.stringify(profileApiKey(profile))}`);
       return ok ? { ok: true } : { ok: false, reason: "Codex projection differs from the requested connection" };
     } catch (error) {
       return { ok: false, reason: String(error) };
     }
   }
   async restoreFile(filePath, current, original, originallyExisted) {
-    if (filePath === this.authPath) {
-      const restored2 = parseJsonObject(current, "Codex auth.json");
-      const before = parseJsonObject(original, "Codex original auth.json");
-      if (Object.prototype.hasOwnProperty.call(before, "OPENAI_API_KEY") && !looksLikePreviousXpodValue(before.OPENAI_API_KEY)) {
-        restored2.OPENAI_API_KEY = before.OPENAI_API_KEY;
-      } else {
-        delete restored2.OPENAI_API_KEY;
+    if (filePath === this.catalogPath) {
+      const state = await this.readState();
+      if (current === undefined || contentFingerprint(current) !== state?.projectionHashes?.[this.catalogPath]) {
+        throw new Error("Codex model catalog changed since projection was applied; refusing restore to avoid data loss");
       }
-      return !originallyExisted && Object.keys(restored2).length === 0 ? null : stringifyJson(restored2);
+      return originallyExisted ? original : null;
+    }
+    if (filePath === this.authPath) {
+      const state = await this.readState();
+      if (!this.ownsLegacyAuth(current, state?.apiKeyFingerprint))
+        return current ?? null;
+      return restoreLegacyAuth(current, original, originallyExisted);
     }
     let restored = this.removeManagedBlock(current ?? "").trim();
     const hasCurrentProvider = hasRootLevelKey(restored, "model_provider");
@@ -578,19 +733,51 @@ class CodexConfigAdapter extends BaseAiClientConfigAdapter {
         restored = insertRootLevelLines(restored, originalRoot);
       }
     }
+    if (!hasRootLevelKey(restored, "model_catalog_json") && !originalHasXpodProjection) {
+      const originalCatalog = rootLevelLines(originalContent, "model_catalog_json");
+      if (originalCatalog.length > 0)
+        restored = insertRootLevelLines(restored, originalCatalog);
+    }
     return !originallyExisted && !restored ? null : `${restored}${restored ? `
 ` : ""}`;
   }
+  async currentApiKeyFingerprint(current) {
+    const token = tableLines(current.get(this.configPath) ?? "", "model_providers.xpod").find((line) => /^experimental_bearer_token\s*=/u.test(line));
+    if (token) {
+      const value = JSON.parse(token.slice(token.indexOf("=") + 1).trim());
+      return typeof value === "string" ? contentFingerprint(value) : undefined;
+    }
+    if (current.has(this.authPath)) {
+      const auth = parseJsonObject(current.get(this.authPath), "Codex auth.json");
+      return typeof auth.OPENAI_API_KEY === "string" ? contentFingerprint(auth.OPENAI_API_KEY) : undefined;
+    }
+    return;
+  }
   removeManagedBlock(content) {
-    const start = content.indexOf(START);
-    if (start < 0)
-      return content;
-    const end = content.indexOf(END, start);
-    if (end < 0)
-      throw new Error("Codex xpod managed block is incomplete");
-    return `${content.slice(0, start)}${content.slice(end + END.length)}`;
+    let start = content.indexOf(START);
+    while (start >= 0) {
+      const end = content.indexOf(END, start);
+      if (end < 0)
+        throw new Error("Codex xpod managed block is incomplete");
+      content = `${content.slice(0, start)}${content.slice(end + END.length)}`;
+      start = content.indexOf(START);
+    }
+    return content;
   }
 }
+function tableLines(content, table) {
+  const lines = [];
+  let selected = false;
+  for (const line of content.split(`
+`)) {
+    if (isTomlTableHeader(line)) {
+      selected = line.trim() === `[${table}]`;
+    } else if (selected) {
+      lines.push(line.trim());
+    }
+  }
+  return lines;
+}
 function stripRootLevelModelKeys(content) {
   const lines = content.split(`
 `);
@@ -643,13 +830,151 @@ ${normalizedContent}` : ""}`;
 function isTomlTableHeader(line) {
   return /^\s*\[\[?[^\]]+\]\]?\s*(?:#.*)?$/u.test(line);
 }
+function hasUnmanagedModelProviderTable(content) {
+  for (const line of content.split(`
+`)) {
+    if (!isTomlTableHeader(line) || /^\s*\[\[/.test(line)) {
+      continue;
+    }
+    if (normalizeTomlTableName(line) === "model_providers.xpod") {
+      return true;
+    }
+  }
+  return false;
+}
+function normalizeTomlTableName(line) {
+  const match = /^\s*\[\s*([^\]]+)\s*\]\s*(?:#.*)?$/u.exec(line);
+  if (!match)
+    return;
+  const rawName = match[1].trim();
+  const segments = parseTomlTableSegments(rawName);
+  return segments.length === 1 ? undefined : normalizeTomlDottedKey(rawName);
+}
+function normalizeTomlDottedKey(content) {
+  const parts = parseTomlTableSegments(content);
+  return parts.map((part) => removeTomlQuotes(part)).join(".");
+}
+function parseTomlTableSegments(input) {
+  const parts = [];
+  let current = "";
+  let quote = null;
+  for (let i = 0;i < input.length; i++) {
+    const char = input[i];
+    if (quote) {
+      if (char === quote) {
+        quote = null;
+        continue;
+      }
+      current += char;
+      continue;
+    }
+    if (char === '"' || char === "'") {
+      quote = char;
+      continue;
+    }
+    if (char === ".") {
+      parts.push(current.trim());
+      current = "";
+      continue;
+    }
+    current += char;
+  }
+  parts.push(current.trim());
+  return parts.map((part) => part.trim()).filter((part) => part.length > 0);
+}
+function removeTomlQuotes(value) {
+  if (value.length === 0)
+    return value;
+  const first = value[0];
+  const last = value[value.length - 1];
+  if (first === '"' && last === '"' || first === "'" && last === "'") {
+    return value.slice(1, -1);
+  }
+  return value;
+}
 function isRootModelKey(line) {
   return rootModelKey(line) !== undefined;
 }
 function rootModelKey(line) {
-  const match = /^\s*(model_provider|model)\s*=/.exec(line);
+  const match = /^\s*(model_provider|model|model_catalog_json)\s*=/.exec(line);
   return match?.[1];
 }
+function restoreLegacyAuth(current, original, originallyExisted) {
+  const restored = parseJsonObject(current, "Codex auth.json");
+  const before = parseJsonObject(original, "Codex original auth.json");
+  if (restored.auth_mode === "apikey") {
+    if (Object.prototype.hasOwnProperty.call(before, "auth_mode")) {
+      restored.auth_mode = before.auth_mode;
+    } else {
+      delete restored.auth_mode;
+    }
+  }
+  if (Object.prototype.hasOwnProperty.call(before, "OPENAI_API_KEY") && !looksLikePreviousXpodValue(before.OPENAI_API_KEY)) {
+    restored.OPENAI_API_KEY = before.OPENAI_API_KEY;
+  } else {
+    delete restored.OPENAI_API_KEY;
+  }
+  return !originallyExisted && Object.keys(restored).length === 0 ? null : stringifyJson(restored);
+}
+function codexModelCatalog(models, nativeModels = []) {
+  if (models === undefined)
+    return;
+  const available = models.filter((model) => model.availability === undefined || model.availability === "available");
+  if (available.length === 0)
+    throw new AiClientConfigError("model_catalog_empty");
+  const seen = new Set;
+  return stringifyJson({ models: available.map((model, index) => {
+    const id = model.id.trim();
+    if (!id || seen.has(id))
+      throw new Error("Codex model catalog requires unique, non-empty Gateway model ids");
+    seen.add(id);
+    const native = nativeModels.find((entry) => entry.slug === id);
+    const nativeModalities = Array.isArray(native?.input_modalities) ? native.input_modalities : ["text"];
+    const declaredModalities = model.inputModalities?.filter((value) => value === "text" || value === "image");
+    const modalities = declaredModalities?.filter((value) => !native || nativeModalities.includes(value)) ?? nativeModalities;
+    const contextWindow = Number.isSafeInteger(model.contextWindow) && model.contextWindow > 0 ? model.contextWindow : undefined;
+    const reasoning = codexReasoningLevels(model);
+    return {
+      slug: id,
+      description: "Xpod Gateway model",
+      supported_reasoning_levels: reasoning.levels,
+      ...reasoning.defaultLevel ? { default_reasoning_level: reasoning.defaultLevel } : {},
+      shell_type: "shell_command",
+      support_verbosity: false,
+      supports_parallel_tool_calls: false,
+      truncation_policy: { mode: "tokens", limit: 1e4 },
+      experimental_supported_tools: [],
+      base_instructions: "You are a coding assistant.",
+      ...native,
+      display_name: model.displayName?.trim() || native?.display_name || id,
+      visibility: "list",
+      supported_in_api: true,
+      priority: index,
+      input_modalities: modalities.length ? [...new Set(modalities)] : ["text"],
+      ...contextWindow !== undefined ? { context_window: contextWindow } : {},
+      ...contextWindow !== undefined && typeof native?.max_context_window === "number" ? { max_context_window: Math.min(contextWindow, native.max_context_window) } : {}
+    };
+  }) });
+}
+function codexReasoningLevels(model) {
+  if (model.provider !== "deepseek" || !model.capabilities?.includes("reasoning"))
+    return { levels: [] };
+  return {
+    levels: [
+      { effort: "low", description: "DeepSeek low reasoning depth" },
+      { effort: "high", description: "DeepSeek standard reasoning depth" },
+      { effort: "max", description: "DeepSeek maximum reasoning depth" }
+    ],
+    defaultLevel: "high"
+  };
+}
+function readCatalogModels(content, label) {
+  const catalog = parseJsonObject(content, label);
+  if (!Array.isArray(catalog.models) || catalog.models.some((model) => !model || typeof model !== "object" || Array.isArray(model) || typeof model.slug !== "string")) {
+    throw new Error(`${label} must contain a models array with string slugs`);
+  }
+  return catalog.models;
+}
 // src/client-config/json-env-adapter.ts
 var fs4 = __toESM(require("node:fs"));
 var os2 = __toESM(require("node:os"));
@@ -667,7 +992,8 @@ class JsonEnvAdapter extends BaseAiClientConfigAdapter {
     const env = settings.env && typeof settings.env === "object" && !Array.isArray(settings.env) ? { ...settings.env } : {};
     Object.assign(env, this.envProjection(profile));
     settings.env = env;
-    settings.model = profile.model;
+    if (profile.model)
+      settings.model = profile.model;
     return new Map([[this.settingsPath, stringifyJson(settings)]]);
   }
   async verifyProjection(profile) {
@@ -675,7 +1001,7 @@ class JsonEnvAdapter extends BaseAiClientConfigAdapter {
       const settings = parseJsonObject(await fs4.promises.readFile(this.settingsPath, "utf8"), `${this.client} settings.json`);
       const env = settings.env;
       const expected = this.envProjection(profile);
-      const ok = env !== undefined && settings.model === profile.model && Object.entries(expected).every(([key, value]) => env[key] === value);
+      const ok = env !== undefined && (!profile.model || settings.model === profile.model) && Object.entries(expected).every(([key, value]) => env[key] === value);
       return ok ? { ok: true } : {
         ok: false,
         reason: `${this.client} projection differs from the requested connection`
@@ -760,15 +1086,18 @@ class PiConfigAdapter extends BaseAiClientConfigAdapter {
     const settings = parseJsonObject(current.get(this.settingsPath), "Pi settings.json");
     const models = parseJsonObject(current.get(this.modelsPath), "Pi models.json");
     const providers = models.providers && typeof models.providers === "object" && !Array.isArray(models.providers) ? { ...models.providers } : {};
+    const previous = isObject2(providers.xpod) ? providers.xpod : {};
     const model = profile.model;
     settings.defaultProvider = "xpod";
-    settings.defaultModel = model;
+    if (model)
+      settings.defaultModel = model;
     providers.xpod = {
+      ...previous,
       baseUrl: normalizeV1Endpoint(profile.endpoint),
       apiKey: profileApiKey(profile),
       authHeader: true,
       api: "openai-responses",
-      models: activeModelReferences(profile)
+      models: profile.activeModels?.length ? activeModelReferences(profile) : model ? mergeModel(previous.models, model) : previous.models ?? []
     };
     models.providers = providers;
     return new Map([
@@ -783,7 +1112,7 @@ class PiConfigAdapter extends BaseAiClientConfigAdapter {
       const configuredModels = isObject2(xpod?.models) || Array.isArray(xpod?.models) ? xpod?.models : undefined;
       const ok = xpod?.baseUrl === normalizeV1Endpoint(profile.endpoint) && xpod.apiKey === profileApiKey(profile);
       const modelIds = Array.isArray(configuredModels) ? configuredModels.map((entry) => isObject2(entry) && typeof entry.id === "string" ? entry.id : undefined).filter((id) => id !== undefined) : [];
-      return ok && modelIds.includes(profile.model ?? "") ? { ok: true } : { ok: false, reason: "Pi projection differs from the requested connection" };
+      return ok && (!profile.model || modelIds.includes(profile.model)) ? { ok: true } : { ok: false, reason: "Pi projection differs from the requested connection" };
     } catch (error) {
       return { ok: false, reason: String(error) };
     }
@@ -820,3 +1149,7 @@ function restoreOwnedProperty(target, original, key) {
 function isObject2(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
+function mergeModel(models, id) {
+  const existing = Array.isArray(models) ? models : [];
+  return existing.some((entry) => isObject2(entry) && entry.id === id) ? existing : [...existing, { id }];
+}

package/node_modules/@undefineds.co/ai-connections/dist/client-config/json-env-adapter.js

@@ -15,7 +15,8 @@ class JsonEnvAdapter extends BaseAiClientConfigAdapter {
             : {};
         Object.assign(env, this.envProjection(profile));
         settings.env = env;
-        settings.model = profile.model;
+        if (profile.model)
+            settings.model = profile.model;
         return new Map([[this.settingsPath, stringifyJson(settings)]]);
     }
     async verifyProjection(profile) {
@@ -24,7 +25,7 @@ class JsonEnvAdapter extends BaseAiClientConfigAdapter {
             const env = settings.env;
             const expected = this.envProjection(profile);
             const ok = env !== undefined
-                && settings.model === profile.model
+                && (!profile.model || settings.model === profile.model)
                 && Object.entries(expected).every(([key, value]) => env[key] === value);
             return ok ? { ok: true } : {
                 ok: false,