Skip to content
Source
Sign inSign up
pingdotgg/t3code
Open History to see the last commit

ProviderModelsSection.tsx

636 lines23.3 KB

1import { ArrowDownIcon, ArrowUpIcon, PencilIcon, PlusIcon, StarIcon, XIcon } from "lucide-react";
2import { useEffect, useRef, useState } from "react";
3import {
4 ProviderDriverKind,
5 type ProviderInstanceId,
6 type ServerProviderModel,
7} from "@t3tools/contracts";
8import { isReasoningControl } from "@t3tools/client-runtime/model-traits";
9import { type CustomModelDefinition, normalizeCustomModelSlug } from "@t3tools/shared/model";
10​
11import { useStableCallback } from "../../hooks/useStableCallback";
12import { cn } from "../../lib/utils";
13import { sortModelsForProviderInstance } from "../../modelOrdering";
14import { MAX_CUSTOM_MODEL_LENGTH } from "../../modelSelection";
15import { Button } from "../ui/button";
16import { Input } from "../ui/input";
17import { Switch } from "../ui/switch";
18import { Tooltip, TooltipPopup, TooltipTrigger } from "../ui/tooltip";
19import { CustomModelEditor } from "./CustomModelEditor";
20​
21const CUSTOM_MODEL_PLACEHOLDER_BY_KIND: Partial<Record<ProviderDriverKind, string>> = {
22 [ProviderDriverKind.make("codex")]: "gpt-6.7-codex-ultra-preview",
23 [ProviderDriverKind.make("claudeAgent")]: "claude-sonnet-5",
24 [ProviderDriverKind.make("cursor")]: "claude-sonnet-4-6",
25 [ProviderDriverKind.make("opencode")]: "openai/gpt-5",
26 [ProviderDriverKind.make("pi")]: "anthropic/claude-sonnet-5",
27};
28​
29const FILTER_THRESHOLD = 8;
30​
31const PROVIDER_ALIAS_SLUGS = new Set(["default", "auto"]);
32​
33function hasReasoningControl(model: ServerProviderModel): boolean {
34 return (model.capabilities?.optionDescriptors ?? []).some(isReasoningControl);
36​
37// Reasoning is the norm, so only its absence is labeled, and only when other models have it.
38// Custom and null capabilities are fallbacks or user-written, not discovered, so they prove nothing.
39// Alias slugs ("default", Cursor's "auto") defer to the provider's own model choice, so reasoning is unknown.
40function describeModelCapabilities(
41 model: ServerProviderModel,
42 flagMissingReasoning: boolean,
43): string[] {
44 const descriptors = model.capabilities?.optionDescriptors ?? [];
45 const labels: string[] = [];
46 const hasFastMode = descriptors.some(
47 (descriptor) =>
48 descriptor.id === "fastMode" ||
49 (descriptor.id === "serviceTier" &&
50 descriptor.type === "select" &&
51 descriptor.options.some((option) => option.id === "fast" || option.label === "Fast")),
52 );
53 if (hasFastMode) labels.push("Fast mode");
54 if (
55 flagMissingReasoning &&
56 !model.isCustom &&
57 model.capabilities &&
58 !PROVIDER_ALIAS_SLUGS.has(model.slug) &&
59 !hasReasoningControl(model)
60 ) {
61 labels.push("No reasoning");
62 }
63 return labels;
65​
66function groupModelsForDisplay<T extends { readonly slug: string; readonly isCustom: boolean }>(
67 models: ReadonlyArray<T>,
68 options: {
69 readonly favoriteModels: ReadonlySet<string>;
70 readonly hiddenModels: ReadonlySet<string>;
71 readonly modelOrder: ReadonlyArray<string>;
72 },
73): T[] {
74 const ordered = sortModelsForProviderInstance(models, {
75 favoriteModels: options.favoriteModels,
76 groupFavorites: true,
77 modelOrder: options.modelOrder,
78 });
79 const isHidden = (model: T) => !model.isCustom && options.hiddenModels.has(model.slug);
80 return [
81 ...ordered.filter((model) => options.favoriteModels.has(model.slug)),
82 ...ordered.filter((model) => !options.favoriteModels.has(model.slug) && !isHidden(model)),
83 ...ordered.filter((model) => !options.favoriteModels.has(model.slug) && isHidden(model)),
84 ];
86​
87function nextHiddenModelsForBulkToggle(
88 models: ReadonlyArray<Pick<ServerProviderModel, "slug" | "isCustom">>,
89 hiddenModels: ReadonlyArray<string>,
90): string[] {
91 const builtInSlugs = models.filter((model) => !model.isCustom).map((model) => model.slug);
92 const builtInSlugSet = new Set(builtInSlugs);
93 const allBuiltInModelsHidden = builtInSlugs.every((slug) => hiddenModels.includes(slug));
94​
95 if (allBuiltInModelsHidden) {
96 return hiddenModels.filter((slug) => !builtInSlugSet.has(slug));
97 }
98​
99 return [...new Set([...hiddenModels, ...builtInSlugs])];
101​
102interface ProviderModelsSectionProps {
103 readonly instanceId: ProviderInstanceId;
104 readonly driverKind: ProviderDriverKind | null;
105 readonly models: ReadonlyArray<ServerProviderModel>;
106 readonly customModels: ReadonlyArray<CustomModelDefinition>;
107 readonly canManageCustomModels: boolean;
108 readonly canWritePreferences?: boolean;
109 readonly hiddenModels: ReadonlyArray<string>;
110 readonly favoriteModels: ReadonlyArray<string>;
111 readonly modelOrder: ReadonlyArray<string>;
112 readonly onChange: (next: ReadonlyArray<CustomModelDefinition>) => void;
113 readonly onHiddenModelsChange: (
114 next: ReadonlyArray<string>,
115 affectedModels: ReadonlyArray<string>,
116 ) => void;
117 readonly onFavoriteModelsChange: (next: ReadonlyArray<string>) => void;
118 readonly onToggleFavorite: (model: string) => void;
119 readonly onModelOrderChange: (next: ReadonlyArray<string>) => void;
121​
122export function ProviderModelsSection({
123 instanceId,
124 driverKind,
125 models,
126 customModels,
127 canManageCustomModels,
128 canWritePreferences = true,
129 hiddenModels,
130 favoriteModels,
131 modelOrder,
132 onChange,
133 onHiddenModelsChange,
134 onFavoriteModelsChange,
135 onToggleFavorite,
136 onModelOrderChange,
137}: ProviderModelsSectionProps) {
138 const [input, setInput] = useState("");
139 const [isAdding, setIsAdding] = useState(false);
140 const [filter, setFilter] = useState("");
141 const [error, setError] = useState<string | null>(null);
142 const [editingSlug, setEditingSlug] = useState<string | null>(null);
143 const listRef = useRef<HTMLDivElement>(null);
144 const scrollToSlugRef = useRef<string | null>(null);
145 const hiddenModelSet = new Set(hiddenModels);
146 const favoriteModelSet = new Set(favoriteModels);
147 const reportedSlugs = new Set(models.map((model) => model.slug));
148 // A favorite the provider no longer reports (disabled, signed out, model removed)
149 // still needs a row, or its star could never be cleared.
150 const unreportedFavoriteModels = favoriteModels.flatMap((slug): ServerProviderModel[] =>
151 reportedSlugs.has(slug) ? [] : [{ slug, name: slug, isCustom: false, capabilities: null }],
152 );
153 const displayModels = groupModelsForDisplay([...models, ...unreportedFavoriteModels], {
154 favoriteModels: favoriteModelSet,
155 hiddenModels: hiddenModelSet,
156 modelOrder,
157 });
158 const favoriteCount = displayModels.filter((model) => favoriteModelSet.has(model.slug)).length;
159 const hiddenCount = displayModels.filter(
160 (model) => !model.isCustom && hiddenModelSet.has(model.slug),
161 ).length;
162 const flagMissingReasoning = models.some(hasReasoningControl);
163 const showFilter = models.length > FILTER_THRESHOLD;
164 const normalizedFilter = filter.trim().toLowerCase();
165 const isFiltering = showFilter && normalizedFilter.length > 0;
166 const visibleModels = isFiltering
167 ? displayModels.filter(
168 (model) =>
169 model.name.toLowerCase().includes(normalizedFilter) ||
170 model.slug.toLowerCase().includes(normalizedFilter),
171 )
172 : displayModels;
173​
174 // A model added or moved lands in a later commit, so each commit looks for the pending row.
175 // oxlint-disable-next-line t3code/no-unreasoned-state-sync -- scrolls the pending model's DOM row into view once a later commit renders it
176 useEffect(() => {
177 const slug = scrollToSlugRef.current;
178 if (slug === null) return;
179 const row = listRef.current?.querySelector<HTMLElement>(
180 `[data-model-slug="${CSS.escape(slug)}"]`,
181 );
182 if (!row) return;
183 scrollToSlugRef.current = null;
184 row.scrollIntoView({ block: "nearest" });
185 });
186​
187 // Derive after the effect and use hiddenModels directly to preserve the editor's option-array cache.
188 const builtInModels = models.filter((model) => !model.isCustom);
189 const allBuiltInModelsHidden =
190 builtInModels.length > 0 && builtInModels.every((model) => hiddenModels.includes(model.slug));
191​
192 const handleAdd = () => {
193 if (!canManageCustomModels || driverKind === "antigravity") return;
194 const normalized = normalizeCustomModelSlug(input);
195 if (!normalized) {
196 setError("Enter a model slug.");
197 return;
198 }
199 if (models.some((model) => !model.isCustom && model.slug === normalized)) {
200 setError("That model is already built in.");
201 return;
202 }
203 if (normalized.length > MAX_CUSTOM_MODEL_LENGTH) {
204 setError(`Model slugs must be ${MAX_CUSTOM_MODEL_LENGTH} characters or less.`);
205 return;
206 }
207 if (customModels.some((entry) => entry.slug === normalized)) {
208 setError("That custom model is already saved.");
209 return;
210 }
211​
212 scrollToSlugRef.current = normalized;
213 setFilter("");
214 onChange([...customModels, { slug: normalized, name: normalized, capabilities: null }]);
215 setInput("");
216 setError(null);
217 setIsAdding(false);
218 };
219​
220 const cancelAdd = () => {
221 setInput("");
222 setError(null);
223 setIsAdding(false);
224 };
225​
226 const handleRemove = (slug: string) => {
227 if (!canManageCustomModels) return;
228 if (editingSlug === slug) setEditingSlug(null);
229 onChange(customModels.filter((entry) => entry.slug !== slug));
230 onModelOrderChange(modelOrder.filter((model) => model !== slug));
231 onFavoriteModelsChange(favoriteModels.filter((model) => model !== slug));
232 setError(null);
233 };
234​
235 const handleSaveEdit = (next: CustomModelDefinition) => {
236 if (!canManageCustomModels) return;
237 onChange(customModels.map((entry) => (entry.slug === next.slug ? next : entry)));
238 setEditingSlug(null);
239 };
240​
241 const setHidden = (slug: string, hidden: boolean) => {
242 if (!canWritePreferences || hidden === hiddenModelSet.has(slug)) return;
243 onHiddenModelsChange(
244 hidden ? [...hiddenModels, slug] : hiddenModels.filter((model) => model !== slug),
245 [slug],
246 );
247 };
248​
249 const handleToggleFavorite = (slug: string) => {
250 if (!canWritePreferences) return;
251 onToggleFavorite(slug);
252 };
253​
254 const groupOf = (model: (typeof displayModels)[number]) =>
255 favoriteModelSet.has(model.slug)
256 ? "favorite"
257 : !model.isCustom && hiddenModelSet.has(model.slug)
258 ? "hidden"
259 : "visible";
260 const handleMove = (slug: string, direction: -1 | 1) => {
261 if (!canWritePreferences) return;
262 const index = displayModels.findIndex((model) => model.slug === slug);
263 const nextIndex = index + direction;
264 if (index < 0 || nextIndex < 0 || nextIndex >= displayModels.length) return;
265 if (groupOf(displayModels[index]!) !== groupOf(displayModels[nextIndex]!)) return;
266 const next = displayModels.map((model) => model.slug);
267 [next[index], next[nextIndex]] = [next[nextIndex]!, next[index]!];
268 onModelOrderChange(next);
269 };
270​
271 const handleToggleEdit = useStableCallback((slug: string) => {
272 if (!canManageCustomModels) return;
273 setEditingSlug((current) => (current === slug ? null : slug));
274 });
275 const rowHandlers = {
276 onToggleFavorite: useStableCallback(handleToggleFavorite),
277 onMove: useStableCallback(handleMove),
278 onSetHidden: useStableCallback(setHidden),
279 onToggleEdit: handleToggleEdit,
280 onRemove: useStableCallback(handleRemove),
281 };
282​
283 const renderRow = (model: (typeof displayModels)[number]) => {
284 const group = groupOf(model);
285 const index = displayModels.indexOf(model);
286 const previousModel = displayModels[index - 1];
287 const nextModel = displayModels[index + 1];
288 return (
289 <ProviderModelRow
290 key={`${instanceId}:${model.slug}`}
291 model={model}
292 isHidden={!model.isCustom && hiddenModelSet.has(model.slug)}
293 isFavorite={group === "favorite"}
294 canMoveUp={!isFiltering && previousModel !== undefined && groupOf(previousModel) === group}
295 canMoveDown={!isFiltering && nextModel !== undefined && groupOf(nextModel) === group}
296 isFiltering={isFiltering}
297 flagMissingReasoning={flagMissingReasoning}
298 canWritePreferences={canWritePreferences}
299 canManageCustomModels={canManageCustomModels}
300 {...rowHandlers}
301 />
302 );
303 };
304​
305 const groupLabel = (label: string, isFirst: boolean) => (
306 <div className={cn("px-2 pb-1.5 text-2xs text-muted-foreground", isFirst ? "pt-1" : "pt-5")}>
307 {label}
308 </div>
309 );
310​
311 return (
312 <div className="lg:flex lg:h-full lg:min-h-0 lg:flex-col">
313 <div className="flex flex-wrap items-center justify-between gap-2">
314 {showFilter ? (
315 <Input
316 value={filter}
317 onChange={(event) => setFilter(event.target.value)}
318 placeholder="Filter models"
319 size="sm"
320 className="w-56 max-w-full"
321 spellCheck={false}
322 aria-label="Filter models"
323 />
324 ) : null}
325 <div className="flex items-center gap-2">
326 {builtInModels.length > 0 ? (
327 <Button
328 type="button"
329 size="xs"
330 variant="ghost-muted"
331 onClick={() =>
332 onHiddenModelsChange(
333 nextHiddenModelsForBulkToggle(models, hiddenModels),
334 builtInModels.map((model) => model.slug),
335 )
336 }
337 >
338 {allBuiltInModelsHidden ? "Enable all" : "Disable all"}
339 </Button>
340 ) : null}
341 <span className="text-xs text-muted-foreground">
342 {models.length} model{models.length === 1 ? "" : "s"}
343 {favoriteCount > 0
344 ? ` · ${favoriteCount} favorite${favoriteCount === 1 ? "" : "s"}`
345 : ""}
346 {hiddenCount > 0 ? ` · ${hiddenCount} hidden` : ""}
347 </span>
348 </div>
349 {driverKind !== "antigravity" && !isAdding ? (
350 <Button
351 type="button"
352 size="xs"
353 variant="ghost-muted"
354 // The ghost padding would inset the label from the column edge the toggles align to.
355 className="-me-2 ml-auto"
356 onClick={() => setIsAdding(true)}
357 >
358 <PlusIcon className="size-3" />
359 Add custom model
360 </Button>
361 ) : null}
362 </div>
363 <div
364 ref={listRef}
365 className="mt-2 -mx-2 max-h-64 overflow-y-auto lg:max-h-none lg:min-h-0 lg:flex-1"
366 >
367 {visibleModels.length === 0 ? (
368 <p className="px-2 py-2 text-xs text-muted-foreground">
369 {isFiltering ? "No models match." : "No models reported for this provider yet."}
370 </p>
371 ) : null}
372 {visibleModels.map((model, index) => {
373 const group = groupOf(model);
374 const previous = visibleModels[index - 1];
375 const startsGroup = previous === undefined || groupOf(previous) !== group;
376 const editingEntry =
377 canManageCustomModels && model.isCustom && editingSlug === model.slug
378 ? customModels.find((entry) => entry.slug === model.slug)
379 : undefined;
380 return (
381 <div key={`${instanceId}:${model.slug}:group`}>
382 {startsGroup && favoriteCount > 0 && group === "favorite"
383 ? groupLabel("Favorites", index === 0)
384 : null}
385 {startsGroup && favoriteCount > 0 && group === "visible"
386 ? groupLabel("All", index === 0)
387 : null}
388 {startsGroup && group === "hidden"
389 ? groupLabel("Hidden from picker", index === 0)
390 : null}
391 {renderRow(model)}
392 {editingEntry ? (
393 <CustomModelEditor
394 key={`${instanceId}:${model.slug}:editor`}
395 instanceId={instanceId}
396 driverKind={driverKind}
397 entry={editingEntry}
398 builtInModels={builtInModels}
399 onSave={handleSaveEdit}
400 onCancel={() => setEditingSlug(null)}
401 />
402 ) : null}
403 </div>
404 );
405 })}
406 </div>
407​
408 {driverKind === "antigravity" || !canManageCustomModels ? null : isAdding ? (
409 <div className="mt-3 flex flex-col gap-2 sm:flex-row">
410 <Input
411 id={`provider-instance-${instanceId}-custom-model`}
412 size="sm"
413 autoFocus
414 value={input}
415 onChange={(event) => {
416 setInput(event.target.value);
417 if (error) setError(null);
418 }}
419 onKeyDown={(event) => {
420 if (event.key === "Escape") {
421 event.preventDefault();
422 cancelAdd();
423 return;
424 }
425 if (event.key !== "Enter") return;
426 event.preventDefault();
427 handleAdd();
428 }}
429 placeholder={driverKind ? CUSTOM_MODEL_PLACEHOLDER_BY_KIND[driverKind] : "model-slug"}
430 spellCheck={false}
431 />
432 <div className="flex shrink-0 gap-2">
433 <Button size="sm" variant="outline" onClick={handleAdd}>
434 Add
435 </Button>
436 <Button size="sm" variant="ghost" onClick={cancelAdd}>
437 Cancel
438 </Button>
439 </div>
440 </div>
441 ) : null}
442​
443 {driverKind !== "antigravity" && error ? (
444 <p className="mt-2 text-xs text-destructive">{error}</p>
445 ) : null}
446 </div>
447 );
449​
450function ProviderModelRow({
451 model,
452 isHidden,
453 isFavorite,
454 canMoveUp,
455 canMoveDown,
456 isFiltering,
457 flagMissingReasoning,
458 canWritePreferences,
459 canManageCustomModels,
460 onToggleFavorite,
461 onMove,
462 onSetHidden,
463 onToggleEdit,
464 onRemove,
465}: {
466 readonly model: ServerProviderModel;
467 readonly isHidden: boolean;
468 readonly isFavorite: boolean;
469 readonly canMoveUp: boolean;
470 readonly canMoveDown: boolean;
471 readonly isFiltering: boolean;
472 readonly flagMissingReasoning: boolean;
473 readonly canWritePreferences: boolean;
474 readonly canManageCustomModels: boolean;
475 readonly onToggleFavorite: (slug: string) => void;
476 readonly onMove: (slug: string, direction: -1 | 1) => void;
477 readonly onSetHidden: (slug: string, hidden: boolean) => void;
478 readonly onToggleEdit: (slug: string) => void;
479 readonly onRemove: (slug: string) => void;
480}) {
481 const capLabels = describeModelCapabilities(model, flagMissingReasoning);
482 const nameClassName = cn("text-xs", isHidden ? "text-muted-foreground" : "text-foreground/90");
483 const pickerTooltip = model.isCustom
484 ? "Custom models are always shown in the picker"
485 : isHidden
486 ? "Hidden from picker"
487 : "Shown in picker";
488​
489 return (
490 <div
491 data-model-slug={model.slug}
492 className={cn(
493 "grid h-7 grid-cols-[1.5rem_minmax(0,1fr)_auto_minmax(5.5rem,auto)_auto] items-center gap-2 rounded-md px-2 transition-colors hover:bg-muted/30",
494 isHidden && "opacity-50",
495 )}
496 >
497 <Tooltip>
498 <TooltipTrigger
499 render={
500 <Button
501 size="icon-micro"
502 variant="ghost-muted"
503 disabled={!canWritePreferences}
504 onClick={() => onToggleFavorite(model.slug)}
505 aria-label={`${isFavorite ? "Remove" : "Add"} ${model.name} ${
506 isFavorite ? "from" : "to"
507 } favorites`}
508 />
509 }
510 >
511 <StarIcon className={cn("size-3", isFavorite && "fill-current text-warning")} />
512 </TooltipTrigger>
513 <TooltipPopup side="top">
514 {isFavorite ? "Remove from favorites" : "Add to favorites"}
515 </TooltipPopup>
516 </Tooltip>
517 <span className="flex min-w-0 items-baseline gap-2">
518 <Tooltip>
519 <TooltipTrigger
520 render={
521 <span tabIndex={0} className="flex min-w-0 items-baseline gap-2 overflow-hidden" />
522 }
523 >
524 <span className={cn(nameClassName, "max-w-full shrink-0 truncate")}>{model.name}</span>
525 {model.name !== model.slug ? (
526 <code className="truncate font-mono text-2xs text-muted-foreground/70">
527 {model.slug}
528 </code>
529 ) : null}
530 </TooltipTrigger>
531 <TooltipPopup side="top" align="start">
532 <div>{model.name}</div>
533 {model.name !== model.slug ? (
534 <code className="font-mono text-2xs text-muted-foreground">{model.slug}</code>
535 ) : null}
536 </TooltipPopup>
537 </Tooltip>
538 {model.isCustom ? (
539 <span className="shrink-0 text-2xs text-muted-foreground/70">custom</span>
540 ) : null}
541 </span>
542 <span className="text-2xs text-muted-foreground/70">
543 {capLabels.length > 0 ? (
544 <span className="hidden sm:inline">{capLabels.join(" · ")}</span>
545 ) : null}
546 </span>
547 <span className="flex shrink-0 items-center justify-end gap-0.5">
548 {!isHidden && !isFiltering ? (
549 <>
550 <Tooltip>
551 <TooltipTrigger
552 render={
553 <Button
554 size="icon-micro"
555 variant="ghost-muted"
556 disabled={!canWritePreferences || !canMoveUp}
557 onClick={() => onMove(model.slug, -1)}
558 aria-label={`Move ${model.name} up`}
559 />
560 }
561 >
562 <ArrowUpIcon className="size-3" />
563 </TooltipTrigger>
564 <TooltipPopup side="top">Move up</TooltipPopup>
565 </Tooltip>
566 <Tooltip>
567 <TooltipTrigger
568 render={
569 <Button
570 size="icon-micro"
571 variant="ghost-muted"
572 disabled={!canWritePreferences || !canMoveDown}
573 onClick={() => onMove(model.slug, 1)}
574 aria-label={`Move ${model.name} down`}
575 />
576 }
577 >
578 <ArrowDownIcon className="size-3" />
579 </TooltipTrigger>
580 <TooltipPopup side="top">Move down</TooltipPopup>
581 </Tooltip>
582 </>
583 ) : null}
584 {model.isCustom ? (
585 <>
586 <Tooltip>
587 <TooltipTrigger
588 render={
589 <Button
590 size="icon-micro"
591 variant="ghost-muted"
592 disabled={!canManageCustomModels}
593 aria-label={`Edit ${model.slug}`}
594 onClick={() => onToggleEdit(model.slug)}
595 />
596 }
597 >
598 <PencilIcon className="size-3" />
599 </TooltipTrigger>
600 <TooltipPopup side="top">Edit name and options</TooltipPopup>
601 </Tooltip>
602 <Tooltip>
603 <TooltipTrigger
604 render={
605 <Button
606 size="icon-micro"
607 variant="ghost-muted"
608 disabled={!canManageCustomModels}
609 aria-label={`Remove ${model.slug}`}
610 onClick={() => onRemove(model.slug)}
611 />
612 }
613 >
614 <XIcon className="size-3" />
615 </TooltipTrigger>
616 <TooltipPopup side="top">Remove custom model</TooltipPopup>
617 </Tooltip>
618 </>
619 ) : null}
620 </span>
621 {/* Disabled switches receive no pointer events; wrap the tooltip trigger. */}
622 <Tooltip>
623 <TooltipTrigger render={<span className="flex shrink-0 items-center" />}>
624 <Switch
625 size="sm"
626 checked={!isHidden}
627 disabled={!canWritePreferences || model.isCustom}
628 onCheckedChange={(checked) => onSetHidden(model.slug, !checked)}
629 aria-label={`Show ${model.name} in the model picker`}
630 />
631 </TooltipTrigger>
632 <TooltipPopup side="top">{pickerTooltip}</TooltipPopup>
633 </Tooltip>
634 </div>
635 );