forked from veniceai/api-docs
-
Notifications
You must be signed in to change notification settings - Fork 0
Expand file tree
/
Copy pathmodel-search.js
More file actions
3230 lines (2838 loc) · 140 KB
/
Copy pathmodel-search.js
File metadata and controls
3230 lines (2838 loc) · 140 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
// Scroll-position safeguard for the Demos landing page.
//
// This site runs with history.scrollRestoration === "auto", so on SPA
// navigation the browser can asynchronously restore a prior scroll offset onto
// the newly rendered page. The Demos overview page is short and has its sidebar
// and "On this page" column hidden, so any restored offset from a taller source
// page is very visible (the page lands scrolled down). We watch the
// data-current-path attribute Mintlify sets on <html> and force the window back
// to the top whenever we land on that route, beating the browser's async
// restoration. Scoped to this one route so it can't affect anchor links or
// scroll behavior anywhere else.
(function() {
var DEMOS_PATH = '/guides/projects/overview';
function resetIfDemos() {
if (document.documentElement.getAttribute('data-current-path') === DEMOS_PATH) {
window.scrollTo(0, 0);
// Re-assert across a few ticks to beat late async browser scroll
// restoration, which can fire after the route attribute updates.
requestAnimationFrame(function() { window.scrollTo(0, 0); });
setTimeout(function() { window.scrollTo(0, 0); }, 60);
}
}
new MutationObserver(resetIfDemos).observe(document.documentElement, {
attributes: true,
attributeFilter: ['data-current-path'],
});
resetIfDemos();
})();
// Relocate the language selector into the right-hand header actions cluster.
//
// Mintlify natively renders the language selector in the left group (next to the
// logo). We want it on the right, just left of the search / Ask AI / theme icon
// group. Rather than absolutely positioning it -- which collides whenever
// Mintlify adds another header button (e.g. the AI assistant) -- we move the
// node into the right actions cluster so it lays out in natural flex flow. The
// header is re-rendered on SPA navigation, so we re-run on DOM changes,
// idempotently and coalesced via requestAnimationFrame to avoid churn.
(function() {
function relocate() {
const trigger = document.querySelector('#localization-select-trigger');
const search = document.querySelector('#search-bar-entry');
if (!trigger || !search) return;
const langWrapper = trigger.parentElement; // <div> wrapping the trigger
const iconGroup = search.parentElement; // <div> holding search + Ask AI
const cluster = iconGroup ? iconGroup.parentElement : null; // right actions cluster
if (!langWrapper || !iconGroup || !cluster) return;
// Already placed immediately before the icon group -> nothing to do (this
// guard also stops our own DOM mutation from causing a relocate loop).
if (langWrapper.parentElement === cluster && langWrapper.nextElementSibling === iconGroup) return;
cluster.insertBefore(langWrapper, iconGroup);
}
let scheduled = false;
function schedule() {
if (scheduled) return;
scheduled = true;
requestAnimationFrame(function() { scheduled = false; relocate(); });
}
new MutationObserver(schedule).observe(document.documentElement, {
childList: true,
subtree: true,
});
relocate();
})();
// Venice AI Model Browser & Pricing Tables - Fetches from API
(function() {
// ========== FEATURE FLAGS ==========
const ENABLE_VIDEO = true; // Video models on /models pages
// ===================================
// Configuration
const API_BASE = 'https://api.venice.ai/api/v1/models';
const MODEL_TYPES = ['text', 'image', 'tts', 'embedding', 'upscale', 'inpaint', 'asr', 'music', ...(ENABLE_VIDEO ? ['video'] : [])];
const CACHE_KEY = 'venice-models-cache';
const CACHE_TTL = 5 * 60 * 1000; // 5 minutes
// Static fallback data for fast first paint. Loaded from a cacheable JSON file
// rather than inlined here, because Mintlify injects this script into every page.
const STATIC_MODELS_URL = '/data/static-models.json';
let STATIC_MODELS = [];
let staticModelsPromise = null;
// Resolves once STATIC_MODELS is populated. Falls back to the live API so the
// tables still render if the snapshot is unavailable.
function ensureStaticModels() {
if (staticModelsPromise) return staticModelsPromise;
staticModelsPromise = fetch(STATIC_MODELS_URL)
.then(r => {
if (!r.ok) throw new Error(`snapshot returned ${r.status}`);
return r.json();
})
.then(models => {
if (Array.isArray(models) && models.length > 0) STATIC_MODELS = models;
return STATIC_MODELS;
})
.catch(() => fetchModelsFromAPI()
.then(models => {
if (models.length > 0) STATIC_MODELS = models;
return STATIC_MODELS;
})
.catch(() => STATIC_MODELS));
return staticModelsPromise;
}
// Privacy types that are always private (no API privacy field needed)
const PRIVATE_TYPES = new Set(['upscale']);
// Rate limit tiers - default limits by model size category
// Models not listed default to their type's standard tier
const RATE_LIMIT_TIERS = {
xsmall: { rpm: 500, tpm: 1000000, label: 'XS', tooltip: 'Rate Limit: 500 RPM · 1M TPM' },
small: { rpm: 75, tpm: 750000, label: 'S', tooltip: 'Rate Limit: 75 RPM · 750K TPM' },
medium: { rpm: 50, tpm: 750000, label: 'M', tooltip: 'Rate Limit: 50 RPM · 750K TPM' },
large: { rpm: 20, tpm: 500000, label: 'L', tooltip: 'Rate Limit: 20 RPM · 500K TPM' }
};
// Model to rate limit tier mapping (text/embedding models only)
const MODEL_RATE_LIMIT_TIER = {
// XSmall - fastest/smallest models
'qwen3-4b': 'xsmall',
'llama-3.2-3b': 'xsmall',
'text-embedding-bge-m3': 'xsmall',
// Small - efficient mid-size models
'mistral-31-24b': 'small',
'venice-uncensored': 'small',
// Medium - capable models
'llama-3.3-70b': 'medium',
'qwen3-next-80b': 'medium',
'google-gemma-3-27b-it': 'medium',
// Large - flagship models (default for unknown text models)
'qwen3-235b': 'large',
'qwen3-235b-a22b-instruct-2507': 'large',
'qwen3-235b-a22b-thinking-2507': 'large',
'grok-41-fast': 'large',
'kimi-k2-thinking': 'large',
'gemini-3-pro-preview': 'large',
'hermes-3-llama-3.1-405b': 'large',
'qwen3-coder-480b-a35b-instruct': 'large',
'zai-org-glm-4.7': 'large',
'openai-gpt-oss-120b': 'large'
};
function getModelRateLimitTier(modelId, modelType) {
if (modelType !== 'text' && modelType !== 'embedding') return null;
return MODEL_RATE_LIMIT_TIER[modelId] || 'large'; // Default to large for unknown text models
}
// Video model display configuration (can't be detected from API)
// - audioPricing: show audio toggle (price differs with audio on/off)
// - resPricing: false = hide resolution dropdown (price same at all resolutions)
// Note: audio_configurable in API just means toggle exists, not that price changes
const VIDEO_MODEL_CONFIG = {
// Veo 3.1 - audio toggle available, resolution doesn't affect price
'veo3.1-fast-text-to-video': { audioPricing: true, resPricing: false },
'veo3.1-full-text-to-video': { audioPricing: true, resPricing: false },
'veo3.1-fast-image-to-video': { resPricing: false },
'veo3.1-full-image-to-video': { resPricing: false },
// Veo 3 - no audio toggle, resolution doesn't affect price
'veo3-fast-text-to-video': { resPricing: false },
'veo3-full-text-to-video': { resPricing: false },
'veo3-fast-image-to-video': { resPricing: false },
'veo3-full-image-to-video': { resPricing: false },
// Kling 2.6 Pro - audio toggle available
'kling-2.6-pro-text-to-video': { audioPricing: true },
// Sora 2 (non-Pro) - only has 720p, resolution doesn't matter
'sora-2-text-to-video': { resPricing: false },
'sora-2-image-to-video': { resPricing: false },
};
function getVideoModelConfig(modelId) {
return VIDEO_MODEL_CONFIG[modelId] || {};
}
const videoQuoteCache = new Map();
const inferredVideoDurations = new Map();
const inferredVideoAspectRatios = new Map();
function getAspectRatios(constraints) {
const ar = constraints.aspect_ratios;
if (!ar) return [];
if (Array.isArray(ar)) return ar;
if (typeof ar === 'string') return [ar];
return [];
}
function extractSupportedIssueValues(errorData, field, pattern) {
if (!Array.isArray(errorData?.issues)) return [];
const matches = errorData.issues
.filter(issue => Array.isArray(issue.path) && issue.path[0] === field && typeof issue.expected === 'string')
.flatMap(issue => issue.expected.match(pattern) || []);
return [...new Set(
matches
.map(match => match.slice(1, -1))
)];
}
function extractSupportedDurations(errorData) {
return extractSupportedIssueValues(errorData, 'duration', /'(\d+s)'/g)
.filter(value => /^\d+s$/.test(value));
}
function extractSupportedAspectRatios(errorData) {
return extractSupportedIssueValues(errorData, 'aspect_ratio', /'(\d+:\d+)'/g)
.filter(value => /^\d+:\d+$/.test(value));
}
async function requestVideoQuote(body) {
const res = await fetch('https://api.venice.ai/api/v1/video/quote', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify(body)
});
let data = null;
try {
data = await res.json();
} catch {
data = null;
}
return { ok: res.ok, data };
}
function isFixedPriceModel(modelId, model) {
if (!model) return false;
const constraints = model.model_spec?.constraints || {};
const config = getVideoModelConfig(modelId);
const durations = constraints.durations || [];
const resolutions = constraints.resolutions || [];
const resPricing = config.resPricing !== false;
// Fixed if: single duration AND (single/no resolution OR resolution doesn't affect price)
return durations.length <= 1 && (resolutions.length <= 1 || !resPricing);
}
// Placeholder image for I2V quote requests (price is same regardless of image content)
const PLACEHOLDER_IMAGE_URL = 'https://venice.ai/favicon.ico';
const MODEL_ICON_BASE_PATH = '/images/icons/models/';
const MODEL_TYPE_ICON_BY_TYPE = {
asr: 'text.svg',
embedding: 'text.svg',
image: 'image.svg',
inpaint: 'image.svg',
music: 'music.svg',
text: 'text.svg',
tts: 'music.svg',
upscale: 'image.svg',
video: 'video.svg'
};
// Mirrors the interface API catalog's best-effort provider/logo matching for
// API-only models whose public response does not include an assetPath.
// Order matters: the first rule whose pattern is a substring of the haystack
// (id + name + modelSource, lowercased) wins. Keep broad provider prefixes
// ('google' before 'gemma', 'openai' before 'sora') ahead of narrower ones.
const SYNTHETIC_PROVIDER_ASSET_RULES = [
['openai.svg', ['openai', 'gpt-image', 'whisper', 'sora']],
['grok.svg', ['grok', 'x.ai', 'xai']],
['qwen.svg', ['qwen', 'wan-', 'tongyi']],
['google.svg', ['google', 'gemini', 'veo', 'nano-banana']],
['gemma.svg', ['gemma']],
['bytedance.svg', ['bytedance', 'seedance', 'seedream', 'doubao']],
['BlackForestLabs.svg', ['black forest', 'blackforest', 'flux-']],
['Zhipu.svg', ['zai-org', 'z-ai', 'glm', 'zhipu']],
['nvidia.svg', ['nvidia', 'parakeet']],
['minimax.svg', ['minimax', 'hailuo']],
['elevenlabs.svg', ['elevenlabs']],
['runway.svg', ['runway']],
['pixversevideo.svg', ['pixverse']],
['kling.svg', ['kling']],
['vidu.svg', ['vidu']],
['hunyuan.svg', ['hunyuan']],
['imagineart.svg', ['imagineart']],
['ltx.svg', ['ltx', 'lightricks']],
['kimi.svg', ['moonshot', 'kimi']],
['arcee-ai.svg', ['arcee']],
['deepseek.svg', ['deepseek']],
['HiDreamLogo.svg', ['hidream']],
['aionlabs.svg', ['aionlabs', 'aion-labs']],
['stable-audio.svg', ['stable-audio']],
['opus.svg', ['claude', 'anthropic']],
['mistral.svg', ['mistral']],
['meta.svg', ['llama', 'meta-llama']],
['ideogram.svg', ['ideogram']],
['longcat.svg', ['longcat']],
['topaz.svg', ['topaz']],
['ovi.svg', ['ovi-']],
['krea.svg', ['krea']],
['inception.svg', ['mercury', 'inception']],
['venice-keys.svg', ['venice', 'firered', 'z-image', 'chroma', 'upscaler']]
];
// Circuit breaker: stop fetching video quotes after repeated CORS/network failures
let videoQuoteFailures = 0;
const VIDEO_QUOTE_MAX_FAILURES = 2;
async function fetchVideoQuote(modelId, model, { resolution, duration, audio } = {}) {
// Circuit breaker: if we've hit too many failures (likely CORS), stop trying
if (videoQuoteFailures >= VIDEO_QUOTE_MAX_FAILURES) {
return null;
}
const constraints = model.model_spec?.constraints || {};
const isImageToVideo = constraints.model_type === 'image-to-video';
const inferredDuration = inferredVideoDurations.get(modelId);
const inferredAspectRatio = inferredVideoAspectRatios.get(modelId);
const defaultDuration = Array.isArray(constraints.durations) ? constraints.durations[0] : inferredDuration;
const effectiveDuration = duration || defaultDuration;
const aspectRatios = getAspectRatios(constraints);
const aspectRatio = aspectRatios[0] || inferredAspectRatio;
const cacheKey = `${modelId}:${resolution || 'default'}:${effectiveDuration || 'default'}:${aspectRatio || 'default'}:${audio ?? 'default'}`;
if (videoQuoteCache.has(cacheKey)) {
return videoQuoteCache.get(cacheKey);
}
const body = { model: modelId, prompt: 'quote' };
if (isImageToVideo) body.image_url = PLACEHOLDER_IMAGE_URL;
if (resolution) body.resolution = resolution;
if (effectiveDuration) body.duration = effectiveDuration;
if (aspectRatio) body.aspect_ratio = aspectRatio;
// Only send audio if explicitly set (true/false), not undefined
if (typeof audio === 'boolean') body.audio = audio;
try {
let quoteRes = await requestVideoQuote(body);
if (!quoteRes.ok && (!effectiveDuration || !aspectRatio)) {
const fallbackDuration = !effectiveDuration ? extractSupportedDurations(quoteRes.data)[0] : undefined;
const fallbackAspectRatio = !aspectRatio ? extractSupportedAspectRatios(quoteRes.data)[0] : undefined;
if (fallbackDuration || fallbackAspectRatio) {
if (fallbackDuration) {
inferredVideoDurations.set(modelId, fallbackDuration);
body.duration = fallbackDuration;
}
if (fallbackAspectRatio) {
inferredVideoAspectRatios.set(modelId, fallbackAspectRatio);
body.aspect_ratio = fallbackAspectRatio;
}
quoteRes = await requestVideoQuote(body);
}
}
if (!quoteRes.ok) return null;
const quote = quoteRes.data?.quote;
if (quote == null) return null;
videoQuoteCache.set(cacheKey, quote);
if ((body.duration && body.duration !== effectiveDuration) || (body.aspect_ratio && body.aspect_ratio !== aspectRatio)) {
const resolvedCacheKey = `${modelId}:${resolution || 'default'}:${body.duration || 'default'}:${body.aspect_ratio || 'default'}:${audio ?? 'default'}`;
videoQuoteCache.set(resolvedCacheKey, quote);
}
return quote;
} catch {
videoQuoteFailures++;
return null;
}
}
// Capability filters only apply to text/chat models.
function categoryAllowsCapabilityFilters(category) {
return category === 'all' || category === 'text';
}
// ========== I18N (filter/sort UI chrome) ==========
// The model browser UI is rendered by JS, so its labels can't be localized by
// Mintlify's per-language content. We detect the locale from the URL prefix
// (e.g. /es/models/...) and translate the visible chrome. Keys are the English
// source strings; unknown keys fall back to English.
const SUPPORTED_LOCALES = ['pt-BR', 'ar', 'it', 'de', 'es', 'fr', 'zh', 'ko'];
function detectLocale() {
try {
const seg = (location.pathname.split('/')[1] || '').toLowerCase();
const hit = SUPPORTED_LOCALES.find(l => l.toLowerCase() === seg);
if (hit) return hit;
const htmlLang = (document.documentElement.getAttribute('lang') || '').trim();
const byLang = SUPPORTED_LOCALES.find(l => l.toLowerCase() === htmlLang.toLowerCase());
if (byLang) return byLang;
} catch (e) {}
return 'en';
}
const LOCALE = detectLocale();
const I18N = {
'pt-BR': { 'Type': 'Tipo', 'Kind': 'Categoria', 'Capability': 'Recurso', 'Privacy': 'Privacidade', 'All types': 'Todos os tipos', 'Text': 'Texto', 'Image': 'Imagem', 'Video': 'Vídeo', 'Audio': 'Áudio', 'Embedding': 'Embedding', 'Generation': 'Geração', 'Upscale': 'Ampliação', 'Edit': 'Edição', 'Uncensored': 'Sem censura', 'Text to Video': 'Texto para vídeo', 'Image to Video': 'Imagem para vídeo', 'Reasoning': 'Raciocínio', 'Vision': 'Visão', 'Function Calling': 'Chamada de funções', 'Code': 'Código', 'Private': 'Privado', 'Anonymized': 'Anonimizado', 'Sort': 'Ordenar', 'Sort models': 'Ordenar modelos', 'Search models': 'Buscar modelos', 'Recommended': 'Recomendado', 'Newest': 'Mais recentes', 'Oldest': 'Mais antigos', 'Name (A–Z)': 'Nome (A–Z)', 'Price: Low to High': 'Preço: menor para maior', 'Price: High to Low': 'Preço: maior para menor', 'Clear filters': 'Limpar filtros', 'Search models...': 'Buscar modelos...', 'models': 'modelos', 'closest matches': 'correspondências mais próximas', 'No close model matches': 'Nenhum modelo próximo encontrado', 'No models match your filters': 'Nenhum modelo corresponde aos seus filtros' },
'ar': { 'Type': 'النوع', 'Kind': 'الفئة', 'Capability': 'القدرة', 'Privacy': 'الخصوصية', 'All types': 'كل الأنواع', 'Text': 'نص', 'Image': 'صورة', 'Video': 'فيديو', 'Audio': 'صوت', 'Embedding': 'تضمين', 'Generation': 'توليد', 'Upscale': 'تحسين الدقة', 'Edit': 'تحرير', 'Uncensored': 'بدون رقابة', 'Text to Video': 'نص إلى فيديو', 'Image to Video': 'صورة إلى فيديو', 'Reasoning': 'استدلال', 'Vision': 'رؤية', 'Function Calling': 'استدعاء الدوال', 'Code': 'برمجة', 'Private': 'خاص', 'Anonymized': 'مجهول الهوية', 'Sort': 'ترتيب', 'Sort models': 'ترتيب النماذج', 'Search models': 'بحث في النماذج', 'Recommended': 'موصى به', 'Newest': 'الأحدث', 'Oldest': 'الأقدم', 'Name (A–Z)': 'الاسم (أ–ي)', 'Price: Low to High': 'السعر: من الأقل إلى الأعلى', 'Price: High to Low': 'السعر: من الأعلى إلى الأقل', 'Clear filters': 'مسح عوامل التصفية', 'Search models...': 'بحث في النماذج...', 'models': 'نماذج', 'closest matches': 'أقرب النتائج', 'No close model matches': 'لا توجد نماذج قريبة', 'No models match your filters': 'لا توجد نماذج تطابق عوامل التصفية' },
'it': { 'Type': 'Tipo', 'Kind': 'Categoria', 'Capability': 'Capacità', 'Privacy': 'Privacy', 'All types': 'Tutti i tipi', 'Text': 'Testo', 'Image': 'Immagine', 'Video': 'Video', 'Audio': 'Audio', 'Embedding': 'Embedding', 'Generation': 'Generazione', 'Upscale': 'Upscaling', 'Edit': 'Modifica', 'Uncensored': 'Senza censura', 'Text to Video': 'Testo in video', 'Image to Video': 'Immagine in video', 'Reasoning': 'Ragionamento', 'Vision': 'Visione', 'Function Calling': 'Chiamata di funzioni', 'Code': 'Codice', 'Private': 'Privato', 'Anonymized': 'Anonimizzato', 'Sort': 'Ordina', 'Sort models': 'Ordina modelli', 'Search models': 'Cerca modelli', 'Recommended': 'Consigliati', 'Newest': 'Più recenti', 'Oldest': 'Meno recenti', 'Name (A–Z)': 'Nome (A–Z)', 'Price: Low to High': 'Prezzo: dal più basso', 'Price: High to Low': 'Prezzo: dal più alto', 'Clear filters': 'Cancella filtri', 'Search models...': 'Cerca modelli...', 'models': 'modelli', 'closest matches': 'corrispondenze più vicine', 'No close model matches': 'Nessun modello simile trovato', 'No models match your filters': 'Nessun modello corrisponde ai filtri' },
'de': { 'Type': 'Typ', 'Kind': 'Art', 'Capability': 'Fähigkeit', 'Privacy': 'Datenschutz', 'All types': 'Alle Typen', 'Text': 'Text', 'Image': 'Bild', 'Video': 'Video', 'Audio': 'Audio', 'Embedding': 'Embedding', 'Generation': 'Generierung', 'Upscale': 'Hochskalierung', 'Edit': 'Bearbeiten', 'Uncensored': 'Unzensiert', 'Text to Video': 'Text zu Video', 'Image to Video': 'Bild zu Video', 'Reasoning': 'Reasoning', 'Vision': 'Vision', 'Function Calling': 'Function Calling', 'Code': 'Code', 'Private': 'Privat', 'Anonymized': 'Anonymisiert', 'Sort': 'Sortieren', 'Sort models': 'Modelle sortieren', 'Search models': 'Modelle suchen', 'Recommended': 'Empfohlen', 'Newest': 'Neueste', 'Oldest': 'Älteste', 'Name (A–Z)': 'Name (A–Z)', 'Price: Low to High': 'Preis: aufsteigend', 'Price: High to Low': 'Preis: absteigend', 'Clear filters': 'Filter zurücksetzen', 'Search models...': 'Modelle suchen...', 'models': 'Modelle', 'closest matches': 'nächste Treffer', 'No close model matches': 'Keine ähnlichen Modelle gefunden', 'No models match your filters': 'Keine Modelle entsprechen deinen Filtern' },
'es': { 'Type': 'Tipo', 'Kind': 'Categoría', 'Capability': 'Capacidad', 'Privacy': 'Privacidad', 'All types': 'Todos los tipos', 'Text': 'Texto', 'Image': 'Imagen', 'Video': 'Vídeo', 'Audio': 'Audio', 'Embedding': 'Embedding', 'Generation': 'Generación', 'Upscale': 'Escalado', 'Edit': 'Edición', 'Uncensored': 'Sin censura', 'Text to Video': 'Texto a vídeo', 'Image to Video': 'Imagen a vídeo', 'Reasoning': 'Razonamiento', 'Vision': 'Visión', 'Function Calling': 'Llamada de funciones', 'Code': 'Código', 'Private': 'Privado', 'Anonymized': 'Anonimizado', 'Sort': 'Ordenar', 'Sort models': 'Ordenar modelos', 'Search models': 'Buscar modelos', 'Recommended': 'Recomendado', 'Newest': 'Más recientes', 'Oldest': 'Más antiguos', 'Name (A–Z)': 'Nombre (A–Z)', 'Price: Low to High': 'Precio: de menor a mayor', 'Price: High to Low': 'Precio: de mayor a menor', 'Clear filters': 'Borrar filtros', 'Search models...': 'Buscar modelos...', 'models': 'modelos', 'closest matches': 'coincidencias más cercanas', 'No close model matches': 'No hay modelos parecidos', 'No models match your filters': 'Ningún modelo coincide con tus filtros' },
'fr': { 'Type': 'Type', 'Kind': 'Catégorie', 'Capability': 'Capacité', 'Privacy': 'Confidentialité', 'All types': 'Tous les types', 'Text': 'Texte', 'Image': 'Image', 'Video': 'Vidéo', 'Audio': 'Audio', 'Embedding': 'Embedding', 'Generation': 'Génération', 'Upscale': 'Agrandissement', 'Edit': 'Édition', 'Uncensored': 'Sans censure', 'Text to Video': 'Texte vers vidéo', 'Image to Video': 'Image vers vidéo', 'Reasoning': 'Raisonnement', 'Vision': 'Vision', 'Function Calling': 'Appel de fonctions', 'Code': 'Code', 'Private': 'Privé', 'Anonymized': 'Anonymisé', 'Sort': 'Trier', 'Sort models': 'Trier les modèles', 'Search models': 'Rechercher des modèles', 'Recommended': 'Recommandé', 'Newest': 'Plus récents', 'Oldest': 'Plus anciens', 'Name (A–Z)': 'Nom (A–Z)', 'Price: Low to High': 'Prix : croissant', 'Price: High to Low': 'Prix : décroissant', 'Clear filters': 'Effacer les filtres', 'Search models...': 'Rechercher des modèles...', 'models': 'modèles', 'closest matches': 'correspondances les plus proches', 'No close model matches': 'Aucun modèle proche', 'No models match your filters': 'Aucun modèle ne correspond à vos filtres' },
'zh': { 'Type': '类型', 'Kind': '类别', 'Capability': '能力', 'Privacy': '隐私', 'All types': '全部类型', 'Text': '文本', 'Image': '图像', 'Video': '视频', 'Audio': '音频', 'Embedding': '嵌入', 'Generation': '生成', 'Upscale': '放大', 'Edit': '编辑', 'Uncensored': '无审查', 'Text to Video': '文本转视频', 'Image to Video': '图像转视频', 'Reasoning': '推理', 'Vision': '视觉', 'Function Calling': '函数调用', 'Code': '代码', 'Private': '私有', 'Anonymized': '匿名化', 'Sort': '排序', 'Sort models': '排序模型', 'Search models': '搜索模型', 'Recommended': '推荐', 'Newest': '最新', 'Oldest': '最早', 'Name (A–Z)': '名称 (A–Z)', 'Price: Low to High': '价格：从低到高', 'Price: High to Low': '价格：从高到低', 'Clear filters': '清除筛选', 'Search models...': '搜索模型...', 'models': '个模型', 'closest matches': '最接近的结果', 'No close model matches': '没有相近的模型', 'No models match your filters': '没有符合筛选条件的模型' },
'ko': { 'Type': '유형', 'Kind': '종류', 'Capability': '기능', 'Privacy': '개인정보', 'All types': '모든 유형', 'Text': '텍스트', 'Image': '이미지', 'Video': '비디오', 'Audio': '오디오', 'Embedding': '임베딩', 'Generation': '생성', 'Upscale': '업스케일', 'Edit': '편집', 'Uncensored': '무검열', 'Text to Video': '텍스트→비디오', 'Image to Video': '이미지→비디오', 'Reasoning': '추론', 'Vision': '비전', 'Function Calling': '함수 호출', 'Code': '코드', 'Private': '프라이빗', 'Anonymized': '익명화', 'Sort': '정렬', 'Sort models': '모델 정렬', 'Search models': '모델 검색', 'Recommended': '추천', 'Newest': '최신순', 'Oldest': '오래된순', 'Name (A–Z)': '이름 (A–Z)', 'Price: Low to High': '가격: 낮은순', 'Price: High to Low': '가격: 높은순', 'Clear filters': '필터 지우기', 'Search models...': '모델 검색...', 'models': '개 모델', 'closest matches': '가장 근접한 결과', 'No close model matches': '유사한 모델이 없습니다', 'No models match your filters': '필터와 일치하는 모델이 없습니다' }
};
function t(s) {
if (LOCALE === 'en') return s;
const table = I18N[LOCALE];
return (table && table[s] != null) ? table[s] : s;
}
// ========== FILTER DROPDOWNS ==========
// The model browser filters are grouped into focused dropdowns instead of a
// flat wall of pills. Type/Kind/Privacy are single-select; Capability is
// multi-select (AND semantics, e.g. Reasoning + Vision).
const FILTER_GROUPS = {
type: {
label: 'Type', mode: 'single', default: 'all',
options: [
{ value: 'all', label: 'All types' },
{ value: 'text', label: 'Text' },
{ value: 'image', label: 'Image' },
...(ENABLE_VIDEO ? [{ value: 'video', label: 'Video' }] : []),
{ value: 'audio', label: 'Audio' },
{ value: 'embedding', label: 'Embedding' },
],
},
image: {
label: 'Kind', mode: 'single', default: null,
options: [
{ value: 'image-gen', label: 'Generation' },
{ value: 'image-upscale', label: 'Upscale' },
{ value: 'image-edit', label: 'Edit' },
{ value: 'image-uncensored', label: 'Uncensored' },
],
},
video: {
label: 'Kind', mode: 'single', default: null,
options: [
{ value: 'text-to-video', label: 'Text to Video' },
{ value: 'image-to-video', label: 'Image to Video' },
],
},
capability: {
label: 'Capability', mode: 'multi', default: null,
options: [
{ value: 'reasoning', label: 'Reasoning' },
{ value: 'vision', label: 'Vision' },
{ value: 'function', label: 'Function Calling' },
{ value: 'code', label: 'Code' },
],
},
privacy: {
label: 'Privacy', mode: 'single', default: null,
options: [
{ value: 'e2ee', label: 'E2EE' },
{ value: 'tee', label: 'TEE' },
{ value: 'private', label: 'Private' },
{ value: 'anonymized', label: 'Anonymized' },
],
},
};
const FILTER_CHEVRON = '<svg class="vmb-dd-chevron" width="12" height="12" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.5" stroke-linecap="round" stroke-linejoin="round"><path d="M6 9l6 6 6-6"/></svg>';
const FILTER_CHECK = '<svg class="vmb-dd-check" width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="3" stroke-linecap="round" stroke-linejoin="round"><polyline points="20 6 9 17 4 12"/></svg>';
const SORT_ICON = '<svg class="vmb-dd-sort-icon" width="15" height="15" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M11 5h10M11 9h7M11 13h4M3 17l3 3 3-3M6 18V4"/></svg>';
// Sort options (single-select). `default` preserves the API's curated order and
// is the natural resting state on preset pages; the overview page defaults to
// newest. All values are handled by sortModels().
const SORT_OPTIONS = [
{ value: 'default', label: 'Recommended' },
{ value: 'newest', label: 'Newest' },
{ value: 'oldest', label: 'Oldest' },
{ value: 'name', label: 'Name (A–Z)' },
{ value: 'price-low', label: 'Price: Low to High' },
{ value: 'price-high', label: 'Price: High to Low' },
];
function renderSortDropdown() {
const opts = SORT_OPTIONS.map(o =>
`<button type="button" class="vmb-dd-option" role="option" aria-selected="false" data-value="${o.value}">` +
`<span class="vmb-dd-option-label">${t(o.label)}</span>${FILTER_CHECK}` +
`</button>`
).join('');
return (
`<div class="vmb-dd vmb-sort-dd">` +
`<button type="button" class="vmb-dd-trigger" aria-haspopup="listbox" aria-expanded="false" aria-label="${t('Sort models')}">` +
`${SORT_ICON}<span class="vmb-dd-label">${t('Sort')}</span>${FILTER_CHEVRON}` +
`</button>` +
`<div class="vmb-dd-panel" role="listbox" aria-label="${t('Sort models')}" hidden>${opts}</div>` +
`</div>`
);
}
function renderFilterDropdown(key, group) {
const opts = group.options.map(o =>
`<button type="button" class="vmb-dd-option" role="option" aria-selected="false" data-group="${key}" data-value="${o.value}">` +
`<span class="vmb-dd-option-label">${t(o.label)}</span>${FILTER_CHECK}` +
`</button>`
).join('');
return (
`<div class="vmb-dd" data-group="${key}" data-mode="${group.mode}">` +
`<button type="button" class="vmb-dd-trigger" aria-haspopup="listbox" aria-expanded="false">` +
`<span class="vmb-dd-label">${t(group.label)}</span>${FILTER_CHEVRON}` +
`</button>` +
`<div class="vmb-dd-panel" role="listbox" aria-label="${t(group.label)}" hidden>${opts}</div>` +
`</div>`
);
}
const MODEL_SEARCH_ALIASES = {
gpt4: ['gpt-4', 'gpt 4', 'openai gpt-4'],
gpt4o: ['gpt-4o', 'gpt 4o', 'openai gpt-4o'],
llama: ['meta-llama', 'meta llama'],
sonnet: ['claude-sonnet', 'claude sonnet'],
opus: ['claude-opus', 'claude opus']
};
const modelSearchIndexCache = new WeakMap();
// Tooltip text
const TOOLTIPS = {
e2ee: 'Private model with end-to-end encryption. Your prompt is encrypted in your browser and only decrypted inside a hardware-secured enclave (TEE). The response is encrypted before leaving the enclave. No prompt data is ever accessible to Venice or the infrastructure provider.',
tee: 'Private model running in a Trusted Execution Environment (TEE). Inference runs inside a hardware-secured enclave with cryptographic attestation. No prompt data is stored or accessible outside the enclave.',
private: 'Private model with zero data retention. No prompt data is stored or shared with any third party.',
anonymized: 'The model provider may retain prompt data, though it is anonymized by Venice. For sensitive content, use a Private, TEE, or E2EE model.',
beta: 'Experimental model that may change or be removed without notice. Not recommended for production.',
deprecated: 'This model is scheduled for removal. See the deprecations page for timeline and migration guide.',
uncensored: 'Responds to all prompts without content-based refusals or filtering.',
upgraded: 'A newer version of this model is available with improved performance.',
content_moderation: 'This model applies upstream content moderation. Requests blocked by the provider\u2019s filters are still billed at the full rate.'
};
// Models subject to upstream provider content moderation that still bills on blocked requests
const CONTENT_MODERATED_MODELS = new Set([
'grok-imagine',
'grok-imagine-edit',
'grok-imagine-text-to-video',
'grok-imagine-image-to-video'
]);
function hasContentModeration(modelId) {
return CONTENT_MODERATED_MODELS.has(modelId);
}
let isInitializing = false;
// Helpers
function formatContext(tokens) {
if (tokens >= 1000000) return (tokens / 1000000).toFixed(1) + 'M';
if (tokens >= 1000) return Math.round(tokens / 1000) + 'K';
return tokens;
}
function formatAddedDate(timestamp) {
if (!timestamp) return null;
const date = new Date(timestamp * 1000);
const now = new Date();
const diffMs = now - date;
const diffDays = Math.floor(diffMs / (1000 * 60 * 60 * 24));
const months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
// Format: "Jan 15, 2025"
const dateStr = `${months[date.getMonth()]} ${date.getDate()}, ${date.getFullYear()}`;
// New models (< 30 days) get a "NEW" badge
const isNew = diffDays <= 30;
return { dateStr, isNew };
}
function formatPrice(price) {
if (price === null || price === undefined) return '-';
if (price < 0.01 && price > 0) return '$' + price.toFixed(4);
return '$' + price.toFixed(2);
}
function formatVideoPricing(modelId, model) {
const isFixed = isFixedPriceModel(modelId, model);
const prefix = isFixed ? '<span class="vmb-fixed-label">FIXED</span> ' : '';
return `${prefix}<span class="vmb-video-price" data-model="${modelId}">Variable</span>`;
}
async function updateVideoPrice(modelId, model, { resolution, duration, audio } = {}, container) {
const priceEl = (container || document).querySelector(`.vmb-video-price[data-model="${modelId}"]`);
if (!priceEl) return;
const price = await fetchVideoQuote(modelId, model, { resolution, duration, audio });
if (price !== null) {
priceEl.textContent = formatPrice(price);
} else {
priceEl.textContent = 'Variable';
}
}
// Capability icons (simple SVG line icons)
const CAP_ICONS = {
// Plug icon - connects to external tools/APIs
function: '<svg class="vmb-cap-icon" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M12 22v-5"/><path d="M9 8V2"/><path d="M15 8V2"/><path d="M18 8v5a4 4 0 0 1-4 4h-4a4 4 0 0 1-4-4V8Z"/></svg>',
// Brain icon - thinking/reasoning
reasoning: '<svg class="vmb-cap-icon" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M12 5a3 3 0 1 0-5.997.125 4 4 0 0 0-2.526 5.77 4 4 0 0 0 .556 6.588A4 4 0 1 0 12 18Z"/><path d="M12 5a3 3 0 1 1 5.997.125 4 4 0 0 1 2.526 5.77 4 4 0 0 1-.556 6.588A4 4 0 1 1 12 18Z"/><path d="M15 13a4.5 4.5 0 0 1-3-4 4.5 4.5 0 0 1-3 4"/><path d="M12 18v-5"/></svg>',
// Eye icon - vision/image understanding
vision: '<svg class="vmb-cap-icon" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M2 12s3-7 10-7 10 7 10 7-3 7-10 7-10-7-10-7Z"/><circle cx="12" cy="12" r="3"/></svg>',
// Code brackets - optimized for coding
code: '<svg class="vmb-cap-icon" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><polyline points="16 18 22 12 16 6"/><polyline points="8 6 2 12 8 18"/></svg>'
};
function getCapabilities(caps) {
if (!caps) return [];
const list = [];
if (caps.supportsFunctionCalling) list.push('Function Calling');
if (caps.supportsReasoning) list.push('Reasoning');
if (caps.supportsVision) list.push('Vision');
if (caps.optimizedForCode) list.push('Code');
return list;
}
function getCapabilityIcons(caps) {
if (!caps) return '';
const icons = [];
if (caps.supportsFunctionCalling) icons.push(`<span class="vmb-cap vmb-tooltip" data-tooltip="Function Calling">${CAP_ICONS.function}</span>`);
if (caps.supportsReasoning) icons.push(`<span class="vmb-cap vmb-tooltip" data-tooltip="Reasoning">${CAP_ICONS.reasoning}</span>`);
if (caps.supportsVision) icons.push(`<span class="vmb-cap vmb-tooltip" data-tooltip="Vision">${CAP_ICONS.vision}</span>`);
if (caps.optimizedForCode) icons.push(`<span class="vmb-cap vmb-tooltip" data-tooltip="Code Optimized">${CAP_ICONS.code}</span>`);
if (icons.length === 0) return '';
return `<span class="vmb-caps">${icons.join('')}</span>`;
}
function getCapabilityTags(caps, isUncensored) {
const tags = [];
if (caps?.supportsFunctionCalling) {
tags.push(`<span class="vpt-cap vpt-tooltip" data-tooltip="Function Calling">${CAP_ICONS.function}</span>`);
}
if (caps?.supportsReasoning) {
tags.push(`<span class="vpt-cap vpt-tooltip" data-tooltip="Reasoning">${CAP_ICONS.reasoning}</span>`);
}
if (caps?.supportsVision) {
tags.push(`<span class="vpt-cap vpt-tooltip" data-tooltip="Vision">${CAP_ICONS.vision}</span>`);
}
if (caps?.optimizedForCode) {
tags.push(`<span class="vpt-cap vpt-tooltip" data-tooltip="Code Optimized">${CAP_ICONS.code}</span>`);
}
if (isUncensored) {
tags.push('<span class="vpt-cap-tag vpt-cap-uncensored">Uncensored</span>');
}
return tags.join('');
}
function escapeHtml(str) {
if (!str) return '';
return str.replace(/&/g, '&').replace(/</g, '<').replace(/>/g, '>').replace(/"/g, '"');
}
function getModelAssetFile(model) {
const spec = model.model_spec || {};
const haystack = [model.id, spec.name, spec.modelSource].filter(Boolean).join(' ').toLowerCase();
const match = SYNTHETIC_PROVIDER_ASSET_RULES.find(([, patterns]) => patterns.some(pattern => haystack.includes(pattern)));
return match?.[0] || MODEL_TYPE_ICON_BY_TYPE[model.type] || 'text.svg';
}
function getModelLogoHtml(model) {
const assetFile = getModelAssetFile(model);
const assetPath = `${MODEL_ICON_BASE_PATH}${assetFile}`;
// Decorative only: the model name is already present as visible, announced
// text in the row, so the avatar is aria-hidden and carries no extra label.
return `
<span class="vmb-model-avatar" aria-hidden="true">
<span class="vmb-model-avatar-mask" style="--vmb-model-icon: url('${escapeHtml(assetPath)}')"></span>
</span>
`;
}
function normalizeSearchText(value) {
return String(value || '')
.toLowerCase()
.replace(/[-_./]+/g, ' ')
.replace(/[^a-z0-9\s]+/g, ' ')
.replace(/\s+/g, ' ')
.trim();
}
function compactSearchText(value) {
return normalizeSearchText(value).replace(/\s+/g, '');
}
function searchTokens(value) {
const normalized = normalizeSearchText(value);
return normalized ? normalized.split(' ').filter(Boolean) : [];
}
function addUniqueSearchTerm(list, seen, value, source) {
const text = normalizeSearchText(value);
if (!text) return;
const key = `${source}:${text}`;
if (seen.has(key)) return;
seen.add(key);
list.push({ text, compact: compactSearchText(text), source });
}
function getAliasTerms(value) {
const compact = compactSearchText(value);
return MODEL_SEARCH_ALIASES[compact] || [];
}
function buildSearchQuery(rawQuery) {
const normalized = normalizeSearchText(rawQuery);
const tokens = searchTokens(rawQuery);
if (!normalized) {
return null;
}
const termSeen = new Set();
const terms = [];
addUniqueSearchTerm(terms, termSeen, normalized, 'query');
const aliasTerms = getAliasTerms(normalized);
aliasTerms.forEach(alias => addUniqueSearchTerm(terms, termSeen, alias, 'alias'));
const aliasExpandedTokens = [];
tokens.forEach(token => {
const tokenAliases = getAliasTerms(token);
if (tokenAliases.length > 0) {
aliasExpandedTokens.push(searchTokens(tokenAliases[0]));
tokenAliases.forEach(alias => addUniqueSearchTerm(terms, termSeen, alias, 'alias'));
} else {
aliasExpandedTokens.push([token]);
}
});
if (aliasExpandedTokens.length > 0) {
addUniqueSearchTerm(terms, termSeen, aliasExpandedTokens.flat().join(' '), 'alias');
}
const highlightSeen = new Set();
const highlightTerms = [];
[...tokens, normalized, ...terms.map(term => term.text)].forEach(term => {
searchTokens(term).forEach(token => {
const compact = compactSearchText(token);
if (compact && !highlightSeen.has(compact)) {
highlightSeen.add(compact);
highlightTerms.push(token);
}
});
const compact = compactSearchText(term);
if (compact && compact.length > 2 && !highlightSeen.has(compact)) {
highlightSeen.add(compact);
highlightTerms.push(term);
}
});
return {
normalized,
compact: compactSearchText(normalized),
tokens,
terms,
highlightTerms
};
}
function buildModelSearchEntry(model) {
const spec = model.model_spec || {};
const caps = getCapabilities(spec.capabilities);
const fields = [
spec.name,
model.id,
model.type,
spec.privacy,
...(spec.traits || []),
...caps,
spec.constraints?.model_type
].filter(Boolean);
const primary = [spec.name, model.id].filter(Boolean).join(' ');
const text = fields.join(' ');
const normalized = normalizeSearchText(text);
const tokens = [...new Set(searchTokens(text))];
return {
name: normalizeSearchText(spec.name || model.id),
nameCompact: compactSearchText(spec.name || model.id),
id: normalizeSearchText(model.id),
idCompact: compactSearchText(model.id),
primary: normalizeSearchText(primary),
primaryCompact: compactSearchText(primary),
normalized,
compact: compactSearchText(text),
tokens
};
}
function getModelSearchEntry(model) {
let entry = modelSearchIndexCache.get(model);
if (!entry) {
entry = buildModelSearchEntry(model);
modelSearchIndexCache.set(model, entry);
}
return entry;
}
function editDistanceWithin(a, b, maxDistance) {
if (Math.abs(a.length - b.length) > maxDistance) return maxDistance + 1;
if (a === b) return 0;
let previous = Array.from({ length: b.length + 1 }, (_, i) => i);
for (let i = 1; i <= a.length; i++) {
const current = [i];
let rowMin = current[0];
for (let j = 1; j <= b.length; j++) {
const cost = a[i - 1] === b[j - 1] ? 0 : 1;
const value = Math.min(
previous[j] + 1,
current[j - 1] + 1,
previous[j - 1] + cost
);
current[j] = value;
rowMin = Math.min(rowMin, value);
}
if (rowMin > maxDistance) return maxDistance + 1;
previous = current;
}
return previous[b.length];
}
function fuzzyMaxDistance(token) {
if (token.length <= 3) return 0;
if (token.length <= 4) return 1;
if (token.length <= 7) return 2;
return 3;
}
function scoreTokenAgainstEntry(token, entry) {
if (!token) return { score: 0, direct: true };
if (entry.tokens.includes(token)) return { score: 0, direct: true };
let best = Infinity;
let direct = false;
for (const candidate of entry.tokens) {
if (candidate.startsWith(token)) {
best = Math.min(best, 0.12);
direct = true;
} else if (candidate.includes(token)) {
best = Math.min(best, 0.25);
direct = true;
}
const maxDistance = fuzzyMaxDistance(token);
if (maxDistance > 0) {
const distance = editDistanceWithin(token, candidate, maxDistance);
if (distance <= maxDistance) {
best = Math.min(best, 0.55 + distance / Math.max(token.length, candidate.length));
}
}
}
return Number.isFinite(best) ? { score: best, direct } : null;
}
function scoreModelSearch(model, query) {
if (!query) {
return { matched: true, rank: 0, score: 0, direct: true };
}
const entry = getModelSearchEntry(model);
let best = null;
const consider = score => {
if (!best || score.rank < best.rank || (score.rank === best.rank && score.score < best.score)) {
best = score;
}
};
query.terms.forEach(term => {
const isAlias = term.source === 'alias';
const rankOffset = isAlias ? 1 : 0;
if (
entry.name === term.text ||
entry.id === term.text ||
entry.nameCompact === term.compact ||
entry.idCompact === term.compact
) {
consider({ matched: true, rank: rankOffset, score: 0, direct: true });
}
if (
(term.text.length > 1 && (entry.primary.includes(term.text) || entry.normalized.includes(term.text))) ||
(term.compact.length > 1 && (entry.primaryCompact.includes(term.compact) || entry.compact.includes(term.compact)))
) {
const indexes = [
entry.primary.indexOf(term.text),
entry.normalized.indexOf(term.text),
entry.primaryCompact.indexOf(term.compact),
entry.compact.indexOf(term.compact)
].filter(index => index >= 0);
const firstIndex = indexes.length > 0 ? Math.min(...indexes) : 0;
const lengthPenalty = Math.min(entry.primary.length || entry.normalized.length, 200) / 10000;
consider({ matched: true, rank: 2 + rankOffset, score: firstIndex / 1000 + lengthPenalty, direct: true });
}
});
const tokenScores = query.tokens.map(token => scoreTokenAgainstEntry(token, entry));
if (tokenScores.length > 0 && tokenScores.every(Boolean)) {
const total = tokenScores.reduce((sum, item) => sum + item.score, 0);
const allDirect = tokenScores.every(item => item.direct);
consider({ matched: true, rank: allDirect ? 3 : 4, score: total, direct: allDirect });
}
return best || { matched: false, rank: Infinity, score: Infinity, direct: false };
}
function buildCompactCharMap(text) {
const chars = [];
const map = [];
String(text || '').split('').forEach((char, index) => {
const lower = char.toLowerCase();
if (/[a-z0-9]/.test(lower)) {
chars.push(lower);
map.push(index);
}
});
return { compact: chars.join(''), map };
}
function addHighlightRange(ranges, start, end) {
if (start < end) ranges.push({ start, end });
}
function findSearchHighlightRanges(text, query) {
if (!query || !query.highlightTerms?.length) return [];
const { compact, map } = buildCompactCharMap(text);
if (!compact) return [];
const ranges = [];
const terms = [...query.highlightTerms]
.map(term => compactSearchText(term))
.filter(term => term.length > 1)
.sort((a, b) => b.length - a.length);
terms.forEach(term => {
let index = compact.indexOf(term);
while (index !== -1) {
addHighlightRange(ranges, map[index], map[index + term.length - 1] + 1);
index = compact.indexOf(term, index + 1);
}
const maxDistance = fuzzyMaxDistance(term);
if (maxDistance > 0 && term.length >= 4) {
for (let length = Math.max(2, term.length - maxDistance); length <= term.length + maxDistance; length++) {
for (let i = 0; i <= compact.length - length; i++) {
const candidate = compact.slice(i, i + length);
if (editDistanceWithin(term, candidate, maxDistance) <= maxDistance) {
addHighlightRange(ranges, map[i], map[i + length - 1] + 1);
}
}
}
}
});
return ranges
.sort((a, b) => a.start - b.start || b.end - a.end)
.reduce((merged, range) => {
const last = merged[merged.length - 1];
if (!last || range.start > last.end) {
merged.push({ ...range });
} else {
last.end = Math.max(last.end, range.end);
}
return merged;
}, []);
}
function highlightSearchText(text, query) {
const raw = String(text || '');
const ranges = findSearchHighlightRanges(raw, query);
if (ranges.length === 0) return escapeHtml(raw);
let html = '';
let cursor = 0;
ranges.forEach(range => {
html += escapeHtml(raw.slice(cursor, range.start));
html += `<mark class="vmb-search-highlight">${escapeHtml(raw.slice(range.start, range.end))}</mark>`;
cursor = range.end;
});
html += escapeHtml(raw.slice(cursor));
return html;
}
function isUncensoredModel(model) {
const spec = model.model_spec || {};
const traits = spec.traits || [];
const modelId = model.id.toLowerCase();
return traits.includes('most_uncensored') ||
modelId.includes('uncensored') ||
modelId.includes('lustify');
}
function isAnonymizedModel(model) {
if (PRIVATE_TYPES.has(model.type)) return false;
return model.model_spec?.privacy === 'anonymized';
}
function isE2EEModel(model) {