@nextclaw/ui 0.6.12 → 0.6.13

package/src/components/config/ProviderForm.tsx

@@ -15,17 +15,19 @@ import { Button } from '@/components/ui/button';
 import { Input } from '@/components/ui/input';
 import { Label } from '@/components/ui/label';
 import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from '@/components/ui/select';
+import { Popover, PopoverContent, PopoverTrigger } from '@/components/ui/popover';
 import { MaskedInput } from '@/components/common/MaskedInput';
 import { KeyValueEditor } from '@/components/common/KeyValueEditor';
 import { StatusDot } from '@/components/ui/status-dot';
 import { getLanguage, t } from '@/lib/i18n';
 import { hintForPath } from '@/lib/config-hints';
-import type { ProviderConfigView, ProviderConfigUpdate, ProviderConnectionTestRequest } from '@/api/types';
+import type { ProviderConfigView, ProviderConfigUpdate, ProviderConnectionTestRequest, ThinkingLevel } from '@/api/types';
 import { CircleDotDashed, Plus, X, Trash2, ChevronDown, Settings2 } from 'lucide-react';
 import { toast } from 'sonner';
 import { CONFIG_DETAIL_CARD_CLASS, CONFIG_EMPTY_DETAIL_CARD_CLASS } from './config-layout';
 
 type WireApiType = 'auto' | 'chat' | 'responses';
