@rnsk/toolkits 0.0.7 → 0.0.9

package/dist/toolkits/youtube/tools/create-comment-reply.js

@@ -0,0 +1,31 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { youtubeRequest, youtubeTokenField } from './client.js';
+export const createCommentReply = tool({
+    description: 'Replies to an existing comment. Use when responding to users or engaging in video conversations.',
+    inputSchema: z.object({
+        youtubeToken: youtubeTokenField,
+        parentId: z.string().describe('ID of the parent comment to reply to'),
+        textOriginal: z.string().min(1).describe('Reply text (cannot be empty)'),
+    }),
+    execute: async ({ youtubeToken, parentId, textOriginal }) => {
+        try {
+            const result = await youtubeRequest(youtubeToken, '/comments', {
+                method: 'POST',
+                query: { part: 'snippet' },
+                body: { snippet: { parentId, textOriginal } },
+            });
+            if (!result.ok)
+                return { error: 'Failed to create comment reply', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return {
+                error: 'Error creating comment reply',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=create-comment-reply.js.map

package/dist/toolkits/youtube/tools/create-playlist.d.ts

@@ -0,0 +1,7 @@
+export declare const createPlaylist: import("ai").Tool<{
+    title: string;
+    youtubeToken: string;
+    description?: string | undefined;
+    privacyStatus?: "private" | "public" | "unlisted" | undefined;
+}, any>;
+//# sourceMappingURL=create-playlist.d.ts.map

package/dist/toolkits/youtube/tools/create-playlist.js

@@ -0,0 +1,38 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { youtubeRequest, youtubeTokenField } from './client.js';
+export const createPlaylist = tool({
+    description: 'Creates a new playlist on the authenticated user channel. Use when organizing videos into collections or building curated playlists.',
+    inputSchema: z.object({
+        youtubeToken: youtubeTokenField,
+        title: z.string().describe('Title of the new playlist (required)'),
+        description: z.string().optional().describe('Playlist description'),
+        privacyStatus: z.enum(['public', 'private', 'unlisted']).optional().describe('Privacy status; omit for YouTube default'),
+    }),
+    execute: async ({ youtubeToken, title, description, privacyStatus }) => {
+        try {
+            const snippet = { title };
+            if (description !== undefined)
+                snippet.description = description;
+            const body = { snippet };
+            if (privacyStatus)
+                body.status = { privacyStatus };
+            const result = await youtubeRequest(youtubeToken, '/playlists', {
+                method: 'POST',
+                query: { part: 'snippet,status' },
+                body,
+            });
+            if (!result.ok)
+                return { error: 'Failed to create playlist', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return {
+                error: 'Error creating playlist',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=create-playlist.js.map

package/dist/toolkits/youtube/tools/delete-channel-section.d.ts

@@ -0,0 +1,27 @@
+export declare const deleteChannelSection: import("ai").Tool<{
+    id: string;
+    youtubeToken: string;
+    onBehalfOfContentOwner?: string | undefined;
+}, {
+    error: string;
+    details: any;
+    channelSectionId?: undefined;
+    deleted?: undefined;
+    httpStatus?: undefined;
+    message?: undefined;
+} | {
+    channelSectionId: string;
+    deleted: boolean;
+    httpStatus: number;
+    error?: undefined;
+    details?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    message: string;
+    details?: undefined;
+    channelSectionId?: undefined;
+    deleted?: undefined;
+    httpStatus?: undefined;
+}>;
+//# sourceMappingURL=delete-channel-section.d.ts.map

package/dist/toolkits/youtube/tools/delete-channel-section.js

@@ -0,0 +1,30 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { onBehalfOfContentOwnerField, youtubeRequest, youtubeTokenField } from './client.js';
+export const deleteChannelSection = tool({
+    description: 'Deletes a channel section. The section must exist and the authenticated user must have permission.',
+    inputSchema: z.object({
+        youtubeToken: youtubeTokenField,
+        id: z.string().describe('Channel section ID to delete (required)'),
+        onBehalfOfContentOwner: onBehalfOfContentOwnerField,
+    }),
+    execute: async ({ youtubeToken, id, onBehalfOfContentOwner }) => {
+        try {
+            const result = await youtubeRequest(youtubeToken, '/channelSections', {
+                method: 'DELETE',
+                query: { id, onBehalfOfContentOwner },
+            });
+            if (!result.ok)
+                return { error: 'Failed to delete channel section', details: result.error };
+            return { channelSectionId: id, deleted: true, httpStatus: 204 };
+        }
+        catch (error) {
+            return {
+                error: 'Error deleting channel section',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=delete-channel-section.js.map

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

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

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

@@ -0,0 +1,29 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { youtubeRequest, youtubeTokenField } from './client.js';
+export const deleteComment = tool({
+    description: 'Deletes a comment owned by the authenticated user or channel.',
+    inputSchema: z.object({
+        youtubeToken: youtubeTokenField,
+        id: z.string().describe('Comment ID to delete (must be owned by the authenticated channel)'),
+    }),
+    execute: async ({ youtubeToken, id }) => {
+        try {
+            const result = await youtubeRequest(youtubeToken, '/comments', {
+                method: 'DELETE',
+                query: { id },
+            });
+            if (!result.ok)
+                return { error: 'Failed to delete comment', details: result.error };
+            return { commentId: id, deleted: true, httpStatus: 204 };
+        }
+        catch (error) {
+            return {
+                error: 'Error deleting comment',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=delete-comment.js.map

package/dist/toolkits/youtube/tools/delete-playlist-item.d.ts

@@ -0,0 +1,26 @@
+export declare const deletePlaylistItem: import("ai").Tool<{
+    id: string;
+    youtubeToken: string;
+}, {
+    error: string;
+    details: any;
+    playlistItemId?: undefined;
+    deleted?: undefined;
+    httpStatus?: undefined;
+    message?: undefined;
+} | {
+    playlistItemId: string;
+    deleted: boolean;
+    httpStatus: number;
+    error?: undefined;
+    details?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    message: string;
+    details?: undefined;
+    playlistItemId?: undefined;
+    deleted?: undefined;
+    httpStatus?: undefined;
+}>;
+//# sourceMappingURL=delete-playlist-item.d.ts.map

package/dist/toolkits/youtube/tools/delete-playlist-item.js

@@ -0,0 +1,29 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { youtubeRequest, youtubeTokenField } from './client.js';
+export const deletePlaylistItem = tool({
+    description: 'Removes a video from a playlist by deleting the playlist item. Use the playlist item ID (not the video ID).',
+    inputSchema: z.object({
+        youtubeToken: youtubeTokenField,
+        id: z.string().describe('Playlist item ID to delete (identifies a specific video within a playlist)'),
+    }),
+    execute: async ({ youtubeToken, id }) => {
+        try {
+            const result = await youtubeRequest(youtubeToken, '/playlistItems', {
+                method: 'DELETE',
+                query: { id },
+            });
+            if (!result.ok)
+                return { error: 'Failed to delete playlist item', details: result.error };
+            return { playlistItemId: id, deleted: true, httpStatus: 204 };
+        }
+        catch (error) {
+            return {
+                error: 'Error deleting playlist item',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=delete-playlist-item.js.map

package/dist/toolkits/youtube/tools/delete-playlist.d.ts

@@ -0,0 +1,35 @@
+export declare const deletePlaylist: import("ai").Tool<{
+    id: string;
+    youtubeToken: string;
+    confirmDelete: boolean;
+    onBehalfOfContentOwner?: string | undefined;
+}, {
+    error: string;
+    details?: undefined;
+    playlistId?: undefined;
+    deleted?: undefined;
+    httpStatus?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    details: any;
+    playlistId?: undefined;
+    deleted?: undefined;
+    httpStatus?: undefined;
+    message?: undefined;
+} | {
+    playlistId: string;
+    deleted: boolean;
+    httpStatus: number;
+    error?: undefined;
+    details?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    message: string;
+    details?: undefined;
+    playlistId?: undefined;
+    deleted?: undefined;
+    httpStatus?: undefined;
+}>;
+//# sourceMappingURL=delete-playlist.d.ts.map

package/dist/toolkits/youtube/tools/delete-playlist.js

@@ -0,0 +1,33 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { onBehalfOfContentOwnerField, youtubeRequest, youtubeTokenField } from './client.js';
+export const deletePlaylist = tool({
+    description: 'Permanently deletes a playlist owned by the authenticated user/channel. Requires explicit confirmDelete=true to prevent accidents.',
+    inputSchema: z.object({
+        youtubeToken: youtubeTokenField,
+        id: z.string().describe('Playlist ID to delete (must be owned by the authenticated user)'),
+        confirmDelete: z.boolean().describe('Must be true to execute the deletion'),
+        onBehalfOfContentOwner: onBehalfOfContentOwnerField,
+    }),
+    execute: async ({ youtubeToken, id, confirmDelete, onBehalfOfContentOwner }) => {
+        try {
+            if (confirmDelete !== true)
+                return { error: 'Deletion requires confirmDelete: true' };
+            const result = await youtubeRequest(youtubeToken, '/playlists', {
+                method: 'DELETE',
+                query: { id, onBehalfOfContentOwner },
+            });
+            if (!result.ok)
+                return { error: 'Failed to delete playlist', details: result.error };
+            return { playlistId: id, deleted: true, httpStatus: 204 };
+        }
+        catch (error) {
+            return {
+                error: 'Error deleting playlist',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=delete-playlist.js.map

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

@@ -0,0 +1,35 @@
+export declare const deleteVideo: import("ai").Tool<{
+    videoId: string;
+    youtubeToken: string;
+    confirmDelete: boolean;
+    onBehalfOfContentOwner?: string | undefined;
+}, {
+    error: string;
+    details?: undefined;
+    videoId?: undefined;
+    deleted?: undefined;
+    httpStatus?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    details: any;
+    videoId?: undefined;
+    deleted?: undefined;
+    httpStatus?: undefined;
+    message?: undefined;
+} | {
+    videoId: string;
+    deleted: boolean;
+    httpStatus: number;
+    error?: undefined;
+    details?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    message: string;
+    details?: undefined;
+    videoId?: undefined;
+    deleted?: undefined;
+    httpStatus?: undefined;
+}>;
+//# sourceMappingURL=delete-video.d.ts.map

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

@@ -0,0 +1,33 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { onBehalfOfContentOwnerField, youtubeRequest, youtubeTokenField } from './client.js';
+export const deleteVideo = tool({
+    description: 'Permanently deletes a video owned by the authenticated channel. Requires explicit confirmDelete=true.',
+    inputSchema: z.object({
+        youtubeToken: youtubeTokenField,
+        videoId: z.string().describe('Video ID to delete (must be owned by the authenticated channel)'),
+        confirmDelete: z.boolean().describe('Must be true to execute the deletion'),
+        onBehalfOfContentOwner: onBehalfOfContentOwnerField,
+    }),
+    execute: async ({ youtubeToken, videoId, confirmDelete, onBehalfOfContentOwner }) => {
+        try {
+            if (confirmDelete !== true)
+                return { error: 'Deletion requires confirmDelete: true' };
+            const result = await youtubeRequest(youtubeToken, '/videos', {
+                method: 'DELETE',
+                query: { id: videoId, onBehalfOfContentOwner },
+            });
+            if (!result.ok)
+                return { error: 'Failed to delete video', details: result.error };
+            return { videoId, deleted: true, httpStatus: 204 };
+        }
+        catch (error) {
+            return {
+                error: 'Error deleting video',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=delete-video.js.map

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

@@ -0,0 +1,21 @@
+export declare const downloadCaptionTrack: import("ai").Tool<{
+    id: string;
+    youtubeToken: string;
+    tfmt?: string | undefined;
+}, {
+    error: string;
+    details: any;
+    captionsText?: undefined;
+    message?: undefined;
+} | {
+    captionsText: any;
+    error?: undefined;
+    details?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    message: string;
+    details?: undefined;
+    captionsText?: undefined;
+}>;
+//# sourceMappingURL=download-caption-track.d.ts.map

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

@@ -0,0 +1,30 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { youtubeRequest, youtubeTokenField } from './client.js';
+export const downloadCaptionTrack = tool({
+    description: 'Downloads an owned caption track as text (srt/sbv/vtt). Requires owning the video — other videos return 403, including many auto-generated tracks.',
+    inputSchema: z.object({
+        youtubeToken: youtubeTokenField,
+        id: z.string().min(1).describe('Caption track ID from listCaptionTrack (NOT the video ID)'),
+        tfmt: z.string().optional().describe("Format: 'srt' (default), 'sbv', or 'vtt'"),
+    }),
+    execute: async ({ youtubeToken, id, tfmt }) => {
+        try {
+            const result = await youtubeRequest(youtubeToken, `/captions/${id}`, {
+                query: { tfmt: tfmt ?? 'srt' },
+                responseType: 'text',
+            });
+            if (!result.ok)
+                return { error: 'Failed to download caption track', details: result.error };
+            return { captionsText: result.data };
+        }
+        catch (error) {
+            return {
+                error: 'Error downloading caption track',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=download-caption-track.js.map

package/dist/toolkits/youtube/tools/get-channel-activities.d.ts

@@ -0,0 +1,10 @@
+export declare const getChannelActivities: import("ai").Tool<{
+    youtubeToken: string;
+    channelId: string;
+    maxResults?: number | undefined;
+    pageToken?: string | undefined;
+    part?: string | undefined;
+    publishedAfter?: string | undefined;
+    publishedBefore?: string | undefined;
+}, any>;
+//# sourceMappingURL=get-channel-activities.d.ts.map

package/dist/toolkits/youtube/tools/get-channel-activities.js

@@ -0,0 +1,33 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { youtubeRequest, youtubeTokenField } from './client.js';
+export const getChannelActivities = tool({
+    description: 'Gets recent channel activities (uploads, playlist additions, likes, and other events) for a channel ID.',
+    inputSchema: z.object({
+        youtubeToken: youtubeTokenField,
+        channelId: z.string().describe("Channel ID (starts with 'UC')"),
+        part: z.string().optional().describe('Resource parts (default snippet,contentDetails)'),
+        maxResults: z.number().min(0).max(50).optional().describe('Activities to return (0-50, default 25)'),
+        pageToken: z.string().optional().describe('Page token from a previous response'),
+        publishedAfter: z.string().optional().describe('RFC 3339 lower bound on activity time'),
+        publishedBefore: z.string().optional().describe('RFC 3339 upper bound on activity time'),
+    }),
+    execute: async ({ youtubeToken, channelId, part, maxResults, pageToken, publishedAfter, publishedBefore }) => {
+        try {
+            const result = await youtubeRequest(youtubeToken, '/activities', {
+                query: { part: part ?? 'snippet,contentDetails', channelId, maxResults, pageToken, publishedAfter, publishedBefore },
+            });
+            if (!result.ok)
+                return { error: 'Failed to get channel activities', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return {
+                error: 'Error getting channel activities',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=get-channel-activities.js.map

package/dist/toolkits/youtube/tools/get-channel-id-by-handle.d.ts

@@ -0,0 +1,5 @@
+export declare const getChannelIdByHandle: import("ai").Tool<{
+    youtubeToken: string;
+    channelHandle: string;
+}, any>;
+//# sourceMappingURL=get-channel-id-by-handle.d.ts.map

package/dist/toolkits/youtube/tools/get-channel-id-by-handle.js

@@ -0,0 +1,31 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { extractHandle, youtubeRequest, youtubeTokenField } from './client.js';
+export const getChannelIdByHandle = tool({
+    description: 'Resolves a channel handle (with or without @, or a full youtube.com/@handle URL) to its channel ID.',
+    inputSchema: z.object({
+        youtubeToken: youtubeTokenField,
+        channelHandle: z.string().describe("Handle like '@Google', 'Google', or a full channel URL"),
+    }),
+    execute: async ({ youtubeToken, channelHandle }) => {
+        try {
+            const handle = extractHandle(channelHandle);
+            if (!handle)
+                return { error: 'Could not extract a handle from channelHandle' };
+            const result = await youtubeRequest(youtubeToken, '/channels', {
+                query: { part: 'snippet,statistics,status', forHandle: handle },
+            });
+            if (!result.ok)
+                return { error: 'Failed to resolve channel handle', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return {
+                error: 'Error resolving channel handle',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=get-channel-id-by-handle.js.map

package/dist/toolkits/youtube/tools/get-channel-statistics.d.ts

@@ -0,0 +1,9 @@
+export declare const getChannelStatistics: import("ai").Tool<{
+    youtubeToken: string;
+    id?: string | undefined;
+    part?: string | undefined;
+    forHandle?: string | undefined;
+    forUsername?: string | undefined;
+    mine?: boolean | undefined;
+}, any>;
+//# sourceMappingURL=get-channel-statistics.d.ts.map

package/dist/toolkits/youtube/tools/get-channel-statistics.js

@@ -0,0 +1,53 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { chunk, youtubeRequest, youtubeTokenField } from './client.js';
+export const getChannelStatistics = tool({
+    description: 'Gets subscriber, view, and video counts for channels by ID, handle, username, or ownership. ID lists over 50 are batched and merged.',
+    inputSchema: z.object({
+        youtubeToken: youtubeTokenField,
+        id: z.string().optional().describe('Comma-separated channel IDs (max 50 per request, auto-batched)'),
+        forHandle: z.string().optional().describe('Channel handle, @ optional'),
+        forUsername: z.string().optional().describe('Legacy username'),
+        mine: z.boolean().optional().describe('True for the authenticated user channel'),
+        part: z.string().optional().describe('Resource parts (default statistics)'),
+    }),
+    execute: async ({ youtubeToken, id, forHandle, forUsername, mine, part }) => {
+        try {
+            if (!id && !forHandle && !forUsername && !mine) {
+                return { error: 'At least one of id, forHandle, forUsername, or mine is required' };
+            }
+            const partParam = part ?? 'statistics';
+            if (!id) {
+                const result = await youtubeRequest(youtubeToken, '/channels', {
+                    query: { part: partParam, forHandle, forUsername, mine },
+                });
+                if (!result.ok)
+                    return { error: 'Failed to get channel statistics', details: result.error };
+                const data = result.data;
+                return { ...result.data, channels: data.items ?? [] };
+            }
+            const ids = id.split(',').map((s) => s.trim()).filter(Boolean);
+            const items = [];
+            let pageInfo;
+            for (const batch of chunk(ids, 50)) {
+                const result = await youtubeRequest(youtubeToken, '/channels', {
+                    query: { part: partParam, id: batch.join(',') },
+                });
+                if (!result.ok)
+                    return { error: 'Failed to get channel statistics', details: result.error };
+                const data = result.data;
+                items.push(...(data.items ?? []));
+                pageInfo = data.pageInfo;
+            }
+            return { kind: 'youtube#channelListResponse', items, channels: items, pageInfo };
+        }
+        catch (error) {
+            return {
+                error: 'Error getting channel statistics',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=get-channel-statistics.js.map

package/dist/toolkits/youtube/tools/get-video-details-batch.d.ts

@@ -0,0 +1,55 @@
+export declare const getVideoDetailsBatch: import("ai").Tool<{
+    id: string[];
+    youtubeToken: string;
+    parts?: string[] | undefined;
+    hl?: string | undefined;
+}, {
+    error: string;
+    details?: undefined;
+    kind?: undefined;
+    items?: undefined;
+    foundCount?: undefined;
+    requestedCount?: undefined;
+    requestedVideoIds?: undefined;
+    notFoundVideoIds?: undefined;
+    notFoundCount?: undefined;
+    partialFailure?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    details: any;
+    kind?: undefined;
+    items?: undefined;
+    foundCount?: undefined;
+    requestedCount?: undefined;
+    requestedVideoIds?: undefined;
+    notFoundVideoIds?: undefined;
+    notFoundCount?: undefined;
+    partialFailure?: undefined;
+    message?: undefined;
+} | {
+    kind: string;
+    items: Record<string, unknown>[];
+    foundCount: number;
+    requestedCount: number;
+    requestedVideoIds: string[];
+    notFoundVideoIds: string[];
+    notFoundCount: number;
+    partialFailure: boolean;
+    error?: undefined;
+    details?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    message: string;
+    details?: undefined;
+    kind?: undefined;
+    items?: undefined;
+    foundCount?: undefined;
+    requestedCount?: undefined;
+    requestedVideoIds?: undefined;
+    notFoundVideoIds?: undefined;
+    notFoundCount?: undefined;
+    partialFailure?: undefined;
+}>;
+//# sourceMappingURL=get-video-details-batch.d.ts.map