@hermespilot/link 0.7.3 → 0.7.4-beta.0

package/dist/{chunk-36L5JCHO.js → chunk-V6Q4B4MA.js}

@@ -2002,7 +2002,7 @@ var DEFAULT_HERMES_API_SERVER_HOST = "127.0.0.1";
 var DEFAULT_HERMES_API_SERVER_PORT = 8642;
 var PROFILE_API_SERVER_PORT_START = DEFAULT_HERMES_API_SERVER_PORT + 1;
 var PROFILE_API_SERVER_PORT_END = DEFAULT_HERMES_API_SERVER_PORT + 999;
-var MODEL_CONFIG_RESTART_HINT = "\u6A21\u578B\u914D\u7F6E\u5DF2\u4FDD\u5B58\u3002\u5EFA\u8BAE\u91CD\u8F7D Hermes Gateway\uFF0C\u6B63\u5728\u8FD0\u884C\u4E2D\u7684 Run \u4E0D\u4F1A\u88AB\u4E2D\u65AD\uFF0C\u65B0\u7684 Run \u4F1A\u8BFB\u53D6\u6700\u65B0\u914D\u7F6E\u3002";
+var MODEL_CONFIG_APPLIED_HINT = "\u6A21\u578B\u914D\u7F6E\u5DF2\u4FDD\u5B58\u3002\u65B0\u7684 Run \u4F1A\u76F4\u63A5\u8BFB\u53D6\u6700\u65B0\u914D\u7F6E\uFF0C\u65E0\u9700\u91CD\u8F7D Hermes Gateway\u3002";
 var MODEL_DEFAULTS_APPLIED_HINT = "\u9ED8\u8BA4\u6A21\u578B\u8BBE\u7F6E\u5DF2\u4FDD\u5B58\u3002\u65B0\u7684 Run \u4F1A\u76F4\u63A5\u8BFB\u53D6\u6700\u65B0\u914D\u7F6E\uFF0C\u65E0\u9700\u91CD\u8F7D Hermes Gateway\u3002";
 var PROFILE_PERMISSIONS_RESTART_HINT = "\u6743\u9650\u914D\u7F6E\u5DF2\u4FDD\u5B58\u3002\u540E\u7EED\u4EE5\u8BE5 Profile \u53D1\u8D77\u7684\u65B0 Run \u4F1A\u8BFB\u53D6\u6700\u65B0\u914D\u7F6E\uFF1B\u5982\u679C\u8BE5 Profile \u7684 Gateway \u5DF2\u7ECF\u5728\u8FD0\u884C\uFF0C\u9700\u8981\u91CD\u8F7D\u5BF9\u5E94 Gateway\u3002";
 var PROFILE_TOOL_CONFIG_RESTART_HINT = "\u5DE5\u5177\u540E\u7AEF\u914D\u7F6E\u5DF2\u4FDD\u5B58\u3002\u540E\u7EED\u4EE5\u8BE5 Profile \u53D1\u8D77\u7684\u65B0 Run \u4F1A\u8BFB\u53D6\u6700\u65B0\u914D\u7F6E\uFF1B\u5982\u679C\u8BE5 Profile \u7684 Gateway \u5DF2\u7ECF\u5728\u8FD0\u884C\uFF0C\u9700\u8981\u91CD\u8F7D\u5BF9\u5E94 Gateway\u3002";
