@rnsk/toolkits 0.0.7 → 0.0.8

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

@@ -0,0 +1,34 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { onBehalfOfContentOwnerField, youtubeRequest, youtubeTokenField } from './client.js';
+export const listPlaylistItems = tool({
+    description: 'Lists videos in a playlist with pagination. Use when walking an uploads playlist (UU... IDs) to enumerate all videos.',
+    inputSchema: z.object({
+        youtubeToken: youtubeTokenField,
+        playlistId: z.string().describe("Playlist ID (PL... for playlists, UU... for channel uploads; do not pass UC... channel IDs)"),
+        part: z.string().optional().describe('Resource parts (default snippet,contentDetails)'),
+        maxResults: z.number().min(0).max(50).optional().describe('Items per page (0-50, default 50)'),
+        pageToken: z.string().optional().describe('Page token from a previous response'),
+        videoId: z.string().optional().describe('Filter to items containing this video ID'),
+        fields: z.string().optional().describe('Partial-response field selector'),
+        onBehalfOfContentOwner: onBehalfOfContentOwnerField,
+    }),
+    execute: async ({ youtubeToken, playlistId, part, maxResults, pageToken, videoId, fields, onBehalfOfContentOwner }) => {
+        try {
+            const result = await youtubeRequest(youtubeToken, '/playlistItems', {
+                query: { part: part ?? 'snippet,contentDetails', playlistId, maxResults, pageToken, videoId, fields, onBehalfOfContentOwner },
+            });
+            if (!result.ok)
+                return { error: 'Failed to list playlist items', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return {
+                error: 'Error listing playlist items',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=list-playlist-items.js.map

package/dist/toolkits/youtube/tools/list-super-chat-events.d.ts

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

package/dist/toolkits/youtube/tools/list-super-chat-events.js

@@ -0,0 +1,31 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { youtubeRequest, youtubeTokenField } from './client.js';
+export const listSuperChatEvents = tool({
+    description: 'Lists Super Chat and Super Sticker purchases from the past 30 days. Use to track and acknowledge supporter contributions.',
+    inputSchema: z.object({
+        youtubeToken: youtubeTokenField,
+        part: z.string().optional().describe("Resource parts: 'id' and/or 'snippet' (default snippet)"),
+        maxResults: z.number().min(1).max(50).optional().describe('Events per page (1-50, default 5)'),
+        pageToken: z.string().optional().describe('Page token from a previous response'),
+        hl: z.string().optional().describe('BCP-47 language for amount display (default en)'),
+    }),
+    execute: async ({ youtubeToken, part, maxResults, pageToken, hl }) => {
+        try {
+            const result = await youtubeRequest(youtubeToken, '/superChatEvents', {
+                query: { part: part ?? 'snippet', maxResults, pageToken, hl },
+            });
+            if (!result.ok)
+                return { error: 'Failed to list Super Chat events', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return {
+                error: 'Error listing Super Chat events',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=list-super-chat-events.js.map

package/dist/toolkits/youtube/tools/list-user-playlists.d.ts

@@ -0,0 +1,7 @@
+export declare const listUserPlaylists: import("ai").Tool<{
+    youtubeToken: string;
+    maxResults?: number | undefined;
+    pageToken?: string | undefined;
+    part?: string | undefined;
+}, any>;
+//# sourceMappingURL=list-user-playlists.d.ts.map

package/dist/toolkits/youtube/tools/list-user-playlists.js

@@ -0,0 +1,30 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { youtubeRequest, youtubeTokenField } from './client.js';
+export const listUserPlaylists = tool({
+    description: 'Retrieves playlists owned by the authenticated user (mine=true). Use to discover playlist IDs before managing items.',
+    inputSchema: z.object({
+        youtubeToken: youtubeTokenField,
+        part: z.string().optional().describe('Resource parts (default snippet)'),
+        maxResults: z.number().min(1).max(50).optional().describe('Playlists per page (1-50, default 5)'),
+        pageToken: z.string().optional().describe('Page token from a previous response'),
+    }),
+    execute: async ({ youtubeToken, part, maxResults, pageToken }) => {
+        try {
+            const result = await youtubeRequest(youtubeToken, '/playlists', {
+                query: { part: part ?? 'snippet', mine: true, maxResults, pageToken },
+            });
+            if (!result.ok)
+                return { error: 'Failed to list user playlists', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return {
+                error: 'Error listing user playlists',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=list-user-playlists.js.map

package/dist/toolkits/youtube/tools/list-user-subscriptions.d.ts

@@ -0,0 +1,7 @@
+export declare const listUserSubscriptions: import("ai").Tool<{
+    youtubeToken: string;
+    maxResults?: number | undefined;
+    pageToken?: string | undefined;
+    part?: string | undefined;
+}, any>;
+//# sourceMappingURL=list-user-subscriptions.d.ts.map

package/dist/toolkits/youtube/tools/list-user-subscriptions.js

@@ -0,0 +1,30 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { youtubeRequest, youtubeTokenField } from './client.js';
+export const listUserSubscriptions = tool({
+    description: 'Retrieves the authenticated user channel subscriptions with pagination.',
+    inputSchema: z.object({
+        youtubeToken: youtubeTokenField,
+        part: z.string().optional().describe('Resource parts (default snippet,contentDetails)'),
+        maxResults: z.number().min(1).max(50).optional().describe('Subscriptions per page (1-50, default 5)'),
+        pageToken: z.string().optional().describe('Page token from a previous response'),
+    }),
+    execute: async ({ youtubeToken, part, maxResults, pageToken }) => {
+        try {
+            const result = await youtubeRequest(youtubeToken, '/subscriptions', {
+                query: { part: part ?? 'snippet,contentDetails', mine: true, maxResults, pageToken },
+            });
+            if (!result.ok)
+                return { error: 'Failed to list subscriptions', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return {
+                error: 'Error listing subscriptions',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=list-user-subscriptions.js.map

package/dist/toolkits/youtube/tools/list-video-abuse-report-reasons.d.ts

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

package/dist/toolkits/youtube/tools/list-video-abuse-report-reasons.js

@@ -0,0 +1,29 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { youtubeRequest, youtubeTokenField } from './client.js';
+export const listVideoAbuseReportReasons = tool({
+    description: 'Lists abuse report reasons with localized labels for use with reportVideoAbuse.',
+    inputSchema: z.object({
+        youtubeToken: youtubeTokenField,
+        part: z.string().optional().describe("Resource parts: 'id' and/or 'snippet' (default snippet)"),
+        hl: z.string().optional().describe('BCP-47 language for labels (default en_US)'),
+    }),
+    execute: async ({ youtubeToken, part, hl }) => {
+        try {
+            const result = await youtubeRequest(youtubeToken, '/videoAbuseReportReasons', {
+                query: { part: part ?? 'snippet', hl },
+            });
+            if (!result.ok)
+                return { error: 'Failed to list abuse report reasons', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return {
+                error: 'Error listing abuse report reasons',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=list-video-abuse-report-reasons.js.map

package/dist/toolkits/youtube/tools/list-video-categories.d.ts

@@ -0,0 +1,8 @@
+export declare const listVideoCategories: import("ai").Tool<{
+    youtubeToken: string;
+    id?: string | undefined;
+    part?: string | undefined;
+    hl?: string | undefined;
+    regionCode?: string | undefined;
+}, any>;
+//# sourceMappingURL=list-video-categories.d.ts.map

package/dist/toolkits/youtube/tools/list-video-categories.js

@@ -0,0 +1,33 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { youtubeRequest, youtubeTokenField } from './client.js';
+export const listVideoCategories = tool({
+    description: 'Lists video categories for a region or by ID. Either id or regionCode must be set.',
+    inputSchema: z.object({
+        youtubeToken: youtubeTokenField,
+        id: z.string().optional().describe('Comma-separated category IDs'),
+        regionCode: z.string().optional().describe("ISO 3166-1 alpha-2 region, e.g. 'US'"),
+        part: z.string().optional().describe("Resource parts (default snippet)"),
+        hl: z.string().optional().describe('BCP-47 language for text (default en_US)'),
+    }),
+    execute: async ({ youtubeToken, id, regionCode, part, hl }) => {
+        try {
+            if (!id && !regionCode)
+                return { error: 'Either id or regionCode must be specified' };
+            const result = await youtubeRequest(youtubeToken, '/videoCategories', {
+                query: { part: part ?? 'snippet', id, regionCode, hl },
+            });
+            if (!result.ok)
+                return { error: 'Failed to list video categories', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return {
+                error: 'Error listing video categories',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=list-video-categories.js.map

package/dist/toolkits/youtube/tools/mark-comment-as-spam.d.ts

@@ -0,0 +1,26 @@
+export declare const markCommentAsSpam: import("ai").Tool<{
+    id: string;
+    youtubeToken: string;
+}, {
+    error: string;
+    details: any;
+    success?: undefined;
+    httpStatus?: undefined;
+    commentIds?: undefined;
+    message?: undefined;
+} | {
+    success: boolean;
+    httpStatus: number;
+    commentIds: string;
+    error?: undefined;
+    details?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    message: string;
+    details?: undefined;
+    success?: undefined;
+    httpStatus?: undefined;
+    commentIds?: undefined;
+}>;
+//# sourceMappingURL=mark-comment-as-spam.d.ts.map

package/dist/toolkits/youtube/tools/mark-comment-as-spam.js

@@ -0,0 +1,29 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { youtubeRequest, youtubeTokenField } from './client.js';
+export const markCommentAsSpam = tool({
+    description: 'Flags comments as spam for moderation. Note: the underlying comments.markAsSpam endpoint is deprecated but still functional.',
+    inputSchema: z.object({
+        youtubeToken: youtubeTokenField,
+        id: z.string().describe('Comma-separated comment IDs to mark as spam'),
+    }),
+    execute: async ({ youtubeToken, id }) => {
+        try {
+            const result = await youtubeRequest(youtubeToken, '/comments/markAsSpam', {
+                method: 'POST',
+                query: { id },
+            });
+            if (!result.ok)
+                return { error: 'Failed to mark comments as spam', details: result.error };
+            return { success: true, httpStatus: 204, commentIds: id };
+        }
+        catch (error) {
+            return {
+                error: 'Error marking comments as spam',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=mark-comment-as-spam.js.map

package/dist/toolkits/youtube/tools/multipart-upload-video.d.ts

@@ -0,0 +1,25 @@
+export declare const multipartUploadVideo: import("ai").Tool<{
+    description: string;
+    title: string;
+    youtubeToken: string;
+    privacyStatus: "private" | "public" | "unlisted";
+    videoUrl: string;
+    categoryId: string;
+    tags?: string[] | undefined;
+}, {
+    error: string;
+    details: any;
+    video?: undefined;
+    message?: undefined;
+} | {
+    video: any;
+    error?: undefined;
+    details?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    message: string;
+    details?: undefined;
+    video?: undefined;
+}>;
+//# sourceMappingURL=multipart-upload-video.d.ts.map

package/dist/toolkits/youtube/tools/multipart-upload-video.js

@@ -0,0 +1,40 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { YOUTUBE_UPLOAD_BASE, youtubeTokenField } from './client.js';
+import { buildMultipart, fetchVideoBytes, snippetStatusVideo } from './upload-shared.js';
+export const multipartUploadVideo = tool({
+    description: 'Uploads a video (metadata + bytes in one multipart request) from a publicly accessible file URL. File must be a YouTube-supported format.',
+    inputSchema: z.object({
+        youtubeToken: youtubeTokenField,
+        videoUrl: z.string().describe('Public URL of the video file to upload'),
+        title: z.string().describe('Video title'),
+        description: z.string().describe('Video description'),
+        categoryId: z.string().describe("Category ID, e.g. '22'"),
+        privacyStatus: z.enum(['public', 'private', 'unlisted']),
+        tags: z.array(z.string()).optional().describe('Keyword tags for discoverability'),
+    }),
+    execute: async ({ youtubeToken, videoUrl, title, description, categoryId, privacyStatus, tags }) => {
+        try {
+            const { bytes, contentType } = await fetchVideoBytes(videoUrl);
+            const { body, boundary } = buildMultipart(snippetStatusVideo(title, description, categoryId, privacyStatus, tags), bytes, contentType);
+            const response = await fetch(`${YOUTUBE_UPLOAD_BASE}/videos?uploadType=multipart&part=snippet,status`, {
+                method: 'POST',
+                headers: { Authorization: `Bearer ${youtubeToken}`, 'Content-Type': `multipart/related; boundary=${boundary}` },
+                body,
+            });
+            if (!response.ok) {
+                const details = await response.json().catch(() => ({}));
+                return { error: 'Failed to upload video', details };
+            }
+            return { video: await response.json() };
+        }
+        catch (error) {
+            return {
+                error: 'Error uploading video',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=multipart-upload-video.js.map

package/dist/toolkits/youtube/tools/post-comment.d.ts

@@ -0,0 +1,7 @@
+export declare const postComment: import("ai").Tool<{
+    youtubeToken: string;
+    videoId: string;
+    textOriginal: string;
+    channelId: string;
+}, any>;
+//# sourceMappingURL=post-comment.d.ts.map

package/dist/toolkits/youtube/tools/post-comment.js

@@ -0,0 +1,34 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { youtubeRequest, youtubeTokenField } from './client.js';
+export const postComment = tool({
+    description: 'Posts a new top-level comment on a video. Use to engage with video content.',
+    inputSchema: z.object({
+        youtubeToken: youtubeTokenField,
+        videoId: z.string().describe('Video ID to comment on (required)'),
+        channelId: z.string().describe('Channel ID that uploaded the video (required)'),
+        textOriginal: z.string().min(1).describe('Comment text to post'),
+    }),
+    execute: async ({ youtubeToken, videoId, channelId, textOriginal }) => {
+        try {
+            const result = await youtubeRequest(youtubeToken, '/commentThreads', {
+                method: 'POST',
+                query: { part: 'snippet' },
+                body: {
+                    snippet: { videoId, channelId, topLevelComment: { snippet: { textOriginal } } },
+                },
+            });
+            if (!result.ok)
+                return { error: 'Failed to post comment', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return {
+                error: 'Error posting comment',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=post-comment.js.map

package/dist/toolkits/youtube/tools/rate-video.d.ts

@@ -0,0 +1,30 @@
+export declare const rateVideo: import("ai").Tool<{
+    id: string;
+    youtubeToken: string;
+    rating: "none" | "like" | "dislike";
+}, {
+    error: string;
+    details: any;
+    videoId?: undefined;
+    rating?: undefined;
+    success?: undefined;
+    httpStatus?: undefined;
+    message?: undefined;
+} | {
+    videoId: string;
+    rating: "none" | "like" | "dislike";
+    success: boolean;
+    httpStatus: number;
+    error?: undefined;
+    details?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    message: string;
+    details?: undefined;
+    videoId?: undefined;
+    rating?: undefined;
+    success?: undefined;
+    httpStatus?: undefined;
+}>;
+//# sourceMappingURL=rate-video.d.ts.map

package/dist/toolkits/youtube/tools/rate-video.js

@@ -0,0 +1,30 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { youtubeRequest, youtubeTokenField } from './client.js';
+export const rateVideo = tool({
+    description: 'Likes, dislikes, or removes the rating on a video on behalf of the authenticated user.',
+    inputSchema: z.object({
+        youtubeToken: youtubeTokenField,
+        id: z.string().describe('Video ID to rate'),
+        rating: z.enum(['like', 'dislike', 'none']).describe('Rating to apply; none removes any existing rating'),
+    }),
+    execute: async ({ youtubeToken, id, rating }) => {
+        try {
+            const result = await youtubeRequest(youtubeToken, '/videos/rate', {
+                method: 'POST',
+                query: { id, rating },
+            });
+            if (!result.ok)
+                return { error: 'Failed to rate video', details: result.error };
+            return { videoId: id, rating, success: true, httpStatus: 204 };
+        }
+        catch (error) {
+            return {
+                error: 'Error rating video',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=rate-video.js.map

package/dist/toolkits/youtube/tools/report-video-abuse.d.ts

@@ -0,0 +1,27 @@
+export declare const reportVideoAbuse: import("ai").Tool<{
+    youtubeToken: string;
+    videoId: string;
+    reasonId: "N" | "V" | "C" | "M" | "E" | "H";
+    language?: string | undefined;
+    comments?: string | undefined;
+    secondaryReasonId?: string | undefined;
+}, {
+    error: string;
+    details: any;
+    success?: undefined;
+    httpStatus?: undefined;
+    message?: undefined;
+} | {
+    success: boolean;
+    httpStatus: number;
+    message: string;
+    error?: undefined;
+    details?: undefined;
+} | {
+    error: string;
+    message: string;
+    details?: undefined;
+    success?: undefined;
+    httpStatus?: undefined;
+}>;
+//# sourceMappingURL=report-video-abuse.d.ts.map

package/dist/toolkits/youtube/tools/report-video-abuse.js

@@ -0,0 +1,40 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { youtubeRequest, youtubeTokenField } from './client.js';
+export const reportVideoAbuse = tool({
+    description: 'Reports a video for abusive content. List valid reasons with listVideoAbuseReportReasons first.',
+    inputSchema: z.object({
+        youtubeToken: youtubeTokenField,
+        videoId: z.string().describe('Video ID being reported'),
+        reasonId: z.enum(['N', 'V', 'C', 'M', 'E', 'H']).describe('Reason: N nudity, V violent/hateful, C child abuse, M medical misinformation, E extremism, H harassment'),
+        secondaryReasonId: z.string().optional().describe('More specific secondary reason'),
+        comments: z.string().optional().describe('Additional reporter information'),
+        language: z.string().optional().describe("Reporter language, e.g. 'en'"),
+    }),
+    execute: async ({ youtubeToken, videoId, reasonId, secondaryReasonId, comments, language }) => {
+        try {
+            const body = { videoId, reasonId };
+            if (secondaryReasonId)
+                body.secondaryReasonId = secondaryReasonId;
+            if (comments)
+                body.comments = comments;
+            if (language)
+                body.language = language;
+            const result = await youtubeRequest(youtubeToken, '/videos/reportAbuse', {
+                method: 'POST',
+                body,
+            });
+            if (!result.ok)
+                return { error: 'Failed to report video', details: result.error };
+            return { success: true, httpStatus: 204, message: 'Abuse report submitted successfully' };
+        }
+        catch (error) {
+            return {
+                error: 'Error reporting video',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=report-video-abuse.js.map

package/dist/toolkits/youtube/tools/search-youtube.d.ts

@@ -0,0 +1,14 @@
+export declare const searchYouTube: import("ai").Tool<{
+    q: string;
+    youtubeToken: string;
+    type?: string | undefined;
+    maxResults?: number | undefined;
+    pageToken?: string | undefined;
+    order?: "date" | "title" | "relevance" | "rating" | "videoCount" | "viewCount" | undefined;
+    part?: string | undefined;
+    publishedAfter?: string | undefined;
+    publishedBefore?: string | undefined;
+    regionCode?: string | undefined;
+    relevanceLanguage?: string | undefined;
+}, any>;
+//# sourceMappingURL=search-youtube.d.ts.map

package/dist/toolkits/youtube/tools/search-youtube.js

@@ -0,0 +1,37 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { youtubeRequest, youtubeTokenField } from './client.js';
+export const searchYouTube = tool({
+    description: 'Searches YouTube for videos, channels, or playlists by query (supports exact phrases, exclusions, OR, @handles). Returns the raw search response.',
+    inputSchema: z.object({
+        youtubeToken: youtubeTokenField,
+        q: z.string().describe('Search query term'),
+        part: z.string().optional().describe("Response parts; only 'snippet' is valid for search (default snippet)"),
+        type: z.string().optional().describe("Restrict to 'video', 'channel', 'playlist' (comma-separated, default video)"),
+        order: z.enum(['date', 'rating', 'relevance', 'title', 'videoCount', 'viewCount']).optional(),
+        maxResults: z.number().min(1).max(50).optional().describe('Results per page (1-50, default 5)'),
+        pageToken: z.string().optional().describe('Page token from a previous response'),
+        regionCode: z.string().optional().describe('ISO 3166-1 alpha-2 country code'),
+        publishedAfter: z.string().optional().describe('RFC 3339 lower bound'),
+        publishedBefore: z.string().optional().describe('RFC 3339 upper bound'),
+        relevanceLanguage: z.string().optional().describe('ISO 639-1 language code'),
+    }),
+    execute: async ({ youtubeToken, q, part, type, order, maxResults, pageToken, regionCode, publishedAfter, publishedBefore, relevanceLanguage }) => {
+        try {
+            const result = await youtubeRequest(youtubeToken, '/search', {
+                query: { part: part ?? 'snippet', q, type: type ?? 'video', order, maxResults, pageToken, regionCode, publishedAfter, publishedBefore, relevanceLanguage },
+            });
+            if (!result.ok)
+                return { error: 'Failed to search YouTube', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return {
+                error: 'Error searching YouTube',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=search-youtube.js.map

package/dist/toolkits/youtube/tools/set-comment-moderation-status.d.ts

@@ -0,0 +1,27 @@
+export declare const setCommentModerationStatus: import("ai").Tool<{
+    id: string;
+    youtubeToken: string;
+    moderationStatus: "published" | "heldForReview" | "rejected";
+    banAuthor?: boolean | undefined;
+}, {
+    error: string;
+    details?: undefined;
+    success?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    details: any;
+    success?: undefined;
+    message?: undefined;
+} | {
+    success: boolean;
+    message: string;
+    error?: undefined;
+    details?: undefined;
+} | {
+    error: string;
+    message: string;
+    details?: undefined;
+    success?: undefined;
+}>;
+//# sourceMappingURL=set-comment-moderation-status.d.ts.map

package/dist/toolkits/youtube/tools/set-comment-moderation-status.js

@@ -0,0 +1,34 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { youtubeRequest, youtubeTokenField } from './client.js';
+export const setCommentModerationStatus = tool({
+    description: 'Holds, publishes, or rejects comments for moderation. Optionally bans the author when rejecting.',
+    inputSchema: z.object({
+        youtubeToken: youtubeTokenField,
+        id: z.string().describe('Comma-separated comment IDs (not thread IDs)'),
+        moderationStatus: z.enum(['heldForReview', 'published', 'rejected']).describe('New moderation status'),
+        banAuthor: z.boolean().optional().describe('Ban the author (only valid with rejected, default false)'),
+    }),
+    execute: async ({ youtubeToken, id, moderationStatus, banAuthor }) => {
+        try {
+            if (banAuthor === true && moderationStatus !== 'rejected') {
+                return { error: 'banAuthor is only valid when moderationStatus is rejected' };
+            }
+            const result = await youtubeRequest(youtubeToken, '/comments/setModerationStatus', {
+                method: 'POST',
+                query: { id, moderationStatus, banAuthor },
+            });
+            if (!result.ok)
+                return { error: 'Failed to set moderation status', details: result.error };
+            return { success: true, message: 'Comment moderation status updated successfully' };
+        }
+        catch (error) {
+            return {
+                error: 'Error setting moderation status',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=set-comment-moderation-status.js.map