@uipath/apollo-wind 2.54.1 → 2.56.0

package/dist/components/ui/model-picker/useModelPickerState.d.ts

@@ -0,0 +1,135 @@
+import type { ModelPickerLabels } from './labels';
+import { type AnnotatedModel } from './primitives/OptionList';
+import type { DiscoveryModel } from './types';
+import { type GroupStrategy } from './utils';
+export interface UseModelPickerStateOptions {
+    models: DiscoveryModel[];
+    value?: string | null;
+    /**
+     * Connection id of the selected BYO model, when the host persists one.
+     * Disambiguates two BYO configurations that serve the same model name
+     * under different connections: `value` alone matches the first row,
+     * so the wrong one highlights. When provided, `matchesValue` also
+     * requires `byomDetails.integrationServiceConnectionId` to equal this.
+     * Omit for non-BYO selections.
+     */
+    valueConnectionId?: string | null;
+    /**
+     * Selection callback. New shape: `(model)`. Legacy `(modelId, model)`
+     * callers can wrap at the call site — see `ModelPickerChangeHandler`
+     * in ModelPicker.tsx for the migration note.
+     */
+    onChange?: (model: DiscoveryModel) => void;
+    /**
+     * Initial grouping strategy. The hook stores this as internal state so
+     * consumers can let the user switch view (Category ⇆ Provider) without
+     * lifting the value into the host. Pass a fresh `groupBy` to reset.
+     */
+    groupBy?: GroupStrategy;
+    /**
+     * Authoritative recommended/preview model IDs sourced from Model_hub
+     * configs in gitops-centralized-cluster. Passed through to
+     * `groupModels` so grouping aligns with chip rendering.
+     */
+    recommendedModelIds?: readonly string[];
+    previewModelIds?: readonly string[];
+    /**
+     * Whether sections may collapse at all. A host that hides the group
+     * headers has removed the only visible expand control, so collapsing
+     * must be off too or rows can vanish with no way back. Default true;
+     * flat grouping disables it regardless.
+     */
+    collapsibleGroups?: boolean;
+    /**
+     * Optional per-product filter applied to the catalog *before* grouping
+     * and search. Runs once per `models` array via `useMemo`; pass a
+     * stable function reference if `models` is large.
+     */
+    filter?: (model: DiscoveryModel) => boolean;
+    /**
+     * Group keys to render as collapsed when the picker first mounts.
+     * The hook keeps the collapse map as internal state so the parent
+     * doesn't have to. A non-empty search query temporarily forces every
+     * group open so matches always show.
+     */
+    initiallyCollapsedGroups?: readonly string[];
+    /**
+     * Translator instance. Forwarded to `groupModels` so group labels +
+     * hints render in the host's active locale. Omit only when the host
+     * supplies no translator (tests, isolated primitives).
+     */
+    labels?: ModelPickerLabels;
+}
+export interface UseModelPickerStateResult {
+    open: boolean;
+    setOpen: (next: boolean) => void;
+    query: string;
+    setQuery: (next: string) => void;
+    /** Current grouping strategy. Initially seeded from `opts.groupBy`. */
+    groupBy: GroupStrategy;
+    setGroupBy: (next: GroupStrategy) => void;
+    /**
+     * `models` after the host's `filter` ran. Use this for downstream
+     * counts and side effects — `annotated`/`filtered` already include
+     * this filter, so most consumers won't need it.
+     */
+    visibleModels: DiscoveryModel[];
+    /** All models, annotated with groupKey/groupLabel, sorted into group order. */
+    annotated: AnnotatedModel[];
+    /** annotated filtered by `query`. */
+    filtered: AnnotatedModel[];
+    /** Per-group counts (post-filter, pre-query). */
+    groupCounts: Record<string, number>;
+    /**
+     * Group keys currently collapsed. While `query` is non-empty every
+     * group is forced open (returns an empty set) so search results stay
+     * visible.
+     */
+    collapsedGroups: ReadonlySet<string>;
+    /** Toggle the collapsed state of a single group. */
+    toggleGroup: (groupKey: string) => void;
+    /** The currently selected model, or null. */
+    selected: DiscoveryModel | null;
+    /**
+     * Raw `value` that couldn't be resolved against `models`. `null` when
+     * the selection resolved cleanly, when no `value` was passed, or
+     * while the catalog is still loading (empty `models`). Used by the
+     * trigger to render an explicit error-state fallback (raw id +
+     * red border) instead of silently dropping the value — which would
+     * look identical to "nothing selected" and risk accidental
+     * overwrites of a stored config.
+     */
+    unknownValue: string | null;
+    activeIndex: number;
+    setActiveIndex: (i: number) => void;
+    /**
+     * False when the highlighted row is inside a collapsed section (or the
+     * list is empty). The combobox must not publish an active descendant
+     * that is not in the DOM.
+     */
+    activeVisible: boolean;
+    /** Bind to the search input's onKeyDown. */
+    onSearchKeyDown: (e: React.KeyboardEvent) => void;
+    /** Programmatically pick a model. Closes the popup. */
+    choose: (m: DiscoveryModel) => void;
+    /** Stable id prefix unique to this picker instance. */
+    id: string;
+    /** Ref to attach to the trigger button so keyboard focus can return there. */
+    triggerRef: React.RefObject<HTMLButtonElement | null>;
+    /** Ref to attach to the search input. */
+    searchRef: React.RefObject<HTMLInputElement | null>;
+}
+/**
+ * Shared state controller for ModelPicker (and any custom picker a
+ * team builds on top of the primitives). Owns:
+ *   - open/close state of the popup
+ *   - search query + filtering
+ *   - grouped + annotated option list
+ *   - keyboard navigation index
+ *   - collapsed-group bookkeeping
+ *   - selection callback
+ *
+ * Consumers can use this hook directly to assemble their own picker from
+ * the exported primitives — see ModelPicker.tsx for the canonical example.
+ */
+export declare function useModelPickerState(opts: UseModelPickerStateOptions): UseModelPickerStateResult;

