@rnsk/toolkits 0.0.6 → 0.0.8

package/dist/toolkits/youtube/tools/index.js

@@ -0,0 +1,104 @@
+// @ts-nocheck
+import { addVideoToPlaylist } from './add-video-to-playlist.js';
+import { createChannelSection } from './create-channel-section.js';
+import { createCommentReply } from './create-comment-reply.js';
+import { createPlaylist } from './create-playlist.js';
+import { deleteChannelSection } from './delete-channel-section.js';
+import { deleteComment } from './delete-comment.js';
+import { deletePlaylist } from './delete-playlist.js';
+import { deletePlaylistItem } from './delete-playlist-item.js';
+import { deleteVideo } from './delete-video.js';
+import { downloadCaptionTrack } from './download-caption-track.js';
+import { getChannelActivities } from './get-channel-activities.js';
+import { getChannelIdByHandle } from './get-channel-id-by-handle.js';
+import { getChannelStatistics } from './get-channel-statistics.js';
+import { getVideoDetailsBatch } from './get-video-details-batch.js';
+import { getVideoRating } from './get-video-rating.js';
+import { listCaptionTrack } from './list-caption-track.js';
+import { listChannelSections } from './list-channel-sections.js';
+import { listChannelVideos } from './list-channel-videos.js';
+import { listChannels } from './list-channels.js';
+import { listCommentThreads } from './list-comment-threads.js';
+import { listComments } from './list-comments.js';
+import { listI18nLanguages } from './list-i18n-languages.js';
+import { listI18nRegions } from './list-i18n-regions.js';
+import { listLiveChatMessages } from './list-live-chat-messages.js';
+import { listPlaylistImages } from './list-playlist-images.js';
+import { listPlaylistItems } from './list-playlist-items.js';
+import { listSuperChatEvents } from './list-super-chat-events.js';
+import { listUserPlaylists } from './list-user-playlists.js';
+import { listUserSubscriptions } from './list-user-subscriptions.js';
+import { listVideoAbuseReportReasons } from './list-video-abuse-report-reasons.js';
+import { listVideoCategories } from './list-video-categories.js';
+import { markCommentAsSpam } from './mark-comment-as-spam.js';
+import { multipartUploadVideo } from './multipart-upload-video.js';
+import { postComment } from './post-comment.js';
+import { rateVideo } from './rate-video.js';
+import { reportVideoAbuse } from './report-video-abuse.js';
+import { searchYouTube } from './search-youtube.js';
+import { setCommentModerationStatus } from './set-comment-moderation-status.js';
+import { subscribeChannel } from './subscribe-channel.js';
+import { unsubscribeChannel } from './unsubscribe-channel.js';
+import { updateCaption } from './update-caption.js';
+import { updateChannel } from './update-channel.js';
+import { updateChannelSection } from './update-channel-section.js';
+import { updateComment } from './update-comment.js';
+import { updatePlaylist } from './update-playlist.js';
+import { updatePlaylistItem } from './update-playlist-item.js';
+import { updateThumbnail } from './update-thumbnail.js';
+import { updateVideo } from './update-video.js';
+import { uploadVideo } from './upload-video.js';
+export { addVideoToPlaylist, createChannelSection, createCommentReply, createPlaylist, deleteChannelSection, deleteComment, deletePlaylist, deletePlaylistItem, deleteVideo, downloadCaptionTrack, getChannelActivities, getChannelIdByHandle, getChannelStatistics, getVideoDetailsBatch, getVideoRating, listCaptionTrack, listChannelSections, listChannelVideos, listChannels, listCommentThreads, listComments, listI18nLanguages, listI18nRegions, listLiveChatMessages, listPlaylistImages, listPlaylistItems, listSuperChatEvents, listUserPlaylists, listUserSubscriptions, listVideoAbuseReportReasons, listVideoCategories, markCommentAsSpam, multipartUploadVideo, postComment, rateVideo, reportVideoAbuse, searchYouTube, setCommentModerationStatus, subscribeChannel, unsubscribeChannel, updateCaption, updateChannel, updateChannelSection, updateComment, updatePlaylist, updatePlaylistItem, updateThumbnail, updateVideo, uploadVideo, };
+const auth = 'youtubeToken';
+export const youtubeTools = [
+    { name: 'youtubeAddVideoToPlaylist', description: 'Adds a video to a playlist. Use to organize videos or build curated collections.', tool: addVideoToPlaylist, requiredAuth: auth, scope: 'write' },
+    { name: 'youtubeCreateChannelSection', description: 'Creates a channel section (featured playlists, uploads, channels) on your channel.', tool: createChannelSection, requiredAuth: auth, scope: 'write' },
+    { name: 'youtubeCreateCommentReply', description: 'Replies to an existing comment. Use to respond to users on videos.', tool: createCommentReply, requiredAuth: auth, scope: 'write' },
+    { name: 'youtubeCreatePlaylist', description: 'Creates a new playlist on your channel.', tool: createPlaylist, requiredAuth: auth, scope: 'write' },
+    { name: 'youtubeDeleteChannelSection', description: 'Deletes a channel section you have permission to remove.', tool: deleteChannelSection, requiredAuth: auth, scope: 'delete' },
+    { name: 'youtubeDeleteComment', description: 'Deletes a comment owned by your channel.', tool: deleteComment, requiredAuth: auth, scope: 'delete' },
+    { name: 'youtubeDeletePlaylist', description: 'Permanently deletes your playlist. Requires explicit confirmation.', tool: deletePlaylist, requiredAuth: auth, scope: 'delete' },
+    { name: 'youtubeDeletePlaylistItem', description: 'Removes a video from a playlist by playlist item ID.', tool: deletePlaylistItem, requiredAuth: auth, scope: 'delete' },
+    { name: 'youtubeDeleteVideo', description: 'Permanently deletes your video. Requires explicit confirmation.', tool: deleteVideo, requiredAuth: auth, scope: 'delete' },
+    { name: 'youtubeDownloadCaptionTrack', description: 'Downloads an owned caption track as text. Requires owning the video.', tool: downloadCaptionTrack, requiredAuth: auth, scope: 'read' },
+    { name: 'youtubeGetChannelActivities', description: 'Gets recent channel activities (uploads, likes, playlist events).', tool: getChannelActivities, requiredAuth: auth, scope: 'read' },
+    { name: 'youtubeGetChannelIdByHandle', description: 'Resolves a channel handle or URL to its channel ID.', tool: getChannelIdByHandle, requiredAuth: auth, scope: 'read' },
+    { name: 'youtubeGetChannelStatistics', description: 'Gets subscriber, view, and video counts for channels.', tool: getChannelStatistics, requiredAuth: auth, scope: 'read' },
+    { name: 'youtubeGetVideoDetailsBatch', description: 'Retrieves details for many videos in one batched call. Use for cohort metrics.', tool: getVideoDetailsBatch, requiredAuth: auth, scope: 'read' },
+    { name: 'youtubeGetVideoRating', description: 'Checks your like/dislike ratings on videos.', tool: getVideoRating, requiredAuth: auth, scope: 'read' },
+    { name: 'youtubeListCaptionTrack', description: 'Lists caption tracks for a video. Use track IDs to download or update.', tool: listCaptionTrack, requiredAuth: auth, scope: 'read' },
+    { name: 'youtubeListChannelSections', description: 'Retrieves channel homepage layout sections.', tool: listChannelSections, requiredAuth: auth, scope: 'read' },
+    { name: 'youtubeListChannelVideos', description: 'Lists videos from a channel via its uploads playlist, with search fallback.', tool: listChannelVideos, requiredAuth: auth, scope: 'read' },
+    { name: 'youtubeListChannels', description: 'Lists channels by ID, handle, username, or ownership with full details.', tool: listChannels, requiredAuth: auth, scope: 'read' },
+    { name: 'youtubeListCommentThreads', description: 'Retrieves comment threads for a video or channel with replies.', tool: listCommentThreads, requiredAuth: auth, scope: 'read' },
+    { name: 'youtubeListComments', description: 'Lists individual comments by ID or replies to a parent comment.', tool: listComments, requiredAuth: auth, scope: 'read' },
+    { name: 'youtubeListI18nLanguages', description: 'Lists interface languages YouTube supports.', tool: listI18nLanguages, requiredAuth: auth, scope: 'read' },
+    { name: 'youtubeListI18nRegions', description: 'Lists content regions YouTube supports for geo filtering.', tool: listI18nRegions, requiredAuth: auth, scope: 'read' },
+    { name: 'youtubeListLiveChatMessages', description: 'Lists live chat messages for monitoring broadcasts or chat history.', tool: listLiveChatMessages, requiredAuth: auth, scope: 'read' },
+    { name: 'youtubeListPlaylistImages', description: 'Retrieves custom thumbnail images for a playlist.', tool: listPlaylistImages, requiredAuth: auth, scope: 'read' },
+    { name: 'youtubeListPlaylistItems', description: 'Lists videos in a playlist with pagination.', tool: listPlaylistItems, requiredAuth: auth, scope: 'read' },
+    { name: 'youtubeListSuperChatEvents', description: 'Lists Super Chat/Sticker purchases from the past 30 days.', tool: listSuperChatEvents, requiredAuth: auth, scope: 'read' },
+    { name: 'youtubeListUserPlaylists', description: 'Lists playlists owned by the authenticated user.', tool: listUserPlaylists, requiredAuth: auth, scope: 'read' },
+    { name: 'youtubeListUserSubscriptions', description: 'Lists the authenticated user channel subscriptions.', tool: listUserSubscriptions, requiredAuth: auth, scope: 'read' },
+    { name: 'youtubeListVideoAbuseReportReasons', description: 'Lists valid abuse report reasons for use with reportVideoAbuse.', tool: listVideoAbuseReportReasons, requiredAuth: auth, scope: 'read' },
+    { name: 'youtubeListVideoCategories', description: 'Lists video categories for a region or by ID.', tool: listVideoCategories, requiredAuth: auth, scope: 'read' },
+    { name: 'youtubeMarkCommentAsSpam', description: 'Flags comments as spam (deprecated endpoint, still functional).', tool: markCommentAsSpam, requiredAuth: auth, scope: 'write' },
+    { name: 'youtubeMultipartUploadVideo', description: 'Uploads a video (metadata + bytes in one request) from a file URL.', tool: multipartUploadVideo, requiredAuth: auth, scope: 'write' },
+    { name: 'youtubePostComment', description: 'Posts a new top-level comment on a video.', tool: postComment, requiredAuth: auth, scope: 'write' },
+    { name: 'youtubeRateVideo', description: 'Likes, dislikes, or un-rates a video.', tool: rateVideo, requiredAuth: auth, scope: 'write' },
+    { name: 'youtubeReportVideoAbuse', description: 'Reports a video for abusive content.', tool: reportVideoAbuse, requiredAuth: auth, scope: 'write' },
+    { name: 'youtubeSearchYouTube', description: 'Searches YouTube for videos, channels, or playlists.', tool: searchYouTube, requiredAuth: auth, scope: 'read' },
+    { name: 'youtubeSetCommentModerationStatus', description: 'Holds, publishes, or rejects comments; optionally bans authors.', tool: setCommentModerationStatus, requiredAuth: auth, scope: 'write' },
+    { name: 'youtubeSubscribeChannel', description: 'Subscribes you to a channel by channel ID.', tool: subscribeChannel, requiredAuth: auth, scope: 'write' },
+    { name: 'youtubeUnsubscribeChannel', description: 'Removes a subscription by subscription ID.', tool: unsubscribeChannel, requiredAuth: auth, scope: 'delete' },
+    { name: 'youtubeUpdateCaption', description: 'Updates caption track metadata (name, language, draft status).', tool: updateCaption, requiredAuth: auth, scope: 'write' },
+    { name: 'youtubeUpdateChannel', description: 'Updates owned channel branding, promotion, and localizations.', tool: updateChannel, requiredAuth: auth, scope: 'write' },
+    { name: 'youtubeUpdateChannelSection', description: 'Updates a channel section (title, position, featured content).', tool: updateChannelSection, requiredAuth: auth, scope: 'write' },
+    { name: 'youtubeUpdateComment', description: 'Edits the text of an existing comment.', tool: updateComment, requiredAuth: auth, scope: 'write' },
+    { name: 'youtubeUpdatePlaylist', description: 'Updates playlist title, description, and privacy status.', tool: updatePlaylist, requiredAuth: auth, scope: 'write' },
+    { name: 'youtubeUpdatePlaylistItem', description: 'Reorders a playlist item or updates its note and privacy.', tool: updatePlaylistItem, requiredAuth: auth, scope: 'write' },
+    { name: 'youtubeUpdateThumbnail', description: 'Sets a custom video thumbnail from an image URL.', tool: updateThumbnail, requiredAuth: auth, scope: 'write' },
+    { name: 'youtubeUpdateVideo', description: 'Updates video title, description, tags, category, and privacy.', tool: updateVideo, requiredAuth: auth, scope: 'write' },
+    { name: 'youtubeUploadVideo', description: 'Uploads a video from a file URL via resumable session (best for large files).', tool: uploadVideo, requiredAuth: auth, scope: 'write' },
+];
+//# sourceMappingURL=index.js.map

