@rnsk/toolkits 0.0.7 → 0.0.9

package/dist/toolkits/slack/tools/users.js

@@ -0,0 +1,396 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { slackApi, toSlackError, requireToken } from './client.js';
+const tokenField = z.string().optional().describe('Injected by system; do not provide');
+export const slackListUsers = tool({
+    description: 'List workspace users with profiles, paginated. Filter is_bot/is_app_user/deleted client-side for human-only rosters. Prefer slackFindUsers for targeted lookups; cache results. Throttle to ~1-2 req/sec.',
+    inputSchema: z.object({
+        slackToken: tokenField,
+        limit: z.number().min(1).optional().describe('Users per page (set ~100 for large workspaces)'),
+        cursor: z.string().optional().describe('Pagination cursor; loop until next_cursor is empty'),
+        includeLocale: z.boolean().optional().describe('Include each user locale'),
+        teamId: z.string().optional().describe('Workspace ID (org-level tokens only)'),
+    }),
+    execute: async ({ slackToken, includeLocale, teamId, ...rest }) => {
+        try {
+            const missing = requireToken(slackToken);
+            if (missing)
+                return missing;
+            return await slackApi(slackToken, 'users.list', {
+                ...rest,
+                include_locale: includeLocale,
+                team_id: teamId,
+            });
+        }
+        catch (error) {
+            return toSlackError(error, 'Failed to list users');
+        }
+    },
+});
+export const slackFindUsers = tool({
+    description: 'Find users by email, user ID, or name. Exact emails use the dedicated lookup; user IDs use users.info; other queries filter users.list. Verify a single user ID before passing to messaging tools.',
+    inputSchema: z.object({
+        slackToken: tokenField,
+        searchQuery: z.string().optional().describe('User ID, email, or name to search for'),
+        email: z.string().optional().describe('Email address (most efficient for exact lookup)'),
+        limit: z.number().min(1).max(1000).optional().default(50).describe('Max users to return'),
+        exactMatch: z.boolean().optional().describe('Only exact matches on name/email fields'),
+        includeBots: z.boolean().optional().describe('Include bot accounts'),
+        includeDeleted: z.boolean().optional().describe('Include deactivated users'),
+        includeRestricted: z.boolean().optional().default(true).describe('Include guest accounts'),
+        includeLocale: z.boolean().optional().describe('Include each user locale'),
+        teamId: z.string().optional().describe('Workspace ID (org-level tokens only)'),
+    }),
+    execute: async ({ slackToken, searchQuery, email, limit = 50, exactMatch, includeBots, includeDeleted, includeRestricted = true, includeLocale, teamId }) => {
+        try {
+            const missing = requireToken(slackToken);
+            if (missing)
+                return missing;
+            const query = email ?? searchQuery;
+            if (!query) {
+                return { error: 'Provide searchQuery or email.' };
+            }
+            if (/^.+@.+\..+$/.test(query) && (exactMatch || email)) {
+                return await slackApi(slackToken, 'users.lookupByEmail', { email: query });
+            }
+            if (/^[UW][A-Z0-9]+$/.test(query)) {
+                return await slackApi(slackToken, 'users.info', {
+                    user: query,
+                    include_locale: includeLocale,
+                });
+            }
+            const data = await slackApi(slackToken, 'users.list', {
+                limit: Math.min(1000, Math.max(limit, 50)),
+                include_locale: includeLocale,
+                team_id: teamId,
+            });
+            const q = query.toLowerCase();
+            const members = (data?.members ?? []).filter((u) => {
+                if (!includeBots && (u.is_bot || u.is_app_user))
+                    return false;
+                if (!includeDeleted && u.deleted)
+                    return false;
+                if (!includeRestricted && (u.is_restricted || u.is_ultra_restricted))
+                    return false;
+                const haystacks = [
+                    u.name, u.real_name, u.profile?.display_name, u.profile?.real_name,
+                    u.profile?.first_name, u.profile?.last_name, u.profile?.email, u.profile?.status_text,
+                ].filter(Boolean).map((v) => String(v).toLowerCase());
+                return exactMatch
+                    ? haystacks.some((v) => v === q)
+                    : haystacks.some((v) => v.includes(q));
+            });
+            return { ok: true, members: members.slice(0, limit) };
+        }
+        catch (error) {
+            return toSlackError(error, 'Failed to find users');
+        }
+    },
+});
+export const slackFindUserByEmail = tool({
+    description: 'Look up an active user by registered email address (requires users:read.email). Fails with users_not_found for unknown, inactive, guest, or privacy-hidden emails.',
+    inputSchema: z.object({
+        slackToken: tokenField,
+        email: z.string().describe('Email address of the user to look up'),
+    }),
+    execute: async ({ slackToken, email }) => {
+        try {
+            const missing = requireToken(slackToken);
+            if (missing)
+                return missing;
+            return await slackApi(slackToken, 'users.lookupByEmail', { email });
+        }
+        catch (error) {
+            return toSlackError(error, 'Failed to find user by email');
+        }
+    },
+});
+export const slackGetUserInfo = tool({
+    description: 'Get comprehensive info for a user ID (profile, status, team flags). Pass IDs only — emails and names return user_not_found. Sensitive fields may be omitted by privacy settings.',
+    inputSchema: z.object({
+        slackToken: tokenField,
+        user: z.string().describe('User ID (U- or W-prefixed)'),
+        includeLocale: z.boolean().optional().describe('Include user locale'),
+    }),
+    execute: async ({ slackToken, user, includeLocale }) => {
+        try {
+            const missing = requireToken(slackToken);
+            if (missing)
+                return missing;
+            return await slackApi(slackToken, 'users.info', { user, include_locale: includeLocale });
+        }
+        catch (error) {
+            return toSlackError(error, 'Failed to get user info');
+        }
+    },
+});
+export const slackGetUserProfile = tool({
+    description: 'Get profile fields for a user (defaults to the caller when omitted). Email/phone may be omitted without users:read.email or by workspace privacy.',
+    inputSchema: z.object({
+        slackToken: tokenField,
+        user: z.string().optional().describe('User ID; omit for the authenticated user'),
+        includeLabels: z.boolean().optional().describe('Include human-readable custom field labels'),
+    }),
+    execute: async ({ slackToken, user, includeLabels }) => {
+        try {
+            const missing = requireToken(slackToken);
+            if (missing)
+                return missing;
+            return await slackApi(slackToken, 'users.profile.get', {
+                user,
+                include_labels: includeLabels,
+            });
+        }
+        catch (error) {
+            return toSlackError(error, 'Failed to get user profile');
+        }
+    },
+});
+export const slackSetUserProfile = tool({
+    description: 'Update a user profile: a single field via name+value, or many via a profile JSON string (takes precedence). Defaults to the caller; admins on paid teams may target others.',
+    inputSchema: z.object({
+        slackToken: tokenField,
+        user: z.string().optional().describe('User ID to update; omit for self'),
+        name: z.string().optional().describe('Single field name, e.g. status_text (use with value)'),
+        value: z.string().optional().describe('Value for the single field'),
+        profile: z.string().optional().describe('JSON string of field updates, e.g. {"status_text":"Exploring"}'),
+    }),
+    execute: async ({ slackToken, user, name, value, profile }) => {
+        try {
+            const missing = requireToken(slackToken);
+            if (missing)
+                return missing;
+            if (!profile && !(name && value !== undefined)) {
+                return { error: 'Provide profile JSON, or both name and value.' };
+            }
+            return await slackApi(slackToken, 'users.profile.set', { user, name, value, profile });
+        }
+        catch (error) {
+            return toSlackError(error, 'Failed to set user profile');
+        }
+    },
+});
+export const slackGetUserPresence = tool({
+    description: "Get a user's real-time presence (active/away). Omit user for self. No history or status reasons.",
+    inputSchema: z.object({
+        slackToken: tokenField,
+        user: z.string().optional().describe('User ID; omit for the authenticated user'),
+    }),
+    execute: async ({ slackToken, user }) => {
+        try {
+            const missing = requireToken(slackToken);
+            if (missing)
+                return missing;
+            return await slackApi(slackToken, 'users.getPresence', { user });
+        }
+        catch (error) {
+            return toSlackError(error, 'Failed to get user presence');
+        }
+    },
+});
+export const slackSetUserPresence = tool({
+    description: "Manually set presence to 'auto' (Slack-managed) or 'away'. Persists across connections but user activity or auto-away can override it.",
+    inputSchema: z.object({
+        slackToken: tokenField,
+        presence: z.enum(['auto', 'away']).describe('Presence state to set'),
+    }),
+    execute: async ({ slackToken, presence }) => {
+        try {
+            const missing = requireToken(slackToken);
+            if (missing)
+                return missing;
+            return await slackApi(slackToken, 'users.setPresence', { presence });
+        }
+        catch (error) {
+            return toSlackError(error, 'Failed to set user presence');
+        }
+    },
+});
+export const slackEndDnd = tool({
+    description: 'End the caller DND session, making them available. Safe no-op when DND is not active.',
+    inputSchema: z.object({
+        slackToken: tokenField,
+    }),
+    execute: async ({ slackToken }) => {
+        try {
+            const missing = requireToken(slackToken);
+            if (missing)
+                return missing;
+            return await slackApi(slackToken, 'dnd.endDnd', {});
+        }
+        catch (error) {
+            return toSlackError(error, 'Failed to end DND');
+        }
+    },
+});
+export const slackEndSnooze = tool({
+    description: 'End the caller snooze immediately, exiting do-not-disturb mode.',
+    inputSchema: z.object({
+        slackToken: tokenField,
+    }),
+    execute: async ({ slackToken }) => {
+        try {
+            const missing = requireToken(slackToken);
+            if (missing)
+                return missing;
+            return await slackApi(slackToken, 'dnd.endSnooze', {});
+        }
+        catch (error) {
+            return toSlackError(error, 'Failed to end snooze');
+        }
+    },
+});
+export const slackSetDndDuration = tool({
+    description: 'Turn on DND (snooze) for the caller for a number of minutes from now.',
+    inputSchema: z.object({
+        slackToken: tokenField,
+        numMinutes: z.string().describe('Minutes from now to snooze, e.g. "60"'),
+    }),
+    execute: async ({ slackToken, numMinutes }) => {
+        try {
+            const missing = requireToken(slackToken);
+            if (missing)
+                return missing;
+            return await slackApi(slackToken, 'dnd.setSnooze', { num_minutes: numMinutes });
+        }
+        catch (error) {
+            return toSlackError(error, 'Failed to set DND duration');
+        }
+    },
+});
+export const slackGetDndStatus = tool({
+    description: 'Get DND status for the caller or one user. Check before interacting to respect availability.',
+    inputSchema: z.object({
+        slackToken: tokenField,
+        user: z.string().optional().describe('User ID; omit for the authenticated user'),
+        teamId: z.string().optional().describe('Workspace ID (org-level tokens only)'),
+    }),
+    execute: async ({ slackToken, user, teamId }) => {
+        try {
+            const missing = requireToken(slackToken);
+            if (missing)
+                return missing;
+            return await slackApi(slackToken, 'dnd.info', { user, team_id: teamId });
+        }
+        catch (error) {
+            return toSlackError(error, 'Failed to get DND status');
+        }
+    },
+});
+export const slackGetTeamDndStatus = tool({
+    description: 'Get DND status for multiple users at once via comma-separated IDs.',
+    inputSchema: z.object({
+        slackToken: tokenField,
+        users: z.string().describe("Comma-separated user IDs, e.g. 'U123,U456'"),
+        teamId: z.string().optional().describe('Workspace ID (org-level tokens only)'),
+    }),
+    execute: async ({ slackToken, users, teamId }) => {
+        try {
+            const missing = requireToken(slackToken);
+            if (missing)
+                return missing;
+            return await slackApi(slackToken, 'dnd.teamInfo', { users, team_id: teamId });
+        }
+        catch (error) {
+            return toSlackError(error, 'Failed to get team DND status');
+        }
+    },
+});
+export const slackDeleteUserPhoto = tool({
+    description: 'Delete the caller profile photo, reverting to the default avatar. Irreversible; succeeds even with no custom photo.',
+    inputSchema: z.object({
+        slackToken: tokenField,
+    }),
+    execute: async ({ slackToken }) => {
+        try {
+            const missing = requireToken(slackToken);
+            if (missing)
+                return missing;
+            return await slackApi(slackToken, 'users.deletePhoto', {});
+        }
+        catch (error) {
+            return toSlackError(error, 'Failed to delete profile photo');
+        }
+    },
+});
+export const slackSetUserPhoto = tool({
+    description: 'Set the caller profile photo from a publicly reachable image URL (GIF/PNG/JPG). The image is fetched and uploaded with optional square cropping.',
+    inputSchema: z.object({
+        slackToken: tokenField,
+        imageUrl: z.string().describe('Public URL of the image to use as the profile photo'),
+        cropX: z.number().min(0).optional().describe('X of the top-left crop corner, in pixels'),
+        cropY: z.number().min(0).optional().describe('Y of the top-left crop corner, in pixels'),
+        cropW: z.number().min(1).optional().describe('Width/height of the square crop box, in pixels'),
+    }),
+    execute: async ({ slackToken, imageUrl, cropX, cropY, cropW }) => {
+        try {
+            const missing = requireToken(slackToken);
+            if (missing)
+                return missing;
+            const imageRes = await fetch(imageUrl);
+            if (!imageRes.ok) {
+                return { error: 'Failed to fetch profile image', details: { status: imageRes.status } };
+            }
+            const bytes = await imageRes.arrayBuffer();
+            const form = new FormData();
+            form.append('image', new Blob([bytes]), 'photo.jpg');
+            if (cropX !== undefined)
+                form.append('crop_x', String(cropX));
+            if (cropY !== undefined)
+                form.append('crop_y', String(cropY));
+            if (cropW !== undefined)
+                form.append('crop_w', String(cropW));
+            const response = await fetch('https://slack.com/api/users.setPhoto', {
+                method: 'POST',
+                headers: { Authorization: `Bearer ${slackToken}` },
+                body: form,
+            });
+            const data = await response.json().catch(() => ({}));
+            if (!response.ok || data?.ok === false) {
+                return { error: 'Failed to set profile photo', details: data };
+            }
+            return data;
+        }
+        catch (error) {
+            return toSlackError(error, 'Failed to set profile photo');
+        }
+    },
+});
+export const slackGetUserIdentity = tool({
+    description: 'Get the caller identity (user + team). Returned fields depend on granted identity scopes (basic, email, avatar, team).',
+    inputSchema: z.object({
+        slackToken: tokenField,
+    }),
+    execute: async ({ slackToken }) => {
+        try {
+            const missing = requireToken(slackToken);
+            if (missing)
+                return missing;
+            return await slackApi(slackToken, 'users.identity', {});
+        }
+        catch (error) {
+            return toSlackError(error, 'Failed to get user identity');
+        }
+    },
+});
+export const slackGetBotInfo = tool({
+    description: 'Get info for a bot user by bot ID (B-prefixed). Does not work for regular users or other integration types.',
+    inputSchema: z.object({
+        slackToken: tokenField,
+        bot: z.string().optional().describe('Bot ID, e.g. B0123456789'),
+        teamId: z.string().optional().describe('Workspace ID (org-level tokens only)'),
+    }),
+    execute: async ({ slackToken, bot, teamId }) => {
+        try {
+            const missing = requireToken(slackToken);
+            if (missing)
+                return missing;
+            return await slackApi(slackToken, 'bots.info', { bot, team_id: teamId });
+        }
+        catch (error) {
+            return toSlackError(error, 'Failed to get bot info');
+        }
+    },
+});
+//# sourceMappingURL=users.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<{
+    videoId: string;
+    youtubeToken: string;
+    playlistId: 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