@rnsk/toolkits 0.0.6 → 0.0.8

package/dist/toolkits/reddit/tools/retrieve-posts-from-subreddit.js

@@ -0,0 +1,56 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { redditGet } from './client.js';
+export const redditRetrievePostsFromSubreddit = tool({
+    description: 'Get posts from a public subreddit sorted by hot, new, top, rising, or controversial. Post data is nested under data.children[].data; paginate with the data.after cursor. Compare created_utc client-side for date filtering. Also covers new/top listings (set timeFilter for top/controversial windows).',
+    inputSchema: z.object({
+        redditToken: z.string().optional().describe('Injected by system; do not provide'),
+        subreddit: z.string().describe("Subreddit name without the 'r/' prefix, e.g. 'technology'"),
+        sort: z
+            .enum(['hot', 'new', 'top', 'rising', 'controversial'])
+            .optional()
+            .default('hot')
+            .describe('Sort order for posts'),
+        timeFilter: z
+            .enum(['hour', 'day', 'week', 'month', 'year', 'all'])
+            .optional()
+            .describe("Time window for 'top' and 'controversial' sorts"),
+        maxResults: z
+            .number()
+            .min(0)
+            .max(100)
+            .optional()
+            .default(5)
+            .describe('Max posts to return (max 100); 0 means maximum'),
+        after: z.string().optional().describe('Fullname cursor for the next page'),
+        before: z.string().optional().describe('Fullname cursor for the previous page'),
+        count: z.number().min(0).optional().describe('Number of items already seen (pagination)'),
+        show: z.string().optional().describe("Pass 'all' to include normally filtered items"),
+    }),
+    execute: async ({ redditToken, subreddit, sort = 'hot', timeFilter, maxResults = 5, after, before, count, show, }) => {
+        try {
+            if (!redditToken) {
+                return { error: 'Reddit token is required. Connect Reddit first.' };
+            }
+            return await redditGet(redditToken, `/r/${subreddit}/${sort}`, {
+                t: timeFilter,
+                limit: maxResults === 0 ? 100 : maxResults,
+                after,
+                before,
+                count,
+                show,
+            });
+        }
+        catch (error) {
+            if (error?.details !== undefined) {
+                return { error: 'Failed to retrieve posts from subreddit', details: error.details };
+            }
+            return {
+                error: 'Error retrieving posts from subreddit',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=retrieve-posts-from-subreddit.js.map

package/dist/toolkits/reddit/tools/retrieve-specific-comment-or-post.d.ts

@@ -0,0 +1,25 @@
+export declare const redditRetrieveSpecificCommentOrPost: import("ai").Tool<{
+    id: string;
+    redditToken?: string | undefined;
+}, {
+    error: string;
+    things?: undefined;
+    details?: undefined;
+    message?: undefined;
+} | {
+    things: any;
+    error?: undefined;
+    details?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    details: any;
+    things?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    message: string;
+    things?: undefined;
+    details?: undefined;
+}>;
+//# sourceMappingURL=retrieve-specific-comment-or-post.d.ts.map

package/dist/toolkits/reddit/tools/retrieve-specific-comment-or-post.js

@@ -0,0 +1,32 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { redditGet } from './client.js';
+export const redditRetrieveSpecificCommentOrPost = tool({
+    description: 'Get detailed information for a single comment or post by its fullname ID. Returns only that item without surrounding thread context — use redditRetrievePostComments for full discussions. Deleted or removed items may return empty payloads.',
+    inputSchema: z.object({
+        redditToken: z.string().optional().describe('Injected by system; do not provide'),
+        id: z
+            .string()
+            .describe("Fullname ID with type prefix (t1_ for comments, t3_ for posts), e.g. 't1_abc123'"),
+    }),
+    execute: async ({ redditToken, id }) => {
+        try {
+            if (!redditToken) {
+                return { error: 'Reddit token is required. Connect Reddit first.' };
+            }
+            const data = await redditGet(redditToken, '/api/info', { id });
+            return { things: data?.data?.children ?? [] };
+        }
+        catch (error) {
+            if (error?.details !== undefined) {
+                return { error: 'Failed to retrieve comment or post', details: error.details };
+            }
+            return {
+                error: 'Error retrieving comment or post',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=retrieve-specific-comment-or-post.js.map

package/dist/toolkits/reddit/tools/search-across-subreddits.d.ts

@@ -0,0 +1,12 @@
+export declare const redditSearchAcrossSubreddits: import("ai").Tool<{
+    sort: "new" | "comments" | "relevance" | "hot" | "top";
+    limit: number;
+    searchQuery: string;
+    restrictSr: boolean;
+    before?: string | undefined;
+    after?: string | undefined;
+    redditToken?: string | undefined;
+    timeFilter?: "all" | "year" | "month" | "day" | "hour" | "week" | undefined;
+    resultType?: ("user" | "link" | "sr")[] | undefined;
+}, any>;
+//# sourceMappingURL=search-across-subreddits.d.ts.map

package/dist/toolkits/reddit/tools/search-across-subreddits.js

@@ -0,0 +1,59 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { redditGet } from './client.js';
+export const redditSearchAcrossSubreddits = tool({
+    description: 'Search Reddit for posts using a query with Reddit search operators (title:, author:, subreddit:, url:, site:, flair:). Supports sort, time windows, pagination via the after cursor, and restricting to posts (links).',
+    inputSchema: z.object({
+        redditToken: z.string().optional().describe('Injected by system; do not provide'),
+        searchQuery: z.string().describe('Search query; raw http(s) URLs are not allowed, use url: or site: operators'),
+        sort: z
+            .enum(['relevance', 'hot', 'new', 'top', 'comments'])
+            .optional()
+            .default('relevance')
+            .describe('Sort order for search results'),
+        timeFilter: z
+            .enum(['hour', 'day', 'week', 'month', 'year', 'all'])
+            .optional()
+            .describe('Restrict results to a time period'),
+        limit: z.number().min(1).max(100).optional().default(5).describe('Max results to return (max 100)'),
+        after: z.string().optional().describe('Pagination cursor for the next page'),
+        before: z.string().optional().describe('Pagination cursor for the previous page'),
+        restrictSr: z
+            .boolean()
+            .optional()
+            .default(true)
+            .describe('Confine the search to posts and comments within subreddits'),
+        resultType: z
+            .array(z.enum(['sr', 'link', 'user']))
+            .optional()
+            .describe("Content types to include; must include 'link' for post results"),
+    }),
+    execute: async ({ redditToken, searchQuery, sort = 'relevance', timeFilter, limit = 5, after, before, restrictSr = true, resultType, }) => {
+        try {
+            if (!redditToken) {
+                return { error: 'Reddit token is required. Connect Reddit first.' };
+            }
+            return await redditGet(redditToken, '/search', {
+                q: searchQuery,
+                sort,
+                t: timeFilter,
+                limit,
+                after,
+                before,
+                restrict_sr: restrictSr,
+                type: resultType?.join(','),
+            });
+        }
+        catch (error) {
+            if (error?.details !== undefined) {
+                return { error: 'Failed to search Reddit', details: error.details };
+            }
+            return {
+                error: 'Error searching Reddit',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=search-across-subreddits.js.map

package/dist/toolkits/reddit/tools/search-subreddits.d.ts

@@ -0,0 +1,12 @@
+export declare const redditSearchSubreddits: import("ai").Tool<{
+    query: string;
+    sort: "activity" | "relevance";
+    limit: number;
+    count?: number | undefined;
+    show?: string | undefined;
+    before?: string | undefined;
+    after?: string | undefined;
+    redditToken?: string | undefined;
+    showUsers?: boolean | undefined;
+}, any>;
+//# sourceMappingURL=search-subreddits.d.ts.map

package/dist/toolkits/reddit/tools/search-subreddits.js

@@ -0,0 +1,49 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { redditGet } from './client.js';
+export const redditSearchSubreddits = tool({
+    description: 'Search for subreddits by title and description to find communities matching a topic or keyword. Returns subscriber counts, descriptions, and metadata. Supports pagination via after/before cursors.',
+    inputSchema: z.object({
+        redditToken: z.string().optional().describe('Injected by system; do not provide'),
+        query: z.string().describe('Search query for subreddit titles and descriptions'),
+        sort: z
+            .enum(['relevance', 'activity'])
+            .optional()
+            .default('relevance')
+            .describe('Sort order for search results'),
+        limit: z.number().min(1).max(100).optional().default(25).describe('Max subreddits to return (max 100)'),
+        after: z.string().optional().describe('Fullname cursor for the next page'),
+        before: z.string().optional().describe('Fullname cursor for the previous page'),
+        count: z.number().min(0).optional().describe('Number of items already seen (pagination)'),
+        show: z.string().optional().describe("Pass 'all' to include normally filtered items"),
+        showUsers: z.boolean().optional().describe('Include matching users in the results'),
+    }),
+    execute: async ({ redditToken, query, sort = 'relevance', limit = 25, after, before, count, show, showUsers }) => {
+        try {
+            if (!redditToken) {
+                return { error: 'Reddit token is required. Connect Reddit first.' };
+            }
+            return await redditGet(redditToken, '/subreddits/search', {
+                q: query,
+                sort,
+                limit,
+                after,
+                before,
+                count,
+                show,
+                show_users: showUsers,
+            });
+        }
+        catch (error) {
+            if (error?.details !== undefined) {
+                return { error: 'Failed to search subreddits', details: error.details };
+            }
+            return {
+                error: 'Error searching subreddits',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=search-subreddits.js.map

package/dist/toolkits/reddit/tools/toggle-inbox-replies.d.ts

@@ -0,0 +1,34 @@
+export declare const redditToggleInboxReplies: import("ai").Tool<{
+    id: string;
+    state: boolean;
+    redditToken?: string | undefined;
+}, {
+    error: string;
+    success?: undefined;
+    id?: undefined;
+    state?: undefined;
+    details?: undefined;
+    message?: undefined;
+} | {
+    success: boolean;
+    id: string;
+    state: boolean;
+    error?: undefined;
+    details?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    details: any;
+    success?: undefined;
+    id?: undefined;
+    state?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    message: string;
+    success?: undefined;
+    id?: undefined;
+    state?: undefined;
+    details?: undefined;
+}>;
+//# sourceMappingURL=toggle-inbox-replies.d.ts.map

package/dist/toolkits/reddit/tools/toggle-inbox-replies.js

@@ -0,0 +1,31 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { redditPost } from './client.js';
+export const redditToggleInboxReplies = tool({
+    description: 'Enable or disable inbox reply notifications for your own submission or comment. Provide the item fullname ID (t3_ for posts, t1_ for comments) and the desired state.',
+    inputSchema: z.object({
+        redditToken: z.string().optional().describe('Injected by system; do not provide'),
+        id: z.string().describe("Fullname of your post or comment, e.g. 't3_abc123' or 't1_def456'"),
+        state: z.boolean().describe('True to receive inbox replies, false to mute them'),
+    }),
+    execute: async ({ redditToken, id, state }) => {
+        try {
+            if (!redditToken) {
+                return { error: 'Reddit token is required. Connect Reddit first.' };
+            }
+            await redditPost(redditToken, '/api/sendreplies', { id, state });
+            return { success: true, id, state };
+        }
+        catch (error) {
+            if (error?.details !== undefined) {
+                return { error: 'Failed to toggle inbox replies', details: error.details };
+            }
+            return {
+                error: 'Error toggling inbox replies',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=toggle-inbox-replies.js.map

package/dist/toolkits/youtube/icon.d.ts

@@ -0,0 +1,5 @@
+export declare const YOUTUBE_ICON: {
+    kind: "svg";
+    dataUri: string;
+};
+//# sourceMappingURL=icon.d.ts.map

package/dist/toolkits/youtube/icon.js

@@ -0,0 +1,20 @@
+const SVG = `<svg width="800px" height="800px" viewBox="0 -7 48 48" version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink">
+    
+    <title>Youtube-color</title>
+    <desc>Created with Sketch.</desc>
+    <defs>
+
+</defs>
+    <g id="Icons" stroke="none" stroke-width="1" fill="none" fill-rule="evenodd">
+        <g id="Color-" transform="translate(-200.000000, -368.000000)" fill="#CE1312">
+            <path d="M219.044,391.269916 L219.0425,377.687742 L232.0115,384.502244 L219.044,391.269916 Z M247.52,375.334163 C247.52,375.334163 247.0505,372.003199 245.612,370.536366 C243.7865,368.610299 241.7405,368.601235 240.803,368.489448 C234.086,368 224.0105,368 224.0105,368 L223.9895,368 C223.9895,368 213.914,368 207.197,368.489448 C206.258,368.601235 204.2135,368.610299 202.3865,370.536366 C200.948,372.003199 200.48,375.334163 200.48,375.334163 C200.48,375.334163 200,379.246723 200,383.157773 L200,386.82561 C200,390.73817 200.48,394.64922 200.48,394.64922 C200.48,394.64922 200.948,397.980184 202.3865,399.447016 C204.2135,401.373084 206.612,401.312658 207.68,401.513574 C211.52,401.885191 224,402 224,402 C224,402 234.086,401.984894 240.803,401.495446 C241.7405,401.382148 243.7865,401.373084 245.612,399.447016 C247.0505,397.980184 247.52,394.64922 247.52,394.64922 C247.52,394.64922 248,390.73817 248,386.82561 L248,383.157773 C248,379.246723 247.52,375.334163 247.52,375.334163 L247.52,375.334163 Z" id="Youtube">
+
+</path>
+        </g>
+    </g>
+</svg>`;
+export const YOUTUBE_ICON = {
+    kind: 'svg',
+    dataUri: `data:image/svg+xml;base64,${Buffer.from(SVG).toString('base64')}`,
+};
+//# sourceMappingURL=icon.js.map

package/dist/toolkits/youtube/manifest.d.ts

@@ -0,0 +1,3 @@
+declare const _default: import("../../index.js").ToolkitManifest;
+export default _default;
+//# sourceMappingURL=manifest.d.ts.map

package/dist/toolkits/youtube/manifest.js

@@ -0,0 +1,48 @@
+import { defineToolkit, defineTool } from '../../core/define.js';
+import { inferToolScope } from '../../core/scope.js';
+import { YOUTUBE_ICON } from './icon.js';
+import { youtubeTools } from './tools/index.js';
+export default defineToolkit({
+    id: 'youtube',
+    displayName: 'YouTube',
+    shortDescription: 'Search, upload, and manage YouTube videos, playlists, channels, and comments.',
+    category: 'Entertainment & Media',
+    icon: YOUTUBE_ICON,
+    auth: {
+        type: 'oauth2',
+        tokenField: 'youtubeToken',
+        provider: {
+            slug: 'youtube',
+            env: { clientId: 'YOUTUBE_CLIENT_ID', clientSecret: 'YOUTUBE_CLIENT_SECRET' },
+            authorizeUrl: 'https://accounts.google.com/o/oauth2/v2/auth',
+            tokenUrl: 'https://oauth2.googleapis.com/token',
+            scopes: [
+                'https://www.googleapis.com/auth/youtube',
+                'https://www.googleapis.com/auth/youtube.force-ssl',
+                'https://www.googleapis.com/auth/youtube.readonly',
+                'https://www.googleapis.com/auth/youtube.upload',
+                'https://www.googleapis.com/auth/youtubepartner',
+                'https://www.googleapis.com/auth/youtubepartner-channel-audit',
+            ],
+            exchangeStyle: 'form',
+            extraAuthParams: { access_type: 'offline', prompt: 'consent' },
+            connectDescription: 'Connect YouTube to search, upload, and manage videos, playlists, and channels.',
+            callbackPath: '/api/auth/youtube/callback',
+            stateCookie: 'youtube_oauth_state',
+        },
+    },
+    allowedHosts: ['www.googleapis.com', 'youtube.googleapis.com'],
+    tools: youtubeTools.map((entry) => defineTool({
+        name: entry.name,
+        description: entry.description,
+        tool: entry.tool,
+        requiredAuth: entry.requiredAuth,
+        scope: entry.scope ?? inferToolScope(entry.name),
+    })),
+    meta: {
+        since: '0.0.8',
+        homepage: 'https://www.youtube.com',
+        docsUrl: 'https://developers.google.com/youtube/v3/docs',
+    },
+});
+//# sourceMappingURL=manifest.js.map

package/dist/toolkits/youtube/tools/add-video-to-playlist.d.ts

@@ -0,0 +1,7 @@
+export declare const addVideoToPlaylist: import("ai").Tool<{
+    youtubeToken: string;
+    playlistId: string;
+    videoId: string;
+    position?: number | undefined;
+}, any>;
+//# sourceMappingURL=add-video-to-playlist.d.ts.map

package/dist/toolkits/youtube/tools/add-video-to-playlist.js

@@ -0,0 +1,38 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { youtubeRequest, youtubeTokenField } from './client.js';
+export const addVideoToPlaylist = tool({
+    description: 'Adds a video to a playlist by inserting a playlist item. Use when organizing videos into playlists or building curated collections.',
+    inputSchema: z.object({
+        youtubeToken: youtubeTokenField,
+        playlistId: z.string().describe('Playlist ID to add the video to (use listUserPlaylists to discover IDs)'),
+        videoId: z.string().describe('YouTube video ID to add (typically 11 characters)'),
+        position: z.number().min(0).optional().describe('Zero-based insert position; omit to append to the end'),
+    }),
+    execute: async ({ youtubeToken, playlistId, videoId, position }) => {
+        try {
+            const snippet = {
+                playlistId,
+                resourceId: { kind: 'youtube#video', videoId },
+            };
+            if (position !== undefined)
+                snippet.position = position;
+            const result = await youtubeRequest(youtubeToken, '/playlistItems', {
+                method: 'POST',
+                query: { part: 'snippet,contentDetails,status' },
+                body: { snippet },
+            });
+            if (!result.ok)
+                return { error: 'Failed to add video to playlist', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return {
+                error: 'Error adding video to playlist',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=add-video-to-playlist.js.map

package/dist/toolkits/youtube/tools/client.d.ts

@@ -0,0 +1,23 @@
+import { z } from 'zod';
+export declare const YOUTUBE_API_BASE = "https://www.googleapis.com/youtube/v3";
+export declare const YOUTUBE_UPLOAD_BASE = "https://www.googleapis.com/upload/youtube/v3";
+export declare const youtubeTokenField: z.ZodString;
+export declare const onBehalfOfContentOwnerField: z.ZodOptional<z.ZodString>;
+export declare function buildQuery(params: Record<string, string | number | boolean | undefined>): string;
+export declare function youtubeRequest(youtubeToken: string, path: string, options?: {
+    method?: string;
+    query?: Record<string, string | number | boolean | undefined>;
+    body?: unknown;
+    responseType?: 'json' | 'text';
+}): Promise<{
+    ok: false;
+    error: any;
+    data?: undefined;
+} | {
+    ok: true;
+    data: any;
+    error?: undefined;
+}>;
+export declare function chunk<T>(items: T[], size: number): T[][];
+export declare function extractHandle(input: string): string;
+//# sourceMappingURL=client.d.ts.map

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

@@ -0,0 +1,55 @@
+// @ts-nocheck
+import { z } from 'zod';
+export const YOUTUBE_API_BASE = 'https://www.googleapis.com/youtube/v3';
+export const YOUTUBE_UPLOAD_BASE = 'https://www.googleapis.com/upload/youtube/v3';
+export const youtubeTokenField = z.string().describe('The YouTube OAuth access token (Bearer)');
+export const onBehalfOfContentOwnerField = z
+    .string()
+    .optional()
+    .describe('For content partners only: CMS user acting on behalf of this content owner');
+export function buildQuery(params) {
+    const search = new URLSearchParams();
+    for (const [key, value] of Object.entries(params)) {
+        if (value !== undefined)
+            search.set(key, String(value));
+    }
+    const qs = search.toString();
+    return qs ? `?${qs}` : '';
+}
+export async function youtubeRequest(youtubeToken, path, options) {
+    const url = `${YOUTUBE_API_BASE}${path}${buildQuery(options?.query ?? {})}`;
+    const response = await fetch(url, {
+        method: options?.method ?? 'GET',
+        headers: {
+            Authorization: `Bearer ${youtubeToken}`,
+            ...(options?.body !== undefined ? { 'Content-Type': 'application/json' } : {}),
+        },
+        body: options?.body !== undefined ? JSON.stringify(options.body) : undefined,
+    });
+    if (!response.ok) {
+        const details = await response.json().catch(() => ({}));
+        return { ok: false, error: details };
+    }
+    if (response.status === 204) {
+        return { ok: true, data: { success: true } };
+    }
+    if (options?.responseType === 'text') {
+        return { ok: true, data: await response.text() };
+    }
+    const data = await response.json().catch(() => ({}));
+    return { ok: true, data };
+}
+export function chunk(items, size) {
+    const out = [];
+    for (let i = 0; i < items.length; i += size)
+        out.push(items.slice(i, i + size));
+    return out;
+}
+export function extractHandle(input) {
+    const trimmed = input.trim();
+    const urlMatch = trimmed.match(/youtube\.com\/@([^/?#\s]+)/i);
+    if (urlMatch)
+        return urlMatch[1];
+    return trimmed.startsWith('@') ? trimmed.slice(1) : trimmed;
+}
+//# sourceMappingURL=client.js.map

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

@@ -0,0 +1,13 @@
+export declare const createChannelSection: import("ai").Tool<{
+    snippet: {
+        type: "allPlaylists" | "completedEvents" | "liveEvents" | "multipleChannels" | "multiplePlaylists" | "popularUploads" | "recentUploads" | "singlePlaylist" | "subscriptions" | "upcomingEvents";
+        title?: string | undefined;
+        position?: number | undefined;
+    };
+    youtubeToken: string;
+    contentDetails?: {
+        playlists?: string[] | undefined;
+        channels?: string[] | undefined;
+    } | undefined;
+}, any>;
+//# sourceMappingURL=create-channel-section.d.ts.map

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

@@ -0,0 +1,42 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { youtubeRequest, youtubeTokenField } from './client.js';
+const sectionType = z.enum(['allPlaylists', 'completedEvents', 'liveEvents', 'multipleChannels', 'multiplePlaylists', 'popularUploads', 'recentUploads', 'singlePlaylist', 'subscriptions', 'upcomingEvents']);
+export const createChannelSection = tool({
+    description: 'Creates a channel section (featured playlists, recent uploads, featured channels) on the authenticated user channel.',
+    inputSchema: z.object({
+        youtubeToken: youtubeTokenField,
+        snippet: z.object({
+            type: sectionType.describe('Section type (required)'),
+            title: z.string().max(100).optional().describe('Title; only for multiplePlaylists/multipleChannels, no angle brackets'),
+            position: z.number().min(0).optional().describe('Zero-based position; omit to append'),
+        }),
+        contentDetails: z.object({
+            playlists: z.array(z.string()).optional().describe('Playlist IDs (exactly one for singlePlaylist)'),
+            channels: z.array(z.string()).optional().describe('Channel IDs for multipleChannels (not your own)'),
+        }).optional(),
+    }),
+    execute: async ({ youtubeToken, snippet, contentDetails }) => {
+        try {
+            const body = { snippet };
+            if (contentDetails)
+                body.contentDetails = contentDetails;
+            const result = await youtubeRequest(youtubeToken, '/channelSections', {
+                method: 'POST',
+                query: { part: 'snippet,contentDetails' },
+                body,
+            });
+            if (!result.ok)
+                return { error: 'Failed to create channel section', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return {
+                error: 'Error creating channel section',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=create-channel-section.js.map

package/dist/toolkits/youtube/tools/create-comment-reply.d.ts

@@ -0,0 +1,6 @@
+export declare const createCommentReply: import("ai").Tool<{
+    parentId: string;
+    youtubeToken: string;
+    textOriginal: string;
+}, any>;
+//# sourceMappingURL=create-comment-reply.d.ts.map

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