@@ -2386,6 +2386,7 @@ async function listHermesModelConfigs(profileName = "default", configPath = reso
     configPath,
     defaultModel,
     defaultReasoningEffort,
+    imageInputMode: readProfileImageInputMode(config),
     compressionModelId,
     compressionModel: resolveCompressionModel(config, models),
     models
@@ -2396,7 +2397,7 @@ async function listHermesModelConfigCatalog(input) {
   const targetModels = targetProfileName ? await listHermesModelConfigs(targetProfileName).then((result) => result.models).catch(() => []) : [];
   const targetKeys = new Set(
     targetModels.map(
-      (model) => modelConfigKey(model.provider, model.baseUrl, model.id)
+      (model) => modelConfigKey(model.provider, model.baseUrl, model.id, model.apiMode)
     )
   );
   const items = /* @__PURE__ */ new Map();
@@ -2410,7 +2411,12 @@ async function listHermesModelConfigCatalog(input) {
       continue;
     }
     for (const model of listed.models) {
-      const key = modelConfigKey(model.provider, model.baseUrl, model.id);
+      const key = modelConfigKey(
+        model.provider,
+        model.baseUrl,
+        model.id,
+        model.apiMode
+      );
       const existing = items.get(key);
       if (existing) {
         if (!existing.sourceProfiles.some(
@@ -2449,6 +2455,7 @@ async function listHermesModelConfigCatalog(input) {
         ...model.reasoningEffort ? { reasoningEffort: model.reasoningEffort } : {},
         reasoningSupport: model.reasoningSupport,
         supportedReasoningEfforts: model.supportedReasoningEfforts,
+        supportsVision: model.supportsVision,
         sourceProfiles: [
           {
             name: profileName,
@@ -2480,12 +2487,24 @@ async function importHermesModelConfig(input, targetProfileName = "default", tar
   });
   const { document, config, existingRaw } = await readHermesConfigDocument(targetConfigPath);
   const targetEnv = await readHermesEnvFile(targetProfileName);
-  const customProviders = ensureCustomProvidersList(config);
-  const targetEntryIndex = findCustomProviderIndexByEndpoint(customProviders, {
+  const providers = ensureProvidersRecordWithLegacyMigration(config);
+  const targetProviderKey = findProviderConfigKeyByVisibleEndpoint(providers, {
+    providerName: source.model.providerName,
+    baseUrl: source.model.baseUrl,
+    apiMode: source.model.apiMode
+  }) ?? findProviderConfigKeyByEndpoint(providers, {
     provider: source.model.provider,
-    baseUrl: source.model.baseUrl
-  });
-  const entry = targetEntryIndex >= 0 ? toRecord(customProviders[targetEntryIndex]) : {};
+    baseUrl: source.model.baseUrl,
+    apiMode: source.model.apiMode
+  }) ?? uniqueProviderConfigKey(
+    providerConfigKeyBase(
+      source.model.provider,
+      source.model.providerName,
+      source.model.baseUrl
+    ),
+    providers
+  );
+  const entry = toRecord(providers[targetProviderKey]);
   const entryHadModels = readEntryModelIds(entry).length > 0;
   const existingKeyEnv = readString2(entry.key_env) ?? parseEnvReference(readString2(entry.api_key));
   const existingInlineApiKey = readInlineApiKey(readString2(entry.api_key));
@@ -2498,14 +2517,26 @@ async function importHermesModelConfig(input, targetProfileName = "default", tar
   if (sourceApiKey && keyEnv && !existingInlineApiKey && (!existingKeyEnv || !targetEnv[keyEnv]?.trim())) {
     await writeHermesEnvValue(targetProfileName, keyEnv, sourceApiKey);
   }
-  entry.name = readString2(entry.name) ?? readString2(entry.provider_name) ?? source.model.providerName;
-  entry.provider_key = source.model.provider;
-  entry.base_url = source.model.baseUrl;
+  writeProviderEndpointConfig(
+    entry,
+    {
+      id: source.model.id,
+      provider: targetProviderKey,
+      providerName: readString2(entry.name) ?? readString2(entry.provider_name) ?? source.model.providerName,
+      baseUrl: source.model.baseUrl,
+      apiMode: source.model.apiMode,
+      contextLength: source.model.contextLength,
+      keyEnv,
+      setDefault: input.setDefault,
+      ...source.model.reasoningEffort ? { reasoningEffort: source.model.reasoningEffort } : {},
+      supportsVision: source.model.supportsVision
+    },
+    keyEnv
+  );
+  ensureEntryModelConfig(entry, source.model.id, source.model.id);
   if (!entryHadModels) {
-    entry.model = source.model.id;
+    entry.default_model = source.model.id;
   }
-  entry.api_mode = source.model.apiMode;
-  addEntryModel(entry, source.model.id);
   if (source.model.contextLength) {
     writeEntryModelContextLength(
       entry,
@@ -2515,43 +2546,39 @@ async function importHermesModelConfig(input, targetProfileName = "default", tar
   } else if (!entryHadModels) {
     delete entry.context_length;
   }
-  if (keyEnv) {
-    entry.key_env = keyEnv;
+  if (!keyEnv && !existingInlineApiKey) {
     delete entry.api_key;
-  } else {
-    delete entry.key_env;
-    if (!existingInlineApiKey) {
-      delete entry.api_key;
-    }
   }
   writeEntryModelReasoningEffort(
     entry,
     source.model.id,
     source.model.reasoningEffort
   );
-  if (targetEntryIndex >= 0) {
-    customProviders[targetEntryIndex] = entry;
-  } else {
-    customProviders.push(entry);
-  }
+  writeEntryModelSupportsVision(
+    entry,
+    source.model.id,
+    source.model.supportsVision
+  );
+  providers[targetProviderKey] = entry;
   const modelConfig = ensureRecord(config, "model");
   const currentDefaultConfig = readModelConfig(modelConfig);
   const currentDefaultReasoningEffort = readProfileReasoningEffort(config);
   if (input.setDefault || !currentDefaultConfig.model) {
     if (input.setDefault && currentDefaultConfig.model && currentDefaultConfig.model !== source.model.id) {
-      retainModelDefaultAsCustomProvider(customProviders, {
+      retainModelDefaultAsProvider(providers, {
         ...currentDefaultConfig,
         ...currentDefaultReasoningEffort ? { reasoningEffort: currentDefaultReasoningEffort } : {}
       });
     }
     writeDefaultModelConfig(modelConfig, {
       id: source.model.id,
-      provider: source.model.provider,
+      provider: targetProviderKey,
       baseUrl: source.model.baseUrl,
       apiMode: source.model.apiMode,
       contextLength: source.model.contextLength,
       keyEnv
     });
+    writeDefaultModelSupportsVision(modelConfig, source.model.supportsVision);
     if (source.model.reasoningEffort) {
       writeProfileReasoningEffort(config, source.model.reasoningEffort);
     }
@@ -2563,9 +2590,17 @@ async function importHermesModelConfig(input, targetProfileName = "default", tar
     existingRaw
   });
   const listed = await listHermesModelConfigs(targetProfileName, targetConfigPath);
-  const importedModel = listed.models.find(
-    (model) => model.id === source.model.id && model.provider === source.model.provider && model.baseUrl === source.model.baseUrl
-  ) ?? listed.models.find((model) => model.id === source.model.id);
+  const importedModel = findManagedModel(listed.models, {
+    id: source.model.id,
+    provider: targetProviderKey,
+    baseUrl: source.model.baseUrl,
+    apiMode: source.model.apiMode
+  }) ?? findManagedModelByVisibleIdentity(listed.models, {
+    id: source.model.id,
+    providerName: source.model.providerName,
+    baseUrl: source.model.baseUrl,
+    apiMode: source.model.apiMode
+  });
   if (!importedModel) {
     throw new Error("imported model is missing from config");
   }
@@ -2574,44 +2609,47 @@ async function importHermesModelConfig(input, targetProfileName = "default", tar
     model: importedModel,
     sourceProfileName,
     backupPath,
-    requiresGatewayReload: true,
-    restartHint: MODEL_CONFIG_RESTART_HINT
+    requiresGatewayReload: false,
+    restartHint: MODEL_CONFIG_APPLIED_HINT
   };
 }
 async function saveHermesModelConfig(input, profileName = "default", configPath = resolveHermesConfigPath(profileName)) {
   const normalized = normalizeModelConfigInput(input);
   const shouldUpdateReasoningEffort = input.reasoningEffort !== void 0;
   const { document, config, existingRaw } = await readHermesConfigDocument(configPath);
-  const customProviders = ensureCustomProvidersList(config);
+  const providers = ensureProvidersRecordWithLegacyMigration(config);
   const originalModelId = input.originalModelId?.trim() || normalized.id;
-  const index = findCustomProviderIndex(customProviders, originalModelId);
-  const entry = index >= 0 ? toRecord(customProviders[index]) : {};
+  const originalProvider = input.originalProvider?.trim();
+  const originalBaseUrl = input.originalBaseUrl?.trim();
+  const originalApiMode = input.originalApiMode?.trim();
+  const existingProviderKey = findProviderConfigKeyByModelIdentity(providers, {
+    id: originalModelId,
+    provider: originalProvider,
+    baseUrl: originalBaseUrl,
+    apiMode: originalApiMode
+  }) ?? (originalProvider && originalBaseUrl ? findProviderConfigKeyByEndpoint(providers, {
+    provider: originalProvider,
+    baseUrl: originalBaseUrl,
+    apiMode: originalApiMode
+  }) : null) ?? findProviderConfigKeyByVisibleEndpoint(providers, normalized) ?? findProviderConfigKeyByEndpoint(providers, normalized);
+  const providerKey = existingProviderKey ?? uniqueProviderConfigKey(
+    providerConfigKeyBase(
+      normalized.provider === "custom" ? void 0 : normalized.provider,
+      normalized.providerName,
+      normalized.baseUrl
+    ),
+    providers
+  );
+  const entry = toRecord(providers[providerKey]);
   const existingKeyEnv = readString2(entry.key_env) ?? parseEnvReference(readString2(entry.api_key));
   const keyEnv = normalized.keyEnv ?? existingKeyEnv ?? (normalized.apiKey ? buildApiKeyEnvName(normalized.providerName, normalized.id) : void 0);
   if (normalized.apiKey && keyEnv) {
     await writeHermesEnvValue(profileName, keyEnv, normalized.apiKey);
   }
-  entry.name = normalized.providerName;
-  entry.provider_key = normalized.provider;
-  entry.base_url = normalized.baseUrl;
-  entry.model = normalized.id;
-  if (normalized.apiMode) {
-    entry.api_mode = normalized.apiMode;
-  } else {
-    delete entry.api_mode;
-  }
-  if (normalized.contextLength) {
-    entry.context_length = normalized.contextLength;
-  } else {
-    delete entry.context_length;
-  }
-  if (keyEnv) {
-    entry.key_env = keyEnv;
-    delete entry.api_key;
-  } else {
-    delete entry.key_env;
-  }
-  updateEntryModels(entry, originalModelId, normalized.id);
+  writeProviderEndpointConfig(entry, normalized, keyEnv);
+  ensureEntryModelConfig(entry, originalModelId, normalized.id);
+  writeEntryModelContextLength(entry, normalized.id, normalized.contextLength);
+  writeEntryModelSupportsVision(entry, normalized.id, input.supportsVision);
   if (shouldUpdateReasoningEffort) {
     writeEntryModelReasoningEffort(
       entry,
@@ -2619,18 +2657,14 @@ async function saveHermesModelConfig(input, profileName = "default", configPath
       normalized.reasoningEffort
     );
   }
-  if (index >= 0) {
-    customProviders[index] = entry;
-  } else {
-    customProviders.push(entry);
-  }
+  providers[providerKey] = entry;
   const modelConfig = ensureRecord(config, "model");
   const currentDefaultConfig = readModelConfig(modelConfig);
   const currentDefault = currentDefaultConfig.model;
   const currentDefaultReasoningEffort = readProfileReasoningEffort(config);
   if (normalized.setDefault || !currentDefault || currentDefault === originalModelId) {
     if (normalized.setDefault && currentDefault && currentDefault !== normalized.id && currentDefault !== originalModelId) {
-      retainModelDefaultAsCustomProvider(customProviders, {
+      retainModelDefaultAsProvider(providers, {
         ...currentDefaultConfig,
         ...currentDefaultReasoningEffort ? { reasoningEffort: currentDefaultReasoningEffort } : {}
       });
@@ -2639,9 +2673,13 @@ async function saveHermesModelConfig(input, profileName = "default", configPath
     const defaultApiKey = normalized.apiKey ?? (!defaultKeyEnv && currentDefault === originalModelId ? currentDefaultConfig.apiKey : void 0);
     writeDefaultModelConfig(modelConfig, {
       ...normalized,
+      provider: providerKey,
       apiKey: defaultApiKey,
       keyEnv: defaultKeyEnv
     });
+    if (input.supportsVision !== void 0) {
+      writeDefaultModelSupportsVision(modelConfig, input.supportsVision);
+    }
     if (shouldUpdateReasoningEffort && normalized.reasoningEffort) {
       writeProfileReasoningEffort(config, normalized.reasoningEffort);
     }
@@ -2653,7 +2691,22 @@ async function saveHermesModelConfig(input, profileName = "default", configPath
     existingRaw
   });
   const listed = await listHermesModelConfigs(profileName, configPath);
-  const savedModel = listed.models.find((model) => model.id === normalized.id);
+  const normalizedApiMode = inferApiMode(
+    providerKey,
+    normalized.baseUrl,
+    normalized.apiMode
+  );
+  const savedModel = findManagedModel(listed.models, {
+    id: normalized.id,
+    provider: providerKey,
+    baseUrl: normalized.baseUrl,
+    apiMode: normalizedApiMode
+  }) ?? findManagedModelByVisibleIdentity(listed.models, {
+    id: normalized.id,
+    providerName: normalized.providerName,
+    baseUrl: normalized.baseUrl,
+    apiMode: normalizedApiMode
+  });
   if (!savedModel) {
     throw new Error("saved model is missing from config");
   }
@@ -2661,12 +2714,18 @@ async function saveHermesModelConfig(input, profileName = "default", configPath
     ...listed,
     model: savedModel,
     backupPath,
-    requiresGatewayReload: true,
-    restartHint: MODEL_CONFIG_RESTART_HINT
+    requiresGatewayReload: false,
+    restartHint: MODEL_CONFIG_APPLIED_HINT
   };
 }
-async function deleteHermesModelConfig(modelId, profileName = "default", configPath = resolveHermesConfigPath(profileName)) {
-  const id = modelId.trim();
+async function deleteHermesModelConfig(input, profileName = "default", configPath = resolveHermesConfigPath(profileName)) {
+  const deleteInput = typeof input === "string" ? { id: input } : {
+    id: input.id,
+    provider: input.provider,
+    baseUrl: input.baseUrl,
+    apiMode: input.apiMode
+  };
+  const id = deleteInput.id.trim();
   if (!id) {
     throw new Error("model id is required");
   }
@@ -2680,7 +2739,7 @@ async function deleteHermesModelConfig(modelId, profileName = "default", configP
     readProfileReasoningEffort(config),
     authBackedProviders
   );
-  const deletingModel = findManagedModelById(existingModels, id);
+  const deletingModel = findManagedModel(existingModels, deleteInput) ?? (hasModelIdentitySelector(deleteInput) ? void 0 : findManagedModelById(existingModels, id));
   if (!deletingModel) {
     throw new Error(`model "${id}" is not configured`);
   }
@@ -2694,9 +2753,19 @@ async function deleteHermesModelConfig(modelId, profileName = "default", configP
       "\u81F3\u5C11\u9700\u8981\u4FDD\u7559\u4E00\u4E2A\u6A21\u578B\uFF0C\u907F\u514D Hermes Agent \u6CA1\u6709\u53EF\u7528\u9ED8\u8BA4\u6A21\u578B\u3002"
     );
   }
-  const customProviders = ensureCustomProvidersList(config);
-  const nextProviders = customProviders.map((entry) => removeModelFromCustomProvider(toRecord(entry), id)).filter((entry) => entry !== null);
-  config.custom_providers = nextProviders;
+  const providers = ensureProvidersRecordWithLegacyMigration(config);
+  for (const [key, rawEntry] of Object.entries(providers)) {
+    const entry = providerConfigToLegacyEntry(key, toRecord(rawEntry));
+    if (!entry || !providerEntryMatchesManagedModel(entry, deletingModel)) {
+      continue;
+    }
+    const nextEntry = removeModelFromProvider(toRecord(rawEntry), id);
+    if (nextEntry) {
+      providers[key] = nextEntry;
+    } else {
+      delete providers[key];
+    }
+  }
   const modelConfig = ensureRecord(config, "model");
   const currentDefault = readModelConfig(modelConfig).model;
   if (currentDefault === id) {
@@ -2716,6 +2785,7 @@ async function deleteHermesModelConfig(modelId, profileName = "default", configP
         contextLength: nextDefault.contextLength,
         keyEnv: nextDefault.keyEnv
       });
+      writeDefaultModelSupportsVision(modelConfig, nextDefault.supportsVision);
       if (nextDefault.reasoningEffort) {
         writeProfileReasoningEffort(config, nextDefault.reasoningEffort);
       }
@@ -2729,6 +2799,7 @@ async function deleteHermesModelConfig(modelId, profileName = "default", configP
       delete modelConfig.key_env;
       delete modelConfig.api_mode;
       delete modelConfig.context_length;
+      delete modelConfig.supports_vision;
     }
   }
   const backupPath = await writeHermesConfigDocument({
@@ -2741,22 +2812,26 @@ async function deleteHermesModelConfig(modelId, profileName = "default", configP
   return {
     ...listed,
     backupPath,
-    requiresGatewayReload: true,
-    restartHint: MODEL_CONFIG_RESTART_HINT
+    requiresGatewayReload: false,
+    restartHint: MODEL_CONFIG_APPLIED_HINT
   };
 }
 async function saveHermesModelDefaults(input, profileName = "default", configPath = resolveHermesConfigPath(profileName)) {
   const taskModelId = input.taskModelId?.trim();
   const compressionModelId = input.compressionModelId?.trim();
+  const imageInputMode = input.imageInputMode ? normalizeImageInputMode(input.imageInputMode) : void 0;
   const reasoningEffort = input.reasoningEffort ? normalizeReasoningEffort(input.reasoningEffort) : void 0;
   if (input.reasoningEffort && !reasoningEffort) {
     throw new Error(
       "reasoningEffort must be none, minimal, low, medium, high or xhigh"
     );
   }
-  if (!taskModelId && !compressionModelId && !reasoningEffort) {
+  if (input.imageInputMode && !imageInputMode) {
+    throw new Error("imageInputMode must be auto, native or text");
+  }
+  if (!taskModelId && !compressionModelId && !reasoningEffort && !imageInputMode) {
     throw new Error(
-      "taskModelId, compressionModelId or reasoningEffort is required"
+      "taskModelId, compressionModelId, reasoningEffort or imageInputMode is required"
     );
   }
   const { document, config, existingRaw } = await readHermesConfigDocument(configPath);
@@ -2773,17 +2848,18 @@ async function saveHermesModelDefaults(input, profileName = "default", configPat
     const selected = findManagedModel(models, {
       id: taskModelId,
       provider: input.taskModelProvider,
-      baseUrl: input.taskModelBaseUrl
+      baseUrl: input.taskModelBaseUrl,
+      apiMode: input.taskModelApiMode
     });
     if (!selected) {
       throw new Error(`model "${taskModelId}" is not configured`);
     }
-    const customProviders = ensureCustomProvidersList(config);
+    const providers = ensureProvidersRecordWithLegacyMigration(config);
     const modelConfig = ensureRecord(config, "model");
     const currentDefaultConfig = readModelConfig(modelConfig);
     const currentDefaultReasoningEffort = readProfileReasoningEffort(config);
     if (currentDefaultConfig.model && currentDefaultConfig.model !== selected.id) {
-      retainModelDefaultAsCustomProvider(customProviders, {
+      retainModelDefaultAsProvider(providers, {
         ...currentDefaultConfig,
         ...currentDefaultReasoningEffort ? { reasoningEffort: currentDefaultReasoningEffort } : {}
       });
@@ -2796,6 +2872,7 @@ async function saveHermesModelDefaults(input, profileName = "default", configPat
       contextLength: selected.contextLength,
       keyEnv: selected.keyEnv
     });
+    writeDefaultModelSupportsVision(modelConfig, selected.supportsVision);
     if (selected.reasoningEffort) {
       writeProfileReasoningEffort(config, selected.reasoningEffort);
     }
@@ -2803,6 +2880,9 @@ async function saveHermesModelDefaults(input, profileName = "default", configPat
   if (reasoningEffort) {
     writeProfileReasoningEffort(config, reasoningEffort);
   }
+  if (imageInputMode) {
+    writeProfileImageInputMode(config, imageInputMode);
+  }
   if (compressionModelId) {
     const models = readManagedModelConfigs(
       config,
@@ -2814,7 +2894,8 @@ async function saveHermesModelDefaults(input, profileName = "default", configPat
     const selected = findManagedModel(models, {
       id: compressionModelId,
       provider: input.compressionModelProvider,
-      baseUrl: input.compressionModelBaseUrl
+      baseUrl: input.compressionModelBaseUrl,
+      apiMode: input.compressionModelApiMode
     });
     if (!selected) {
       throw new Error(`model "${compressionModelId}" is not configured`);
@@ -2992,6 +3073,15 @@ async function saveHermesProfileToolConfig(profileName, toolKey, input, configPa
         "PARALLEL_API_KEY"
       ]);
       break;
+    case "vision":
+      configTouched = applyVisionToolConfig(config, input.values);
+      await writeToolConfigEnvValues(profileName, input.values, [
+        "OPENROUTER_API_KEY",
+        "OPENAI_API_KEY",
+        "ANTHROPIC_API_KEY",
+        "AUXILIARY_VISION_API_KEY"
+      ]);
+      break;
     case "image_gen":
       configTouched = applyImageGenToolConfig(config, input.values);
       await writeToolConfigEnvValues(profileName, input.values, [
@@ -3307,12 +3397,411 @@ async function writeHermesConfigDocument(input) {
   );
   return backupPath;
 }
+function readCompatibleModelProviderEntries(config) {
+  const entries = [];
+  const seenProviderKeys = /* @__PURE__ */ new Set();
+  const seenEndpointModels = /* @__PURE__ */ new Set();
+  const seenVisibleModels = /* @__PURE__ */ new Set();
+  const append = (entry) => {
+    const provider = readString2(entry.provider_key) ?? readString2(entry.provider) ?? "custom";
+    const providerName = readString2(entry.name) ?? readString2(entry.provider_name) ?? readString2(entry.provider_key) ?? "Custom Provider";
+    const baseUrl = readString2(entry.base_url) ?? readString2(entry.url) ?? readString2(entry.api) ?? "";
+    const apiMode = inferApiMode(provider, baseUrl, readString2(entry.api_mode));
+    const providerKey = provider.trim().toLowerCase();
+    const dedupeProviderKey = providerKey && providerKey !== "custom";
+    const modelIds = readEntryModelIds(entry);
+    const endpointModels = modelIds.map(
+      (modelId) => modelConfigKey(provider, baseUrl, modelId, apiMode)
+    );
+    const visibleModels = modelIds.map(
+      (modelId) => modelVisibleKey({ providerName, baseUrl, id: modelId, apiMode })
+    );
+    if (dedupeProviderKey && seenProviderKeys.has(providerKey)) {
+      return;
+    }
+    if (endpointModels.length > 0 && endpointModels.every((key) => seenEndpointModels.has(key))) {
+      return;
+    }
+    if (visibleModels.length > 0 && visibleModels.every((key) => seenVisibleModels.has(key))) {
+      return;
+    }
+    entries.push(entry);
+    if (dedupeProviderKey) {
+      seenProviderKeys.add(providerKey);
+    }
+    for (const key of endpointModels) {
+      seenEndpointModels.add(key);
+    }
+    for (const key of visibleModels) {
+      seenVisibleModels.add(key);
+    }
+  };
+  const customProviders = Array.isArray(config.custom_providers) ? config.custom_providers : [];
+  for (const rawEntry of customProviders) {
+    append(toRecord(rawEntry));
+  }
+  const providers = toRecord(config.providers);
+  for (const [key, rawEntry] of Object.entries(providers)) {
+    const entry = providerConfigToLegacyEntry(key, toRecord(rawEntry));
+    if (entry) {
+      append(entry);
+    }
+  }
+  return entries;
+}
+function providerConfigToLegacyEntry(providerKey, entry) {
+  const baseUrl = readString2(entry.base_url) ?? readString2(entry.url) ?? readString2(entry.api);
+  if (!baseUrl) {
+    return null;
+  }
+  const normalized = {
+    ...entry,
+    name: readString2(entry.name) ?? providerKey,
+    provider_key: providerKey,
+    base_url: baseUrl
+  };
+  const apiMode = readString2(entry.api_mode) ?? readString2(entry.transport);
+  if (apiMode) {
+    normalized.api_mode = apiMode;
+  }
+  const defaultModel = readString2(entry.model) ?? readString2(entry.default_model);
+  if (defaultModel) {
+    normalized.model = defaultModel;
+  }
+  return normalized;
+}
+function ensureProvidersRecordWithLegacyMigration(config) {
+  const providers = ensureRecord(config, "providers");
+  const customProviders = Array.isArray(config.custom_providers) ? config.custom_providers : [];
+  for (const rawEntry of customProviders) {
+    const entry = toRecord(rawEntry);
+    const baseUrl = readString2(entry.base_url) ?? readString2(entry.url) ?? readString2(entry.api);
+    if (!baseUrl) {
+      continue;
+    }
+    const providerKey = findProviderConfigKeyForLegacyMigration(providers, entry, baseUrl) ?? buildProviderConfigKey(entry, providers);
+    const nextConfig = legacyEntryToProviderConfig(entry, baseUrl);
+    providers[providerKey] = providers[providerKey] ? mergeProviderConfig(toRecord(providers[providerKey]), nextConfig) : nextConfig;
+  }
+  delete config.custom_providers;
+  const providerAliases = mergeDuplicateProviderConfigs(providers);
+  rewriteProviderReferences(config, providerAliases);
+  return providers;
+}
+function mergeDuplicateProviderConfigs(providers) {
+  const groupKeys = /* @__PURE__ */ new Map();
+  const aliases = /* @__PURE__ */ new Map();
+  for (const [key, rawEntry] of Object.entries(providers)) {
+    const entry = toRecord(rawEntry);
+    const legacyEntry = providerConfigToLegacyEntry(key, entry);
+    if (!legacyEntry) {
+      continue;
+    }
+    const groupKey = providerConfigGroupKey(legacyEntry);
+    const existingKey = groupKeys.get(groupKey);
+    if (!existingKey) {
+      groupKeys.set(groupKey, key);
+      providers[key] = entry;
+      continue;
+    }
+    providers[existingKey] = mergeProviderConfig(
+      toRecord(providers[existingKey]),
+      entry
+    );
+    delete providers[key];
+    aliases.set(key, existingKey);
+  }
+  return aliases;
+}
+function rewriteProviderReferences(config, aliases) {
+  if (aliases.size === 0) {
+    return;
+  }
+  const rewriteProvider = (record) => {
+    const provider = readString2(record.provider);
+    if (provider && aliases.has(provider)) {
+      record.provider = aliases.get(provider);
+    }
+  };
+  rewriteProvider(toRecord(config.model));
+  const auxiliary = toRecord(config.auxiliary);
+  rewriteProvider(toRecord(auxiliary.compression));
+  rewriteProvider(toRecord(config.fallback_model));
+  if (Array.isArray(config.fallback_model)) {
+    for (const entry of config.fallback_model) {
+      rewriteProvider(toRecord(entry));
+    }
+  }
+  if (Array.isArray(config.fallback_providers)) {
+    for (const entry of config.fallback_providers) {
+      rewriteProvider(toRecord(entry));
+    }
+  }
+}
+function findProviderConfigKeyForLegacyMigration(providers, entry, baseUrl) {
+  const provider = readString2(entry.provider_key) ?? readString2(entry.provider) ?? "custom";
+  const apiMode = readString2(entry.api_mode) ?? readString2(entry.transport);
+  if (provider !== "custom" && Object.prototype.hasOwnProperty.call(providers, provider)) {
+    const existingEntry = providerConfigToLegacyEntry(
+      provider,
+      toRecord(providers[provider])
+    );
+    if (existingEntry) {
+      const existingBaseUrl = readString2(existingEntry.base_url) ?? readString2(existingEntry.url) ?? readString2(existingEntry.api) ?? "";
+      const existingApiMode = inferApiMode(
+        provider,
+        existingBaseUrl,
+        readString2(existingEntry.api_mode)
+      );
+      if (normalizeBaseUrl(existingBaseUrl) === normalizeBaseUrl(baseUrl) && existingApiMode === inferApiMode(provider, baseUrl, apiMode) && providerCredentialIdentity(existingEntry) === providerCredentialIdentity(entry)) {
+        return provider;
+      }
+    }
+  }
+  return findProviderConfigKeyByEndpoint(providers, {
+    provider,
+    baseUrl,
+    apiMode
+  }) ?? findProviderConfigKeyByVisibleEndpoint(providers, {
+    providerName: readString2(entry.name) ?? readString2(entry.provider_name) ?? readString2(entry.provider_key) ?? provider,
+    baseUrl,
+    apiMode,
+    keyEnv: readString2(entry.key_env) ?? parseEnvReference(readString2(entry.api_key))
+  });
+}
+function mergeProviderConfig(existing, next) {
+  const merged = { ...existing };
+  for (const [key, value] of Object.entries(next)) {
+    if (key === "models") {
+      continue;
+    }
+    if (merged[key] === void 0 || merged[key] === null) {
+      merged[key] = value;
+    }
+  }
+  const models = mergeEntryModelsMap(existing, next);
+  if (Object.keys(models).length > 0) {
+    merged.models = models;
+  }
+  const defaultModel = readString2(existing.default_model) ?? readString2(existing.model) ?? readString2(next.default_model) ?? readString2(next.model);
+  if (defaultModel) {
+    merged.default_model = defaultModel;
+    delete merged.model;
+  }
+  return merged;
+}
+function mergeEntryModelsMap(existing, next) {
+  const merged = { ...normalizeEntryModelsMap(existing) };
+  for (const [id, rawNextModelConfig] of Object.entries(
+    normalizeEntryModelsMap(next)
+  )) {
+    const existingModelConfig = toRecord(merged[id]);
+    const nextModelConfig = toRecord(rawNextModelConfig);
+    merged[id] = { ...nextModelConfig, ...existingModelConfig };
+  }
+  return merged;
+}
+function legacyEntryToProviderConfig(entry, baseUrl) {
+  const next = {
+    name: readString2(entry.name) ?? readString2(entry.provider_name) ?? readString2(entry.provider_key) ?? "Custom Provider",
+    api: baseUrl
+  };
+  const apiKey = readString2(entry.api_key);
+  const keyEnv = readString2(entry.key_env) ?? parseEnvReference(apiKey);
+  if (keyEnv) {
+    next.key_env = keyEnv;
+  } else if (apiKey) {
+    next.api_key = apiKey;
+  }
+  const transport = readString2(entry.api_mode) ?? readString2(entry.transport);
+  if (transport) {
+    next.transport = transport;
+  }
+  const defaultModel = readString2(entry.model) ?? readString2(entry.default_model);
+  if (defaultModel) {
+    next.default_model = defaultModel;
+  }
+  const models = normalizeEntryModelsMap(entry);
+  if (Object.keys(models).length > 0) {
+    next.models = models;
+  }
+  const contextLength = readPositiveInteger(entry.context_length);
+  if (contextLength) {
+    next.context_length = contextLength;
+  }
+  const reasoningEffort = normalizeReasoningEffort(
+    entry.reasoning_effort ?? entry.reasoningEffort
+  );
+  if (reasoningEffort) {
+    next.reasoning_effort = reasoningEffort;
+  }
+  const supportsVision = readCapabilityBoolean(
+    entry.supports_vision ?? entry.supportsVision
+  );
+  if (supportsVision !== void 0) {
+    next.supports_vision = supportsVision;
+  }
+  return next;
+}
+function normalizeEntryModelsMap(entry) {
+  const models = entry.models;
+  if (typeof models === "object" && models !== null && !Array.isArray(models)) {
+    return { ...models };
+  }
+  return Object.fromEntries(readEntryModelIds(entry).map((id) => [id, {}]));
+}
+function buildProviderConfigKey(entry, existing) {
+  const rawProviderKey = readString2(entry.provider_key);
+  const rawName = readString2(entry.name) ?? readString2(entry.provider_name);
+  const rawBaseUrl = readString2(entry.base_url) ?? readString2(entry.url) ?? readString2(entry.api);
+  const base = providerConfigKeyBase(
+    rawProviderKey && rawProviderKey !== "custom" ? rawProviderKey : void 0,
+    rawName,
+    rawBaseUrl
+  );
+  return uniqueProviderConfigKey(base, existing);
+}
+function providerConfigKeyBase(provider, providerName, baseUrl) {
+  const fromProvider = provider?.trim();
+  const fromName = providerName?.trim();
+  const host = baseUrl ? UriHostname.safe(baseUrl) : "";
+  return slugifyProviderKey(fromProvider || fromName || host || "provider");
+}
+function uniqueProviderConfigKey(base, existing) {
+  let key = base || "provider";
+  let index = 2;
+  while (Object.prototype.hasOwnProperty.call(existing, key)) {
+    key = `${base}-${index}`;
+    index += 1;
+  }
+  return key;
+}
+function slugifyProviderKey(value) {
+  const slug = value.trim().toLowerCase().replace(/[^a-z0-9]+/gu, "-").replace(/^-+|-+$/gu, "");
+  return slug || "provider";
+}
+function findProviderConfigKeyByModelIdentity(providers, input) {
+  const provider = input.provider?.trim();
+  const baseUrl = input.baseUrl?.trim();
+  const apiMode = input.apiMode?.trim();
+  for (const [key, rawEntry] of Object.entries(providers)) {
+    const entry = providerConfigToLegacyEntry(key, toRecord(rawEntry));
+    if (!entry || !readEntryModelIds(entry).includes(input.id)) {
+      continue;
+    }
+    const entryProvider = readString2(entry.provider_key) ?? readString2(entry.provider) ?? "custom";
+    const entryBaseUrl = readString2(entry.base_url) ?? readString2(entry.url) ?? readString2(entry.api) ?? "";
+    const entryApiMode = inferApiMode(
+      entryProvider,
+      entryBaseUrl,
+      readString2(entry.api_mode)
+    );
+    if (provider && provider !== key && provider !== entryProvider) {
+      continue;
+    }
+    if (baseUrl !== void 0 && normalizeBaseUrl(baseUrl) !== normalizeBaseUrl(entryBaseUrl)) {
+      continue;
+    }
+    if (apiMode && apiMode !== entryApiMode) {
+      continue;
+    }
+    return key;
+  }
+  return null;
+}
+function findProviderConfigKeyByVisibleEndpoint(providers, endpoint) {
+  const targetProviderName = endpoint.providerName?.trim().toLowerCase();
+  if (!targetProviderName) {
+    return null;
+  }
+  const targetBaseUrl = normalizeBaseUrl(endpoint.baseUrl);
+  const targetApiMode = endpoint.apiMode?.trim();
+  const targetKeyEnv = endpoint.keyEnv?.trim().toLowerCase();
+  for (const [key, rawEntry] of Object.entries(providers)) {
+    const entry = providerConfigToLegacyEntry(key, toRecord(rawEntry));
+    if (!entry) {
+      continue;
+    }
+    const provider = readString2(entry.provider_key) ?? readString2(entry.provider) ?? "custom";
+    const providerName = readString2(entry.name) ?? readString2(entry.provider_name) ?? readString2(entry.provider_key) ?? key;
+    const baseUrl = readString2(entry.base_url) ?? readString2(entry.url) ?? readString2(entry.api) ?? "";
+    const apiMode = inferApiMode(provider, baseUrl, readString2(entry.api_mode));
+    const keyEnv = (readString2(entry.key_env) ?? parseEnvReference(readString2(entry.api_key)))?.toLowerCase();
+    if (providerName.trim().toLowerCase() !== targetProviderName) {
+      continue;
+    }
+    if (normalizeBaseUrl(baseUrl) !== targetBaseUrl) {
+      continue;
+    }
+    if (targetApiMode && targetApiMode !== apiMode) {
+      continue;
+    }
+    if (targetKeyEnv && targetKeyEnv !== keyEnv) {
+      continue;
+    }
+    return key;
+  }
+  return null;
+}
+function findProviderConfigKeyByEndpoint(providers, endpoint) {
+  const targetProvider = endpoint.provider.trim().toLowerCase();
+  const targetBaseUrl = normalizeBaseUrl(endpoint.baseUrl);
+  const targetApiMode = endpoint.apiMode?.trim();
+  for (const [key, rawEntry] of Object.entries(providers)) {
+    const entry = providerConfigToLegacyEntry(key, toRecord(rawEntry));
+    if (!entry) {
+      continue;
+    }
+    const provider = readString2(entry.provider_key) ?? readString2(entry.provider) ?? "custom";
+    const baseUrl = readString2(entry.base_url) ?? readString2(entry.url) ?? readString2(entry.api) ?? "";
+    const apiMode = inferApiMode(provider, baseUrl, readString2(entry.api_mode));
+    if (targetApiMode && targetApiMode !== apiMode) {
+      continue;
+    }
+    if ((key.toLowerCase() === targetProvider || provider.trim().toLowerCase() === targetProvider) && normalizeBaseUrl(baseUrl) === targetBaseUrl) {
+      return key;
+    }
+  }
+  return null;
+}
+function writeProviderEndpointConfig(entry, input, keyEnv) {
+  entry.name = input.providerName;
+  entry.api = input.baseUrl;
+  delete entry.base_url;
+  delete entry.url;
+  entry.default_model = input.id;
+  delete entry.model;
+  entry.transport = inferApiMode(input.provider, input.baseUrl, input.apiMode);
+  delete entry.api_mode;
+  if (input.contextLength) {
+    entry.context_length = input.contextLength;
+  } else {
+    delete entry.context_length;
+    delete entry.contextLength;
+  }
+  if (keyEnv) {
+    entry.key_env = keyEnv;
+    delete entry.api_key;
+  } else {
+    delete entry.key_env;
+  }
+}
+var UriHostname = class {
+  static safe(value) {
+    try {
+      return new URL(value).hostname.replace(/\./gu, "-");
+    } catch {
+      return "";
+    }
+  }
+};
 function readManagedModelConfigs(config, env, defaultModel, defaultReasoningEffort, authBackedProviders = EMPTY_AUTH_BACKED_PROVIDER_STATE) {
   const models = [];
   const seen = /* @__PURE__ */ new Set();
+  const seenVisibleModels = /* @__PURE__ */ new Map();
   const seenEndpoint = /* @__PURE__ */ new Map();
   const modelConfig = readModelConfig(config.model);
-  const customProviders = Array.isArray(config.custom_providers) ? config.custom_providers : [];
+  const customProviders = readCompatibleModelProviderEntries(config);
   for (const rawEntry of customProviders) {
     const entry = toRecord(rawEntry);
     const providerName = readString2(entry.name) ?? readString2(entry.provider_name) ?? readString2(entry.provider_key) ?? "Custom Provider";
@@ -3329,21 +3818,30 @@ function readManagedModelConfigs(config, env, defaultModel, defaultReasoningEffo
       authBackedProviders
     );
     for (const id of readEntryModelIds(entry)) {
-      const key = modelConfigKey(provider, baseUrl, id);
+      const key = modelConfigKey(provider, baseUrl, id, apiMode);
       if (seen.has(key)) {
         continue;
       }
       seen.add(key);
-      const endpointKey = modelEndpointKey(baseUrl, id);
+      const endpointKey = modelEndpointKey(baseUrl, id, apiMode);
       const modelContextLength = readEntryModelContextLength(entry, id) ?? contextLength;
       const reasoningEffort = readEntryModelReasoningEffort(entry, id);
+      const supportsVision = readEntryModelSupportsVision(entry, id);
       const reasoningMetadata = modelReasoningMetadata({
         provider,
         baseUrl,
         modelId: id,
         apiMode
       });
-      models.push({
+      const isDefault = matchesDefaultModelConfig({
+        id,
+        provider,
+        baseUrl,
+        apiMode,
+        defaultModel,
+        modelConfig
+      });
+      const index = upsertManagedModelConfig(models, seenVisibleModels, {
         id,
         provider,
         providerName,
@@ -3354,32 +3852,40 @@ function readManagedModelConfigs(config, env, defaultModel, defaultReasoningEffo
         ...keyEnv ? { keyEnv } : {},
         credentialConfigured: credentialMetadata.credentialState === "configured",
         ...credentialMetadata,
-        isDefault: id === defaultModel,
+        isDefault,
         ...reasoningEffort ? { reasoningEffort } : {},
-        ...reasoningMetadata
+        ...reasoningMetadata,
+        supportsVision
       });
-      seenEndpoint.set(endpointKey, models.length - 1);
+      seenEndpoint.set(endpointKey, index);
     }
   }
   if (defaultModel) {
     const provider = modelConfig.provider ?? "default";
     const authDefinition = AUTH_BACKED_MODEL_PROVIDER_BY_KEY.get(provider);
     const baseUrl = modelConfig.baseUrl ?? authDefinition?.baseUrl ?? "";
+    const defaultApiMode = inferApiMode(provider, baseUrl, modelConfig.apiMode);
     const endpointMatchIndex = seenEndpoint.get(
-      modelEndpointKey(baseUrl, defaultModel)
+      modelEndpointKey(baseUrl, defaultModel, defaultApiMode)
     );
     if (endpointMatchIndex !== void 0) {
       const existing = models[endpointMatchIndex];
       models[endpointMatchIndex] = {
         ...existing,
-        apiMode: modelConfig.apiMode ? inferApiMode(provider, baseUrl, modelConfig.apiMode) : existing.apiMode,
+        apiMode: defaultApiMode,
         contextLength: existing.contextLength ?? modelConfig.contextLength,
         keyEnv: existing.keyEnv ?? modelConfig.keyEnv,
         isDefault: true,
-        reasoningEffort: existing.reasoningEffort ?? defaultReasoningEffort ?? void 0
+        reasoningEffort: existing.reasoningEffort ?? defaultReasoningEffort ?? void 0,
+        supportsVision: existing.supportsVision ?? modelConfig.supportsVision ?? null
       };
     } else {
-      const key = modelConfigKey(provider, baseUrl, defaultModel);
+      const key = modelConfigKey(
+        provider,
+        baseUrl,
+        defaultModel,
+        defaultApiMode
+      );
       if (!seen.has(key)) {
         const credentialMetadata = readModelCredentialMetadata(
           modelConfig,
@@ -3388,8 +3894,9 @@ function readManagedModelConfigs(config, env, defaultModel, defaultReasoningEffo
           authBackedProviders
         );
         const reasoningEffort = modelConfig.reasoningEffort ?? defaultReasoningEffort;
-        const apiMode = inferApiMode(provider, baseUrl, modelConfig.apiMode);
-        models.unshift({
+        const supportsVision = modelConfig.supportsVision ?? null;
+        const apiMode = defaultApiMode;
+        const index = upsertManagedModelConfig(models, seenVisibleModels, {
           id: defaultModel,
           provider,
           providerName: authDefinition?.providerName ?? provider,
@@ -3407,18 +3914,21 @@ function readManagedModelConfigs(config, env, defaultModel, defaultReasoningEffo
             baseUrl,
             modelId: defaultModel,
             apiMode
-          })
+          }),
+          supportsVision
         });
         seen.add(key);
-        seenEndpoint.set(modelEndpointKey(baseUrl, defaultModel), 0);
+        seenEndpoint.set(modelEndpointKey(baseUrl, defaultModel, apiMode), index);
       }
     }
   }
   appendAuthBackedModelConfigs({
     models,
     seen,
+    seenVisibleModels,
     seenEndpoint,
     defaultModel,
+    modelConfig,
     defaultProvider: modelConfig.provider ?? null,
     defaultReasoningEffort,
     authBackedProviders
@@ -3437,46 +3947,132 @@ function appendAuthBackedModelConfigs(input) {
       definition.provider
     ) ? "external_auth" : "auth_store";
     for (const id of definition.modelIds) {
-      const key = modelConfigKey(definition.provider, baseUrl, id);
-      if (input.seen.has(key)) {
-        continue;
-      }
-      input.seen.add(key);
       const apiMode = inferApiMode(
         definition.provider,
         baseUrl,
         definition.apiMode
       );
-      const isDefault = id === input.defaultModel && definition.provider === input.defaultProvider;
-      input.models.push({
+      const key = modelConfigKey(definition.provider, baseUrl, id, apiMode);
+      if (input.seen.has(key)) {
+        continue;
+      }
+      input.seen.add(key);
+      const isDefault = matchesDefaultModelConfig({
         id,
         provider: definition.provider,
-        providerName: definition.providerName,
-        source: "auth_store",
         baseUrl,
         apiMode,
-        credentialConfigured: true,
-        credentialState: "configured",
-        credentialSource,
-        authType: definition.authType,
-        editable: false,
-        isReadOnly: true,
-        isDefault,
-        ...isDefault && input.defaultReasoningEffort ? { reasoningEffort: input.defaultReasoningEffort } : {},
-        ...modelReasoningMetadata({
+        defaultModel: input.defaultModel,
+        modelConfig: input.modelConfig
+      });
+      const index = upsertManagedModelConfig(
+        input.models,
+        input.seenVisibleModels,
+        {
+          id,
           provider: definition.provider,
+          providerName: definition.providerName,
+          source: "auth_store",
           baseUrl,
-          modelId: id,
-          apiMode
-        })
-      });
-      input.seenEndpoint.set(
-        modelEndpointKey(baseUrl, id),
-        input.models.length - 1
+          apiMode,
+          credentialConfigured: true,
+          credentialState: "configured",
+          credentialSource,
+          authType: definition.authType,
+          editable: false,
+          isReadOnly: true,
+          isDefault,
+          ...isDefault && input.defaultReasoningEffort ? { reasoningEffort: input.defaultReasoningEffort } : {},
+          ...modelReasoningMetadata({
+            provider: definition.provider,
+            baseUrl,
+            modelId: id,
+            apiMode
+          }),
+          supportsVision: null
+        }
       );
+      input.seenEndpoint.set(modelEndpointKey(baseUrl, id, apiMode), index);
     }
   }
 }
+function modelVisibleKey(model) {
+  return [
+    model.providerName.trim(),
+    normalizeBaseUrl(model.baseUrl),
+    model.id.trim(),
+    model.apiMode.trim()
+  ].map((value) => value.toLowerCase()).join("\n");
+}
+function upsertManagedModelConfig(models, seenVisibleModels, next) {
+  const key = modelVisibleKey(next);
+  const existingIndex = seenVisibleModels.get(key);
+  if (existingIndex === void 0) {
+    models.push(next);
+    const index = models.length - 1;
+    seenVisibleModels.set(key, index);
+    return index;
+  }
+  models[existingIndex] = mergeManagedModelConfig(
+    models[existingIndex],
+    next
+  );
+  return existingIndex;
+}
+function mergeManagedModelConfig(existing, next) {
+  const primary = managedModelPreferenceScore(next) > managedModelPreferenceScore(existing) ? next : existing;
+  const secondary = primary === next ? existing : next;
+  const credentialState = primary.credentialState === "configured" || secondary.credentialState !== "configured" ? primary.credentialState : secondary.credentialState;
+  return {
+    ...primary,
+    contextLength: primary.contextLength ?? secondary.contextLength,
+    keyEnv: primary.keyEnv ?? secondary.keyEnv,
+    credentialConfigured: primary.credentialConfigured || secondary.credentialConfigured,
+    credentialState,
+    credentialSource: primary.credentialState === "configured" || secondary.credentialState !== "configured" ? primary.credentialSource : secondary.credentialSource,
+    isDefault: primary.isDefault || secondary.isDefault,
+    reasoningEffort: primary.reasoningEffort ?? secondary.reasoningEffort,
+    reasoningSupport: primary.reasoningSupport === "unknown" ? secondary.reasoningSupport : primary.reasoningSupport,
+    supportedReasoningEfforts: primary.supportedReasoningEfforts ?? secondary.supportedReasoningEfforts,
+    supportsVision: primary.supportsVision ?? secondary.supportsVision
+  };
+}
+function managedModelPreferenceScore(model) {
+  return (model.isDefault ? 1e3 : 0) + (model.credentialState === "configured" ? 200 : 0) + (model.credentialState === "missing" ? 50 : 0) + (model.source === "auth_store" ? 100 : 0) + (model.credentialSource !== "unknown" ? 40 : 0) + (model.isReadOnly ? 10 : 0);
+}
+function matchesDefaultModelConfig(input) {
+  if (!input.defaultModel || input.id !== input.defaultModel) {
+    return false;
+  }
+  const defaultApiMode = input.modelConfig.apiMode?.trim();
+  if (defaultApiMode && input.apiMode !== defaultApiMode) {
+    return false;
+  }
+  const defaultBaseUrl = input.modelConfig.baseUrl;
+  if (defaultBaseUrl?.trim()) {
+    return normalizeBaseUrl(input.baseUrl) === normalizeBaseUrl(defaultBaseUrl);
+  }
+  const defaultProvider = input.modelConfig.provider?.trim();
+  if (defaultProvider) {
+    return input.provider === defaultProvider;
+  }
+  return true;
+}
+function providerEntryMatchesManagedModel(entry, model) {
+  const providerName = readString2(entry.name) ?? readString2(entry.provider_name) ?? readString2(entry.provider_key) ?? "Custom Provider";
+  const baseUrl = readString2(entry.base_url) ?? readString2(entry.url) ?? readString2(entry.api) ?? "";
+  const apiMode = inferApiMode(
+    readString2(entry.provider_key) ?? readString2(entry.provider) ?? "custom",
+    baseUrl,
+    readString2(entry.api_mode)
+  );
+  return modelVisibleKey({
+    providerName,
+    baseUrl,
+    id: model.id,
+    apiMode
+  }) === modelVisibleKey(model);
+}
 function readEntryCredentialMetadata(entry, env, provider, authBackedProviders) {
   const apiKey = readString2(entry.api_key);
   const keyEnv = readString2(entry.key_env) ?? parseEnvReference(apiKey);
@@ -3673,6 +4269,7 @@ function findManagedModelById(models, id) {
 function findManagedModel(models, input) {
   const provider = input.provider?.trim();
   const baseUrl = input.baseUrl?.trim();
+  const apiMode = input.apiMode?.trim();
   return models.find((model) => {
     if (model.id !== input.id) {
       return false;
@@ -3683,9 +4280,21 @@ function findManagedModel(models, input) {
     if (baseUrl !== void 0 && normalizeBaseUrl(model.baseUrl) !== normalizeBaseUrl(baseUrl)) {
       return false;
     }
+    if (apiMode && model.apiMode !== apiMode) {
+      return false;
+    }
     return true;
   });
 }
+function findManagedModelByVisibleIdentity(models, input) {
+  const key = modelVisibleKey(input);
+  return models.find((model) => modelVisibleKey(model) === key);
+}
+function hasModelIdentitySelector(input) {
+  return Boolean(
+    input.provider?.trim() || input.baseUrl?.trim() || input.apiMode?.trim()
+  );
+}
 function writeAuxiliaryCompressionModelConfig(config, model, env) {
   const auxiliary = ensureRecord(config, "auxiliary");
   const compression = ensureRecord(auxiliary, "compression");
@@ -3722,8 +4331,7 @@ function resolveManagedModelApiKey(config, env, model) {
       return defaultKey;
     }
   }
-  const customProviders = Array.isArray(config.custom_providers) ? config.custom_providers : [];
-  for (const rawEntry of customProviders) {
+  for (const rawEntry of readCompatibleModelProviderEntries(config)) {
     const entry = toRecord(rawEntry);
     const provider = readString2(entry.provider_key) ?? readString2(entry.provider) ?? "custom";
     const baseUrl = readString2(entry.base_url) ?? readString2(entry.url) ?? readString2(entry.api) ?? "";
@@ -3774,53 +4382,59 @@ function normalizeModelConfigInput(input) {
     ...reasoningEffort ? { reasoningEffort } : {}
   };
 }
-function ensureCustomProvidersList(config) {
-  const existing = config.custom_providers;
-  if (Array.isArray(existing)) {
-    return existing;
-  }
-  const next = [];
-  config.custom_providers = next;
-  return next;
-}
-function retainModelDefaultAsCustomProvider(entries, model) {
+function retainModelDefaultAsProvider(providers, model) {
   const id = model.model?.trim();
   if (!id) {
     return;
   }
   const provider = model.provider?.trim() || "default";
   const baseUrl = model.baseUrl?.trim() || "";
-  const key = modelConfigKey(provider, baseUrl, id);
-  const exists = entries.some((entry2) => {
-    const record = toRecord(entry2);
-    const entryProvider = readString2(record.provider_key) ?? readString2(record.provider) ?? "custom";
-    const entryBaseUrl = readString2(record.base_url) ?? readString2(record.url) ?? readString2(record.api) ?? "";
-    return readEntryModelIds(record).some(
-      (modelId) => modelConfigKey(entryProvider, entryBaseUrl, modelId) === key
-    );
-  });
+  const apiMode = inferApiMode(provider, baseUrl, model.apiMode);
+  const key = modelConfigKey(provider, baseUrl, id, apiMode);
+  const exists = readCompatibleModelProviderEntries({ providers }).some(
+    (entry2) => {
+      const record = toRecord(entry2);
+      const entryProvider = readString2(record.provider_key) ?? readString2(record.provider) ?? "custom";
+      const entryBaseUrl = readString2(record.base_url) ?? readString2(record.url) ?? readString2(record.api) ?? "";
+      const entryApiMode = inferApiMode(
+        entryProvider,
+        entryBaseUrl,
+        readString2(record.api_mode)
+      );
+      return readEntryModelIds(record).some(
+        (modelId) => modelConfigKey(entryProvider, entryBaseUrl, modelId, entryApiMode) === key
+      );
+    }
+  );
   if (exists) {
     return;
   }
+  const providerKey = uniqueProviderConfigKey(
+    providerConfigKeyBase(provider, provider, baseUrl),
+    providers
+  );
   const entry = {
     name: provider,
-    provider_key: provider,
-    base_url: baseUrl,
-    api_mode: inferApiMode(provider, baseUrl, model.apiMode),
-    model: id
+    api: baseUrl,
+    transport: inferApiMode(provider, baseUrl, model.apiMode),
+    default_model: id,
+    models: { [id]: {} }
   };
   if (model.contextLength) {
     entry.context_length = model.contextLength;
   }
   if (model.reasoningEffort) {
-    entry.reasoning_effort = model.reasoningEffort;
+    writeEntryModelReasoningEffort(entry, id, model.reasoningEffort);
+  }
+  if (model.supportsVision !== void 0) {
+    writeEntryModelSupportsVision(entry, id, model.supportsVision);
   }
   if (model.keyEnv) {
     entry.key_env = model.keyEnv;
   } else if (model.apiKey) {
     entry.api_key = model.apiKey;
   }
-  entries.push(entry);
+  providers[providerKey] = entry;
 }
 function writeDefaultModelConfig(modelConfig, model) {
   modelConfig.default = model.id;
@@ -3847,71 +4461,15 @@ function writeDefaultModelConfig(modelConfig, model) {
     delete modelConfig.context_length;
   }
 }
-function findCustomProviderIndex(entries, modelId) {
-  return entries.findIndex(
-    (entry) => readEntryModelIds(toRecord(entry)).includes(modelId)
-  );
-}
-function findCustomProviderIndexByEndpoint(entries, endpoint) {
-  return entries.findIndex((entry) => {
-    const record = toRecord(entry);
-    const provider = readString2(record.provider_key) ?? readString2(record.provider) ?? "custom";
-    const baseUrl = readString2(record.base_url) ?? readString2(record.url) ?? readString2(record.api) ?? "";
-    return provider.trim().toLowerCase() === endpoint.provider.trim().toLowerCase() && normalizeBaseUrl(baseUrl) === normalizeBaseUrl(endpoint.baseUrl);
-  });
-}
-function updateEntryModels(entry, originalModelId, nextModelId) {
-  const models = entry.models;
-  if (Array.isArray(models)) {
-    const next = models.map((value) => value === originalModelId ? nextModelId : value).filter(
-      (value) => typeof value === "string" && value.trim().length > 0
-    );
-    if (!next.includes(nextModelId)) {
-      next.unshift(nextModelId);
-    }
-    entry.models = Array.from(new Set(next));
+function writeDefaultModelSupportsVision(modelConfig, supportsVision) {
+  if (supportsVision === void 0 || supportsVision === null) {
+    delete modelConfig.supports_vision;
+    delete modelConfig.supportsVision;
     return;
   }
-  if (typeof models === "object" && models !== null && originalModelId !== nextModelId && originalModelId in models) {
-    const record = models;
-    record[nextModelId] = record[originalModelId];
-    delete record[originalModelId];
-  }
+  modelConfig.supports_vision = supportsVision;
 }
-function addEntryModel(entry, modelId) {
-  const id = modelId.trim();
-  if (!id) {
-    return;
-  }
-  const models = entry.models;
-  if (Array.isArray(models)) {
-    entry.models = Object.fromEntries(
-      Array.from(
-        /* @__PURE__ */ new Set([
-          ...models.filter(
-            (value) => typeof value === "string" && value.trim().length > 0
-          ),
-          id
-        ])
-      ).map((model) => [model, {}])
-    );
-    return;
-  }
-  if (typeof models === "object" && models !== null) {
-    const record = models;
-    record[id] = toRecord(record[id]);
-    return;
-  }
-  if (readString2(entry.model) !== id && readString2(entry.default_model) !== id) {
-    entry.models = Object.fromEntries(
-      Array.from(/* @__PURE__ */ new Set([...readEntryModelIds(entry), id])).map((model) => [
-        model,
-        {}
-      ])
-    );
-  }
-}
-function removeModelFromCustomProvider(entry, modelId) {
+function removeModelFromProvider(entry, modelId) {
   if (readString2(entry.model) === modelId || readString2(entry.default_model) === modelId) {
     delete entry.model;
     delete entry.default_model;
@@ -3924,7 +4482,7 @@ function removeModelFromCustomProvider(entry, modelId) {
   }
   const remainingModels = readEntryModelIds(entry);
   if (remainingModels.length > 0) {
-    entry.model = readString2(entry.model) ?? remainingModels[0];
+    entry.default_model = readString2(entry.default_model) ?? remainingModels[0];
     return entry;
   }
   return null;
@@ -4017,6 +4575,63 @@ function writeEntryModelReasoningEffort(entry, modelId, reasoningEffort) {
     delete entry.reasoningEffort;
   }
 }
+function readEntryModelSupportsVision(entry, modelId) {
+  const models = entry.models;
+  if (typeof models === "object" && models !== null && !Array.isArray(models)) {
+    const modelConfig = toRecord(models[modelId]);
+    const modelValue = readCapabilityBoolean(
+      modelConfig.supports_vision ?? modelConfig.supportsVision
+    );
+    if (modelValue !== void 0) {
+      return modelValue;
+    }
+  }
+  const entryValue = readCapabilityBoolean(
+    entry.supports_vision ?? entry.supportsVision
+  );
+  return entryValue ?? null;
+}
+function writeEntryModelSupportsVision(entry, modelId, supportsVision) {
+  if (supportsVision === void 0) {
+    return;
+  }
+  const modelConfig = ensureEntryModelConfig(entry, modelId, modelId);
+  if (supportsVision === null) {
+    delete modelConfig.supports_vision;
+    delete modelConfig.supportsVision;
+  } else {
+    modelConfig.supports_vision = supportsVision;
+  }
+}
+function readCapabilityBoolean(value) {
+  if (typeof value === "boolean") {
+    return value;
+  }
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const normalized = value.trim().toLowerCase();
+  if (["true", "1", "yes", "y", "on"].includes(normalized)) {
+    return true;
+  }
+  if (["false", "0", "no", "n", "off"].includes(normalized)) {
+    return false;
+  }
+  return void 0;
+}
+function ensureEntryModelConfig(entry, originalModelId, nextModelId) {
+  const modelMap = normalizeEntryModelsMap(entry);
+  if (originalModelId !== nextModelId && Object.prototype.hasOwnProperty.call(modelMap, originalModelId) && !Object.prototype.hasOwnProperty.call(modelMap, nextModelId)) {
+    modelMap[nextModelId] = modelMap[originalModelId];
+  }
+  if (originalModelId !== nextModelId) {
+    delete modelMap[originalModelId];
+  }
+  const modelConfig = toRecord(modelMap[nextModelId]);
+  modelMap[nextModelId] = modelConfig;
+  entry.models = modelMap;
+  return modelConfig;
+}
 async function readHermesModelConfigForImport(input) {
   const { config } = await readHermesConfigDocument(
     resolveHermesConfigPath(input.profileName)
@@ -4064,8 +4679,7 @@ function readInlineApiKeyForModel(config, model) {
       return key;
     }
   }
-  const customProviders = Array.isArray(config.custom_providers) ? config.custom_providers : [];
-  for (const rawEntry of customProviders) {
+  for (const rawEntry of readCompatibleModelProviderEntries(config)) {
     const entry = toRecord(rawEntry);
     const provider = readString2(entry.provider_key) ?? readString2(entry.provider) ?? "custom";
     const baseUrl = readString2(entry.base_url) ?? readString2(entry.url) ?? readString2(entry.api) ?? "";
@@ -4095,11 +4709,35 @@ function compareCatalogItems(left, right) {
   }
   return left.id.localeCompare(right.id);
 }
-function modelConfigKey(provider, baseUrl, modelId) {
-  return [provider, normalizeBaseUrl(baseUrl), modelId].join("\n").toLowerCase();
+function modelConfigKey(provider, baseUrl, modelId, apiMode) {
+  return [provider, normalizeBaseUrl(baseUrl), modelId, apiMode].join("\n").toLowerCase();
+}
+function modelEndpointKey(baseUrl, modelId, apiMode) {
+  return [normalizeBaseUrl(baseUrl), modelId, apiMode].join("\n").toLowerCase();
 }
-function modelEndpointKey(baseUrl, modelId) {
-  return [normalizeBaseUrl(baseUrl), modelId].join("\n").toLowerCase();
+function providerConfigGroupKey(entry) {
+  const provider = readString2(entry.provider_key) ?? readString2(entry.provider) ?? "custom";
+  const providerName = readString2(entry.name) ?? readString2(entry.provider_name) ?? "";
+  const baseUrl = readString2(entry.base_url) ?? readString2(entry.url) ?? readString2(entry.api) ?? "";
+  const apiMode = inferApiMode(provider, baseUrl, readString2(entry.api_mode));
+  return [
+    providerName.trim().toLowerCase(),
+    normalizeBaseUrl(baseUrl).toLowerCase(),
+    apiMode.trim().toLowerCase(),
+    providerCredentialIdentity(entry)
+  ].join("\n");
+}
+function providerCredentialIdentity(entry) {
+  const apiKey = readString2(entry.api_key);
+  const keyEnv = readString2(entry.key_env) ?? parseEnvReference(apiKey);
+  if (keyEnv) {
+    return `env:${keyEnv.trim().toLowerCase()}`;
+  }
+  const inlineApiKey = readInlineApiKey(apiKey);
+  if (inlineApiKey) {
+    return `inline:${inlineApiKey}`;
+  }
+  return "";
 }
 function normalizeBaseUrl(baseUrl) {
   return baseUrl.trim().replace(/\/+$/u, "");
@@ -4206,9 +4844,18 @@ function readModelConfig(value) {
     contextLength,
     reasoningEffort: normalizeReasoningEffort(
       model.reasoning_effort ?? model.reasoningEffort
-    )
+    ),
+    supportsVision: readCapabilityBoolean(model.supports_vision ?? model.supportsVision) ?? null
   };
 }
+function readProfileImageInputMode(config) {
+  const agent = toRecord(config.agent);
+  return normalizeImageInputMode(agent.image_input_mode) ?? "auto";
+}
+function writeProfileImageInputMode(config, imageInputMode) {
+  const agent = ensureRecord(config, "agent");
+  agent.image_input_mode = imageInputMode;
+}
 function readProfileReasoningEffort(config) {
   const agent = toRecord(config.agent);
   return normalizeReasoningEffort(agent.reasoning_effort ?? agent.reasoningEffort) ?? null;
@@ -4224,6 +4871,13 @@ function normalizeReasoningEffort(value) {
   const normalized = value.trim().toLowerCase();
   return REASONING_EFFORTS.includes(normalized) ? normalized : void 0;
 }
+function normalizeImageInputMode(value) {
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const normalized = value.trim().toLowerCase();
+  return normalized === "auto" || normalized === "native" || normalized === "text" ? normalized : void 0;
+}
 function readPositiveInteger(value) {
   if (typeof value === "number" && Number.isFinite(value) && value > 0) {
     return Math.floor(value);
@@ -4293,6 +4947,11 @@ function readToolsetConfigState(key, config, env) {
         requiresConfig: true,
         configured: isWebToolConfigured(config, env)
       };
+    case "vision":
+      return {
+        requiresConfig: true,
+        configured: isVisionToolConfigured(config, env)
+      };
     case "image_gen":
       return {
         requiresConfig: true,
@@ -4348,6 +5007,34 @@ function isWebToolConfigured(config, env) {
   }
   return isEnvValueConfigured(env.FIRECRAWL_API_KEY) || isEnvValueConfigured(env.FIRECRAWL_API_URL) || isEnvValueConfigured(env.TAVILY_API_KEY) || isEnvValueConfigured(env.EXA_API_KEY) || isEnvValueConfigured(env.PARALLEL_API_KEY);
 }
+function isVisionToolConfigured(config, env) {
+  const auxiliary = toRecord(config.auxiliary);
+  const vision = toRecord(auxiliary.vision);
+  const provider = readString2(vision.provider)?.toLowerCase() ?? "auto";
+  const baseUrl = readString2(vision.base_url);
+  const apiKey = readString2(vision.api_key);
+  const keyEnv = parseEnvReference(apiKey);
+  const resolvedApiKey = resolveConfiguredApiKey(apiKey, keyEnv, env);
+  if (provider === "auto" && !baseUrl) {
+    return true;
+  }
+  if (provider === "nous") {
+    return true;
+  }
+  if (provider === "openrouter") {
+    return isEnvValueConfigured(env.OPENROUTER_API_KEY);
+  }
+  if (provider === "openai") {
+    return isEnvValueConfigured(env.OPENAI_API_KEY) || isEnvValueConfigured(resolvedApiKey);
+  }
+  if (provider === "anthropic") {
+    return isEnvValueConfigured(env.ANTHROPIC_API_KEY);
+  }
+  if (provider === "custom" || baseUrl) {
+    return isEnvValueConfigured(resolvedApiKey);
+  }
+  return true;
+}
 function isImageGenToolConfigured(config, env) {
   const imageGen = toRecord(config.image_gen);
   const provider = readString2(imageGen.provider)?.toLowerCase() ?? "fal";
@@ -4474,7 +5161,7 @@ function readString2(value) {
 }
 function normalizeProfileToolConfigKey(value) {
   const normalized = value.trim();
-  if (normalized === "web" || normalized === "image_gen" || normalized === "stt" || normalized === "tts" || normalized === "messaging" || normalized === "homeassistant" || normalized === "rl") {
+  if (normalized === "web" || normalized === "vision" || normalized === "image_gen" || normalized === "stt" || normalized === "tts" || normalized === "messaging" || normalized === "homeassistant" || normalized === "rl") {
     return normalized;
   }
   throw new Error(`unsupported tool config "${value}"`);
@@ -4501,6 +5188,25 @@ function profileToolConfigFromSources(profileName, configPath, toolKey, config,
       configured.FIRECRAWL_API_URL = isEnvValueConfigured(env.FIRECRAWL_API_URL);
       break;
     }
+    case "vision": {
+      const auxiliary = toRecord(config.auxiliary);
+      const section = toRecord(auxiliary.vision);
+      values.provider = readString2(section.provider) ?? "auto";
+      values.model = readString2(section.model) ?? env.AUXILIARY_VISION_MODEL?.trim() ?? "";
+      values.baseUrl = readString2(section.base_url) ?? env.AUXILIARY_VISION_BASE_URL?.trim() ?? "";
+      values.apiMode = readString2(section.api_mode) ?? "";
+      configured.OPENROUTER_API_KEY = isEnvValueConfigured(env.OPENROUTER_API_KEY);
+      configured.OPENAI_API_KEY = isEnvValueConfigured(env.OPENAI_API_KEY);
+      configured.ANTHROPIC_API_KEY = isEnvValueConfigured(env.ANTHROPIC_API_KEY);
+      configured.AUXILIARY_VISION_API_KEY = isEnvValueConfigured(env.AUXILIARY_VISION_API_KEY) || isEnvValueConfigured(
+        resolveConfiguredApiKey(
+          readString2(section.api_key),
+          parseEnvReference(readString2(section.api_key)),
+          env
+        )
+      );
+      break;
+    }
     case "image_gen": {
       const section = toRecord(config.image_gen);
       values.provider = readString2(section.provider) ?? "fal";
@@ -4669,6 +5375,71 @@ function applyImageGenToolConfig(config, values) {
   }
   return changed;
 }
+function applyVisionToolConfig(config, values) {
+  let changed = false;
+  const auxiliary = ensureRecord(config, "auxiliary");
+  const section = ensureRecord(auxiliary, "vision");
+  const provider = readToolConfigString(values.provider);
+  if (provider !== void 0) {
+    if (![
+      "auto",
+      "openrouter",
+      "nous",
+      "openai",
+      "anthropic",
+      "custom"
+    ].includes(provider)) {
+      throw new Error("auxiliary.vision.provider is not supported");
+    }
+    section.provider = provider;
+    changed = true;
+    if (provider === "auto") {
+      delete section.base_url;
+      delete section.api_key;
+      delete section.api_mode;
+    }
+  }
+  if (Object.prototype.hasOwnProperty.call(values, "model")) {
+    const model = readToolConfigString(values.model);
+    if (model) {
+      section.model = model;
+    } else {
+      delete section.model;
+    }
+    changed = true;
+  }
+  if (Object.prototype.hasOwnProperty.call(values, "baseUrl")) {
+    const baseUrl = readToolConfigString(values.baseUrl);
+    if (baseUrl) {
+      section.base_url = normalizeToolConfigHttpUrl(
+        baseUrl,
+        "auxiliary.vision.base_url"
+      );
+      section.api_key = "${AUXILIARY_VISION_API_KEY}";
+    } else {
+      delete section.base_url;
+      if (readString2(section.api_key) === "${AUXILIARY_VISION_API_KEY}") {
+        delete section.api_key;
+      }
+    }
+    changed = true;
+  }
+  if (Object.prototype.hasOwnProperty.call(values, "apiMode")) {
+    const apiMode = readToolConfigString(values.apiMode);
+    if (apiMode) {
+      section.api_mode = apiMode;
+    } else {
+      delete section.api_mode;
+    }
+    changed = true;
+  }
+  if (readToolConfigString(values.AUXILIARY_VISION_API_KEY) && readString2(section.base_url)) {
+    section.api_key = "${AUXILIARY_VISION_API_KEY}";
+    changed = true;
+  }
+  deleteEmptyNestedToolSection(auxiliary, "vision");
+  return changed;
+}
 function applyOptionalNestedToolString(parent, sectionKey, targetKey, values, inputKeys) {
   const inputKey = inputKeys.find(
     (key) => Object.prototype.hasOwnProperty.call(values, key)
@@ -5621,7 +6392,7 @@ function isConversationMissingError(error) {
 }
 
 // src/constants.ts
-var LINK_VERSION = "0.7.3";
+var LINK_VERSION = "0.7.4-beta.0";
 var LINK_COMMAND = "hermeslink";
 var LINK_DEFAULT_PORT = 52379;
 var LINK_RUNTIME_DIR_NAME = ".hermeslink";
@@ -9210,7 +9981,8 @@ var ConversationCommandHandlers = class {
         {
           taskModelId: configuredModel.id,
           taskModelProvider: configuredModel.provider,
-          taskModelBaseUrl: configuredModel.baseUrl
+          taskModelBaseUrl: configuredModel.baseUrl,
+          taskModelApiMode: configuredModel.apiMode
         },
         runtime.profileName
       );
@@ -16315,6 +17087,13 @@ async function resolveHermesPythonRuntime() {
   const hermesBin = await resolveExecutablePath2(resolveHermesBin());
   let shebangRuntime = null;
   if (hermesBin) {
+    const launcherTarget = await readHermesLauncherTarget(hermesBin);
+    if (launcherTarget) {
+      const launcherRuntime = await resolveHermesEntrypointRuntime(launcherTarget);
+      if (launcherRuntime) {
+        return launcherRuntime;
+      }
+    }
     const installRoot = await findHermesSourceRoot(hermesBin);
     const shebang = await readShebang(hermesBin);
     const command = shebangToPythonCommand(shebang);
@@ -16435,6 +17214,42 @@ async function findDevHermesAgentSource() {
   }
   return null;
 }
+async function readHermesLauncherTarget(filePath) {
+  const raw = await readFile11(filePath, "utf8").catch(() => "");
+  for (const line of raw.split(/\r?\n/u)) {
+    const quoted = /^\s*exec\s+(["'])(?<target>.+?)\1\s+(?:"\$@"|'\$@')/.exec(
+      line
+    );
+    const rawTarget = quoted?.groups?.target ?? /^\s*exec\s+(?<target>\S+)\s+(?:"\$@"|'\$@')/.exec(line)?.groups?.target;
+    if (!rawTarget || !path18.isAbsolute(rawTarget)) {
+      continue;
+    }
+    if (await isExecutableFile(rawTarget)) {
+      return rawTarget;
+    }
+  }
+  return null;
+}
+async function resolveHermesEntrypointRuntime(entrypointPath) {
+  const installRoot = await findHermesSourceRoot(entrypointPath);
+  const shebang = await readShebang(entrypointPath);
+  const command = shebangToPythonCommand(shebang);
+  if (command) {
+    return {
+      ...command,
+      sourceRoot: await findHermesSourceRoot(command.command) ?? installRoot
+    };
+  }
+  const installPython = installRoot ? await findHermesVenvPython(installRoot) : null;
+  if (installPython) {
+    return {
+      command: installPython,
+      args: [],
+      sourceRoot: installRoot
+    };
+  }
+  return null;
+}
 async function findHermesSourceRoot(executablePath) {
   let cursor = path18.dirname(path18.resolve(executablePath));
   for (let index = 0; index < 6; index += 1) {
@@ -21553,7 +22368,8 @@ var ConversationService = class {
         {
           taskModelId: configuredModel.id,
           taskModelProvider: configuredModel.provider,
-          taskModelBaseUrl: configuredModel.baseUrl
+          taskModelBaseUrl: configuredModel.baseUrl,
+          taskModelApiMode: configuredModel.apiMode
         },
         currentRuntime.profile.name
       );
@@ -24314,16 +25130,13 @@ function registerModelConfigRoutes(router, options) {
   router.delete("/api/v1/model-configs", async (ctx) => {
     await authenticateRequest(ctx, paths);
     const body = await readJsonBody(ctx.req);
-    const modelId = readString17(body, "model_id") ?? readString17(body, "modelId");
-    if (!modelId) {
-      throw new LinkHttpError(400, "model_id_required", "model_id is required");
-    }
+    const input = readModelDeleteInput(body);
     try {
-      const result = await deleteHermesModelConfig(modelId);
-      ctx.body = await reloadGatewayAfterModelConfigChange(result, {
+      const result = await deleteHermesModelConfig(input);
+      ctx.body = shouldReloadGatewayAfterModelConfigChange(body) ? await reloadGatewayAfterModelConfigChange(result, {
         paths,
         logger
-      });
+      }) : markModelConfigAppliedWithoutGatewayReload(result);
     } catch (error) {
       throw toModelConfigHttpError(error);
     }
@@ -24386,17 +25199,14 @@ function registerModelConfigRoutes(router, options) {
     await authenticateRequest(ctx, paths);
     await getHermesProfileStatus(ctx.params.name, paths);
     const body = await readJsonBody(ctx.req);
-    const modelId = readString17(body, "model_id") ?? readString17(body, "modelId");
-    if (!modelId) {
-      throw new LinkHttpError(400, "model_id_required", "model_id is required");
-    }
+    const input = readModelDeleteInput(body);
     try {
-      const result = await deleteHermesModelConfig(modelId, ctx.params.name);
-      ctx.body = await reloadGatewayAfterProfileModelConfigChange(result, {
+      const result = await deleteHermesModelConfig(input, ctx.params.name);
+      ctx.body = shouldReloadGatewayAfterModelConfigChange(body) ? await reloadGatewayAfterProfileModelConfigChange(result, {
         paths,
         logger,
         profileName: ctx.params.name
-      });
+      }) : markModelConfigAppliedWithoutGatewayReload(result);
     } catch (error) {
       throw toModelConfigHttpError(error);
     }
@@ -24416,6 +25226,9 @@ function readModelConfigInput(body) {
   return {
     id,
     originalModelId: readString17(body, "original_model_id") ?? readString17(body, "originalModelId") ?? readString17(body, "original_id") ?? void 0,
+    originalProvider: readString17(body, "original_provider") ?? readString17(body, "originalProvider") ?? readString17(body, "original_provider_key") ?? readString17(body, "originalProviderKey") ?? void 0,
+    originalBaseUrl: readString17(body, "original_base_url") ?? readString17(body, "originalBaseUrl") ?? void 0,
+    originalApiMode: readString17(body, "original_api_mode") ?? readString17(body, "originalApiMode") ?? void 0,
     provider,
     providerName: readString17(body, "provider_name") ?? readString17(body, "providerName") ?? void 0,
     baseUrl,
@@ -24426,7 +25239,10 @@ function readModelConfigInput(body) {
     ),
     keyEnv: readString17(body, "key_env") ?? readString17(body, "keyEnv") ?? void 0,
     setDefault: readBoolean3(body.set_default ?? body.setDefault),
-    reasoningEffort: readString17(body, "reasoning_effort") ?? readString17(body, "reasoningEffort") ?? void 0
+    reasoningEffort: readString17(body, "reasoning_effort") ?? readString17(body, "reasoningEffort") ?? void 0,
+    supportsVision: readNullableBoolean(
+      body.supports_vision ?? body.supportsVision
+    )
   };
 }
 function readModelDefaultsInput(body) {
@@ -24434,12 +25250,46 @@ function readModelDefaultsInput(body) {
     taskModelId: readString17(body, "task_model_id") ?? readString17(body, "taskModelId") ?? readString17(body, "default_model_id") ?? readString17(body, "defaultModelId") ?? void 0,
     taskModelProvider: readString17(body, "task_model_provider") ?? readString17(body, "taskModelProvider") ?? readString17(body, "default_model_provider") ?? readString17(body, "defaultModelProvider") ?? void 0,
     taskModelBaseUrl: readString17(body, "task_model_base_url") ?? readString17(body, "taskModelBaseUrl") ?? readString17(body, "default_model_base_url") ?? readString17(body, "defaultModelBaseUrl") ?? void 0,
+    taskModelApiMode: readString17(body, "task_model_api_mode") ?? readString17(body, "taskModelApiMode") ?? readString17(body, "default_model_api_mode") ?? readString17(body, "defaultModelApiMode") ?? void 0,
     compressionModelId: readString17(body, "compression_model_id") ?? readString17(body, "compressionModelId") ?? void 0,
     compressionModelProvider: readString17(body, "compression_model_provider") ?? readString17(body, "compressionModelProvider") ?? void 0,
     compressionModelBaseUrl: readString17(body, "compression_model_base_url") ?? readString17(body, "compressionModelBaseUrl") ?? void 0,
-    reasoningEffort: readString17(body, "reasoning_effort") ?? readString17(body, "reasoningEffort") ?? readString17(body, "default_reasoning_effort") ?? readString17(body, "defaultReasoningEffort") ?? void 0
+    compressionModelApiMode: readString17(body, "compression_model_api_mode") ?? readString17(body, "compressionModelApiMode") ?? void 0,
+    reasoningEffort: readString17(body, "reasoning_effort") ?? readString17(body, "reasoningEffort") ?? readString17(body, "default_reasoning_effort") ?? readString17(body, "defaultReasoningEffort") ?? void 0,
+    imageInputMode: readString17(body, "image_input_mode") ?? readString17(body, "imageInputMode") ?? void 0
   };
 }
+function readModelDeleteInput(body) {
+  const id = readString17(body, "model_id") ?? readString17(body, "modelId");
+  if (!id) {
+    throw new LinkHttpError(400, "model_id_required", "model_id is required");
+  }
+  return {
+    id,
+    provider: readString17(body, "provider") ?? readString17(body, "provider_key") ?? readString17(body, "providerKey") ?? void 0,
+    baseUrl: readString17(body, "base_url") ?? readString17(body, "baseUrl") ?? void 0,
+    apiMode: readString17(body, "api_mode") ?? readString17(body, "apiMode") ?? void 0
+  };
+}
+function readNullableBoolean(value) {
+  if (value === null) {
+    return null;
+  }
+  if (typeof value === "boolean") {
+    return value;
+  }
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const normalized = value.trim().toLowerCase();
+  if (["true", "1", "yes", "on"].includes(normalized)) {
+    return true;
+  }
+  if (["false", "0", "no", "off"].includes(normalized)) {
+    return false;
+  }
+  return void 0;
+}
 function readModelConfigImportInput(body) {
   const sourceProfileName = readString17(body, "source_profile") ?? readString17(body, "sourceProfile") ?? readString17(body, "source_profile_name") ?? readString17(body, "sourceProfileName");
   const modelId = readString17(body, "model_id") ?? readString17(body, "modelId") ?? readString17(body, "id");
@@ -24461,7 +25311,7 @@ function readModelConfigImportInput(body) {
 }
 function shouldReloadGatewayAfterModelConfigChange(body) {
   const explicit = readBoolean3(body.reload_gateway ?? body.reloadGateway) ?? (readBoolean3(body.skip_gateway_reload ?? body.skipGatewayReload) === true ? false : void 0);
-  return explicit ?? true;
+  return explicit ?? false;
 }
 function markModelConfigAppliedWithoutGatewayReload(result) {
   return {