package/dist/toolkits/youtube/tools/list-caption-track.d.ts

@@ -0,0 +1,6 @@
+export declare const listCaptionTrack: import("ai").Tool<{
+    youtubeToken: string;
+    videoId: string;
+    part?: string | undefined;
+}, any>;
+//# sourceMappingURL=list-caption-track.d.ts.map

package/dist/toolkits/youtube/tools/list-caption-track.js

@@ -0,0 +1,29 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { youtubeRequest, youtubeTokenField } from './client.js';
+export const listCaptionTrack = tool({
+    description: 'Lists caption tracks for a video. Returns an empty items list when none exist. Use track IDs from here with downloadCaptionTrack.',
+    inputSchema: z.object({
+        youtubeToken: youtubeTokenField,
+        videoId: z.string().describe('Video ID to list caption tracks for (required)'),
+        part: z.string().optional().describe("Resource parts: 'id' and/or 'snippet' (default snippet)"),
+    }),
+    execute: async ({ youtubeToken, videoId, part }) => {
+        try {
+            const result = await youtubeRequest(youtubeToken, '/captions', {
+                query: { part: part ?? 'snippet', videoId },
+            });
+            if (!result.ok)
+                return { error: 'Failed to list caption tracks', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return {
+                error: 'Error listing caption tracks',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=list-caption-track.js.map

package/dist/toolkits/youtube/tools/list-channel-sections.d.ts

@@ -0,0 +1,10 @@
+export declare const listChannelSections: import("ai").Tool<{
+    youtubeToken: string;
+    part: string;
+    id?: string | undefined;
+    onBehalfOfContentOwner?: string | undefined;
+    channelId?: string | undefined;
+    mine?: boolean | undefined;
+    hl?: string | undefined;
+}, any>;
+//# sourceMappingURL=list-channel-sections.d.ts.map

package/dist/toolkits/youtube/tools/list-channel-sections.js

@@ -0,0 +1,36 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { onBehalfOfContentOwnerField, youtubeRequest, youtubeTokenField } from './client.js';
+export const listChannelSections = tool({
+    description: "Retrieves a channel homepage's layout sections. Exactly one of channelId, id, or mine must be set.",
+    inputSchema: z.object({
+        youtubeToken: youtubeTokenField,
+        part: z.string().describe("Resource parts, e.g. 'snippet' or 'snippet,contentDetails' (required)"),
+        channelId: z.string().optional().describe('Channel ID to list sections for'),
+        id: z.string().optional().describe('Comma-separated channel section IDs'),
+        mine: z.boolean().optional().describe('True for the authenticated user channel'),
+        hl: z.string().optional().describe('Deprecated language hint for localized metadata'),
+        onBehalfOfContentOwner: onBehalfOfContentOwnerField,
+    }),
+    execute: async ({ youtubeToken, part, channelId, id, mine, hl, onBehalfOfContentOwner }) => {
+        try {
+            const filters = [channelId, id, mine === true ? 'mine' : undefined].filter(Boolean);
+            if (filters.length !== 1)
+                return { error: 'Exactly one of channelId, id, or mine must be provided' };
+            const result = await youtubeRequest(youtubeToken, '/channelSections', {
+                query: { part, channelId, id, mine, hl, onBehalfOfContentOwner },
+            });
+            if (!result.ok)
+                return { error: 'Failed to list channel sections', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return {
+                error: 'Error listing channel sections',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=list-channel-sections.js.map

package/dist/toolkits/youtube/tools/list-channel-videos.d.ts

@@ -0,0 +1,9 @@
+export declare const listChannelVideos: import("ai").Tool<{
+    youtubeToken: string;
+    maxResults?: number | undefined;
+    pageToken?: string | undefined;
+    channelId?: string | undefined;
+    part?: string | undefined;
+    mine?: boolean | undefined;
+}, any>;
+//# sourceMappingURL=list-channel-videos.d.ts.map

package/dist/toolkits/youtube/tools/list-channel-videos.js

@@ -0,0 +1,76 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { extractHandle, youtubeRequest, youtubeTokenField } from './client.js';
+async function resolveChannelId(youtubeToken, channelId, mine) {
+    if (mine)
+        return { id: 'me' };
+    if (!channelId)
+        return {};
+    const trimmed = channelId.trim();
+    if (trimmed === 'me' || /^UC[\w-]{22}$/.test(trimmed))
+        return { id: trimmed };
+    const channelMatch = trimmed.match(/youtube\.com\/channel\/(UC[\w-]{22})/i);
+    if (channelMatch)
+        return { id: channelMatch[1] };
+    const handle = extractHandle(trimmed);
+    const resolved = await youtubeRequest(youtubeToken, '/channels', {
+        query: { part: 'id', forHandle: handle },
+    });
+    if (!resolved.ok)
+        return { error: resolved.error };
+    const items = resolved.data.items ?? [];
+    if (!items[0]?.id)
+        return { error: `No channel found for handle '${trimmed}'` };
+    return { id: items[0].id };
+}
+export const listChannelVideos = tool({
+    description: 'Lists videos from a channel via its uploads playlist (cheap), with automatic search fallback if the uploads playlist is missing. Accepts channel IDs, handles, URLs, or mine.',
+    inputSchema: z.object({
+        youtubeToken: youtubeTokenField,
+        channelId: z.string().optional().describe("Channel ID, @handle, 'me', or channel URL"),
+        mine: z.boolean().optional().describe('True for the authenticated user channel'),
+        part: z.string().optional().describe('Playlist item parts (default snippet)'),
+        maxResults: z.number().min(1).max(50).optional().describe('Videos per page (1-50, default 5)'),
+        pageToken: z.string().optional().describe('Page token from a previous response'),
+    }),
+    execute: async ({ youtubeToken, channelId, mine, part, maxResults, pageToken }) => {
+        try {
+            if (!channelId && !mine)
+                return { error: 'Either channelId or mine must be provided' };
+            const resolved = await resolveChannelId(youtubeToken, channelId, mine);
+            if (resolved.error)
+                return { error: 'Failed to resolve channel', details: resolved.error };
+            const cid = resolved.id;
+            const channelResult = await youtubeRequest(youtubeToken, '/channels', {
+                query: { part: 'contentDetails', id: cid === 'me' ? undefined : cid, mine: cid === 'me' ? true : undefined },
+            });
+            const channelData = channelResult.data;
+            const uploadsId = channelData.items?.[0]?.contentDetails?.relatedPlaylists?.uploads;
+            if (uploadsId) {
+                const itemsResult = await youtubeRequest(youtubeToken, '/playlistItems', {
+                    query: { part: part ?? 'snippet', playlistId: uploadsId, maxResults: maxResults ?? 5, pageToken },
+                });
+                if (itemsResult.ok)
+                    return itemsResult.data;
+                const code = itemsResult.error?.error?.code;
+                if (code !== 404)
+                    return { error: 'Failed to list channel videos', details: itemsResult.error };
+            }
+            // Fallback: search endpoint (higher quota cost, capped at ~500 results).
+            const searchResult = await youtubeRequest(youtubeToken, '/search', {
+                query: { part: 'snippet', channelId: cid, type: 'video', order: 'date', maxResults: maxResults ?? 5, pageToken },
+            });
+            if (!searchResult.ok)
+                return { error: 'Failed to list channel videos', details: searchResult.error };
+            return searchResult.data;
+        }
+        catch (error) {
+            return {
+                error: 'Error listing channel videos',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=list-channel-videos.js.map

package/dist/toolkits/youtube/tools/list-channels.d.ts

@@ -0,0 +1,14 @@
+export declare const listChannels: import("ai").Tool<{
+    youtubeToken: string;
+    id?: string | undefined;
+    maxResults?: number | undefined;
+    pageToken?: string | undefined;
+    onBehalfOfContentOwner?: string | undefined;
+    part?: string | undefined;
+    forHandle?: string | undefined;
+    forUsername?: string | undefined;
+    mine?: boolean | undefined;
+    hl?: string | undefined;
+    managedByMe?: boolean | undefined;
+}, any>;
+//# sourceMappingURL=list-channels.d.ts.map

package/dist/toolkits/youtube/tools/list-channels.js

@@ -0,0 +1,40 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { youtubeRequest, youtubeTokenField } from './client.js';
+export const listChannels = tool({
+    description: 'Lists channels by ID, handle, username, or ownership with metadata, statistics, and content details. For keyword search use searchYouTube instead.',
+    inputSchema: z.object({
+        youtubeToken: youtubeTokenField,
+        part: z.string().optional().describe('Resource parts (default snippet,contentDetails,statistics)'),
+        id: z.string().optional().describe('Comma-separated channel IDs (start with UC)'),
+        forHandle: z.string().optional().describe('Channel handle, @ optional'),
+        forUsername: z.string().optional().describe('Legacy username'),
+        mine: z.boolean().optional().describe('True for channels owned by the authenticated user'),
+        managedByMe: z.boolean().optional().describe('True for partner-managed channels'),
+        hl: z.string().optional().describe('BCP-47 language for localized metadata'),
+        maxResults: z.number().min(0).max(50).optional().describe('Results per page (0-50)'),
+        pageToken: z.string().optional().describe('Page token from a previous response'),
+        onBehalfOfContentOwner: z.string().optional(),
+    }),
+    execute: async ({ youtubeToken, part, id, forHandle, forUsername, mine, managedByMe, hl, maxResults, pageToken, onBehalfOfContentOwner }) => {
+        try {
+            if (!id && !forHandle && !forUsername && !mine && !managedByMe) {
+                return { error: 'At least one filter (id, forHandle, forUsername, mine, managedByMe) is required' };
+            }
+            const result = await youtubeRequest(youtubeToken, '/channels', {
+                query: { part: part ?? 'snippet,contentDetails,statistics', id, forHandle, forUsername, mine, managedByMe, hl, maxResults, pageToken, onBehalfOfContentOwner },
+            });
+            if (!result.ok)
+                return { error: 'Failed to list channels', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return {
+                error: 'Error listing channels',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=list-channels.js.map

package/dist/toolkits/youtube/tools/list-comment-threads.d.ts

@@ -0,0 +1,15 @@
+export declare const listCommentThreads: import("ai").Tool<{
+    youtubeToken: string;
+    part: string;
+    id?: string | undefined;
+    maxResults?: number | undefined;
+    pageToken?: string | undefined;
+    order?: "time" | "relevance" | undefined;
+    videoId?: string | undefined;
+    channelId?: string | undefined;
+    allThreadsRelatedToChannelId?: string | undefined;
+    searchTerms?: string | undefined;
+    moderationStatus?: "published" | "heldForReview" | "likelySpam" | undefined;
+    textFormat?: "html" | "plainText" | undefined;
+}, any>;
+//# sourceMappingURL=list-comment-threads.d.ts.map

package/dist/toolkits/youtube/tools/list-comment-threads.js

@@ -0,0 +1,38 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { youtubeRequest, youtubeTokenField } from './client.js';
+export const listCommentThreads = tool({
+    description: 'Retrieves comment threads for a video, channel, or thread IDs, with top-level comments plus up to 5 replies each. Prefer videoId for video comments.',
+    inputSchema: z.object({
+        youtubeToken: youtubeTokenField,
+        part: z.string().describe("Resource parts (required), e.g. 'snippet,replies'"),
+        videoId: z.string().optional().describe('Video ID for its comment threads (most common)'),
+        channelId: z.string().optional().describe('Channel ID for comments about the channel itself'),
+        allThreadsRelatedToChannelId: z.string().optional().describe('Channel ID for all related threads (requires OAuth)'),
+        id: z.string().optional().describe('Comma-separated thread IDs'),
+        order: z.enum(['time', 'relevance']).optional().describe('Sort order (default time)'),
+        searchTerms: z.string().optional().describe('Filter query (only with allThreadsRelatedToChannelId)'),
+        moderationStatus: z.enum(['heldForReview', 'likelySpam', 'published']).optional().describe('Filter by status (channel owner only)'),
+        textFormat: z.enum(['html', 'plainText']).optional(),
+        maxResults: z.number().min(1).max(100).optional().describe('Threads per page (1-100)'),
+        pageToken: z.string().optional().describe('Page token from a previous response'),
+    }),
+    execute: async ({ youtubeToken, part, videoId, channelId, allThreadsRelatedToChannelId, id, order, searchTerms, moderationStatus, textFormat, maxResults, pageToken }) => {
+        try {
+            const result = await youtubeRequest(youtubeToken, '/commentThreads', {
+                query: { part, videoId, channelId, allThreadsRelatedToChannelId, id, order, searchTerms, moderationStatus, textFormat, maxResults, pageToken },
+            });
+            if (!result.ok)
+                return { error: 'Failed to list comment threads', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return {
+                error: 'Error listing comment threads',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=list-comment-threads.js.map

package/dist/toolkits/youtube/tools/list-comments.d.ts

@@ -0,0 +1,10 @@
+export declare const listComments: import("ai").Tool<{
+    youtubeToken: string;
+    id?: string | undefined;
+    maxResults?: number | undefined;
+    pageToken?: string | undefined;
+    parentId?: string | undefined;
+    part?: string | undefined;
+    textFormat?: "html" | "plainText" | undefined;
+}, any>;
+//# sourceMappingURL=list-comments.d.ts.map

package/dist/toolkits/youtube/tools/list-comments.js

@@ -0,0 +1,35 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { youtubeRequest, youtubeTokenField } from './client.js';
+export const listComments = tool({
+    description: 'Lists individual comments by ID, or all replies to a top-level comment via parentId. Exactly one of id or parentId is typically used.',
+    inputSchema: z.object({
+        youtubeToken: youtubeTokenField,
+        id: z.string().optional().describe('Comma-separated comment IDs (mutually exclusive with parentId)'),
+        parentId: z.string().optional().describe('Parent comment ID to fetch replies for (mutually exclusive with id)'),
+        part: z.string().optional().describe("Resource parts: 'id' and/or 'snippet' (default snippet)"),
+        maxResults: z.number().min(1).max(100).optional().describe('Results per page (1-100, default 20; incompatible with id)'),
+        pageToken: z.string().optional().describe('Page token from a previous response'),
+        textFormat: z.enum(['html', 'plainText']).optional().describe('Text format (default html)'),
+    }),
+    execute: async ({ youtubeToken, id, parentId, part, maxResults, pageToken, textFormat }) => {
+        try {
+            if (id && parentId)
+                return { error: 'id and parentId are mutually exclusive' };
+            const result = await youtubeRequest(youtubeToken, '/comments', {
+                query: { part: part ?? 'snippet', id, parentId, maxResults, pageToken, textFormat },
+            });
+            if (!result.ok)
+                return { error: 'Failed to list comments', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return {
+                error: 'Error listing comments',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=list-comments.js.map

package/dist/toolkits/youtube/tools/list-i18n-languages.d.ts

@@ -0,0 +1,6 @@
+export declare const listI18nLanguages: import("ai").Tool<{
+    youtubeToken: string;
+    part?: string | undefined;
+    hl?: string | undefined;
+}, any>;
+//# sourceMappingURL=list-i18n-languages.d.ts.map

package/dist/toolkits/youtube/tools/list-i18n-languages.js

@@ -0,0 +1,29 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { youtubeRequest, youtubeTokenField } from './client.js';
+export const listI18nLanguages = tool({
+    description: 'Lists application languages the YouTube website supports. Use for interface localization options.',
+    inputSchema: z.object({
+        youtubeToken: youtubeTokenField,
+        part: z.string().optional().describe("Resource parts (default snippet)"),
+        hl: z.string().optional().describe('BCP-47 language for language names (default en_US)'),
+    }),
+    execute: async ({ youtubeToken, part, hl }) => {
+        try {
+            const result = await youtubeRequest(youtubeToken, '/i18nLanguages', {
+                query: { part: part ?? 'snippet', hl },
+            });
+            if (!result.ok)
+                return { error: 'Failed to list i18n languages', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return {
+                error: 'Error listing i18n languages',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=list-i18n-languages.js.map

package/dist/toolkits/youtube/tools/list-i18n-regions.d.ts

@@ -0,0 +1,6 @@
+export declare const listI18nRegions: import("ai").Tool<{
+    youtubeToken: string;
+    part?: string | undefined;
+    hl?: string | undefined;
+}, any>;
+//# sourceMappingURL=list-i18n-regions.d.ts.map

package/dist/toolkits/youtube/tools/list-i18n-regions.js

@@ -0,0 +1,29 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { youtubeRequest, youtubeTokenField } from './client.js';
+export const listI18nRegions = tool({
+    description: 'Lists content regions (ISO 3166-1 alpha-2 codes with localized names) that YouTube supports. Use for geo filtering and display.',
+    inputSchema: z.object({
+        youtubeToken: youtubeTokenField,
+        part: z.string().optional().describe("Resource parts (default snippet)"),
+        hl: z.string().optional().describe('BCP-47 language for region names (default en_US)'),
+    }),
+    execute: async ({ youtubeToken, part, hl }) => {
+        try {
+            const result = await youtubeRequest(youtubeToken, '/i18nRegions', {
+                query: { part: part ?? 'snippet', hl },
+            });
+            if (!result.ok)
+                return { error: 'Failed to list i18n regions', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return {
+                error: 'Error listing i18n regions',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=list-i18n-regions.js.map

package/dist/toolkits/youtube/tools/list-live-chat-messages.d.ts

@@ -0,0 +1,10 @@
+export declare const listLiveChatMessages: import("ai").Tool<{
+    youtubeToken: string;
+    liveChatId: string;
+    maxResults?: number | undefined;
+    pageToken?: string | undefined;
+    part?: string | undefined;
+    hl?: string | undefined;
+    profileImageSize?: number | undefined;
+}, any>;
+//# sourceMappingURL=list-live-chat-messages.d.ts.map

package/dist/toolkits/youtube/tools/list-live-chat-messages.js

@@ -0,0 +1,33 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { youtubeRequest, youtubeTokenField } from './client.js';
+export const listLiveChatMessages = tool({
+    description: 'Lists live chat messages (text, Super Chat, moderation events) for a chat ID from a liveBroadcast resource. Use pollingIntervalMillis for polling cadence.',
+    inputSchema: z.object({
+        youtubeToken: youtubeTokenField,
+        liveChatId: z.string().describe('Chat ID from the liveBroadcast snippet.liveChatId'),
+        part: z.string().optional().describe('Resource parts (default snippet,authorDetails)'),
+        maxResults: z.number().min(200).max(2000).optional().describe('Messages per page (200-2000, default 500)'),
+        pageToken: z.string().optional().describe('nextPageToken from a previous response for subsequent messages'),
+        hl: z.string().optional().describe('BCP-47 language for Super Chat currency display'),
+        profileImageSize: z.number().min(16).max(720).optional().describe('Profile image size in px (16-720, default 88)'),
+    }),
+    execute: async ({ youtubeToken, liveChatId, part, maxResults, pageToken, hl, profileImageSize }) => {
+        try {
+            const result = await youtubeRequest(youtubeToken, '/liveChat/messages', {
+                query: { liveChatId, part: part ?? 'snippet,authorDetails', maxResults, pageToken, hl, profileImageSize },
+            });
+            if (!result.ok)
+                return { error: 'Failed to list live chat messages', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return {
+                error: 'Error listing live chat messages',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=list-live-chat-messages.js.map

package/dist/toolkits/youtube/tools/list-playlist-images.d.ts

@@ -0,0 +1,11 @@
+export declare const listPlaylistImages: import("ai").Tool<{
+    youtubeToken: string;
+    id?: string | undefined;
+    maxResults?: number | undefined;
+    pageToken?: string | undefined;
+    parent?: string | undefined;
+    onBehalfOfContentOwner?: string | undefined;
+    part?: string | undefined;
+    onBehalfOfContentOwnerChannel?: string | undefined;
+}, any>;
+//# sourceMappingURL=list-playlist-images.d.ts.map

package/dist/toolkits/youtube/tools/list-playlist-images.js

@@ -0,0 +1,36 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { youtubeRequest, youtubeTokenField } from './client.js';
+export const listPlaylistImages = tool({
+    description: 'Retrieves custom thumbnail images for a playlist. Specify either image IDs or the parent playlist ID.',
+    inputSchema: z.object({
+        youtubeToken: youtubeTokenField,
+        id: z.string().optional().describe('Comma-separated playlist image IDs'),
+        parent: z.string().optional().describe('Playlist ID to retrieve images for'),
+        part: z.string().optional().describe('Resource parts (default snippet)'),
+        maxResults: z.number().min(0).max(50).optional().describe('Images per page (0-50, default 5)'),
+        pageToken: z.string().optional().describe('Page token from a previous response'),
+        onBehalfOfContentOwner: z.string().optional(),
+        onBehalfOfContentOwnerChannel: z.string().optional(),
+    }),
+    execute: async ({ youtubeToken, id, parent, part, maxResults, pageToken, onBehalfOfContentOwner, onBehalfOfContentOwnerChannel }) => {
+        try {
+            if (!id && !parent)
+                return { error: 'Either id or parent must be provided' };
+            const result = await youtubeRequest(youtubeToken, '/playlistImages', {
+                query: { part: part ?? 'snippet', id, parent, maxResults, pageToken, onBehalfOfContentOwner, onBehalfOfContentOwnerChannel },
+            });
+            if (!result.ok)
+                return { error: 'Failed to list playlist images', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return {
+                error: 'Error listing playlist images',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=list-playlist-images.js.map

package/dist/toolkits/youtube/tools/list-playlist-items.d.ts

@@ -0,0 +1,11 @@
+export declare const listPlaylistItems: import("ai").Tool<{
+    youtubeToken: string;
+    playlistId: string;
+    maxResults?: number | undefined;
+    pageToken?: string | undefined;
+    fields?: string | undefined;
+    videoId?: string | undefined;
+    onBehalfOfContentOwner?: string | undefined;
+    part?: string | undefined;
+}, any>;
+//# sourceMappingURL=list-playlist-items.d.ts.map