ompchamber 2.0.2 → 3.0.0

package/src/client/data/settings/provider.ts

@@ -1,4 +1,4 @@
-import type { ProviderItem } from '@/shared/types';
+import type { PresetProviderOption, ProviderItem } from '@/shared/types/settings/provider';
 
 export const DEFAULT_PROVIDERS_LIST: ProviderItem[] = [
   {
@@ -8,6 +8,7 @@ export const DEFAULT_PROVIDERS_LIST: ProviderItem[] = [
     icon: 'deepseek',
     status: 'connected',
     configuredIn: 'auth credentials',
+    credentialSource: 'chamber',
     apiKey: 'sk-ds-••••••••••••••••••••38f1',
     baseUrl: 'https://api.deepseek.com/v1',
     models: [
@@ -59,6 +60,7 @@ export const DEFAULT_PROVIDERS_LIST: ProviderItem[] = [
     icon: 'agentrouter',
     status: 'connected',
     configuredIn: 'auth credentials',
+    credentialSource: 'chamber',
     apiKey: 'ar-live-•••••••••••••••••••89c2',
     baseUrl: 'https://router.agent.ai/v1',
     models: [
@@ -104,6 +106,7 @@ export const DEFAULT_PROVIDERS_LIST: ProviderItem[] = [
     icon: 'commandcode',
     status: 'connected',
     configuredIn: 'auth credentials',
+    credentialSource: 'chamber',
     apiKey: 'cc-key-••••••••••••••••••••7a12',
     baseUrl: 'https://api.commandcode.dev/v1',
     models: Array.from({ length: 41 }, (_, i) => {
@@ -142,6 +145,7 @@ export const DEFAULT_PROVIDERS_LIST: ProviderItem[] = [
     icon: 'opencode',
     status: 'connected',
     configuredIn: 'auth credentials',
+    credentialSource: 'chamber',
     apiKey: 'zen-live-•••••••••••••••••••44fa',
     baseUrl: 'https://zen.opencode.ai/v1',
     models: [
@@ -161,6 +165,7 @@ export const DEFAULT_PROVIDERS_LIST: ProviderItem[] = [
     icon: 'claude',
     status: 'connected',
     configuredIn: 'auth credentials',
+    credentialSource: 'chamber',
     apiKey: 'sk-ant-•••••••••••••••••••••991c',
     baseUrl: 'https://api.anthropic.com/v1',
     models: [
@@ -174,12 +179,139 @@ export const DEFAULT_PROVIDERS_LIST: ProviderItem[] = [
   },
 ];
 
-export const PRESET_NEW_PROVIDERS = [
-  { id: 'openai', name: 'OpenAI', slug: 'openai', icon: 'openai', defaultUrl: 'https://api.openai.com/v1' },
-  { id: 'anthropic', name: 'Anthropic', slug: 'anthropic', icon: 'claude', defaultUrl: 'https://api.anthropic.com/v1' },
-  { id: 'google', name: 'Google Gemini', slug: 'google', icon: 'gemini', defaultUrl: 'https://generativelanguage.googleapis.com/v1beta' },
-  { id: 'groq', name: 'Groq Cloud', slug: 'groq', icon: 'groq', defaultUrl: 'https://api.groq.com/openai/v1' },
-  { id: 'mistral', name: 'Mistral AI', slug: 'mistral', icon: 'mistral', defaultUrl: 'https://api.mistral.ai/v1' },
-  { id: 'ollama', name: 'Ollama (Local)', slug: 'ollama', icon: 'ollama', defaultUrl: 'http://localhost:11434/v1' },
-  { id: 'custom', name: 'Custom OpenAI-Compatible', slug: 'custom', icon: 'custom', defaultUrl: 'https://' },
+/**
+ * Providers offered by the Add Provider picker. `group` is the section the
+ * picker renders; `api`/`auth`/`discovery` are the `models.yml` fields the
+ * preset seeds, so a choice that omp understands is made once here rather than
+ * re-derived from the URL at write time.
+ *
+ * A preset whose id names a provider omp already bundles (`bundled: true`) is
+ * an OVERRIDE entry: omp keeps serving its own model list for that provider and
+ * only the endpoint changes. That is the documented way to point a bundled
+ * provider at a proxy, and it is deliberately not offered for providers whose
+ * models the chamber would then have to duplicate.
+ */
+export const PRESET_NEW_PROVIDERS: PresetProviderOption[] = [
+  {
+    id: 'openai', name: 'OpenAI', slug: 'openai', icon: 'openai',
+    defaultUrl: 'https://api.openai.com/v1', api: 'openai-responses', group: 'Frontier APIs',
+  },
+  {
+    id: 'anthropic', name: 'Anthropic', slug: 'anthropic', icon: 'claude',
+    defaultUrl: 'https://api.anthropic.com/v1', api: 'anthropic-messages', group: 'Frontier APIs',
+  },
+  {
+    id: 'google', name: 'Google Gemini', slug: 'google', icon: 'gemini',
+    defaultUrl: 'https://generativelanguage.googleapis.com/v1beta',
+    api: 'google-generative-ai', group: 'Frontier APIs',
+  },
+  {
+    id: 'groq', name: 'Groq Cloud', slug: 'groq', icon: 'groq',
+    defaultUrl: 'https://api.groq.com/openai/v1', api: 'openai-completions', group: 'Frontier APIs',
+  },
+  {
+    id: 'mistral', name: 'Mistral AI', slug: 'mistral', icon: 'mistral',
+    defaultUrl: 'https://api.mistral.ai/v1', api: 'openai-completions', group: 'Frontier APIs',
+  },
+  {
+    id: 'xai', name: 'xAI', slug: 'xai', icon: 'xai',
+    defaultUrl: 'https://api.x.ai/v1', api: 'openai-completions', group: 'Frontier APIs',
+  },
+  {
+    id: 'cerebras', name: 'Cerebras', slug: 'cerebras', icon: 'cerebras',
+    defaultUrl: 'https://api.cerebras.ai/v1', api: 'openai-completions', group: 'Frontier APIs',
+  },
+  {
+    id: 'deepseek', name: 'DeepSeek', slug: 'deepseek', icon: 'deepseek',
+    defaultUrl: 'https://api.deepseek.com/v1', api: 'openai-completions', group: 'Frontier APIs',
+  },
+  {
+    id: 'openrouter', name: 'OpenRouter', slug: 'openrouter', icon: 'openrouter',
+    defaultUrl: 'https://openrouter.ai/api/v1', api: 'openai-completions', group: 'Gateways',
+  },
+  {
+    id: 'together', name: 'Together AI', slug: 'together', icon: 'together',
+    defaultUrl: 'https://api.together.xyz/v1', api: 'openai-completions', group: 'Gateways',
+  },
+  {
+    id: 'fireworks', name: 'Fireworks', slug: 'fireworks', icon: 'fireworks',
+    defaultUrl: 'https://api.fireworks.ai/inference/v1', api: 'openai-completions', group: 'Gateways',
+  },
+  {
+    id: 'deepinfra', name: 'DeepInfra', slug: 'deepinfra', icon: 'deepinfra',
+    defaultUrl: 'https://api.deepinfra.com/v1/openai', api: 'openai-completions', group: 'Gateways',
+  },
+  {
+    id: 'siliconflow', name: 'SiliconFlow', slug: 'siliconflow', icon: 'siliconflow',
+    defaultUrl: 'https://api.siliconflow.com/v1', api: 'openai-completions', group: 'Gateways',
+  },
+  {
+    id: 'nvidia', name: 'NVIDIA NIM', slug: 'nvidia', icon: 'nvidia',
+    defaultUrl: 'https://integrate.api.nvidia.com/v1', api: 'openai-completions', group: 'Gateways',
+  },
+  {
+    id: 'novita', name: 'Novita AI', slug: 'novita', icon: 'novita',
+    defaultUrl: 'https://api.novita.ai/v3/openai', api: 'openai-completions', group: 'Gateways',
+  },
+  {
+    id: 'vercel-ai-gateway', name: 'Vercel AI Gateway', slug: 'vercel-ai-gateway', icon: 'vercel',
+    defaultUrl: 'https://ai-gateway.vercel.sh/v1', api: 'openai-completions', group: 'Gateways',
+  },
+  {
+    id: 'ollama', name: 'Ollama (Local)', slug: 'ollama', icon: 'ollama',
+    defaultUrl: 'http://127.0.0.1:11434', api: 'openai-responses',
+    auth: 'none', discovery: 'ollama', group: 'Local & self-hosted',
+  },
+  {
+    id: 'lm-studio', name: 'LM Studio (Local)', slug: 'lm-studio', icon: 'lmstudio',
+    defaultUrl: 'http://127.0.0.1:1234/v1', api: 'openai-completions',
+    auth: 'none', discovery: 'lm-studio', group: 'Local & self-hosted',
+  },
+  {
+    id: 'llama-cpp', name: 'llama.cpp (Local)', slug: 'llama.cpp', icon: 'llamacpp',
+    defaultUrl: 'http://127.0.0.1:8080', api: 'openai-responses',
+    auth: 'none', discovery: 'llama.cpp', group: 'Local & self-hosted',
+  },
+  {
+    id: 'vllm', name: 'vLLM (Local)', slug: 'vllm', icon: 'vllm',
+    defaultUrl: 'http://127.0.0.1:8000/v1', api: 'openai-completions',
+    auth: 'none', discovery: 'openai-models-list', group: 'Local & self-hosted',
+  },
+  {
+    id: 'litellm', name: 'LiteLLM Proxy', slug: 'litellm', icon: 'litellm',
+    defaultUrl: 'http://localhost:4000/v1', api: 'openai-completions',
+    discovery: 'litellm', group: 'Local & self-hosted',
+  },
+  {
+    id: 'azure', name: 'Azure OpenAI', slug: 'azure', icon: 'azure',
+    defaultUrl: 'https://YOUR-RESOURCE.openai.azure.com/openai/v1',
+    api: 'azure-openai-responses', bundled: true, group: 'Other dialects',
+  },
+  {
+    id: 'amazon-bedrock', name: 'Amazon Bedrock', slug: 'amazon-bedrock', icon: 'amazon',
+    defaultUrl: 'https://bedrock-runtime.us-east-1.amazonaws.com',
+    api: 'bedrock-converse-stream', bundled: true, group: 'Other dialects',
+  },
+  {
+    id: 'google-vertex', name: 'Google Vertex AI', slug: 'google-vertex', icon: 'vertexai',
+    defaultUrl: 'https://us-central1-aiplatform.googleapis.com/v1',
+    api: 'google-vertex', bundled: true, group: 'Other dialects',
+  },
+  {
+    id: 'openai-codex', name: 'OpenAI Codex', slug: 'openai-codex', icon: 'codex',
+    defaultUrl: 'https://chatgpt.com/backend-api/codex',
+    api: 'openai-codex-responses', bundled: true, group: 'Other dialects',
+  },
+  {
+    id: 'anthropic-custom', name: 'Anthropic-Compatible Proxy', slug: 'anthropic-custom', icon: 'claude',
+    defaultUrl: 'https://', api: 'anthropic-messages', group: 'Custom',
+  },
+  {
+    id: 'openai-custom', name: 'OpenAI-Compatible Gateway', slug: 'openai-custom', icon: 'openai',
+    defaultUrl: 'https://', api: 'openai-completions', group: 'Custom',
+  },
+  {
+    id: 'custom', name: 'Custom OpenAI-Compatible', slug: 'custom', icon: 'custom',
+    defaultUrl: 'https://', api: 'openai-completions', group: 'Custom',
+  },
 ];

package/src/client/hooks/editor/use-file-editor.ts

@@ -19,10 +19,6 @@ export interface FileEditorTarget {
 }
 
 export interface UseFileEditorOptions {
-  /** Content substituted when a read fails (desktop). Omit to report the failure (mobile). */
-  fallback?: (name: string) => string;
-  /** Surface read failures through `loadError` instead of silently substituting `fallback`. */
-  reportLoadError?: boolean;
   /** Flush a pending debounced write on unmount so closing the editor cannot drop an edit. */
   flushOnUnmount?: boolean;
   /** Mark a failed write as `'error'`; otherwise the status returns to `'idle'`. */
@@ -74,8 +70,6 @@ export function useFileEditor(
   options: UseFileEditorOptions = {},
 ): UseFileEditorResult {
   const {
-    fallback,
-    reportLoadError = false,
     flushOnUnmount = false,
     reportSaveError = false,
     downloadMimeType = 'text/plain',
@@ -184,11 +178,9 @@ export function useFileEditor(
     }
 
     if (!target.path) {
-      if (reportLoadError) {
-        setLoadError('No file path supplied for this attachment.');
-        return;
-      }
-      remember(fileKey, fallback ? fallback(target.name) : '');
+      // An attachment chip with no path has nothing to read and nothing to
+      // save; the message is the honest outcome.
+      setLoadError('No file path supplied for this attachment.');
       return;
     }
 
@@ -203,14 +195,11 @@ export function useFileEditor(
     if (target.repo && target.repo !== '.') params.set('repo', target.repo);
     fetch(`/api/fs/read?${params.toString()}`)
       .then(async (res) => {
-        const data = await res.json().catch(() => null);
-        if (reportLoadError) {
-          if (!res.ok || !data || typeof data.content !== 'string') {
-            throw new Error((data as { error?: string } | null)?.error || `HTTP ${res.status}`);
-          }
-          return data.content as string;
+        const data = (await res.json().catch(() => null)) as { content?: unknown; error?: string } | null;
+        if (!res.ok || !data || typeof data.content !== 'string') {
+          throw new Error(data?.error || `HTTP ${res.status}`);
         }
-        return typeof data?.content === 'string' ? (data.content as string) : null;
+        return data.content;
       })
       .then((text) => {
         if (cancelled) return;
@@ -222,18 +211,16 @@ export function useFileEditor(
         if (typed !== undefined && typed !== baselinesRef.current[fileKey]) return;
         const queued = pendingRef.current;
         if (queued && targetKey(queued.file) === fileKey) return;
-        remember(fileKey, text ?? (fallback ? fallback(target.name) : ''));
+        remember(fileKey, text);
       })
       .catch((err: unknown) => {
         if (cancelled) return;
         // A failed re-read keeps what is on screen; only a first load reports.
         if (!firstLoad) return;
-        if (reportLoadError) {
-          remember(fileKey, '');
-          setLoadError(err instanceof Error ? err.message : 'Failed to read file');
-        } else {
-          remember(fileKey, fallback ? fallback(target.name) : '');
-        }
+        // An empty buffer, never a substitute: the next save would write the
+        // substitute over the real file.
+        remember(fileKey, '');
+        setLoadError(err instanceof Error ? err.message : 'Failed to read file');
       })
       .finally(() => {
         if (!cancelled) setIsLoading(false);
@@ -242,7 +229,7 @@ export function useFileEditor(
     return () => {
       cancelled = true;
     };
-  }, [key, target, fallback, reportLoadError, remember, revision, isImage]);
+  }, [key, target, remember, revision, isImage]);
 
   useEffect(() => {
     if (saveStatus !== 'saved') return;
@@ -250,6 +237,13 @@ export function useFileEditor(
     return () => window.clearTimeout(timer);
   }, [saveStatus]);
 
+  // The save status describes the file that was written, so it must not outlive
+  // that tab: opening another file used to keep showing the previous file's
+  // "Save failed" (and its error icon) against a file that was never saved.
+  useEffect(() => {
+    setSaveStatus('idle');
+  }, [key]);
+
   const onChange = useCallback(
     (next: string) => {
       if (!target || isImage) return;
@@ -268,6 +262,9 @@ export function useFileEditor(
 
   const saveNow = useCallback(() => {
     if (!target || isImage) return;
+    // A file whose read failed has no trustworthy buffer: saving it would write
+    // the empty placeholder over the real file. The user must reopen it first.
+    if (loadError) return;
     const text = contents[targetKey(target)];
     if (text === undefined) return;
     if (pendingRef.current) {
@@ -275,7 +272,7 @@ export function useFileEditor(
       pendingRef.current = null;
     }
     void persistRef.current(target, text);
-  }, [target, contents, isImage]);
+  }, [target, contents, isImage, loadError]);
 
   const { copied, copy, download } = useFileTransfer({
     target,

package/src/client/hooks/models/use-provider-names.ts

@@ -1,5 +1,5 @@
 import type { ModelsResponse } from '@/shared/lib/models/client';
-import { providerNamesFromConnected } from '@/shared/lib/models/provider-label';
+import { providerNamesFromConnected } from '@/shared/lib/models/provider/label';
 import { useModelsCatalog } from '@/client/hooks/models/use-models-catalog';
 
 /** slug → display-name map from `connectedProviders` ({} when none connected). */

package/src/client/hooks/settings/providers/actions.ts

@@ -0,0 +1,337 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * The provider mutation actions behind Settings → Providers.
+ *
+ * Split from the hook (`providers.ts`) so that file holds state wiring only:
+ * every action here is a write whose failure has to be reported, and keeping
+ * them together means the "what does each mutation actually change" contract
+ * has one home. `deps` is a single record rather than a positional list, so a
+ * caller cannot silently pass the wrong setter.
+ */
+
+import type { ProviderItem, ProviderModel } from '@/shared/types';
+import { notifyModelsUpdated } from '@/shared/lib/models/client';
+import {
+  deleteProvider,
+  saveProviderOverlay,
+  setProviderEnabled,
+} from '@/shared/lib/models/provider/connection';
+import {
+  fetchProviderModelsRemote,
+  mergeProviderModels,
+  syncProviderModelsToCatalog,
+} from '@/shared/lib/models/provider/models';
+import { removeLegacyKenariModels } from '@/shared/lib/models/provider/cleanup';
+import { addProviderMessage, fetchModelsNote } from '@/client/hooks/settings/providers/messages';
+import { saveModelOverrideRemote } from '@/client/hooks/settings/providers/api';
+
+export interface ProviderActionsDeps {
+  providers: ProviderItem[];
+  selectedProvider: ProviderItem | undefined;
+  connectedProviders: ProviderItem[];
+  isFetchingModels: boolean;
+  isDeletingProvider: boolean;
+  pushToast: (message: string, tone: 'success' | 'error') => void;
+  setProviders: (providers: ProviderItem[]) => void;
+  setSelectedProviderId: (id: string) => void;
+  setIsAddModalOpen: (open: boolean) => void;
+  setIsDeleteModalOpen: (open: boolean) => void;
+  setIsDeletingProvider: (deleting: boolean) => void;
+  setIsFetchingModels: (fetching: boolean) => void;
+  onAddModalClose?: () => void;
+}
+
+export function createProviderActions(deps: ProviderActionsDeps) {
+  const {
+    providers,
+    selectedProvider,
+    connectedProviders,
+    isFetchingModels,
+    isDeletingProvider,
+    pushToast,
+    setProviders,
+    setSelectedProviderId,
+    setIsAddModalOpen,
+    setIsDeleteModalOpen,
+    setIsDeletingProvider,
+    setIsFetchingModels,
+    onAddModalClose,
+  } = deps;
+
+  /** Publish an overlay edit and adopt whatever the server merged back. */
+  const persistProviders = async (updated: ProviderItem[]) => {
+    setProviders(updated);
+    try {
+      const merged = await saveProviderOverlay(updated);
+      if (merged) setProviders(merged);
+    } catch (error) {
+      console.error('Failed to save providers via API:', error);
+      pushToast('Failed to save provider settings.', 'error');
+    }
+  };
+
+  const toggleProviderEnabled = async (
+    slug: string,
+    enabled: boolean,
+  ): Promise<ProviderItem[] | null> => {
+    try {
+      const merged = await setProviderEnabled(slug, enabled);
+      if (merged) setProviders(merged);
+      return merged;
+    } catch (error) {
+      console.error('Failed to update provider connection:', error);
+      pushToast('Failed to update the provider connection.', 'error');
+      return null;
+    }
+  };
+
+  const handleAddProvider = async (
+    newProvider: ProviderItem,
+    options: { fetchedCount: number; ompNote?: string },
+  ) => {
+    // Replace by slug rather than append: an endpoint override reuses the slug
+    // of a provider omp already ships, and two overlay rows for one slug would
+    // let the stale one win the next merge.
+    const slug = newProvider.slug.trim().toLowerCase();
+    const withoutExisting = providers.filter((p) => p.slug.trim().toLowerCase() !== slug);
+    await persistProviders([...withoutExisting, newProvider]);
+    const merged = await toggleProviderEnabled(newProvider.slug, true);
+    const registered = merged?.find((provider) => provider.slug.trim().toLowerCase() === slug);
+    setSelectedProviderId(registered?.id || newProvider.id);
+    setIsAddModalOpen(false);
+    onAddModalClose?.();
+
+    const message = addProviderMessage(newProvider, options);
+    pushToast(message.text, message.tone);
+  };
+
+  const handleReconnect = async (updates: Partial<ProviderItem>) => {
+    if (!selectedProvider) return;
+    const target = selectedProvider;
+    // A keyless provider stores no credential, so a masked placeholder echoed
+    // back from the dialog must never be persisted as one — it would show a key
+    // that authenticates nothing.
+    const patch: Partial<ProviderItem> = target.auth === 'none'
+      ? Object.fromEntries(Object.entries(updates).filter(([key]) => key !== 'apiKey'))
+      : updates;
+    await persistProviders(providers.map((p) => (
+      p.id === target.id ? { ...p, ...patch, status: 'connected' as const } : p
+    )));
+    if (target.status !== 'connected') {
+      await toggleProviderEnabled(target.slug, true);
+    }
+  };
+
+  const handleFetchModels = async (credentials: { apiKey?: string; baseUrl?: string }) => {
+    if (!selectedProvider || isFetchingModels) return;
+    const baseUrl = credentials.baseUrl || selectedProvider.baseUrl;
+    if (!baseUrl) {
+      pushToast('Base URL is required to fetch models.', 'error');
+      return;
+    }
+    setIsFetchingModels(true);
+    try {
+      const result = await fetchModelsFor(selectedProvider, baseUrl, credentials.apiKey);
+      if (!result) return;
+      if (result.omp?.written) notifyModelsUpdated();
+    } finally {
+      setIsFetchingModels(false);
+    }
+  };
+
+  /**
+   * The listing probe plus its reporting. Kept as one unit because the three
+   * outcomes — models added, legacy models pruned, nothing new — each have their
+   * own message, and a partial report reads as a failed fetch.
+   */
+  const fetchModelsFor = async (
+    provider: ProviderItem,
+    baseUrl: string,
+    credential: string | undefined,
+  ): Promise<{ omp?: { written: boolean; reason?: string } } | null> => {
+    const result = await fetchProviderModelsRemote({
+      baseUrl,
+      apiKey: credential || provider.apiKey,
+      providerSlug: provider.slug,
+      persistToOmp: true,
+      // The provider's own dialect decides the auth header the probe sends;
+      // falling back to the URL classifier would send a Bearer header to an
+      // Anthropic-shaped proxy that only accepts x-api-key.
+      ...(provider.api ? { api: provider.api } : {}),
+      ...(provider.auth ? { auth: provider.auth } : {}),
+    });
+    if (!result.ok || !result.models) {
+      pushToast(result.error || 'Failed to fetch models from the provider.', 'error');
+      return null;
+    }
+    const cleaned = removeLegacyKenariModels(provider, provider.models);
+    const removedCount = provider.models.length - cleaned.length;
+    const { merged, addedCount } = mergeProviderModels(cleaned, result.models);
+    if (addedCount > 0 || removedCount > 0) {
+      await handleReconnect({ models: merged });
+    }
+    if (addedCount > 0) {
+      pushToast(`Fetched ${addedCount} new model${addedCount === 1 ? '' : 's'} from the provider.`, 'success');
+    } else if (removedCount > 0) {
+      pushToast('Removed legacy fallback models from the provider.', 'success');
+    } else {
+      pushToast('No new models found — all fetched models already exist.', 'success');
+    }
+    const note = fetchModelsNote(result);
+    if (note) pushToast(note.text, note.tone);
+    if (addedCount > 0) void syncProviderModelsToCatalog(provider.name, result.models);
+    return { omp: result.omp };
+  };
+
+  const handleFetchModelsFromList = async () => {
+    if (!selectedProvider) return;
+    await handleFetchModels({
+      apiKey: selectedProvider.apiKey,
+      baseUrl: selectedProvider.baseUrl,
+    });
+  };
+
+  const handleOmpAuthSuccess = () => {
+    if (!selectedProvider) return;
+    const target = selectedProvider;
+    void persistProviders(providers.map((p) => (
+      p.id === target.id ? { ...p, status: 'connected' as const } : p
+    )));
+    void toggleProviderEnabled(target.slug, true);
+  };
+
+  const handleToggleDisconnect = async () => {
+    if (!selectedProvider) return;
+    const target = selectedProvider;
+    const disconnecting = target.status === 'connected';
+    if (disconnecting) {
+      setSelectedProviderId(connectedProviders.find((provider) => provider.id !== target.id)?.id || '');
+    }
+    const merged = await toggleProviderEnabled(target.slug, !disconnecting);
+    if (!merged) return;
+    pushToast(
+      disconnecting
+        ? `${target.name} disconnected — its models are no longer offered in the chat picker.`
+        : `${target.name} reconnected.`,
+      'success',
+    );
+  };
+
+  const updateSelectedModels = (transform: (models: ProviderModel[]) => ProviderModel[]) => {
+    if (!selectedProvider) return;
+    void persistProviders(providers.map((p) => (
+      p.id === selectedProvider.id ? { ...p, models: transform(p.models) } : p
+    )));
+  };
+
+  /**
+   * Disable/enable from omp's own config.yml `disabledProviders`. This is the
+   * coarse switch that removes the provider — and every model it serves — from
+   * the chat picker; the per-model eye toggle is the fine-grained one.
+   */
+  const handleToggleProviderDisabled = async () => {
+    if (!selectedProvider) return;
+    const target = selectedProvider;
+    const disabling = target.disabled !== true;
+    const merged = await toggleProviderEnabled(target.slug, !disabling);
+    if (!merged) return;
+    pushToast(
+      disabling
+        ? `${target.name} disabled — it no longer appears in the model list.`
+        : `${target.name} enabled — its models are offered again.`,
+      'success',
+    );
+  };
+
+  /**
+   * Delete a provider's `models.yml` entry (and the chamber's overlay row).
+   *
+   * Only offered for a provider the server reports as `inModelsYml`, because
+   * the action is a file edit: a login provider's credential is untouched, and
+   * a provider with no file entry has nothing to delete. The selection moves off
+   * the deleted provider BEFORE the list is republished — leaving it selected
+   * would render a detail pane for a provider that no longer exists.
+   */
+  const handleDeleteProvider = async () => {
+    if (!selectedProvider || isDeletingProvider) return;
+    const target = selectedProvider;
+    setIsDeletingProvider(true);
+    try {
+      const result = await deleteProvider(target.id);
+      if (!result.ok) {
+        pushToast(result.error || 'Failed to delete the provider.', 'error');
+        return;
+      }
+      setIsDeleteModalOpen(false);
+      const remaining = result.providers ?? [];
+      setSelectedProviderId(remaining.find((provider) => provider.status === 'connected')?.id || '');
+      setProviders(remaining);
+      // The overlay row is gone even when the file cleanup failed, so the
+      // warning is reported rather than presented as a clean delete.
+      if (result.warning) {
+        pushToast(`${target.name} removed from the chamber, but models.yml cleanup failed: ${result.warning}`, 'error');
+      } else if (result.removedFromOmp) {
+        const count = result.modelsRemoved ?? 0;
+        pushToast(
+          `${target.name} deleted from models.yml${count > 0 ? ` with its ${count} model${count === 1 ? '' : 's'}` : ''}.`,
+          'success',
+        );
+      } else {
+        pushToast(`${target.name} removed from the chamber list.`, 'success');
+      }
+    } finally {
+      setIsDeletingProvider(false);
+    }
+  };
+
+  const handleHideAll = () => updateSelectedModels(
+    (models) => models.map((m) => ({ ...m, isVisible: false })),
+  );
+
+  const handleShowAll = () => updateSelectedModels(
+    (models) => models.map((m) => ({ ...m, isVisible: true })),
+  );
+
+  const handleToggleModelVisibility = (modelId: string) => updateSelectedModels(
+    (models) => models.map((m) => (m.id === modelId ? { ...m, isVisible: !m.isVisible } : m)),
+  );
+
+  /**
+   * Save the per-model knobs omp honours (`models.yml` modelOverrides). The
+   * overlay still stores the display value so the dialog reopens where the user
+   * left it, but omp only reads the override — writing just the overlay was the
+   * bug that made these controls inert.
+   */
+  const handleSaveModelConfig = async (modelId: string, updates: Partial<ProviderModel>) => {
+    if (!selectedProvider) return;
+    const provider = selectedProvider;
+    updateSelectedModels((models) => models.map((m) => (m.id === modelId ? { ...m, ...updates } : m)));
+
+    const result = await saveModelOverrideRemote(provider.slug, modelId, updates);
+    if (!result.ok) {
+      pushToast(result.error || 'Failed to save the model configuration.', 'error');
+      return;
+    }
+    if (result.written) notifyModelsUpdated();
+    else if (result.reason) pushToast(result.reason, 'error');
+  };
+
+  return {
+    handleAddProvider,
+    handleReconnect,
+    handleFetchModels,
+    handleFetchModelsFromList,
+    handleOmpAuthSuccess,
+    handleToggleDisconnect,
+    handleToggleProviderDisabled,
+    handleDeleteProvider,
+    handleHideAll,
+    handleShowAll,
+    handleToggleModelVisibility,
+    handleSaveModelConfig,
+  };
+}