+type ModelThinkingConfig = Record<string, { supported: ThinkingLevel[]; default?: ThinkingLevel | null }>;
 
 type ProviderFormProps = {
   providerName?: string;
@@ -48,8 +50,11 @@ const EMPTY_PROVIDER_CONFIG: ProviderConfigView = {
   apiBase: null,
   extraHeaders: null,
   wireApi: null,
-  models: []
+  models: [],
+  modelThinking: {}
 };
+const THINKING_LEVELS: ThinkingLevel[] = ['off', 'minimal', 'low', 'medium', 'high', 'adaptive', 'xhigh'];
+const THINKING_LEVEL_SET = new Set<string>(THINKING_LEVELS);
 
 function normalizeHeaders(input: Record<string, string> | null | undefined): Record<string, string> | null {
   if (!input) {
@@ -160,6 +165,128 @@ function serializeModelsForSave(models: string[], defaultModels: string[]): stri
   return models;
 }
 
+function parseThinkingLevel(value: unknown): ThinkingLevel | null {
+  if (typeof value !== 'string') {
+    return null;
+  }
+  const normalized = value.trim().toLowerCase();
+  if (!normalized) {
+    return null;
+  }
+  return THINKING_LEVEL_SET.has(normalized) ? (normalized as ThinkingLevel) : null;
+}
+
+function normalizeThinkingLevels(values: unknown): ThinkingLevel[] {
+  if (!Array.isArray(values)) {
+    return [];
+  }
+  const deduped: ThinkingLevel[] = [];
+  for (const value of values) {
+    const level = parseThinkingLevel(value);
+    if (!level || deduped.includes(level)) {
+      continue;
+    }
+    deduped.push(level);
+  }
+  return deduped;
+}
+
+function normalizeModelThinkingConfig(
+  input: ProviderConfigView['modelThinking'],
+  aliases: string[]
+): ModelThinkingConfig {
+  if (!input) {
+    return {};
+  }
+  const normalized: ModelThinkingConfig = {};
+  for (const [rawModel, rawValue] of Object.entries(input)) {
+    const model = toProviderLocalModelId(rawModel, aliases);
+    if (!model) {
+      continue;
+    }
+    const supported = normalizeThinkingLevels(rawValue?.supported);
+    if (supported.length === 0) {
+      continue;
+    }
+    const defaultLevel = parseThinkingLevel(rawValue?.default);
+    normalized[model] =
+      defaultLevel && supported.includes(defaultLevel)
+        ? { supported, default: defaultLevel }
+        : { supported };
+  }
+  return normalized;
+}
+
+function normalizeModelThinkingForModels(modelThinking: ModelThinkingConfig, models: string[]): ModelThinkingConfig {
+  const modelSet = new Set(models.map((item) => item.trim()).filter(Boolean));
+  const normalized: ModelThinkingConfig = {};
+  for (const [model, entry] of Object.entries(modelThinking)) {
+    if (!modelSet.has(model)) {
+      continue;
+    }
+    const supported = normalizeThinkingLevels(entry.supported);
+    if (supported.length === 0) {
+      continue;
+    }
+    const defaultLevel = parseThinkingLevel(entry.default);
+    normalized[model] =
+      defaultLevel && supported.includes(defaultLevel)
+        ? { supported, default: defaultLevel }
+        : { supported };
+  }
+  return normalized;
+}
+
+function modelThinkingEqual(left: ModelThinkingConfig, right: ModelThinkingConfig): boolean {
+  const leftKeys = Object.keys(left).sort();
+  const rightKeys = Object.keys(right).sort();
+  if (leftKeys.length !== rightKeys.length) {
+    return false;
+  }
+  for (let index = 0; index < leftKeys.length; index += 1) {
+    const key = leftKeys[index];
+    if (key !== rightKeys[index]) {
+      return false;
+    }
+    const leftEntry = left[key];
+    const rightEntry = right[key];
+    if (!leftEntry || !rightEntry) {
+      return false;
+    }
+    const leftSupported = [...leftEntry.supported].sort();
+    const rightSupported = [...rightEntry.supported].sort();
+    if (!modelListsEqual(leftSupported, rightSupported)) {
+      return false;
+    }
+    if ((leftEntry.default ?? null) !== (rightEntry.default ?? null)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+function formatThinkingLevelLabel(level: ThinkingLevel): string {
+  if (level === 'off') {
+    return t('chatThinkingLevelOff');
+  }
+  if (level === 'minimal') {
+    return t('chatThinkingLevelMinimal');
+  }
+  if (level === 'low') {
+    return t('chatThinkingLevelLow');
+  }
+  if (level === 'medium') {
+    return t('chatThinkingLevelMedium');
+  }
+  if (level === 'high') {
+    return t('chatThinkingLevelHigh');
+  }
+  if (level === 'adaptive') {
+    return t('chatThinkingLevelAdaptive');
+  }
+  return t('chatThinkingLevelXhigh');
+}
+
 function resolvePreferredAuthMethodId(params: {
   providerName?: string;
   methods: ProviderAuthMethodOption[];
@@ -272,6 +399,7 @@ export function ProviderForm({ providerName, onProviderDeleted }: ProviderFormPr
   const [extraHeaders, setExtraHeaders] = useState<Record<string, string> | null>(null);
   const [wireApi, setWireApi] = useState<WireApiType>('auto');
   const [models, setModels] = useState<string[]>([]);
+  const [modelThinking, setModelThinking] = useState<ModelThinkingConfig>({});
   const [modelDraft, setModelDraft] = useState('');
   const [providerDisplayName, setProviderDisplayName] = useState('');
   const [showAdvanced, setShowAdvanced] = useState(false);
@@ -323,6 +451,14 @@ export function ProviderForm({ providerName, onProviderDeleted }: ProviderFormPr
     () => resolveEditableModels(defaultModels, currentModels),
     [defaultModels, currentModels]
   );
+  const currentModelThinking = useMemo(
+    () =>
+      normalizeModelThinkingForModels(
+        normalizeModelThinkingConfig(resolvedProviderConfig.modelThinking, providerModelAliases),
+        currentEditableModels
+      ),
+    [currentEditableModels, providerModelAliases, resolvedProviderConfig.modelThinking]
+  );
   const language = getLanguage();
   const apiBaseHelpText =
     providerSpec?.apiBaseHelp?.[language] ||
@@ -443,6 +579,7 @@ export function ProviderForm({ providerName, onProviderDeleted }: ProviderFormPr
       setExtraHeaders(null);
       setWireApi('auto');
       setModels([]);
+      setModelThinking({});
       setModelDraft('');
       setProviderDisplayName('');
       setAuthSessionId(null);
@@ -457,6 +594,7 @@ export function ProviderForm({ providerName, onProviderDeleted }: ProviderFormPr
     setExtraHeaders(resolvedProviderConfig.extraHeaders || null);
     setWireApi(currentWireApi);
     setModels(currentEditableModels);
+    setModelThinking(currentModelThinking);
     setModelDraft('');
     setProviderDisplayName(effectiveDisplayName);
     setAuthSessionId(null);
@@ -469,6 +607,7 @@ export function ProviderForm({ providerName, onProviderDeleted }: ProviderFormPr
     resolvedProviderConfig.extraHeaders,
     currentWireApi,
     currentEditableModels,
+    currentModelThinking,
     effectiveDisplayName,
     preferredAuthMethodId,
     clearAuthPollTimer
@@ -476,6 +615,10 @@ export function ProviderForm({ providerName, onProviderDeleted }: ProviderFormPr
 
   useEffect(() => () => clearAuthPollTimer(), [clearAuthPollTimer]);
 
+  useEffect(() => {
+    setModelThinking((prev) => normalizeModelThinkingForModels(prev, models));
+  }, [models]);
+
   const hasChanges = useMemo(() => {
     if (!providerName) {
       return false;
@@ -485,11 +628,20 @@ export function ProviderForm({ providerName, onProviderDeleted }: ProviderFormPr
     const headersChanged = !headersEqual(extraHeaders, currentHeaders);
     const wireApiChanged = providerSpec?.supportsWireApi ? wireApi !== currentWireApi : false;
     const modelsChanged = !modelListsEqual(models, currentEditableModels);
+    const modelThinkingChanged = !modelThinkingEqual(modelThinking, currentModelThinking);
     const displayNameChanged = isCustomProvider
       ? providerDisplayName.trim() !== effectiveDisplayName
       : false;
 
-    return apiKeyChanged || apiBaseChanged || headersChanged || wireApiChanged || modelsChanged || displayNameChanged;
+    return (
+      apiKeyChanged ||
+      apiBaseChanged ||
+      headersChanged ||
+      wireApiChanged ||
+      modelsChanged ||
+      modelThinkingChanged ||
+      displayNameChanged
+    );
   }, [
     providerName,
     isCustomProvider,
@@ -504,7 +656,9 @@ export function ProviderForm({ providerName, onProviderDeleted }: ProviderFormPr
     wireApi,
     currentWireApi,
     models,
-    currentEditableModels
+    currentEditableModels,
+    modelThinking,
+    currentModelThinking
   ]);
 
   const handleAddModel = () => {
@@ -520,6 +674,45 @@ export function ProviderForm({ providerName, onProviderDeleted }: ProviderFormPr
     setModelDraft('');
   };
 
+  const toggleModelThinkingLevel = (modelName: string, level: ThinkingLevel) => {
+    setModelThinking((prev) => {
+      const currentEntry = prev[modelName];
+      const currentLevels = currentEntry?.supported ?? [];
+      const nextLevels = currentLevels.includes(level)
+        ? currentLevels.filter((item) => item !== level)
+        : THINKING_LEVELS.filter((item) => item === level || currentLevels.includes(item));
+      if (nextLevels.length === 0) {
+        const next = { ...prev };
+        delete next[modelName];
+        return next;
+      }
+      const nextDefault =
+        currentEntry?.default && nextLevels.includes(currentEntry.default) ? currentEntry.default : undefined;
+      return {
+        ...prev,
+        [modelName]: nextDefault ? { supported: nextLevels, default: nextDefault } : { supported: nextLevels }
+      };
+    });
+  };
+
+  const setModelThinkingDefault = (modelName: string, level: ThinkingLevel | null) => {
+    setModelThinking((prev) => {
+      const currentEntry = prev[modelName];
+      if (!currentEntry || currentEntry.supported.length === 0) {
+        return prev;
+      }
+      if (level && !currentEntry.supported.includes(level)) {
+        return prev;
+      }
+      return {
+        ...prev,
+        [modelName]: level
+          ? { supported: currentEntry.supported, default: level }
+          : { supported: currentEntry.supported }
+      };
+    });
+  };
+
   const handleSubmit = (e: React.FormEvent) => {
     e.preventDefault();
 
@@ -555,6 +748,9 @@ export function ProviderForm({ providerName, onProviderDeleted }: ProviderFormPr
     if (!modelListsEqual(models, currentEditableModels)) {
       payload.models = serializeModelsForSave(models, defaultModels);
     }
+    if (!modelThinkingEqual(modelThinking, currentModelThinking)) {
+      payload.modelThinking = normalizeModelThinkingForModels(modelThinking, models);
+    }
 
     updateProvider.mutate({ provider: providerName, data: payload });
   };
@@ -876,22 +1072,99 @@ export function ProviderForm({ providerName, onProviderDeleted }: ProviderFormPr
               </div>
             ) : (
               <div className="flex flex-wrap gap-2">
-                {models.map((modelName) => (
-                  <div
-                    key={modelName}
-                    className="group inline-flex max-w-full items-center gap-1 rounded-full border border-gray-200 bg-white px-3 py-1.5"
-                  >
-                    <span className="max-w-[180px] truncate text-sm text-gray-800 sm:max-w-[240px]">{modelName}</span>
-                    <button
-                      type="button"
-                      onClick={() => setModels((prev) => prev.filter((name) => name !== modelName))}
-                      className="inline-flex h-5 w-5 items-center justify-center rounded-full text-gray-400 transition-opacity hover:bg-gray-100 hover:text-gray-600 opacity-100 md:opacity-0 md:group-hover:opacity-100 md:group-focus-within:opacity-100"
-                      aria-label={t('remove')}
+                {models.map((modelName) => {
+                  const thinkingEntry = modelThinking[modelName];
+                  const supportedLevels = thinkingEntry?.supported ?? [];
+                  const defaultThinkingLevel = thinkingEntry?.default ?? null;
+                  return (
+                    <div
+                      key={modelName}
+                      className="group inline-flex max-w-full items-center gap-1 rounded-full border border-gray-200 bg-white px-3 py-1.5"
                     >
-                      <X className="h-3 w-3" />
-                    </button>
-                  </div>
-                ))}
+                      <span className="max-w-[140px] truncate text-sm text-gray-800 sm:max-w-[220px]">{modelName}</span>
+                      <Popover>
+                        <PopoverTrigger asChild>
+                          <button
+                            type="button"
+                            className="inline-flex h-5 w-5 items-center justify-center rounded-full text-gray-400 transition-opacity hover:bg-gray-100 hover:text-gray-600 opacity-100 md:opacity-0 md:group-hover:opacity-100 md:group-focus-within:opacity-100"
+                            aria-label={t('providerModelThinkingTitle')}
+                            title={t('providerModelThinkingTitle')}
+                          >
+                            <Settings2 className="h-3 w-3" />
+                          </button>
+                        </PopoverTrigger>
+                        <PopoverContent className="w-80 space-y-3">
+                          <div className="space-y-1">
+                            <p className="text-xs font-semibold text-gray-800">{t('providerModelThinkingTitle')}</p>
+                            <p className="text-xs text-gray-500">{t('providerModelThinkingHint')}</p>
+                          </div>
+                          <div className="flex flex-wrap gap-1.5">
+                            {THINKING_LEVELS.map((level) => {
+                              const selected = supportedLevels.includes(level);
+                              return (
+                                <button
+                                  key={level}
+                                  type="button"
+                                  onClick={() => toggleModelThinkingLevel(modelName, level)}
+                                  className={`rounded-full border px-2.5 py-1 text-xs font-medium transition-colors ${
+                                    selected
+                                      ? 'border-primary bg-primary text-white'
+                                      : 'border-gray-200 bg-white text-gray-600 hover:border-primary/40 hover:text-primary'
+                                  }`}
+                                >
+                                  {formatThinkingLevelLabel(level)}
+                                </button>
+                              );
+                            })}
+                          </div>
+                          <div className="space-y-1.5">
+                            <Label className="text-xs font-medium text-gray-700">{t('providerModelThinkingDefault')}</Label>
+                            <Select
+                              value={defaultThinkingLevel ?? '__none__'}
+                              onValueChange={(value) =>
+                                setModelThinkingDefault(
+                                  modelName,
+                                  value === '__none__' ? null : (value as ThinkingLevel)
+                                )
+                              }
+                              disabled={supportedLevels.length === 0}
+                            >
+                              <SelectTrigger className="h-8 rounded-lg bg-white text-xs">
+                                <SelectValue />
+                              </SelectTrigger>
+                              <SelectContent>
+                                <SelectItem value="__none__">{t('providerModelThinkingDefaultNone')}</SelectItem>
+                                {supportedLevels.map((level) => (
+                                  <SelectItem key={level} value={level}>
+                                    {formatThinkingLevelLabel(level)}
+                                  </SelectItem>
+                                ))}
+                              </SelectContent>
+                            </Select>
+                            {supportedLevels.length === 0 ? (
+                              <p className="text-xs text-gray-500">{t('providerModelThinkingNoSupported')}</p>
+                            ) : null}
+                          </div>
+                        </PopoverContent>
+                      </Popover>
+                      <button
+                        type="button"
+                        onClick={() => {
+                          setModels((prev) => prev.filter((name) => name !== modelName));
+                          setModelThinking((prev) => {
+                            const next = { ...prev };
+                            delete next[modelName];
+                            return next;
+                          });
+                        }}
+                        className="inline-flex h-5 w-5 items-center justify-center rounded-full text-gray-400 transition-opacity hover:bg-gray-100 hover:text-gray-600 opacity-100 md:opacity-0 md:group-hover:opacity-100 md:group-focus-within:opacity-100"
+                        aria-label={t('remove')}
+                      >
+                        <X className="h-3 w-3" />
+                      </button>
+                    </div>
+                  );
+                })}
               </div>
             )}
           </div>

package/src/lib/i18n.ts

@@ -272,6 +272,14 @@ export const LABELS: Record<string, { zh: string; en: string }> = {
   },
   providerModelsEmptyShort: { zh: '暂无可用模型', en: 'No models available' },
   providerAddFirstModel: { zh: '添加第一个模型', en: 'Add first model' },
+  providerModelThinkingTitle: { zh: '思考档位能力', en: 'Thinking Capability' },
+  providerModelThinkingHint: {
+    zh: '为该模型声明可切换的思考档位，聊天会话将按这里的能力展示下拉。',
+    en: 'Declare supported thinking levels for this model. Chat sessions will show the selector accordingly.'
+  },
+  providerModelThinkingDefault: { zh: '默认思考档位', en: 'Default Thinking Level' },
+  providerModelThinkingDefaultNone: { zh: '无默认（回落 off）', en: 'No default (fallback off)' },
+  providerModelThinkingNoSupported: { zh: '请先至少选择一个支持档位。', en: 'Select at least one supported level first.' },
   providerDisplayNameHelpShort: { zh: '便于区分多个自定义提供商', en: 'Helps distinguish multiple custom providers' },
   providerApiBaseHelpShort: { zh: '一般只需填写域名，系统自动补全路径', en: 'Usually just the domain; path auto-appended' },
   providerExtraHeadersHelpShort: { zh: '可选，用于自定义鉴权等场景', en: 'Optional, for custom auth etc.' },
@@ -528,6 +536,13 @@ export const LABELS: Record<string, { zh: string; en: string }> = {
   chatSelectAgent: { zh: '选择 Agent', en: 'Select Agent' },
   chatModelLabel: { zh: '对话模型', en: 'Chat Model' },
   chatSelectModel: { zh: '选择模型', en: 'Select model' },
+  chatThinkingLevelOff: { zh: '思考关闭', en: 'Thinking Off' },
+  chatThinkingLevelMinimal: { zh: '思考 Minimal', en: 'Thinking Minimal' },
+  chatThinkingLevelLow: { zh: '思考 Low', en: 'Thinking Low' },
+  chatThinkingLevelMedium: { zh: '思考 Medium', en: 'Thinking Medium' },
+  chatThinkingLevelHigh: { zh: '思考 High', en: 'Thinking High' },
+  chatThinkingLevelAdaptive: { zh: '思考 Adaptive', en: 'Thinking Adaptive' },
+  chatThinkingLevelXhigh: { zh: '思考 XHigh', en: 'Thinking XHigh' },
   chatSessionTypeLabel: { zh: '会话类型', en: 'Session Type' },
   chatSessionTypeNative: { zh: '原生', en: 'Native' },
   chatSessionTypeCodex: { zh: 'Codex', en: 'Codex' },

package/src/lib/provider-models.ts

@@ -1,4 +1,12 @@
-import type { ConfigMetaView, ConfigView, ProviderConfigView } from '@/api/types';
+import type { ConfigMetaView, ConfigView, ProviderConfigView, ThinkingLevel } from '@/api/types';
+
+const THINKING_LEVELS: ThinkingLevel[] = ['off', 'minimal', 'low', 'medium', 'high', 'adaptive', 'xhigh'];
+const THINKING_LEVEL_SET = new Set<string>(THINKING_LEVELS);
+
+export type ModelThinkingCapability = {
+  supported: ThinkingLevel[];
+  default?: ThinkingLevel | null;
+};
 
 export type ProviderModelCatalogItem = {
   name: string;
@@ -6,6 +14,7 @@ export type ProviderModelCatalogItem = {
   prefix: string;
   aliases: string[];
   models: string[];
+  modelThinking: Record<string, ModelThinkingCapability>;
   configured: boolean;
 };
 
@@ -59,9 +68,73 @@ export function composeProviderModel(prefix: string, localModel: string): string
   return `${normalizedPrefix}/${normalizedModel}`;
 }
 
+function parseThinkingLevel(value: unknown): ThinkingLevel | null {
+  if (typeof value !== 'string') {
+    return null;
+  }
+  const normalized = value.trim().toLowerCase();
+  if (!normalized) {
+    return null;
+  }
+  return THINKING_LEVEL_SET.has(normalized) ? (normalized as ThinkingLevel) : null;
+}
+
+function normalizeThinkingLevels(values: unknown): ThinkingLevel[] {
+  if (!Array.isArray(values)) {
+    return [];
+  }
+  const deduped: ThinkingLevel[] = [];
+  for (const value of values) {
+    const level = parseThinkingLevel(value);
+    if (!level || deduped.includes(level)) {
+      continue;
+    }
+    deduped.push(level);
+  }
+  return deduped;
+}
+
+export function normalizeModelThinkingMap(
+  input: ProviderConfigView['modelThinking'],
+  aliases: string[]
+): Record<string, ModelThinkingCapability> {
+  if (!input) {
+    return {};
+  }
+  const normalized: Record<string, ModelThinkingCapability> = {};
+  for (const [rawModel, rawValue] of Object.entries(input)) {
+    const localModel = toProviderLocalModel(rawModel, aliases);
+    if (!localModel) {
+      continue;
+    }
+    const supported = normalizeThinkingLevels(rawValue?.supported);
+    if (supported.length === 0) {
+      continue;
+    }
+    const defaultLevel = parseThinkingLevel(rawValue?.default);
+    normalized[localModel] =
+      defaultLevel && supported.includes(defaultLevel)
+        ? { supported, default: defaultLevel }
+        : { supported };
+  }
+  return normalized;
+}
+
+export function resolveModelThinkingCapability(
+  map: Record<string, ModelThinkingCapability>,
+  model: string,
+  aliases: string[]
+): ModelThinkingCapability | null {
+  const localModel = toProviderLocalModel(model, aliases);
+  if (!localModel) {
+    return null;
+  }
+  return map[localModel] ?? null;
+}
+
 export function findProviderByModel(
   model: string,
-  providerCatalog: Array<{ name: string; aliases: string[] }>
+  providerCatalog: Array<{ name: string; aliases: string[]; models?: string[] }>
 ): string | null {
   const trimmed = model.trim();
   if (!trimmed) {
@@ -81,7 +154,20 @@ export function findProviderByModel(
       }
     }
   }
-  return bestMatch?.name ?? null;
+  if (bestMatch) {
+    return bestMatch.name;
+  }
+  for (const provider of providerCatalog) {
+    const normalizedModel = toProviderLocalModel(trimmed, provider.aliases);
+    if (!normalizedModel) {
+      continue;
+    }
+    const models = normalizeStringList(provider.models ?? []);
+    if (models.some((modelId) => modelId === normalizedModel)) {
+      return provider.name;
+    }
+  }
+  return null;
 }
 
 function isProviderConfigured(provider: ProviderConfigView | undefined): boolean {
@@ -108,6 +194,7 @@ export function buildProviderModelCatalog(params: {
       (providerConfig?.models ?? []).map((model) => toProviderLocalModel(model, aliases))
     );
     const models = normalizeStringList([...defaultModels, ...customModels]);
+    const modelThinking = normalizeModelThinkingMap(providerConfig?.modelThinking, aliases);
     const configDisplayName = providerConfig?.displayName?.trim();
     const configured = isProviderConfigured(providerConfig);
 
@@ -117,6 +204,7 @@ export function buildProviderModelCatalog(params: {
       prefix,
       aliases,
       models,
+      modelThinking,
       configured
     } satisfies ProviderModelCatalogItem;
   });