@khanglvm/llm-router 2.3.5 → 2.3.7

package/src/node/coding-tool-config.js

@@ -4,14 +4,18 @@ import { promises as fs } from "node:fs";
 import {
   CODEX_CLI_INHERIT_MODEL_VALUE,
   CLAUDE_CODE_EFFORT_LEVEL_SETTINGS_JSON_VALUE,
+  buildFactoryDroidRouterDisplayName,
+  buildFactoryDroidRouterModelId,
   isCodexCliInheritModelBinding,
+  isFactoryDroidRouterModelId,
   mapClaudeCodeThinkingLevelToTokens,
   mapClaudeCodeThinkingTokensToLevel,
   normalizeClaudeCodeThinkingLevel,
   normalizeClaudeCodeEffortLevel,
   migrateLegacyThinkingTokensToEffortLevel,
   normalizeCodexCliReasoningEffort,
-  normalizeFactoryDroidReasoningEffort
+  normalizeFactoryDroidReasoningEffort,
+  resolveFactoryDroidRouterModelRef
 } from "../shared/coding-tool-bindings.js";
 
 const BACKUP_SUFFIX = ".llm_router_backup";
@@ -966,7 +970,38 @@ export async function patchClaudeCodeEffortLevel({
 }
 
 const FACTORY_DROID_ROUTER_MARKER = "_llmRouterManaged";
-const FACTORY_DROID_ROUTER_PROVIDER = "generic-chat-completion-api";
+const FACTORY_DROID_OPENAI_PROVIDER = "openai";
+const FACTORY_DROID_ANTHROPIC_PROVIDER = "anthropic";
+const FACTORY_DROID_ROUTER_PROVIDERS = Object.freeze([
+  FACTORY_DROID_OPENAI_PROVIDER,
+  FACTORY_DROID_ANTHROPIC_PROVIDER
+]);
+
+function dedupeStrings(values = []) {
+  const seen = new Set();
+  const out = [];
+  for (const value of values) {
+    const normalized = String(value || "").trim();
+    if (!normalized || seen.has(normalized)) continue;
+    seen.add(normalized);
+    out.push(normalized);
+  }
+  return out;
+}
+
+function normalizeFactoryDroidFormat(value) {
+  const normalized = String(value || "").trim().toLowerCase();
+  if (normalized === "openai") return "openai";
+  if (normalized === "claude" || normalized === "anthropic") return "claude";
+  return "";
+}
+
+function mapFactoryDroidFormatToProvider(format) {
+  const normalized = normalizeFactoryDroidFormat(format);
+  if (normalized === "claude") return FACTORY_DROID_ANTHROPIC_PROVIDER;
+  if (normalized === "openai") return FACTORY_DROID_OPENAI_PROVIDER;
+  return "";
+}
 
 function normalizeFactoryDroidBindings(bindings = {}) {
   const source = bindings && typeof bindings === "object" && !Array.isArray(bindings) ? bindings : {};
@@ -980,15 +1015,276 @@ function normalizeFactoryDroidBindings(bindings = {}) {
   };
 }
 
-function buildFactoryDroidBaseUrl(endpointUrl) {
+function buildFactoryDroidBaseUrl(endpointUrl, provider = FACTORY_DROID_OPENAI_PROVIDER) {
   const normalized = normalizeHttpUrl(endpointUrl);
-  return normalized ? `${normalized}/openai/v1` : "";
+  const resolvedProvider = String(provider || "").trim().toLowerCase() || FACTORY_DROID_OPENAI_PROVIDER;
+  if (!normalized) return "";
+  return resolvedProvider === FACTORY_DROID_ANTHROPIC_PROVIDER
+    ? `${normalized}/anthropic`
+    : `${normalized}/openai/v1`;
+}
+
+function inferFactoryDroidFormatFromModelId(modelId) {
+  const normalized = String(modelId || "").trim().toLowerCase();
+  if (!normalized) return "";
+  if (/^(?:claude|opus|sonnet|haiku)(?=[-./\s]|$)/i.test(normalized)) return "claude";
+  if (/^gpt(?=[-./\s]|$)/i.test(normalized)) return "openai";
+  return "";
+}
+
+function inferFactoryDroidFormatFromProviderId(providerId) {
+  const normalized = String(providerId || "").trim().toLowerCase();
+  if (!normalized) return "";
+  if (normalized === "anthropic") return "claude";
+  if (normalized === "openai") return "openai";
+  return "";
+}
+
+function getFactoryDroidProviderModelFormats(provider, model, modelId = "") {
+  const resolvedModelId = String(modelId || model?.id || "").trim();
+  const preferredFormat = normalizeFactoryDroidFormat(provider?.lastProbe?.modelPreferredFormat?.[resolvedModelId]);
+  if (preferredFormat) return [preferredFormat];
+
+  return dedupeStrings([
+    ...(provider?.lastProbe?.modelSupport?.[resolvedModelId] || []),
+    ...(model?.formats || []),
+    model?.format
+  ])
+    .map(normalizeFactoryDroidFormat)
+    .filter(Boolean);
+}
+
+function getFactoryDroidProviderFormats(provider) {
+  return dedupeStrings([
+    ...(provider?.formats || []),
+    provider?.format
+  ])
+    .map(normalizeFactoryDroidFormat)
+    .filter(Boolean);
+}
+
+function getFactoryDroidAliasTargetRefs(alias) {
+  const refs = [];
+  const push = (entry) => {
+    const ref = String(
+      typeof entry === "string"
+        ? entry
+        : (entry?.ref || entry?.sourceRef || "")
+    ).trim();
+    if (ref) refs.push(ref);
+  };
+
+  for (const entry of Array.isArray(alias?.targets) ? alias.targets : []) push(entry);
+  for (const entry of Array.isArray(alias?.fallbackTargets) ? alias.fallbackTargets : []) push(entry);
+
+  return refs;
+}
+
+function resolveFactoryDroidRouteFormat(modelRef, config = {}, seen = new Set()) {
+  const normalizedModelRef = String(modelRef || "").trim();
+  if (!normalizedModelRef || seen.has(normalizedModelRef)) return "";
+
+  if (normalizedModelRef.includes("/")) {
+    const separatorIndex = normalizedModelRef.indexOf("/");
+    const providerId = normalizedModelRef.slice(0, separatorIndex).trim();
+    const modelId = normalizedModelRef.slice(separatorIndex + 1).trim();
+    const provider = (Array.isArray(config?.providers) ? config.providers : [])
+      .find((entry) => String(entry?.id || "").trim() === providerId);
+    const model = Array.isArray(provider?.models)
+      ? provider.models.find((entry) => String(entry?.id || "").trim() === modelId)
+      : null;
+    return getFactoryDroidProviderModelFormats(provider, model, modelId)[0]
+      || inferFactoryDroidFormatFromModelId(modelId)
+      || getFactoryDroidProviderFormats(provider)[0]
+      || inferFactoryDroidFormatFromProviderId(providerId)
+      || "";
+  }
+
+  seen.add(normalizedModelRef);
+  const aliases = config?.modelAliases && typeof config.modelAliases === "object" && !Array.isArray(config.modelAliases)
+    ? config.modelAliases
+    : {};
+  const alias = aliases[normalizedModelRef];
+  if (!alias || typeof alias !== "object" || Array.isArray(alias)) return "";
+
+  for (const targetRef of getFactoryDroidAliasTargetRefs(alias)) {
+    const resolved = resolveFactoryDroidRouteFormat(targetRef, config, new Set(seen));
+    if (resolved) return resolved;
+  }
+
+  return "";
+}
+
+function resolveFactoryDroidCustomModelProvider(modelRef, config = {}) {
+  return mapFactoryDroidFormatToProvider(resolveFactoryDroidRouteFormat(modelRef, config))
+    || FACTORY_DROID_OPENAI_PROVIDER;
+}
+
+function resolveFactoryDroidProviderDisplayName(modelRef, config = {}) {
+  const normalizedModelRef = String(modelRef || "").trim();
+  if (!normalizedModelRef.includes("/")) return "";
+  const separatorIndex = normalizedModelRef.indexOf("/");
+  const providerId = normalizedModelRef.slice(0, separatorIndex).trim();
+  const provider = (Array.isArray(config?.providers) ? config.providers : [])
+    .find((entry) => String(entry?.id || "").trim() === providerId);
+  return String(provider?.name || providerId || "").trim();
+}
+
+function collectFactoryDroidAvailableModels(config = {}, bindings = {}) {
+  const refs = [];
+  const seen = new Set();
+  const push = (value) => {
+    const normalized = String(value || "").trim();
+    if (!normalized || seen.has(normalized)) return;
+    seen.add(normalized);
+    refs.push(normalized);
+  };
+
+  const aliases = config?.modelAliases && typeof config.modelAliases === "object" && !Array.isArray(config.modelAliases)
+    ? config.modelAliases
+    : {};
+  for (const aliasId of Object.keys(aliases)) {
+    push(aliasId);
+  }
+
+  push(bindings?.defaultModel);
+  push(bindings?.missionOrchestratorModel);
+  push(bindings?.missionWorkerModel);
+  push(bindings?.missionValidatorModel);
+
+  for (const provider of Array.isArray(config?.providers) ? config.providers : []) {
+    if (provider?.enabled === false) continue;
+    const providerId = String(provider?.id || "").trim();
+    if (!providerId) continue;
+    for (const model of Array.isArray(provider?.models) ? provider.models : []) {
+      if (model?.enabled === false) continue;
+      const modelId = String(model?.id || "").trim();
+      if (!modelId) continue;
+      push(`${providerId}/${modelId}`);
+    }
+  }
+
+  return refs;
+}
+
+function buildFactoryDroidAvailableModelDescriptors(config = {}, bindings = {}) {
+  return collectFactoryDroidAvailableModels(config, bindings)
+    .map((modelRef) => {
+      const kind = modelRef.includes("/") ? "model" : "alias";
+      return {
+        modelRef,
+        kind,
+        id: buildFactoryDroidRouterModelId(modelRef, { kind }),
+        displayName: buildFactoryDroidRouterDisplayName(modelRef, {
+          kind,
+          providerName: kind === "model" ? resolveFactoryDroidProviderDisplayName(modelRef, config) : ""
+        })
+      };
+    })
+    .filter((entry) => String(entry.id || "").trim() && String(entry.modelRef || "").trim());
+}
+
+function buildFactoryDroidRouteLookup(config = {}, bindings = {}) {
+  const descriptors = buildFactoryDroidAvailableModelDescriptors(config, bindings);
+  const byId = new Map();
+  const byDisplayName = new Map();
+
+  for (const descriptor of descriptors) {
+    if (descriptor.id) byId.set(descriptor.id, descriptor.modelRef);
+    if (descriptor.displayName) byDisplayName.set(descriptor.displayName, descriptor.modelRef);
+  }
+
+  return {
+    descriptors,
+    byId,
+    byDisplayName
+  };
+}
+
+function resolveFactoryDroidRouteRefFromLookup(value, routeLookup) {
+  const normalizedValue = String(value || "").trim();
+  if (!normalizedValue || !routeLookup || typeof routeLookup !== "object") return "";
+  if (routeLookup.byId instanceof Map && routeLookup.byId.has(normalizedValue)) {
+    return String(routeLookup.byId.get(normalizedValue) || "").trim();
+  }
+  if (routeLookup.byDisplayName instanceof Map && routeLookup.byDisplayName.has(normalizedValue)) {
+    return String(routeLookup.byDisplayName.get(normalizedValue) || "").trim();
+  }
+  return "";
+}
+
+function getFactoryDroidCustomModelEntryByValue(customModels, value, { preferRouterManaged = false } = {}) {
+  const normalizedValue = String(value || "").trim();
+  if (!normalizedValue || !Array.isArray(customModels)) return null;
+
+  const entries = preferRouterManaged
+    ? [
+      ...customModels.filter((entry) => isFactoryDroidRouterManagedEntry(entry)),
+      ...customModels.filter((entry) => !isFactoryDroidRouterManagedEntry(entry))
+    ]
+    : customModels;
+
+  return entries.find((entry) => entry && typeof entry === "object" && (
+    String(entry.id || "").trim() === normalizedValue
+    || String(entry.model || "").trim() === normalizedValue
+    || String(entry.displayName || "").trim() === normalizedValue
+  )) || null;
+}
+
+function resolveFactoryDroidBindingModelRef(value, customModels, routeLookup = null) {
+  const normalizedValue = String(value || "").trim();
+  if (!normalizedValue) return "";
+  const matchedEntry = getFactoryDroidCustomModelEntryByValue(customModels, normalizedValue, { preferRouterManaged: true });
+  if (!matchedEntry) {
+    return resolveFactoryDroidRouteRefFromLookup(normalizedValue, routeLookup)
+      || resolveFactoryDroidRouterModelRef(normalizedValue);
+  }
+  return resolveFactoryDroidRouterModelRef(
+    String(matchedEntry.model || matchedEntry.displayName || matchedEntry.id || normalizedValue).trim()
+  );
+}
+
+function getNextFactoryDroidCustomModelIndex(customModels) {
+  if (!Array.isArray(customModels) || customModels.length === 0) return 0;
+  let maxIndex = -1;
+  for (const entry of customModels) {
+    const parsed = Number(entry?.index);
+    if (Number.isFinite(parsed)) maxIndex = Math.max(maxIndex, parsed);
+  }
+  return maxIndex >= 0 ? (maxIndex + 1) : customModels.length;
+}
+
+function buildFactoryDroidCustomModelId(modelRef, index) {
+  return buildFactoryDroidRouterModelId(modelRef) || `custom:llm-alias-llm-router-${Number(index)}`;
+}
+
+function resolveFactoryDroidBindingSelectionValue(value, customModels, routeLookup = null) {
+  const normalizedValue = String(value || "").trim();
+  if (!normalizedValue) return "";
+  const matchedEntry = getFactoryDroidCustomModelEntryByValue(customModels, normalizedValue, { preferRouterManaged: true });
+  if (matchedEntry) {
+    const matchedId = String(matchedEntry.id || "").trim();
+    const preferredId = buildFactoryDroidCustomModelId(
+      resolveFactoryDroidBindingModelRef(normalizedValue, customModels, routeLookup),
+      Number(matchedEntry.index) || 0
+    );
+    if (matchedEntry[FACTORY_DROID_ROUTER_MARKER] === true || isFactoryDroidRouterModelId(matchedId)) {
+      return preferredId || matchedId || normalizedValue;
+    }
+    return matchedId || preferredId || normalizedValue;
+  }
+  const resolvedRouteRef = resolveFactoryDroidRouteRefFromLookup(normalizedValue, routeLookup);
+  if (resolvedRouteRef) return buildFactoryDroidCustomModelId(resolvedRouteRef, 0) || normalizedValue;
+  return buildFactoryDroidCustomModelId(
+    resolveFactoryDroidBindingModelRef(normalizedValue, customModels, routeLookup),
+    0
+  ) || normalizedValue;
 }
 
 function findRouterManagedCustomModelIndex(customModels) {
   if (!Array.isArray(customModels)) return -1;
   return customModels.findIndex(
-    (entry) => entry && typeof entry === "object" && entry[FACTORY_DROID_ROUTER_MARKER] === true
+    (entry) => isFactoryDroidRouterManagedEntry(entry)
   );
 }
 
@@ -997,10 +1293,30 @@ function getRouterManagedCustomModel(customModels) {
   return routerIndex >= 0 ? customModels[routerIndex] : null;
 }
 
-function stripRouterManagedCustomModels(customModels) {
+function isFactoryDroidRouterManagedEntry(entry, { baseUrl = "" } = {}) {
+  if (!entry || typeof entry !== "object" || Array.isArray(entry)) return false;
+  if (entry[FACTORY_DROID_ROUTER_MARKER] === true) return true;
+
+  const entryId = String(entry.id || "").trim();
+  if (isFactoryDroidRouterModelId(entryId)) return true;
+
+  const provider = String(entry.provider || "").trim().toLowerCase();
+  if (!FACTORY_DROID_ROUTER_PROVIDERS.includes(provider)) return false;
+
+  const entryBaseUrl = String(entry.baseUrl || "").trim();
+  if (baseUrl && entryBaseUrl === String(baseUrl || "").trim()) return true;
+
+  const apiKey = String(entry.apiKey || "").trim();
+  return apiKey.startsWith("gw_") && (
+    entryBaseUrl.includes("/openai/v1")
+    || entryBaseUrl.includes("/anthropic")
+  );
+}
+
+function stripRouterManagedCustomModels(customModels, { baseUrl = "" } = {}) {
   if (!Array.isArray(customModels)) return [];
   return customModels.filter(
-    (entry) => !(entry && typeof entry === "object" && entry[FACTORY_DROID_ROUTER_MARKER] === true)
+    (entry) => !isFactoryDroidRouterManagedEntry(entry, { baseUrl })
   );
 }
 
@@ -1136,21 +1452,34 @@ export async function readFactoryDroidRoutingState({
   settingsFilePath = "",
   backupFilePath = "",
   endpointUrl = "",
+  config = {},
   homeDir = os.homedir()
 } = {}) {
   const resolvedSettingsPath = path.resolve(String(settingsFilePath || resolveFactoryDroidSettingsFilePath({ homeDir })).trim());
   const resolvedBackupPath = path.resolve(String(backupFilePath || resolveCodingToolBackupFilePath(resolvedSettingsPath)).trim());
-  const expectedBaseUrl = buildFactoryDroidBaseUrl(endpointUrl);
+  const routeLookup = buildFactoryDroidRouteLookup(config);
   const settingsState = await readJsonObjectFile(resolvedSettingsPath, `Factory Droid settings file '${resolvedSettingsPath}'`);
   const backupState = await readJsonObjectFile(resolvedBackupPath, `Backup file '${resolvedBackupPath}'`);
   const customModels = Array.isArray(settingsState.data?.customModels) ? settingsState.data.customModels : [];
-  const routerEntry = getRouterManagedCustomModel(customModels);
+  const resolvedDefaultModelValue = getNestedObjectValue(settingsState.data, ["sessionDefaultSettings", "model"])
+    || settingsState.data?.model
+    || "";
+  const resolvedMissionOrchestratorValue = settingsState.data?.missionOrchestratorModel || "";
+  const resolvedMissionWorkerValue = getNestedObjectValue(settingsState.data, ["missionModelSettings", "workerModel"]) || "";
+  const resolvedMissionValidatorValue = getNestedObjectValue(settingsState.data, ["missionModelSettings", "validationWorkerModel"]) || "";
+  const routerEntry = getFactoryDroidCustomModelEntryByValue(customModels, resolvedDefaultModelValue, { preferRouterManaged: true })
+    || getRouterManagedCustomModel(customModels);
   const configuredBaseUrl = routerEntry ? String(routerEntry.baseUrl || "").trim() : "";
   const configuredProvider = routerEntry ? String(routerEntry.provider || "").trim() : "";
+  const expectedBaseUrls = new Set(
+    FACTORY_DROID_ROUTER_PROVIDERS
+      .map((provider) => buildFactoryDroidBaseUrl(endpointUrl, provider))
+      .filter(Boolean)
+  );
   const routedViaRouter = Boolean(
-    expectedBaseUrl
+    configuredBaseUrl
       && routerEntry
-      && configuredBaseUrl === expectedBaseUrl
+      && expectedBaseUrls.has(configuredBaseUrl)
   );
 
   return {
@@ -1163,13 +1492,17 @@ export async function readFactoryDroidRoutingState({
     configuredBaseUrl,
     configuredProvider,
     bindings: normalizeFactoryDroidBindings({
-      defaultModel: getNestedObjectValue(settingsState.data, ["sessionDefaultSettings", "model"])
-        || settingsState.data?.model
-        || routerEntry?.model
-        || "",
-      missionOrchestratorModel: settingsState.data?.missionOrchestratorModel || "",
-      missionWorkerModel: getNestedObjectValue(settingsState.data, ["missionModelSettings", "workerModel"]) || "",
-      missionValidatorModel: getNestedObjectValue(settingsState.data, ["missionModelSettings", "validationWorkerModel"]) || "",
+      defaultModel: resolveFactoryDroidBindingModelRef(resolvedDefaultModelValue, customModels, routeLookup),
+      missionOrchestratorModel: resolveFactoryDroidBindingModelRef(resolvedMissionOrchestratorValue, customModels, routeLookup),
+      missionWorkerModel: resolveFactoryDroidBindingModelRef(resolvedMissionWorkerValue, customModels, routeLookup),
+      missionValidatorModel: resolveFactoryDroidBindingModelRef(resolvedMissionValidatorValue, customModels, routeLookup),
+      reasoningEffort: normalizeFactoryDroidReasoningEffort(settingsState.data?.reasoningEffort)
+    }),
+    bindingIds: normalizeFactoryDroidBindings({
+      defaultModel: resolveFactoryDroidBindingSelectionValue(resolvedDefaultModelValue, customModels, routeLookup),
+      missionOrchestratorModel: resolveFactoryDroidBindingSelectionValue(resolvedMissionOrchestratorValue, customModels, routeLookup),
+      missionWorkerModel: resolveFactoryDroidBindingSelectionValue(resolvedMissionWorkerValue, customModels, routeLookup),
+      missionValidatorModel: resolveFactoryDroidBindingSelectionValue(resolvedMissionValidatorValue, customModels, routeLookup),
       reasoningEffort: normalizeFactoryDroidReasoningEffort(settingsState.data?.reasoningEffort)
     })
   };
@@ -1181,14 +1514,16 @@ export async function patchFactoryDroidSettingsFile({
   endpointUrl = "",
   apiKey = "",
   bindings = {},
+  config = {},
   captureBackup = true,
   homeDir = os.homedir()
 } = {}) {
   const resolvedSettingsPath = path.resolve(String(settingsFilePath || resolveFactoryDroidSettingsFilePath({ homeDir })).trim());
   const resolvedBackupPath = path.resolve(String(backupFilePath || resolveCodingToolBackupFilePath(resolvedSettingsPath)).trim());
-  const baseUrl = buildFactoryDroidBaseUrl(endpointUrl);
+  const baseUrl = buildFactoryDroidBaseUrl(endpointUrl, FACTORY_DROID_OPENAI_PROVIDER);
   const normalizedApiKey = String(apiKey || "").trim();
   const normalizedBindings = normalizeFactoryDroidBindings(bindings);
+  const routeLookup = buildFactoryDroidRouteLookup(config);
 
   if (!baseUrl) {
     throw new Error("Factory Droid endpoint URL must be a valid http:// or https:// URL.");
@@ -1203,51 +1538,90 @@ export async function patchFactoryDroidSettingsFile({
   const nextSettings = settingsState.data && typeof settingsState.data === "object" && !Array.isArray(settingsState.data)
     ? structuredClone(settingsState.data)
     : {};
+  const existingCustomModels = Array.isArray(nextSettings.customModels) ? nextSettings.customModels : [];
 
   if (captureBackup && !backupHasData(existingBackup)) {
     const backup = settingsState.existed ? captureFactoryDroidBackup(nextSettings) : {};
     await writeJsonObjectFile(resolvedBackupPath, backup);
   }
 
-  const customModels = stripRouterManagedCustomModels(nextSettings.customModels);
-  const routerEntry = {
-    [FACTORY_DROID_ROUTER_MARKER]: true,
-    model: normalizedBindings.defaultModel
-      || normalizedBindings.missionOrchestratorModel
-      || normalizedBindings.missionWorkerModel
-      || normalizedBindings.missionValidatorModel
-      || "llm-router",
-    displayName: "LLM Router",
-    baseUrl,
-    apiKey: normalizedApiKey,
-    provider: FACTORY_DROID_ROUTER_PROVIDER
-  };
+  const resolvedBindings = normalizeFactoryDroidBindings({
+    defaultModel: resolveFactoryDroidBindingModelRef(normalizedBindings.defaultModel, existingCustomModels, routeLookup),
+    missionOrchestratorModel: resolveFactoryDroidBindingModelRef(normalizedBindings.missionOrchestratorModel, existingCustomModels, routeLookup),
+    missionWorkerModel: resolveFactoryDroidBindingModelRef(normalizedBindings.missionWorkerModel, existingCustomModels, routeLookup),
+    missionValidatorModel: resolveFactoryDroidBindingModelRef(normalizedBindings.missionValidatorModel, existingCustomModels, routeLookup),
+    reasoningEffort: normalizedBindings.reasoningEffort
+  });
 
-  customModels.push(routerEntry);
+  const customModels = stripRouterManagedCustomModels(existingCustomModels, { baseUrl });
+  const availableModels = buildFactoryDroidAvailableModelDescriptors(config, resolvedBindings);
+  const routerEntryStartIndex = getNextFactoryDroidCustomModelIndex(customModels);
+  const routerEntries = availableModels.length > 0
+    ? availableModels.map((descriptor, index) => {
+      const entryIndex = routerEntryStartIndex + index;
+      const modelId = buildFactoryDroidCustomModelId(descriptor.modelRef, entryIndex);
+      const provider = resolveFactoryDroidCustomModelProvider(descriptor.modelRef, config);
+      return {
+        [FACTORY_DROID_ROUTER_MARKER]: true,
+        model: descriptor.modelRef,
+        id: modelId,
+        index: entryIndex,
+        displayName: descriptor.displayName,
+        baseUrl: buildFactoryDroidBaseUrl(endpointUrl, provider),
+        apiKey: normalizedApiKey,
+        provider
+      };
+    })
+    : [{
+      [FACTORY_DROID_ROUTER_MARKER]: true,
+      model: "llm-router",
+      id: buildFactoryDroidCustomModelId("llm-router", routerEntryStartIndex),
+      index: routerEntryStartIndex,
+      displayName: buildFactoryDroidRouterDisplayName("llm-router", { kind: "alias" }),
+      baseUrl,
+      apiKey: normalizedApiKey,
+      provider: FACTORY_DROID_OPENAI_PROVIDER
+    }];
+
+  customModels.push(...routerEntries);
   nextSettings.customModels = customModels;
+  const allCustomModels = nextSettings.customModels;
 
   if (normalizedBindings.defaultModel) {
-    nextSettings.model = normalizedBindings.defaultModel;
-    setNestedObjectValue(nextSettings, ["sessionDefaultSettings", "model"], normalizedBindings.defaultModel);
+    const selectedModel = resolveFactoryDroidBindingSelectionValue(normalizedBindings.defaultModel, allCustomModels, routeLookup);
+    nextSettings.model = selectedModel;
+    setNestedObjectValue(nextSettings, ["sessionDefaultSettings", "model"], selectedModel);
   } else {
     delete nextSettings.model;
     deleteNestedObjectValue(nextSettings, ["sessionDefaultSettings", "model"]);
   }
 
   if (normalizedBindings.missionOrchestratorModel) {
-    nextSettings.missionOrchestratorModel = normalizedBindings.missionOrchestratorModel;
+    nextSettings.missionOrchestratorModel = resolveFactoryDroidBindingSelectionValue(
+      normalizedBindings.missionOrchestratorModel,
+      allCustomModels,
+      routeLookup
+    );
   } else {
     delete nextSettings.missionOrchestratorModel;
   }
 
   if (normalizedBindings.missionWorkerModel) {
-    setNestedObjectValue(nextSettings, ["missionModelSettings", "workerModel"], normalizedBindings.missionWorkerModel);
+    setNestedObjectValue(
+      nextSettings,
+      ["missionModelSettings", "workerModel"],
+      resolveFactoryDroidBindingSelectionValue(normalizedBindings.missionWorkerModel, allCustomModels, routeLookup)
+    );
   } else {
     deleteNestedObjectValue(nextSettings, ["missionModelSettings", "workerModel"]);
   }
 
   if (normalizedBindings.missionValidatorModel) {
-    setNestedObjectValue(nextSettings, ["missionModelSettings", "validationWorkerModel"], normalizedBindings.missionValidatorModel);
+    setNestedObjectValue(
+      nextSettings,
+      ["missionModelSettings", "validationWorkerModel"],
+      resolveFactoryDroidBindingSelectionValue(normalizedBindings.missionValidatorModel, allCustomModels, routeLookup)
+    );
   } else {
     deleteNestedObjectValue(nextSettings, ["missionModelSettings", "validationWorkerModel"]);
   }
@@ -1259,13 +1633,32 @@ export async function patchFactoryDroidSettingsFile({
   }
 
   await writeJsonObjectFile(resolvedSettingsPath, nextSettings);
+  const primaryEntry = resolvedBindings.defaultModel
+    ? getFactoryDroidCustomModelEntryByValue(allCustomModels, resolvedBindings.defaultModel, { preferRouterManaged: true })
+    : null;
+  const configuredEntry = primaryEntry || getRouterManagedCustomModel(allCustomModels);
   return {
     settingsFilePath: resolvedSettingsPath,
     backupFilePath: resolvedBackupPath,
     settingsCreated: !settingsState.existed,
-    baseUrl,
-    configuredProvider: FACTORY_DROID_ROUTER_PROVIDER,
-    bindings: normalizedBindings
+    baseUrl: String(configuredEntry?.baseUrl || baseUrl).trim(),
+    configuredProvider: String(configuredEntry?.provider || FACTORY_DROID_OPENAI_PROVIDER).trim(),
+    bindings: resolvedBindings,
+    bindingIds: normalizeFactoryDroidBindings({
+      defaultModel: normalizedBindings.defaultModel
+        ? resolveFactoryDroidBindingSelectionValue(normalizedBindings.defaultModel, allCustomModels, routeLookup)
+        : "",
+      missionOrchestratorModel: normalizedBindings.missionOrchestratorModel
+        ? resolveFactoryDroidBindingSelectionValue(normalizedBindings.missionOrchestratorModel, allCustomModels, routeLookup)
+        : "",
+      missionWorkerModel: normalizedBindings.missionWorkerModel
+        ? resolveFactoryDroidBindingSelectionValue(normalizedBindings.missionWorkerModel, allCustomModels, routeLookup)
+        : "",
+      missionValidatorModel: normalizedBindings.missionValidatorModel
+        ? resolveFactoryDroidBindingSelectionValue(normalizedBindings.missionValidatorModel, allCustomModels, routeLookup)
+        : "",
+      reasoningEffort: normalizedBindings.reasoningEffort
+    })
   };
 }
 

package/src/node/config-store.js

@@ -1,5 +1,5 @@
 /**
- * Local config persistence for ~/.llm-router.json.
+ * Local config persistence for the default and development config files.
  */
 
 import os from "node:os";
@@ -14,11 +14,16 @@ import {
 import { sanitizePersistedLocalServerConfig } from "./local-server-settings.js";
 
 export const DEFAULT_CONFIG_FILENAME = ".llm-router.json";
+export const DEFAULT_DEV_CONFIG_FILENAME = ".llm-router-dev.json";
 
 export function getDefaultConfigPath() {
   return path.join(os.homedir(), DEFAULT_CONFIG_FILENAME);
 }
 
+export function getDefaultDevConfigPath() {
+  return path.join(os.homedir(), DEFAULT_DEV_CONFIG_FILENAME);
+}
+
 function normalizePersistedConfig(config, normalizeOptions = undefined) {
   return sanitizePersistedLocalServerConfig(
     normalizeRuntimeConfig(config, normalizeOptions)

package/src/node/instance-state.js

@@ -6,6 +6,7 @@ import { FIXED_LOCAL_ROUTER_HOST, FIXED_LOCAL_ROUTER_PORT } from "./local-server
 
 const DEFAULT_INSTANCE_STATE_FILENAME = ".llm-router.runtime.json";
 const MAX_START_OUTPUT_CHARS = 4000;
+export const RUNTIME_STATE_PATH_ENV = "LLM_ROUTER_RUNTIME_STATE_PATH";
 
 function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
@@ -80,7 +81,9 @@ function runtimeMatchesStartOptions(runtime, {
     && normalized.requireAuth === normalizeBoolean(requireAuth, false);
 }
 
-export function getRuntimeStatePath() {
+export function getRuntimeStatePath({ env = process.env } = {}) {
+  const override = String(env?.[RUNTIME_STATE_PATH_ENV] || "").trim();
+  if (override) return path.resolve(override);
   return path.join(os.homedir(), DEFAULT_INSTANCE_STATE_FILENAME);
 }