@nextclaw/ui 0.14.1-beta.0 → 0.14.1

package/src/features/settings/components/config/provider-status-badge.tsx

@@ -7,9 +7,9 @@ type ProviderStatusBadgeProps = {
   className?: string;
 };
 
-export function ProviderStatusBadge(props: ProviderStatusBadgeProps) {
-  if (!props.enabled) {
-    return <StatusDot status="inactive" label={t('disabled')} className={props.className} />;
+export function ProviderStatusBadge({ apiKeySet, className, enabled }: ProviderStatusBadgeProps) {
+  if (!enabled) {
+    return <StatusDot status="inactive" label={t('disabled')} className={className} />;
   }
-  return <StatusDot status={props.apiKeySet ? 'ready' : 'setup'} label={props.apiKeySet ? t('statusReady') : t('statusSetup')} className={props.className} />;
+  return <StatusDot status={apiKeySet ? 'ready' : 'setup'} label={apiKeySet ? t('statusReady') : t('statusSetup')} className={className} />;
 }

package/src/features/settings/components/config/secrets-config-form.tsx

@@ -7,114 +7,18 @@ import { Label } from '@/shared/components/ui/label';
 import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from '@/shared/components/ui/select';
 import { Switch } from '@/shared/components/ui/switch';
 import { PageHeader, PageLayout } from '@/app/components/layout/page-layout';
-import type { SecretProviderView, SecretRefView, SecretSourceView, SecretsView } from '@/shared/lib/api';
+import type { SecretSourceView } from '@/shared/lib/api';
 import { t } from '@/shared/lib/i18n';
 import { toast } from 'sonner';
-
-type ProviderRow = {
-  alias: string;
-  source: SecretSourceView;
-  prefix: string;
-  path: string;
-  command: string;
-  argsText: string;
-  cwd: string;
-  timeoutMs: number;
-};
-
-type RefRow = {
-  path: string;
-  source: SecretSourceView;
-  provider: string;
-  id: string;
-};
-
-export type SecretsFormState = {
-  enabled: boolean;
-  defaultEnv: string;
-  defaultFile: string;
-  defaultExec: string;
-  providers: ProviderRow[];
-  refs: RefRow[];
-};
-
-const SOURCE_OPTIONS: SecretSourceView[] = ['env', 'file', 'exec'];
-
-function createProviderRow(alias = ''): ProviderRow {
-  return { alias, source: 'env', prefix: '', path: '', command: '', argsText: '', cwd: '', timeoutMs: 5000 };
-}
-
-function createRefRow(): RefRow {
-  return { path: '', source: 'env', provider: '', id: '' };
-}
-
-function providerToRow(alias: string, provider: SecretProviderView): ProviderRow {
-  if (provider.source === 'env') return { ...createProviderRow(alias), source: 'env', prefix: provider.prefix ?? '' };
-  if (provider.source === 'file') return { ...createProviderRow(alias), source: 'file', path: provider.path };
-  return {
-    ...createProviderRow(alias),
-    source: 'exec',
-    command: provider.command,
-    argsText: (provider.args ?? []).join('\n'),
-    cwd: provider.cwd ?? '',
-    timeoutMs: provider.timeoutMs ?? 5000,
-  };
-}
-
-function rowToProvider(row: ProviderRow): SecretProviderView {
-  if (row.source === 'env') return { source: 'env', ...(row.prefix.trim() ? { prefix: row.prefix.trim() } : {}) };
-  if (row.source === 'file') return { source: 'file', path: row.path.trim(), format: 'json' };
-  return {
-    source: 'exec',
-    command: row.command.trim(),
-    args: row.argsText.split('\n').map((item) => item.trim()).filter(Boolean),
-    ...(row.cwd.trim() ? { cwd: row.cwd.trim() } : {}),
-    timeoutMs: Math.max(1, Math.trunc(row.timeoutMs || 5000)),
-  };
-}
-
-export function buildSecretsFormState(secrets?: SecretsView): SecretsFormState {
-  if (!secrets) {
-    return { enabled: true, defaultEnv: '', defaultFile: '', defaultExec: '', providers: [], refs: [] };
-  }
-  return {
-    enabled: Boolean(secrets.enabled),
-    defaultEnv: secrets.defaults.env ?? '',
-    defaultFile: secrets.defaults.file ?? '',
-    defaultExec: secrets.defaults.exec ?? '',
-    providers: Object.entries(secrets.providers).map(([alias, provider]) => providerToRow(alias, provider)),
-    refs: Object.entries(secrets.refs).map(([path, ref]) => ({
-      path,
-      source: ref.source,
-      provider: ref.provider ?? '',
-      id: ref.id,
-    })),
-  };
-}
-
-export function buildSecretsSubmitPayload(state: SecretsFormState) {
-  return {
-    enabled: state.enabled,
-    defaults: {
-      env: state.defaultEnv || null,
-      file: state.defaultFile || null,
-      exec: state.defaultExec || null,
-    },
-    providers: Object.fromEntries(
-      state.providers.map((row) => [row.alias.trim(), rowToProvider(row)]).filter(([alias]) => alias),
-    ),
-    refs: Object.fromEntries(
-      state.refs.map((row) => [
-        row.path.trim(),
-        {
-          source: row.source,
-          ...(row.provider.trim() ? { provider: row.provider.trim() } : {}),
-          id: row.id.trim(),
-        },
-      ]).filter(([path, ref]) => path && (ref as SecretRefView).id),
-    ),
-  };
-}
+import {
+  SOURCE_OPTIONS,
+  createProviderRow,
+  createRefRow,
+  prepareSecretsFormSubmitState,
+  type ProviderRow,
+  type RefRow,
+  type SecretsFormState,
+} from '@/features/settings/utils/secrets-config-form.utils';
 
 function SecretsDefaultsCard(props: {
   defaultEnv: string;
@@ -324,35 +228,7 @@ export function SecretsConfigForm(props: {
 
   const handleSave = () => {
     try {
-      const providerMap: Record<string, SecretProviderView> = {};
-      for (const [index, row] of state.providers.entries()) {
-        const alias = row.alias.trim();
-        if (!alias) throw new Error(`${t('providerAlias')} #${index + 1} ${t('isRequired')}`);
-        if (providerMap[alias]) throw new Error(`${t('providerAlias')}: ${alias} (${t('duplicate')})`);
-        if (row.source === 'file' && !row.path.trim()) throw new Error(`${t('secretFilePath')} #${index + 1} ${t('isRequired')}`);
-        if (row.source === 'exec' && !row.command.trim()) throw new Error(`${t('secretExecCommand')} #${index + 1} ${t('isRequired')}`);
-        providerMap[alias] = rowToProvider(row);
-      }
-
-      const refMap: Record<string, SecretRefView> = {};
-      for (const [index, row] of state.refs.entries()) {
-        const path = row.path.trim();
-        const id = row.id.trim();
-        if (!path) throw new Error(`${t('secretConfigPath')} #${index + 1} ${t('isRequired')}`);
-        if (!id) throw new Error(`${t('secretId')} #${index + 1} ${t('isRequired')}`);
-        const provider = row.provider.trim();
-        if (provider && !providerMap[provider]) throw new Error(`${t('secretProviderAlias')}: ${provider} ${t('notFound')}`);
-        refMap[path] = { source: row.source, ...(provider ? { provider } : {}), id };
-      }
-
-      onSubmit({
-        enabled: state.enabled,
-        defaultEnv: state.defaultEnv.trim(),
-        defaultFile: state.defaultFile.trim(),
-        defaultExec: state.defaultExec.trim(),
-        providers: Object.entries(providerMap).map(([alias, provider]) => providerToRow(alias, provider)),
-        refs: Object.entries(refMap).map(([path, ref]) => ({ path, source: ref.source, provider: ref.provider ?? '', id: ref.id })),
-      });
+      onSubmit(prepareSecretsFormSubmitState(state));
     } catch (error) {
       toast.error(error instanceof Error ? error.message : String(error));
     }

package/src/features/settings/hooks/use-provider-auth-flow.ts

@@ -0,0 +1,140 @@
+import { useCallback, useEffect, useRef, useState } from 'react';
+import { useQueryClient } from '@tanstack/react-query';
+import { toast } from 'sonner';
+import type { ProviderTemplateView } from '@/shared/lib/api';
+import {
+  useImportProviderAuthFromCli,
+  usePollProviderAuth,
+  useStartProviderAuth
+} from '@/shared/hooks/use-config';
+import { hostCapabilityManager } from '@/shared/lib/host-capabilities';
+import { t } from '@/shared/lib/i18n';
+
+type UseProviderAuthFlowParams = {
+  providerName?: string;
+  providerAuth?: ProviderTemplateView['auth'];
+  resolvedAuthMethodId: string;
+};
+
+export function useProviderAuthFlow(params: UseProviderAuthFlowParams) {
+  const { providerName, providerAuth, resolvedAuthMethodId } = params;
+  const queryClient = useQueryClient();
+  const startProviderAuth = useStartProviderAuth();
+  const pollProviderAuth = usePollProviderAuth();
+  const importProviderAuthFromCli = useImportProviderAuthFromCli();
+  const [authProviderName, setAuthProviderName] = useState('');
+  const [authSessionId, setAuthSessionId] = useState<string | null>(null);
+  const [authStatusMessage, setAuthStatusMessage] = useState('');
+  const authPollTimerRef = useRef<number | null>(null);
+
+  const clearAuthPollTimer = useCallback(() => {
+    if (authPollTimerRef.current !== null) {
+      window.clearTimeout(authPollTimerRef.current);
+      authPollTimerRef.current = null;
+    }
+  }, []);
+
+  const scheduleProviderAuthPoll = useCallback(
+    (sessionId: string, delayMs: number) => {
+      clearAuthPollTimer();
+      authPollTimerRef.current = window.setTimeout(() => {
+        void (async () => {
+          if (!providerName) {
+            return;
+          }
+          try {
+            const result = await pollProviderAuth.mutateAsync({ provider: providerName, data: { sessionId } });
+            if (result.status === 'pending') {
+              setAuthStatusMessage(t('providerAuthWaitingBrowser'));
+              scheduleProviderAuthPoll(sessionId, result.nextPollMs ?? delayMs);
+              return;
+            }
+            if (result.status === 'authorized') {
+              setAuthSessionId(null);
+              clearAuthPollTimer();
+              setAuthStatusMessage(t('providerAuthCompleted'));
+              toast.success(t('providerAuthCompleted'));
+              queryClient.invalidateQueries({ queryKey: ['config'] });
+              queryClient.invalidateQueries({ queryKey: ['providers'] });
+              return;
+            }
+            setAuthSessionId(null);
+            clearAuthPollTimer();
+            setAuthStatusMessage(result.message || `Authorization ${result.status}.`);
+            toast.error(result.message || `Authorization ${result.status}.`);
+          } catch (error) {
+            setAuthSessionId(null);
+            clearAuthPollTimer();
+            const message = error instanceof Error ? error.message : String(error);
+            setAuthStatusMessage(message);
+            toast.error(`Authorization failed: ${message}`);
+          }
+        })();
+      }, Math.max(1000, delayMs));
+    },
+    [clearAuthPollTimer, pollProviderAuth, providerName, queryClient]
+  );
+
+  const startAuth = useCallback(async () => {
+    if (!providerName || providerAuth?.kind !== 'device_code') {
+      return;
+    }
+
+    try {
+      setAuthProviderName(providerName);
+      setAuthStatusMessage('');
+      const result = await startProviderAuth.mutateAsync({
+        provider: providerName,
+        data: resolvedAuthMethodId ? { methodId: resolvedAuthMethodId } : {}
+      });
+      if (!result.sessionId || !result.verificationUri) {
+        throw new Error(t('providerAuthStartFailed'));
+      }
+      setAuthSessionId(result.sessionId);
+      setAuthStatusMessage(`${t('providerAuthOpenPrompt')}${result.userCode}${t('providerAuthOpenPromptSuffix')}`);
+      await hostCapabilityManager.openExternalUrl(result.verificationUri);
+      scheduleProviderAuthPoll(result.sessionId, result.intervalMs);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      setAuthSessionId(null);
+      clearAuthPollTimer();
+      setAuthStatusMessage(message);
+      toast.error(`${t('providerAuthStartFailed')}: ${message}`);
+    }
+  }, [clearAuthPollTimer, providerAuth?.kind, providerName, resolvedAuthMethodId, scheduleProviderAuthPoll, startProviderAuth]);
+
+  const importAuthFromCli = useCallback(async () => {
+    if (!providerName || providerAuth?.kind !== 'device_code') {
+      return;
+    }
+    try {
+      setAuthProviderName(providerName);
+      clearAuthPollTimer();
+      setAuthSessionId(null);
+      const result = await importProviderAuthFromCli.mutateAsync({ provider: providerName });
+      setAuthStatusMessage(`${t('providerAuthImportStatusPrefix')}${result.expiresAt ? ` (expires: ${result.expiresAt})` : ''}`);
+      toast.success(t('providerAuthImportSuccess'));
+      queryClient.invalidateQueries({ queryKey: ['config'] });
+      queryClient.invalidateQueries({ queryKey: ['providers'] });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      setAuthStatusMessage(message);
+      toast.error(`${t('providerAuthImportFailed')}: ${message}`);
+    }
+  }, [clearAuthPollTimer, importProviderAuthFromCli, providerAuth?.kind, providerName, queryClient]);
+
+  useEffect(() => {
+    clearAuthPollTimer();
+  }, [clearAuthPollTimer, providerName]);
+
+  useEffect(() => () => clearAuthPollTimer(), [clearAuthPollTimer]);
+
+  return {
+    authSessionId: authProviderName === providerName ? authSessionId : null,
+    authStatusMessage: authProviderName === providerName ? authStatusMessage : '',
+    importAuthFromCli,
+    importPending: importProviderAuthFromCli.isPending,
+    startAuth,
+    startPending: startProviderAuth.isPending
+  };
+}

package/src/features/settings/pages/__tests__/model-config-page.test.tsx

@@ -3,6 +3,7 @@ import userEvent from '@testing-library/user-event';
 import { useState } from 'react';
 import { ProviderScopedModelInput } from '@/shared/components/common/provider-scoped-model-input';
 import { ModelConfigPage } from '@/features/settings/pages/model-config-page';
+import { createPopoverAvailableHeightLimit } from '@/shared/components/ui/popover';
 import { setLanguage } from '@/shared/lib/i18n';
 
 const mocks = vi.hoisted(() => ({
@@ -279,4 +280,19 @@ describe('ModelConfigPage', () => {
     expect(providerTrigger.textContent).toContain('CustomHub');
     expect(screen.getByDisplayValue('reasoner-v1')).toBeTruthy();
   });
+
+  it('uses the shared popover height contract for searchable model options', async () => {
+    const user = userEvent.setup();
+
+    render(<ModelConfigPage />);
+
+    await user.click(screen.getByRole('button', { name: 'Toggle model options' }));
+
+    const option = await screen.findByText('gpt-5.2');
+    const panel = option.closest('[data-state="open"]') as HTMLElement | null;
+    expect(panel?.style.maxHeight).toBe(createPopoverAvailableHeightLimit('15rem'));
+    expect(panel?.style.maxHeight).toContain('max(0px');
+    expect(panel?.style.maxHeight).toContain('100vh');
+    expect(panel?.className).toContain('overflow-hidden');
+  });
 });

package/src/features/settings/pages/secrets-config-page.tsx

@@ -1,6 +1,7 @@
 import { useConfig, useUpdateSecrets } from '@/shared/hooks/use-config';
 import { t } from '@/shared/lib/i18n';
-import { buildSecretsFormState, buildSecretsSubmitPayload, SecretsConfigForm } from '@/features/settings/components/config/secrets-config-form';
+import { SecretsConfigForm } from '@/features/settings/components/config/secrets-config-form';
+import { buildSecretsFormState, buildSecretsSubmitPayload } from '@/features/settings/utils/secrets-config-form.utils';
 
 export function SecretsConfigPage() {
   const { data: config, isLoading } = useConfig();

package/src/features/settings/utils/__tests__/provider-form-support.utils.test.ts

@@ -1,5 +1,14 @@
 import { describe, expect, it } from 'vitest';
-import { resolveEditableModels, serializeModelsForSave } from '../provider-form-support.utils';
+import {
+  buildProviderSavePayload,
+  resolveEditableModels,
+  serializeModelsForSave
+} from '@/features/settings/utils/provider-form-support.utils';
+import {
+  addProviderLocalModel,
+  setModelThinkingDefaultInConfig,
+  toggleModelThinkingLevelInConfig
+} from '@/features/settings/utils/provider-form-model.utils';
 
 describe('provider form model defaults', () => {
   it('keeps persisted empty models empty', () => {
@@ -18,4 +27,54 @@ describe('provider form model defaults', () => {
       'openai-work/gpt-5.4'
     ]);
   });
+
+  it('builds a minimal save payload from changed provider fields', () => {
+    expect(buildProviderSavePayload({
+      providerName: 'openai-work',
+      apiKey: ' sk-test ',
+      apiBase: 'https://api.openai.com/v1',
+      currentApiBase: 'https://old.example.com',
+      defaultApiBase: 'https://api.openai.com/v1',
+      extraHeaders: { ' X-Team ': 'nextclaw' },
+      currentHeaders: null,
+      supportsWireApi: true,
+      wireApi: 'responses',
+      currentWireApi: 'auto',
+      models: ['gpt-5.5'],
+      currentEditableModels: [],
+      modelConfig: { 'gpt-5.5': { thinking: { supported: ['high'], default: 'high' } } },
+      currentModelConfig: {},
+      providerDisplayName: ' OpenAI Work ',
+      effectiveDisplayName: 'OpenAI'
+    })).toEqual({
+      apiKey: 'sk-test',
+      apiBase: null,
+      displayName: 'OpenAI Work',
+      extraHeaders: { 'X-Team': 'nextclaw' },
+      wireApi: 'responses',
+      models: ['openai-work/gpt-5.5'],
+      modelConfig: { 'gpt-5.5': { thinking: { supported: ['high'], default: 'high' } } }
+    });
+  });
+
+  it('adds local model drafts without accepting provider prefixes', () => {
+    expect(addProviderLocalModel([], ' gpt-5.5 ', ['openai-work'])).toEqual({
+      models: ['gpt-5.5'],
+      draft: ''
+    });
+    expect(addProviderLocalModel([], ' other/gpt-5.5 ', ['openai-work'])).toEqual({
+      models: [],
+      draft: ' other/gpt-5.5 ',
+      errorKey: 'providerModelInvalidProviderPrefix'
+    });
+  });
+
+  it('keeps model thinking defaults inside the supported level set', () => {
+    const config = toggleModelThinkingLevelInConfig({}, 'gpt-5.5', 'high');
+
+    expect(setModelThinkingDefaultInConfig(config, 'gpt-5.5', 'high')).toEqual({
+      'gpt-5.5': { thinking: { supported: ['high'], default: 'high' } }
+    });
+    expect(setModelThinkingDefaultInConfig(config, 'gpt-5.5', 'low')).toBe(config);
+  });
 });

package/src/features/settings/utils/__tests__/secrets-config-form.utils.test.ts

@@ -0,0 +1,66 @@
+import { describe, expect, it } from 'vitest';
+import {
+  buildSecretsFormState,
+  buildSecretsSubmitPayload,
+  createProviderRow,
+  createRefRow,
+  prepareSecretsFormSubmitState,
+  type SecretsFormState,
+} from '@/features/settings/utils/secrets-config-form.utils';
+
+function createState(patch: Partial<SecretsFormState> = {}): SecretsFormState {
+  return {
+    enabled: true,
+    defaultEnv: '',
+    defaultFile: '',
+    defaultExec: '',
+    providers: [],
+    refs: [],
+    ...patch,
+  };
+}
+
+describe('secrets config form utils', () => {
+  it('round-trips loaded secrets config into a submit payload', () => {
+    const state = buildSecretsFormState({
+      enabled: true,
+      defaults: { env: 'vault-env', file: 'vault-file' },
+      providers: {
+        'vault-env': { source: 'env', prefix: 'NEXTCLAW_' },
+        'vault-file': { source: 'file', path: '/tmp/secrets.json', format: 'json' },
+      },
+      refs: {
+        'agents.defaults.model': { source: 'env', provider: 'vault-env', id: 'DEFAULT_MODEL' },
+      },
+    });
+
+    expect(buildSecretsSubmitPayload(prepareSecretsFormSubmitState(state))).toEqual({
+      enabled: true,
+      defaults: { env: 'vault-env', file: 'vault-file', exec: null },
+      providers: {
+        'vault-env': { source: 'env', prefix: 'NEXTCLAW_' },
+        'vault-file': { source: 'file', path: '/tmp/secrets.json', format: 'json' },
+      },
+      refs: {
+        'agents.defaults.model': { source: 'env', provider: 'vault-env', id: 'DEFAULT_MODEL' },
+      },
+    });
+  });
+
+  it('rejects duplicate provider aliases before submit', () => {
+    const state = createState({
+      providers: [createProviderRow('vault'), createProviderRow(' vault ')],
+    });
+
+    expect(() => prepareSecretsFormSubmitState(state)).toThrow('vault');
+  });
+
+  it('rejects refs that point at an unknown provider', () => {
+    const state = createState({
+      providers: [createProviderRow('vault-env')],
+      refs: [{ ...createRefRow(), path: 'agents.defaults.model', id: 'DEFAULT_MODEL', provider: 'missing' }],
+    });
+
+    expect(() => prepareSecretsFormSubmitState(state)).toThrow('missing');
+  });
+});

package/src/features/settings/utils/provider-form-context.utils.ts

@@ -0,0 +1,131 @@
+import { hintForPath } from '@/shared/lib/config-hints';
+import { t } from '@/shared/lib/i18n';
+import type { getLanguage } from '@/shared/lib/i18n';
+import type {
+  ConfigSchemaResponse,
+  ProviderTemplateView,
+  ProviderTemplatesView,
+  ProvidersView
+} from '@/shared/lib/api';
+import {
+  EMPTY_PROVIDER_CONFIG,
+  mergeModelConfig,
+  normalizeHeaders,
+  normalizeModelConfigForModels,
+  normalizeModelList,
+  resolveEditableModels,
+  resolvePreferredAuthMethodId,
+  shouldUsePillSelector,
+  toProviderLocalModelId,
+  type WireApiType
+} from './provider-form-support.utils';
+
+type ProviderFormContextInput = {
+  providerName?: string;
+  providersView?: ProvidersView;
+  templatesView?: ProviderTemplatesView;
+  schema?: ConfigSchemaResponse;
+  language: ReturnType<typeof getLanguage>;
+};
+type ProviderFormAuthContextInput = {
+  providerName?: string;
+  providerSpec?: ProviderTemplateView;
+  language: ReturnType<typeof getLanguage>;
+};
+
+function resolveProviderFormAuthContext(input: ProviderFormAuthContextInput) {
+  const { providerName, providerSpec, language } = input;
+  const providerAuth = providerSpec?.auth;
+  const providerAuthMethods = providerAuth?.methods ?? [];
+  const providerAuthMethodOptions = providerAuthMethods.map((method) => ({
+    value: method.id,
+    label: method.label?.[language] || method.label?.en || method.id
+  }));
+  const preferredAuthMethodId = resolvePreferredAuthMethodId({
+    providerName: providerSpec?.providerType ?? providerName,
+    methods: providerAuthMethods,
+    defaultMethodId: providerAuth?.defaultMethodId,
+    language
+  });
+  const shouldUseAuthMethodPills = shouldUsePillSelector({
+    required: providerAuth?.kind === 'device_code',
+    hasDefault: Boolean(providerAuth?.defaultMethodId?.trim()),
+    optionCount: providerAuthMethods.length
+  });
+
+  return { providerAuth, providerAuthMethodOptions, providerAuthMethods, preferredAuthMethodId, shouldUseAuthMethodPills };
+}
+
+function resolveProviderWireApiContext(providerSpec: ProviderTemplateView | undefined, isCustomProvider: boolean) {
+  const supportsWireApi = Boolean(providerSpec?.supportsWireApi) || isCustomProvider;
+  const wireApiSelectOptions = (providerSpec?.wireApiOptions || ['auto', 'chat', 'responses']).map((option) => ({
+    value: option,
+    label: option === 'chat' ? t('wireApiChat') : option === 'responses' ? t('wireApiResponses') : t('wireApiAuto')
+  }));
+  const shouldUseWireApiPills = shouldUsePillSelector({
+    required: supportsWireApi,
+    hasDefault: typeof providerSpec?.defaultWireApi === 'string' && providerSpec.defaultWireApi.length > 0,
+    optionCount: wireApiSelectOptions.length
+  });
+
+  return { shouldUseWireApiPills, supportsWireApi, wireApiSelectOptions };
+}
+
+export function resolveProviderFormContext(input: ProviderFormContextInput) {
+  const { providerName, providersView, templatesView, schema, language } = input;
+  const providerConfig = providerName ? providersView?.providers[providerName] : null;
+  const providerSpec = templatesView?.providerTemplates.find((template) => template.providerType === providerConfig?.providerType);
+  const resolvedProviderConfig = providerConfig ?? EMPTY_PROVIDER_CONFIG;
+  const uiHints = schema?.uiHints;
+  const isCustomProvider = Boolean(providerConfig?.isCustom);
+  const apiKeyHint = providerName ? hintForPath(`providers.${providerName}.apiKey`, uiHints) : undefined;
+  const apiBaseHint = providerName ? hintForPath(`providers.${providerName}.apiBase`, uiHints) : undefined;
+  const extraHeadersHint = providerName ? hintForPath(`providers.${providerName}.extraHeaders`, uiHints) : undefined;
+  const wireApiHint = providerName ? hintForPath(`providers.${providerName}.wireApi`, uiHints) : undefined;
+  const defaultDisplayName = providerSpec?.displayName || providerConfig?.displayName || providerName || '';
+  const currentDisplayName = (resolvedProviderConfig.displayName || '').trim();
+  const effectiveDisplayName = currentDisplayName || defaultDisplayName;
+  const currentEnabled = resolvedProviderConfig.enabled !== false;
+  const providerModelAliases = normalizeModelList([providerSpec?.modelPrefix || providerSpec?.providerType || '', providerName || '']);
+  const defaultApiBase = providerSpec?.defaultApiBase || '';
+  const currentApiBase = resolvedProviderConfig.apiBase || defaultApiBase;
+  const currentHeaders = normalizeHeaders(resolvedProviderConfig.extraHeaders || null);
+  const currentWireApi = (resolvedProviderConfig.wireApi || providerSpec?.defaultWireApi || 'auto') as WireApiType;
+  const defaultModels = normalizeModelList(
+    (providerSpec?.defaultModels ?? []).map((model) => toProviderLocalModelId(model, providerModelAliases))
+  );
+  const currentModels = normalizeModelList(
+    (resolvedProviderConfig.models ?? []).map((model) => toProviderLocalModelId(model, providerModelAliases))
+  );
+  const currentEditableModels = resolveEditableModels(defaultModels, currentModels);
+  const currentModelConfig = normalizeModelConfigForModels(
+    mergeModelConfig(providerSpec?.modelConfig, resolvedProviderConfig.modelConfig, providerModelAliases),
+    currentEditableModels
+  );
+  const apiBaseHelpText =
+    providerSpec?.apiBaseHelp?.[language] || providerSpec?.apiBaseHelp?.en || apiBaseHint?.help || t('providerApiBaseHelp');
+  const authContext = resolveProviderFormAuthContext({ providerName, providerSpec, language });
+  const wireApiContext = resolveProviderWireApiContext(providerSpec, isCustomProvider);
+
+  return {
+    apiBaseHelpText,
+    apiBaseHint,
+    apiKeyHint,
+    currentApiBase,
+    currentEditableModels,
+    currentEnabled,
+    currentHeaders,
+    currentModelConfig,
+    currentWireApi,
+    defaultApiBase,
+    defaultDisplayName,
+    effectiveDisplayName,
+    extraHeadersHint,
+    ...authContext,
+    providerConfig,
+    providerModelAliases,
+    resolvedProviderConfig,
+    wireApiHint,
+    ...wireApiContext
+  };
+}