package/dist/components/ui/model-picker/useModelPickerState.js

@@ -0,0 +1,216 @@
+import { useCallback, useEffect, useId, useMemo, useRef, useState } from "react";
+import { isCollapsibleGroup } from "./primitives/OptionList.js";
+import { filterModels, groupModels, isByoModel } from "./utils.js";
+function useModelPickerState(opts) {
+    const { models, value, valueConnectionId, onChange, groupBy: initialGroupBy = "subscription", collapsibleGroups = true, recommendedModelIds, previewModelIds, filter, initiallyCollapsedGroups, labels } = opts;
+    const reactId = useId().replace(/[^A-Za-z0-9_-]/g, '');
+    const id = `apollo-model-picker-${reactId}`;
+    const triggerRef = useRef(null);
+    const searchRef = useRef(null);
+    const [open, setOpen] = useState(false);
+    const [query, setQuery] = useState('');
+    const [activeIndex, setActiveIndex] = useState(0);
+    const [groupBy, setGroupBy] = useState(initialGroupBy);
+    const lastInitialGroupBy = useRef(initialGroupBy);
+    useEffect(()=>{
+        if (lastInitialGroupBy.current === initialGroupBy) return;
+        lastInitialGroupBy.current = initialGroupBy;
+        setGroupBy(initialGroupBy);
+    }, [
+        initialGroupBy
+    ]);
+    const [collapsedSet, setCollapsedSet] = useState(()=>new Set(initiallyCollapsedGroups ?? []));
+    const visibleModels = useMemo(()=>filter ? models.filter(filter) : models, [
+        models,
+        filter
+    ]);
+    const annotated = useMemo(()=>{
+        const groups = groupModels(visibleModels, groupBy, {
+            recommendedModelIds,
+            previewModelIds,
+            labels
+        });
+        return groups.flatMap((g)=>g.models.map((m)=>({
+                    ...m,
+                    groupKey: g.key,
+                    groupLabel: g.label
+                })));
+    }, [
+        visibleModels,
+        groupBy,
+        recommendedModelIds,
+        previewModelIds,
+        labels
+    ]);
+    const filtered = useMemo(()=>filterModels(annotated, query), [
+        annotated,
+        query
+    ]);
+    const groupCounts = useMemo(()=>{
+        const out = {};
+        for (const m of annotated)out[m.groupKey] = (out[m.groupKey] ?? 0) + 1;
+        return out;
+    }, [
+        annotated
+    ]);
+    const matchesValue = useCallback((m)=>{
+        if (valueConnectionId) {
+            const connId = m.byomDetails?.integrationServiceConnectionId;
+            if (connId !== valueConnectionId) return false;
+        }
+        return m.modelId === value || m.modelName === value;
+    }, [
+        value,
+        valueConnectionId
+    ]);
+    const pickMatch = useCallback((list)=>{
+        const hits = list.filter(matchesValue);
+        if (0 === hits.length) return null;
+        if (valueConnectionId) return hits[0] ?? null;
+        return hits.find((m)=>!isByoModel(m)) ?? hits[0] ?? null;
+    }, [
+        matchesValue,
+        valueConnectionId
+    ]);
+    const selected = useMemo(()=>pickMatch(annotated) ?? pickMatch(models), [
+        annotated,
+        models,
+        pickMatch
+    ]);
+    const unknownValue = useMemo(()=>{
+        if (!value) return null;
+        if (selected) return null;
+        if (0 === models.length) return null;
+        return value;
+    }, [
+        models,
+        selected,
+        value
+    ]);
+    const canCollapse = collapsibleGroups && 'flat' !== groupBy && !query.trim();
+    const collapsedGroups = useMemo(()=>canCollapse ? collapsedSet : new Set(), [
+        canCollapse,
+        collapsedSet
+    ]);
+    const toggleGroup = useCallback((groupKey)=>{
+        setCollapsedSet((prev)=>{
+            const next = new Set(prev);
+            if (next.has(groupKey)) next.delete(groupKey);
+            else next.add(groupKey);
+            return next;
+        });
+    }, []);
+    useEffect(()=>{
+        if (open) {
+            const sel = filtered.findIndex(matchesValue);
+            setActiveIndex(sel >= 0 ? sel : 0);
+            requestAnimationFrame(()=>searchRef.current?.focus());
+        } else setQuery('');
+    }, [
+        open
+    ]);
+    const isHiddenAt = useCallback((i)=>{
+        const g = filtered[i]?.groupKey;
+        return void 0 !== g && isCollapsibleGroup(g) && collapsedGroups.has(g);
+    }, [
+        filtered,
+        collapsedGroups
+    ]);
+    const isCollapsedStop = useCallback((i)=>isHiddenAt(i) && (0 === i || filtered[i - 1]?.groupKey !== filtered[i]?.groupKey), [
+        filtered,
+        isHiddenAt
+    ]);
+    const nearestStop = useCallback((from, dir)=>{
+        for(let i = from; i >= 0 && i < filtered.length; i += dir)if (!isHiddenAt(i) || isCollapsedStop(i)) return i;
+        return -1;
+    }, [
+        filtered.length,
+        isHiddenAt,
+        isCollapsedStop
+    ]);
+    useEffect(()=>{
+        if (activeIndex >= filtered.length) return void setActiveIndex(0);
+        if (!isHiddenAt(activeIndex) || isCollapsedStop(activeIndex)) return;
+        let i = activeIndex;
+        while(i > 0 && filtered[i - 1]?.groupKey === filtered[i]?.groupKey)i -= 1;
+        setActiveIndex(i);
+    }, [
+        filtered,
+        activeIndex,
+        isHiddenAt,
+        isCollapsedStop
+    ]);
+    const activeVisible = filtered.length > 0 && !isHiddenAt(activeIndex);
+    const choose = useCallback((m)=>{
+        onChange?.(m);
+        setOpen(false);
+        triggerRef.current?.focus();
+    }, [
+        onChange
+    ]);
+    const onSearchKeyDown = useCallback((e)=>{
+        if ('ArrowDown' === e.key) {
+            e.preventDefault();
+            setActiveIndex((i)=>{
+                const next = nearestStop(i + 1, 1);
+                return -1 === next ? i : next;
+            });
+        } else if ('ArrowUp' === e.key) {
+            e.preventDefault();
+            setActiveIndex((i)=>{
+                const prev = nearestStop(i - 1, -1);
+                return -1 === prev ? i : prev;
+            });
+        } else if ('Enter' === e.key) {
+            e.preventDefault();
+            const m = filtered[activeIndex];
+            if (m && !isHiddenAt(activeIndex)) choose(m);
+        } else if ('ArrowLeft' === e.key || 'ArrowRight' === e.key) {
+            const groupKey = filtered[activeIndex]?.groupKey;
+            if (!groupKey || !isCollapsibleGroup(groupKey) || !canCollapse) return;
+            const collapsed = collapsedGroups.has(groupKey);
+            if ('ArrowLeft' === e.key ? !collapsed : collapsed) {
+                e.preventDefault();
+                toggleGroup(groupKey);
+            }
+        } else if ('Escape' === e.key) {
+            e.preventDefault();
+            setOpen(false);
+            triggerRef.current?.focus();
+        }
+    }, [
+        filtered,
+        activeIndex,
+        choose,
+        collapsedGroups,
+        canCollapse,
+        toggleGroup,
+        nearestStop,
+        isHiddenAt
+    ]);
+    return {
+        open,
+        setOpen,
+        query,
+        setQuery,
+        groupBy,
+        setGroupBy,
+        visibleModels,
+        annotated,
+        filtered,
+        groupCounts,
+        collapsedGroups,
+        toggleGroup,
+        selected,
+        unknownValue,
+        activeIndex,
+        setActiveIndex,
+        onSearchKeyDown,
+        choose,
+        id,
+        triggerRef,
+        searchRef,
+        activeVisible
+    };
+}
+export { useModelPickerState };

