Enhanced ChatGPT Clone: Features Agents, MCP, Skills, DeepSeek, Anthropic, AWS, OpenAI, Responses API, Azure, Groq, o1, GPT-5, Mistral, OpenRouter, Vertex AI, Gemini, Artifacts, AI model switching, message search, Code Interpreter, langchain, DALL-E-3, OpenAPI Actions, Functions, Secure Multi-User Auth, Presets, open-source for self-hosting. Active
TypeScript aianthropicartifactsawsazurechatgptchatgpt-cloneclaudeclonedeepseekgeminigooglegpt-5librechatmcpo1openairesponses-apivisionwebui
import { Providers } from '@librechat/agents';
import { ContentTypes } from 'librechat-data-provider';
import type { MessageContentComplex } from '@librechat/agents';
import {
hasUrlContextTool,
extractYouTubeUrls,
hasYouTubeVideoParts,
appendYouTubeVideoParts,
DEFAULT_MAX_YOUTUBE_PARTS,
resolveYouTubeInjectionConfig,
} from './youtube';
const WATCH = (id: string) => `https://www.youtube.com/watch?v=${id}`;
describe('extractYouTubeUrls', () => {
it('extracts a standard watch URL', () => {
expect(extractYouTubeUrls('Watch https://www.youtube.com/watch?v=dQw4w9WgXcQ now')).toEqual([
WATCH('dQw4w9WgXcQ'),
]);
});
it('extracts youtu.be short links (with tracking params)', () => {
expect(extractYouTubeUrls('see https://youtu.be/dQw4w9WgXcQ?si=abc123')).toEqual([
WATCH('dQw4w9WgXcQ'),
]);
});
it('extracts shorts URLs', () => {
expect(extractYouTubeUrls('https://www.youtube.com/shorts/dQw4w9WgXcQ')).toEqual([
WATCH('dQw4w9WgXcQ'),
]);
});
it('extracts live URLs', () => {
expect(extractYouTubeUrls('https://www.youtube.com/live/dQw4w9WgXcQ')).toEqual([
WATCH('dQw4w9WgXcQ'),
]);
});
it('extracts embed URLs', () => {
expect(extractYouTubeUrls('https://www.youtube.com/embed/dQw4w9WgXcQ')).toEqual([
WATCH('dQw4w9WgXcQ'),
]);
});
it('handles watch URLs with leading/trailing query params', () => {
expect(
extractYouTubeUrls('https://www.youtube.com/watch?list=PLxyz&v=dQw4w9WgXcQ&t=42'),
).toEqual([WATCH('dQw4w9WgXcQ')]);
});
it('handles m. and scheme-less hosts', () => {
expect(extractYouTubeUrls('m.youtube.com/watch?v=dQw4w9WgXcQ')).toEqual([WATCH('dQw4w9WgXcQ')]);
});
it('handles other YouTube subdomains (music., gaming.)', () => {
expect(extractYouTubeUrls('https://music.youtube.com/watch?v=dQw4w9WgXcQ')).toEqual([
WATCH('dQw4w9WgXcQ'),
]);
expect(extractYouTubeUrls('https://gaming.youtube.com/watch?v=dQw4w9WgXcQ')).toEqual([
WATCH('dQw4w9WgXcQ'),
]);
});
it('handles youtube-nocookie embed URLs', () => {
expect(extractYouTubeUrls('https://www.youtube-nocookie.com/embed/dQw4w9WgXcQ')).toEqual([
WATCH('dQw4w9WgXcQ'),
]);
});
it('preserves order across multiple distinct videos', () => {
const text = 'https://youtu.be/aaaaaaaaaaa then https://www.youtube.com/watch?v=bbbbbbbbbbb';
expect(extractYouTubeUrls(text)).toEqual([WATCH('aaaaaaaaaaa'), WATCH('bbbbbbbbbbb')]);
});
it('de-duplicates the same video id across different URL forms', () => {
const text =
'https://youtu.be/dQw4w9WgXcQ and https://www.youtube.com/watch?v=dQw4w9WgXcQ&t=10';
expect(extractYouTubeUrls(text)).toEqual([WATCH('dQw4w9WgXcQ')]);
});
it('extracts both URLs from a comma-separated pair in one token', () => {
const text = 'https://youtu.be/aaaaaaaaaaa,https://youtu.be/bbbbbbbbbbb';
expect(extractYouTubeUrls(text)).toEqual([WATCH('aaaaaaaaaaa'), WATCH('bbbbbbbbbbb')]);
});
it('extracts adjacent markdown-style links', () => {
const text = '[a](https://youtu.be/aaaaaaaaaaa)[b](https://youtu.be/bbbbbbbbbbb)';
expect(extractYouTubeUrls(text)).toEqual([WATCH('aaaaaaaaaaa'), WATCH('bbbbbbbbbbb')]);
});
it('extracts adjacent links separated by semicolons or pipes', () => {
expect(extractYouTubeUrls('https://youtu.be/aaaaaaaaaaa;https://youtu.be/bbbbbbbbbbb')).toEqual(
[WATCH('aaaaaaaaaaa'), WATCH('bbbbbbbbbbb')],
);
expect(extractYouTubeUrls('https://youtu.be/aaaaaaaaaaa|https://youtu.be/bbbbbbbbbbb')).toEqual(
[WATCH('aaaaaaaaaaa'), WATCH('bbbbbbbbbbb')],
);
});
it('finds a nested youtu.be link inside an unrecognized YouTube URL', () => {
const text = 'https://www.youtube.com/redirect?q=https://youtu.be/dQw4w9WgXcQ';
expect(extractYouTubeUrls(text)).toEqual([WATCH('dQw4w9WgXcQ')]);
});
it('finds a nested youtu.be link inside a watch URL with no own v=', () => {
const text = 'https://www.youtube.com/watch?url=https://youtu.be/dQw4w9WgXcQ';
expect(extractYouTubeUrls(text)).toEqual([WATCH('dQw4w9WgXcQ')]);
});
it('skips a malformed v= and uses a later valid one', () => {
const text = 'https://www.youtube.com/watch?v=tooShort&list=x&v=dQw4w9WgXcQ';
expect(extractYouTubeUrls(text)).toEqual([WATCH('dQw4w9WgXcQ')]);
});
it('ignores unrecognized YouTube routes with no nested video', () => {
expect(extractYouTubeUrls('https://www.youtube.com/results?search_query=cats')).toEqual([]);
expect(extractYouTubeUrls('https://www.youtube.com/@SomeChannel')).toEqual([]);
});
it('matches capitalized watch/embed paths (case-insensitive)', () => {
expect(extractYouTubeUrls('https://www.youtube.com/WATCH?v=dQw4w9WgXcQ')).toEqual([
WATCH('dQw4w9WgXcQ'),
]);
expect(extractYouTubeUrls('https://www.youtube.com/EMBED/dQw4w9WgXcQ')).toEqual([
WATCH('dQw4w9WgXcQ'),
]);
});
it('ignores non-YouTube URLs', () => {
expect(extractYouTubeUrls('https://example.com/watch?v=dQw4w9WgXcQ')).toEqual([]);
});
it('ignores look-alike hosts (e.g. notyoutube.com, evil-youtube.com)', () => {
expect(extractYouTubeUrls('https://notyoutube.com/watch?v=dQw4w9WgXcQ')).toEqual([]);
expect(extractYouTubeUrls('https://evil-youtube.com/watch?v=dQw4w9WgXcQ')).toEqual([]);
expect(extractYouTubeUrls('https://youtube.com.evil.com/watch?v=dQw4w9WgXcQ')).toEqual([]);
});
it('ignores ids that are not exactly 11 valid characters', () => {
expect(extractYouTubeUrls('https://www.youtube.com/watch?v=tooShort')).toEqual([]);
});
it('returns an empty array for empty / nullish input', () => {
expect(extractYouTubeUrls('')).toEqual([]);
expect(extractYouTubeUrls(undefined)).toEqual([]);
expect(extractYouTubeUrls(null)).toEqual([]);
});
it('caps the number of returned URLs at the default', () => {
const ids = Array.from(
{ length: DEFAULT_MAX_YOUTUBE_PARTS + 3 },
(_, i) => `vid${String(i).padStart(8, '0')}`,
);
const text = ids.map((id) => `https://youtu.be/${id}`).join(' ');
expect(extractYouTubeUrls(text)).toHaveLength(DEFAULT_MAX_YOUTUBE_PARTS);
});
it('honors a custom max', () => {
const text = 'https://youtu.be/aaaaaaaaaaa https://youtu.be/bbbbbbbbbbb';
expect(extractYouTubeUrls(text, 1)).toEqual([WATCH('aaaaaaaaaaa')]);
});
it('returns an empty array when max is zero', () => {
expect(extractYouTubeUrls('https://youtu.be/dQw4w9WgXcQ', 0)).toEqual([]);
});
});
describe('hasUrlContextTool', () => {
it('returns true when a urlContext tool is present', () => {
expect(hasUrlContextTool([{ urlContext: {} }])).toBe(true);
});
it('returns true when mixed with other provider tools', () => {
expect(hasUrlContextTool([{ googleSearch: {} }, { urlContext: {} }])).toBe(true);
});
it('returns false when only other provider tools are present', () => {
expect(hasUrlContextTool([{ googleSearch: {} }])).toBe(false);
});
it('returns false for empty / non-array inputs', () => {
expect(hasUrlContextTool([])).toBe(false);
expect(hasUrlContextTool(undefined)).toBe(false);
expect(hasUrlContextTool(null)).toBe(false);
expect(hasUrlContextTool('urlContext')).toBe(false);
});
});
describe('appendYouTubeVideoParts', () => {
const youtubeText = 'Summarize https://www.youtube.com/watch?v=dQw4w9WgXcQ for me';
it('returns content unchanged when disabled', () => {
const result = appendYouTubeVideoParts({
enabled: false,
text: youtubeText,
content: youtubeText,
});
expect(result).toBe(youtubeText);
});
it('returns content unchanged when there are no YouTube URLs', () => {
const text = 'Read https://example.com/article';
const result = appendYouTubeVideoParts({ enabled: true, text, content: text });
expect(result).toBe(text);
});
it('upgrades string content to a parts array, stripping the URL from text', () => {
const result = appendYouTubeVideoParts({
enabled: true,
text: youtubeText,
content: youtubeText,
});
expect(Array.isArray(result)).toBe(true);
const parts = result as MessageContentComplex[];
/** The YouTube URL is removed from the text since it now flows through video understanding. */
expect(parts[0]).toEqual({ type: ContentTypes.TEXT, text: 'Summarize for me' });
const mediaPart = parts[1] as Record<string, unknown>;
expect(mediaPart.type).toBe('media');
expect(mediaPart.fileUri).toBe(WATCH('dQw4w9WgXcQ'));
/** The agents media converter requires the `mimeType` key to be present. */
expect('mimeType' in mediaPart).toBe(true);
expect(mediaPart.mimeType).toBeUndefined();
});
it('strips the YouTube URL from an existing text part but leaves other parts intact', () => {
const content: MessageContentComplex[] = [
{ type: ContentTypes.TEXT, text: youtubeText } as MessageContentComplex,
{
type: 'image_url',
image_url: { url: 'data:image/png;base64,AAAA' },
} as MessageContentComplex,
];
const result = appendYouTubeVideoParts({
enabled: true,
text: youtubeText,
content,
}) as MessageContentComplex[];
expect(result).toHaveLength(3);
expect(result[0]).toEqual({ type: ContentTypes.TEXT, text: 'Summarize for me' });
expect(result[1]).toEqual(content[1]);
expect((result[2] as Record<string, unknown>).fileUri).toBe(WATCH('dQw4w9WgXcQ'));
});
it('strips YouTube links from text but leaves non-YouTube URLs intact for urlContext', () => {
const text = 'Watch https://youtu.be/dQw4w9WgXcQ and read https://example.com/article please';
const result = appendYouTubeVideoParts({ enabled: true, text, content: text });
const parts = result as MessageContentComplex[];
const textPart = parts[0] as { type: string; text: string };
expect(textPart.text).not.toContain('youtu.be');
expect(textPart.text).not.toContain('dQw4w9WgXcQ');
expect(textPart.text).toContain('https://example.com/article');
expect(textPart.text).toBe('Watch and read https://example.com/article please');
const mediaParts = parts.filter((p) => (p as Record<string, unknown>).type === 'media');
expect(mediaParts).toHaveLength(1);
expect((mediaParts[0] as Record<string, unknown>).fileUri).toBe(WATCH('dQw4w9WgXcQ'));
});
it('drops a text part that becomes empty after stripping a sole YouTube URL', () => {
const text = 'https://youtu.be/dQw4w9WgXcQ';
const result = appendYouTubeVideoParts({ enabled: true, text, content: text });
const parts = result as MessageContentComplex[];
expect(parts).toHaveLength(1);
expect((parts[0] as Record<string, unknown>).type).toBe('media');
expect((parts[0] as Record<string, unknown>).fileUri).toBe(WATCH('dQw4w9WgXcQ'));
});
it('keeps over-limit YouTube links in the text (only injected ones are stripped)', () => {
const text = 'https://youtu.be/aaaaaaaaaaa and https://youtu.be/bbbbbbbbbbb';
const result = appendYouTubeVideoParts({
enabled: true,
text,
content: text,
max: 1,
}) as MessageContentComplex[];
const mediaParts = result.filter((p) => (p as Record<string, unknown>).type === 'media');
expect(mediaParts).toHaveLength(1);
expect((mediaParts[0] as Record<string, unknown>).fileUri).toBe(WATCH('aaaaaaaaaaa'));
const textPart = result.find((p) => (p as Record<string, unknown>).type === 'text') as {
text: string;
};
/** The injected link is stripped; the over-limit link is preserved for the model. */
expect(textPart.text).not.toContain('aaaaaaaaaaa');
expect(textPart.text).toContain('bbbbbbbbbbb');
});
it('keeps a timestamped YouTube link in the text so the moment cue survives', () => {
const text = 'what happens here https://youtu.be/dQw4w9WgXcQ?t=90';
const result = appendYouTubeVideoParts({ enabled: true, text, content: text });
const parts = result as MessageContentComplex[];
const textPart = parts.find((p) => (p as Record<string, unknown>).type === 'text') as {
text: string;
};
expect(textPart.text).toContain('t=90');
const mediaParts = parts.filter((p) => (p as Record<string, unknown>).type === 'media');
expect(mediaParts).toHaveLength(1);
expect((mediaParts[0] as Record<string, unknown>).fileUri).toBe(WATCH('dQw4w9WgXcQ'));
});
it('keeps a timestamp that precedes the video id in the watch URL', () => {
const text = 'jump to https://www.youtube.com/watch?t=90&v=dQw4w9WgXcQ';
const result = appendYouTubeVideoParts({ enabled: true, text, content: text });
const parts = result as MessageContentComplex[];
const textPart = parts.find((p) => (p as Record<string, unknown>).type === 'text') as {
text: string;
};
expect(textPart.text).toContain('t=90');
expect(textPart.text).toContain('dQw4w9WgXcQ');
const mediaParts = parts.filter((p) => (p as Record<string, unknown>).type === 'media');
expect(mediaParts).toHaveLength(1);
});
it('does not duplicate a video already present as a media part', () => {
const content: MessageContentComplex[] = [
{ type: ContentTypes.TEXT, text: youtubeText } as MessageContentComplex,
{
type: 'media',
mimeType: undefined,
fileUri: WATCH('dQw4w9WgXcQ'),
} as MessageContentComplex,
];
const result = appendYouTubeVideoParts({ enabled: true, text: youtubeText, content });
expect(result).toBe(content);
});
it('de-duplicates against an existing fileData part', () => {
const content: MessageContentComplex[] = [
{ type: ContentTypes.TEXT, text: youtubeText } as MessageContentComplex,
{
type: 'media',
fileData: { fileUri: WATCH('dQw4w9WgXcQ') },
} as unknown as MessageContentComplex,
];
const result = appendYouTubeVideoParts({ enabled: true, text: youtubeText, content });
expect(result).toBe(content);
});
it('stamps the provided mimeType on the media part (Vertex)', () => {
const result = appendYouTubeVideoParts({
enabled: true,
text: youtubeText,
content: youtubeText,
mimeType: 'video/mp4',
}) as MessageContentComplex[];
const mediaPart = result[result.length - 1] as Record<string, unknown>;
expect(mediaPart.type).toBe('media');
expect(mediaPart.mimeType).toBe('video/mp4');
});
it('respects max=1 even when the message has multiple YouTube links', () => {
const text = 'https://youtu.be/aaaaaaaaaaa and https://youtu.be/bbbbbbbbbbb';
const result = appendYouTubeVideoParts({
enabled: true,
text,
content: text,
max: 1,
}) as MessageContentComplex[];
const mediaParts = result.filter((p) => (p as Record<string, unknown>).type === 'media');
expect(mediaParts).toHaveLength(1);
expect((mediaParts[0] as Record<string, unknown>).fileUri).toBe(WATCH('aaaaaaaaaaa'));
});
it('strips a watch URL fully when it has a URL-valued param after the id (no orphan)', () => {
const text =
'summarize https://www.youtube.com/watch?v=dQw4w9WgXcQ&next=https://example.com please';
const result = appendYouTubeVideoParts({ enabled: true, text, content: text, max: 5 });
const parts = result as MessageContentComplex[];
const textPart = parts.find((p) => (p as Record<string, unknown>).type === 'text') as {
text: string;
};
expect(textPart.text).toBe('summarize please');
expect(textPart.text).not.toContain('example.com');
const mediaParts = parts.filter((p) => (p as Record<string, unknown>).type === 'media');
expect(mediaParts).toHaveLength(1);
expect((mediaParts[0] as Record<string, unknown>).fileUri).toBe(WATCH('dQw4w9WgXcQ'));
});
});
describe('hasYouTubeVideoParts', () => {
const youtubeText = 'Summarize https://www.youtube.com/watch?v=dQw4w9WgXcQ for me';
it('detects the parts appendYouTubeVideoParts actually produces', () => {
const content = appendYouTubeVideoParts({
enabled: true,
text: youtubeText,
content: youtubeText,
});
expect(hasYouTubeVideoParts(content)).toBe(true);
});
it('detects Vertex-shaped parts carrying an explicit mimeType', () => {
const content = appendYouTubeVideoParts({
enabled: true,
text: youtubeText,
content: youtubeText,
max: 1,
mimeType: 'video/mp4',
});
expect(hasYouTubeVideoParts(content)).toBe(true);
});
it('returns false for the untouched content of a no-op injection', () => {
const text = 'Read https://example.com/article';
const content = appendYouTubeVideoParts({ enabled: true, text, content: text });
expect(hasYouTubeVideoParts(content)).toBe(false);
});
it('returns false for string content', () => {
expect(hasYouTubeVideoParts(youtubeText)).toBe(false);
});
it('ignores non-YouTube media parts', () => {
const content: MessageContentComplex[] = [
{ type: ContentTypes.TEXT, text: 'look at this' } as MessageContentComplex,
{
type: 'media',
fileUri: 'https://example.com/clip.mp4',
} as unknown as MessageContentComplex,
];
expect(hasYouTubeVideoParts(content)).toBe(false);
});
it('tolerates malformed parts', () => {
const content = [
null,
undefined,
'text',
{ type: 'media' },
] as unknown as MessageContentComplex[];
expect(hasYouTubeVideoParts(content)).toBe(false);
});
});
describe('resolveYouTubeInjectionConfig', () => {
it('caps Vertex at one video and sets a video/mp4 mimeType', () => {
expect(
resolveYouTubeInjectionConfig({ provider: Providers.VERTEXAI, model: 'gemini-2.5-flash' }),
).toEqual({
max: 1,
mimeType: 'video/mp4',
});
});
it('allows multiple videos with no mimeType for Gemini 2.5+ on the Developer API', () => {
expect(
resolveYouTubeInjectionConfig({ provider: Providers.GOOGLE, model: 'gemini-2.5-flash' }),
).toEqual({
max: DEFAULT_MAX_YOUTUBE_PARTS,
});
expect(
resolveYouTubeInjectionConfig({ provider: Providers.GOOGLE, model: 'gemini-3-pro-preview' }),
).toEqual({
max: DEFAULT_MAX_YOUTUBE_PARTS,
});
});
it('caps pre-2.5 and unknown Developer API models at one video', () => {
expect(
resolveYouTubeInjectionConfig({ provider: Providers.GOOGLE, model: 'gemini-2.0-flash' }),
).toEqual({
max: 1,
});
expect(
resolveYouTubeInjectionConfig({ provider: Providers.GOOGLE, model: 'gemini-1.5-pro' }),
).toEqual({
max: 1,
});
expect(resolveYouTubeInjectionConfig({ provider: Providers.GOOGLE })).toEqual({ max: 1 });
});
});
describe('ReDoS safety', () => {
it('returns quickly for a long malformed watch token with no v= parameter', () => {
/** One ~600KB non-whitespace token; before the fix this exhibited quadratic backtracking. */
const malicious = 'https://www.youtube.com/watch?'.repeat(20000);
const start = Date.now();
const result = extractYouTubeUrls(malicious, 5);
const elapsed = Date.now() - start;
expect(result).toEqual([]);
expect(elapsed).toBeLessThan(1000);
});
it('returns quickly for a malformed path of millions of slashes', () => {
const malicious = `https://www.youtube.com/${'/'.repeat(3_000_000)}`;
const start = Date.now();
const result = extractYouTubeUrls(malicious, 5);
expect(result).toEqual([]);
expect(Date.now() - start).toBeLessThan(1000);
});
it('returns quickly for many medium malformed watch tokens', () => {
const token = 'https://www.youtube.com/watch?'.repeat(50); // ~1.5KB malformed token
const malicious = `${token} `.repeat(2000); // ~3MB of whitespace-separated malformed tokens
const start = Date.now();
const result = extractYouTubeUrls(malicious, 5);
expect(result).toEqual([]);
expect(Date.now() - start).toBeLessThan(1000);
});
it('still extracts a valid URL that appears before a huge token', () => {
const text = `https://youtu.be/dQw4w9WgXcQ ${'x'.repeat(60000)}`;
expect(extractYouTubeUrls(text, 5)).toEqual([WATCH('dQw4w9WgXcQ')]);
});
it('injects + strips quickly when a valid URL is followed by a huge malformed token', () => {
const text = `https://youtu.be/dQw4w9WgXcQ ${'https://www.youtube.com/watch?'.repeat(20000)}`;
const start = Date.now();
const result = appendYouTubeVideoParts({ enabled: true, text, content: text, max: 5 });
const elapsed = Date.now() - start;
expect(elapsed).toBeLessThan(1000);
const mediaParts = (result as MessageContentComplex[]).filter(
(p) => (p as Record<string, unknown>).type === 'media',
);
expect(mediaParts).toHaveLength(1);
expect((mediaParts[0] as Record<string, unknown>).fileUri).toBe(WATCH('dQw4w9WgXcQ'));
});
it('strips quickly when a valid URL precedes ~3MB of medium malformed tokens', () => {
/** Exercises the strip path: extraction finds the valid URL, then strip must stay bounded. */
const tail = `${'https://www.youtube.com/watch?'.repeat(50)} `.repeat(2000);
const text = `https://youtu.be/dQw4w9WgXcQ ${tail}`;
const start = Date.now();
const result = appendYouTubeVideoParts({ enabled: true, text, content: text, max: 5 });
const elapsed = Date.now() - start;
expect(elapsed).toBeLessThan(1000);
const mediaParts = (result as MessageContentComplex[]).filter(
(p) => (p as Record<string, unknown>).type === 'media',
);
expect(mediaParts).toHaveLength(1);
expect((mediaParts[0] as Record<string, unknown>).fileUri).toBe(WATCH('dQw4w9WgXcQ'));
});
});
describe('long-text handling (no content discarded)', () => {
it('extracts a URL that appears far into a long prompt', () => {
const text = `${'word '.repeat(40000)}see https://youtu.be/dQw4w9WgXcQ`; // ~200KB before the URL
expect(extractYouTubeUrls(text, 5)).toEqual([WATCH('dQw4w9WgXcQ')]);
});
it('strips the injected URL even when large context is prepended to the content', () => {
/** Mirrors AgentClient prepending file/quote context to `content` while extraction uses `text`. */
const prompt = 'summarize https://youtu.be/dQw4w9WgXcQ';
const prependedContext = 'attached context line.\n'.repeat(8000); // ~180KB preamble
const result = appendYouTubeVideoParts({
enabled: true,
text: prompt,
content: prependedContext + prompt,
max: 5,
});
const parts = result as MessageContentComplex[];
const textPart = parts.find((p) => (p as Record<string, unknown>).type === 'text') as {
text: string;
};
expect(textPart.text).not.toContain('youtu.be/dQw4w9WgXcQ');
expect(textPart.text).toContain('attached context line.');
const mediaParts = parts.filter((p) => (p as Record<string, unknown>).type === 'media');
expect(mediaParts).toHaveLength(1);
expect((mediaParts[0] as Record<string, unknown>).fileUri).toBe(WATCH('dQw4w9WgXcQ'));
});
});