package/dist/components/ui/model-picker/utils.cjs

@@ -0,0 +1,327 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    resolveHomeGeography: ()=>resolveHomeGeography,
+    isTextGenerationModel: ()=>isTextGenerationModel,
+    getSubstitutionTarget: ()=>getSubstitutionTarget,
+    filterModels: ()=>filterModels,
+    deriveModelTags: ()=>deriveModelTags,
+    isByoModel: ()=>isByoModel,
+    groupModels: ()=>groupModels,
+    defaultCostTier: ()=>defaultCostTier
+});
+const external_badges_cjs_namespaceObject = require("./badges.cjs");
+const external_labels_cjs_namespaceObject = require("./labels.cjs");
+const RECOMMENDED_SUBSCRIPTION = 'UiPathOwned';
+const isByoModel = (m)=>'BYOMAdded' === m.modelSubscriptionType || 'BYOMReplacedAlternative' === m.modelSubscriptionType || 'BYOMReplacedLikeForLike' === m.modelSubscriptionType || !!m.byomDetails || !!m.byoConnectionLabel;
+function isTextGenerationModel(m) {
+    if ('Realtime' === m.modelType) return false;
+    return !(m.apiFlavor ?? '').includes('Embeddings');
+}
+const OMS_REGION_TO_GEOGRAPHY = {
+    europe: 'EU',
+    unitedstates: 'US',
+    japan: 'JA',
+    canada: 'CA',
+    australia: 'AU',
+    india: 'IN',
+    unitedkingdom: 'UK',
+    singapore: 'SI',
+    switzerland: 'CH',
+    unitedarabemirates: 'UAE',
+    southkorea: 'SK'
+};
+const GEOGRAPHY_CODES = new Set([
+    'EU',
+    'CA',
+    'US',
+    'SI',
+    'JA',
+    'AU',
+    'IN',
+    'UK',
+    'CH',
+    'UAE',
+    'SK',
+    'GLOBAL'
+]);
+function resolveHomeGeography(homeRegion) {
+    const raw = homeRegion?.trim();
+    if (!raw) return;
+    const upper = raw.toUpperCase();
+    if ('GLOBAL' === upper) return;
+    if (GEOGRAPHY_CODES.has(upper)) return upper;
+    return OMS_REGION_TO_GEOGRAPHY[raw.toLowerCase().replace(/[\s_-]/g, '')];
+}
+function listMatchesModel(ids, model) {
+    return ids.includes(model.modelId) || ids.includes(model.modelName);
+}
+function deriveModelTags(model, context = {}) {
+    const tags = [];
+    const labels = context.labels ?? external_labels_cjs_namespaceObject.DEFAULT_MODEL_PICKER_LABELS;
+    const isByo = isByoModel(model);
+    const isRecommended = void 0 !== context.recommendedModelIds ? listMatchesModel(context.recommendedModelIds, model) : model.isRecommended ?? (model.modelSubscriptionType === RECOMMENDED_SUBSCRIPTION && !model.isPreview && !model.deprecationDetails?.usageEndDate);
+    if (isRecommended) tags.push({
+        kind: 'recommended',
+        label: labels.recommendedTag,
+        tooltip: labels.recommendedTagTooltip
+    });
+    const isPreview = void 0 !== context.previewModelIds ? listMatchesModel(context.previewModelIds, model) : !!model.isPreview;
+    if (!isByo && isPreview) tags.push({
+        kind: 'preview',
+        label: labels.previewTag
+    });
+    const substitutionTarget = getSubstitutionTarget(model);
+    if (substitutionTarget) tags.push({
+        kind: 'substituted',
+        label: labels.substitutedTag(substitutionTarget),
+        tooltip: labels.substitutedTagTooltip(substitutionTarget)
+    });
+    else if (model.deprecationDetails?.usageEndDate) {
+        const date = formatDate(model.deprecationDetails.usageEndDate);
+        tags.push({
+            kind: 'deprecating',
+            label: labels.deprecatingTag(date),
+            tooltip: model.deprecationDetails.replacedBy ? labels.deprecatingTagTooltip(model.deprecationDetails.replacedBy) : void 0
+        });
+    }
+    if (isByo) tags.push({
+        kind: 'custom',
+        label: labels.customTag
+    });
+    if (!isByo) {
+        const geo = model.routingDetails?.geography;
+        const home = 'GLOBAL' === context.homeRegion ? void 0 : context.homeRegion;
+        if (geo && home && 'GLOBAL' !== geo && geo !== home) tags.push({
+            kind: 'out-of-region',
+            label: labels.outOfRegionTag(geo),
+            tooltip: labels.outOfRegionTagTooltip(home)
+        });
+    }
+    const poolBadges = context.badgesFor?.(model) ?? (()=>{
+        const tier = defaultCostTier(model);
+        return tier ? [
+            `cost-${tier}`
+        ] : [];
+    })();
+    for (const kind of poolBadges){
+        const def = external_badges_cjs_namespaceObject.MODEL_BADGES[kind];
+        if (def) tags.push({
+            kind,
+            label: labels[def.label],
+            tooltip: def.tooltip ? labels[def.tooltip] : void 0,
+            variant: def.variant
+        });
+    }
+    if (context.customTagsFor) {
+        const extra = context.customTagsFor(model);
+        if (extra?.length) tags.push(...extra);
+    }
+    return tags;
+}
+const DEFAULT_BASIC_THRESHOLD = 100;
+const DEFAULT_PREMIUM_THRESHOLD = 500;
+function defaultCostTier(model) {
+    const costDetails = model.modelDetails?.costDetails;
+    const inputCost = costDetails?.flatCosts?.inputTokenCost ?? costDetails?.tieredCosts?.[0]?.inputTokenCost;
+    if (null == inputCost) return null;
+    if (inputCost < DEFAULT_BASIC_THRESHOLD) return 'basic';
+    if (inputCost < DEFAULT_PREMIUM_THRESHOLD) return 'standard';
+    return 'premium';
+}
+function getSubstitutionTarget(model) {
+    const effective = model.effectiveModel;
+    if (effective && effective !== model.modelName && effective !== model.modelId) return model.deprecationDetails?.replacedBy ?? effective;
+    const routed = model.routingDetails?.model;
+    if (routed && routed !== model.modelName && routed !== model.modelId) return model.deprecationDetails?.replacedBy ?? routed;
+    return null;
+}
+const VENDOR_LABELS = {
+    AnthropicClaude: 'Anthropic',
+    OpenAi: 'OpenAI',
+    AzureOpenAi: 'Azure OpenAI',
+    VertexAi: 'Google Vertex',
+    AwsBedrock: 'AWS Bedrock'
+};
+function vendorLabel(vendor) {
+    return VENDOR_LABELS[vendor] ?? vendor;
+}
+function formatDate(iso) {
+    const date = new Date(iso);
+    if (Number.isNaN(date.getTime())) return iso;
+    const dateOnly = /^\d{4}-\d{2}-\d{2}$/.test(iso);
+    return date.toLocaleDateString(void 0, {
+        month: 'short',
+        year: 'numeric',
+        ...dateOnly ? {
+            timeZone: 'UTC'
+        } : {}
+    });
+}
+function buildSubscriptionMatchers(ctx) {
+    const isRecommended = (m)=>void 0 !== ctx.recommendedModelIds ? listMatchesModel(ctx.recommendedModelIds, m) : m.isRecommended ?? (m.modelSubscriptionType === RECOMMENDED_SUBSCRIPTION && !m.isPreview && !m.deprecationDetails?.usageEndDate);
+    const isPreview = (m)=>void 0 !== ctx.previewModelIds ? listMatchesModel(ctx.previewModelIds, m) : !!m.isPreview;
+    const labels = ctx.labels ?? external_labels_cjs_namespaceObject.DEFAULT_MODEL_PICKER_LABELS;
+    return [
+        {
+            key: 'byo',
+            label: labels.byoGroup,
+            hint: labels.byoGroupHint,
+            match: (m)=>isByoModel(m)
+        },
+        {
+            key: 'recommended',
+            label: labels.recommendedGroup,
+            hint: labels.recommendedGroupHint,
+            match: (m)=>isRecommended(m) && !m.deprecationDetails?.usageEndDate
+        },
+        {
+            key: 'preview',
+            label: labels.previewGroup,
+            hint: labels.previewGroupHint,
+            match: (m)=>isPreview(m) && !isByoModel(m) && !m.deprecationDetails?.usageEndDate
+        },
+        {
+            key: 'more',
+            label: labels.moreGroup,
+            hint: labels.moreGroupHint,
+            match: (m)=>!isByoModel(m) && !m.deprecationDetails?.usageEndDate
+        },
+        {
+            key: 'deprecating',
+            label: labels.deprecatingGroup,
+            hint: labels.deprecatingGroupHint,
+            match: (m)=>!!m.deprecationDetails?.usageEndDate
+        },
+        {
+            key: 'shared',
+            label: labels.otherGroup,
+            match: ()=>true
+        }
+    ];
+}
+function groupModels(models, strategy = "subscription", context = {}) {
+    const labels = context.labels ?? external_labels_cjs_namespaceObject.DEFAULT_MODEL_PICKER_LABELS;
+    if ('flat' === strategy) return [
+        {
+            key: 'all',
+            label: labels.allModelsGroup,
+            models
+        }
+    ];
+    if ('vendor' === strategy) {
+        const byVendor = new Map();
+        const byo = [];
+        for (const m of models){
+            if (isByoModel(m)) {
+                byo.push(m);
+                continue;
+            }
+            const k = m.vendor || 'Other';
+            if (!byVendor.has(k)) byVendor.set(k, []);
+            byVendor.get(k).push(m);
+        }
+        const groups = [];
+        if (byo.length) groups.push({
+            key: 'byo',
+            label: labels.byoGroup,
+            models: byo
+        });
+        const matchers = buildSubscriptionMatchers(context);
+        const ranks = new Map();
+        const lifecycleRank = (m)=>{
+            let r = ranks.get(m);
+            if (void 0 === r) {
+                const i = matchers.findIndex((g)=>g.match(m));
+                r = -1 === i ? matchers.length : i;
+                ranks.set(m, r);
+            }
+            return r;
+        };
+        for (const [key, list] of byVendor.entries())groups.push({
+            key,
+            label: vendorLabel(key),
+            models: list.sort((a, b)=>lifecycleRank(a) - lifecycleRank(b))
+        });
+        return groups;
+    }
+    const matchers = buildSubscriptionMatchers(context);
+    const buckets = {};
+    for (const m of models){
+        const bucket = matchers.find((g)=>g.match(m));
+        if (!bucket) continue;
+        const list = buckets[bucket.key] ?? (buckets[bucket.key] = []);
+        list.push(m);
+    }
+    const out = [];
+    for (const g of matchers){
+        const list = buckets[g.key];
+        if (list?.length) out.push({
+            key: g.key,
+            label: g.label,
+            hint: g.hint,
+            models: list
+        });
+    }
+    return out;
+}
+function filterModels(models, query) {
+    const q = query.trim().toLowerCase();
+    if (!q) return models;
+    return models.filter((m)=>{
+        const haystack = [
+            m.modelName,
+            m.displayName,
+            m.modelId,
+            m.vendor,
+            m.modelFamily,
+            m.effectiveModel,
+            m.byoConnectionLabel
+        ].filter(Boolean).join(' ').toLowerCase();
+        return haystack.includes(q);
+    });
+}
+exports.defaultCostTier = __webpack_exports__.defaultCostTier;
+exports.deriveModelTags = __webpack_exports__.deriveModelTags;
+exports.filterModels = __webpack_exports__.filterModels;
+exports.getSubstitutionTarget = __webpack_exports__.getSubstitutionTarget;
+exports.groupModels = __webpack_exports__.groupModels;
+exports.isByoModel = __webpack_exports__.isByoModel;
+exports.isTextGenerationModel = __webpack_exports__.isTextGenerationModel;
+exports.resolveHomeGeography = __webpack_exports__.resolveHomeGeography;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "defaultCostTier",
+    "deriveModelTags",
+    "filterModels",
+    "getSubstitutionTarget",
+    "groupModels",
+    "isByoModel",
+    "isTextGenerationModel",
+    "resolveHomeGeography"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});