@rnsk/toolkits 0.0.8 → 0.0.9

package/dist/toolkits/google-photos/tools/index.d.ts

@@ -0,0 +1,261 @@
+import { addEnrichment, batchAddMediaItems, createAlbum, getAlbum, listAlbums, updateAlbum } from './albums.js';
+import { batchCreateMediaItems, uploadMedia } from './uploads.js';
+import { batchGetMediaItems, downloadMediaItem, listMediaItems, searchMediaItems, updateMediaItem } from './media.js';
+export { addEnrichment, batchAddMediaItems, createAlbum, getAlbum, listAlbums, updateAlbum, batchCreateMediaItems, uploadMedia, batchGetMediaItems, downloadMediaItem, listMediaItems, searchMediaItems, updateMediaItem, };
+export declare const googlePhotosTools: ({
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        title: string;
+        googlePhotosToken: string;
+    }, any>;
+    requiredAuth: "googlePhotosToken";
+    scope: "write";
+} | {
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        googlePhotosToken: string;
+        albumId: string;
+    }, any>;
+    requiredAuth: "googlePhotosToken";
+    scope: "read";
+} | {
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        googlePhotosToken: string;
+        pageToken?: string | undefined;
+        pageSize?: number | undefined;
+        excludeNonAppCreatedData?: boolean | undefined;
+    }, any>;
+    requiredAuth: "googlePhotosToken";
+    scope: "read";
+} | {
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        googlePhotosToken: string;
+        albumId: string;
+        title?: string | undefined;
+        coverPhotoMediaItemId?: string | undefined;
+    }, any>;
+    requiredAuth: "googlePhotosToken";
+    scope: "write";
+} | {
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        googlePhotosToken: string;
+        albumId: string;
+        newEnrichmentItem: {
+            textEnrichment?: {
+                text: string;
+            } | undefined;
+            locationEnrichment?: {
+                location: {
+                    latlng: {
+                        latitude: number;
+                        longitude: number;
+                    };
+                    locationName: string;
+                };
+            } | undefined;
+            mapEnrichment?: {
+                origin: {
+                    latlng: {
+                        latitude: number;
+                        longitude: number;
+                    };
+                    locationName: string;
+                };
+                destination: {
+                    latlng: {
+                        latitude: number;
+                        longitude: number;
+                    };
+                    locationName: string;
+                };
+            } | undefined;
+        };
+        albumPosition: {
+            position: "POSITION_TYPE_UNSPECIFIED" | "FIRST_IN_ALBUM" | "LAST_IN_ALBUM" | "AFTER_MEDIA_ITEM" | "AFTER_ENRICHMENT_ITEM";
+            relativeMediaItemId?: string | undefined;
+            relativeEnrichmentItemId?: string | undefined;
+        };
+    }, any>;
+    requiredAuth: "googlePhotosToken";
+    scope: "write";
+} | {
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        googlePhotosToken: string;
+        albumId: string;
+        mediaItemIds: string[];
+    }, {
+        error: string;
+        details: any;
+        albumId?: undefined;
+        mediaItemsAdded?: undefined;
+        message?: undefined;
+    } | {
+        albumId: string;
+        mediaItemsAdded: number;
+        message: string;
+        error?: undefined;
+        details?: undefined;
+    } | {
+        error: string;
+        message: string;
+        details?: undefined;
+        albumId?: undefined;
+        mediaItemsAdded?: undefined;
+    }>;
+    requiredAuth: "googlePhotosToken";
+    scope: "write";
+} | {
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        googlePhotosToken: string;
+        albumId?: string | undefined;
+        albumPosition?: Record<string, any> | undefined;
+        urls?: string[] | undefined;
+        mediaFiles?: {
+            description?: string | undefined;
+            fileName?: string | undefined;
+            url?: string | undefined;
+        }[] | undefined;
+    }, {
+        error: string;
+        details?: undefined;
+        newMediaItemResults?: undefined;
+        message?: undefined;
+    } | {
+        error: string;
+        details: any;
+        newMediaItemResults?: undefined;
+        message?: undefined;
+    } | {
+        newMediaItemResults: Record<string, unknown>[];
+        error?: undefined;
+        details?: undefined;
+        message?: undefined;
+    } | {
+        error: string;
+        message: string;
+        details?: undefined;
+        newMediaItemResults?: undefined;
+    }>;
+    requiredAuth: "googlePhotosToken";
+    scope: "write";
+} | {
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        googlePhotosToken: string;
+        description?: string | undefined;
+        fileName?: string | undefined;
+        url?: string | undefined;
+    }, {
+        error: string;
+        details?: undefined;
+        mediaItem?: undefined;
+        message?: undefined;
+    } | {
+        error: string;
+        details: any;
+        mediaItem?: undefined;
+        message?: undefined;
+    } | {
+        mediaItem: {};
+        error?: undefined;
+        details?: undefined;
+        message?: undefined;
+    } | {
+        error: string;
+        message: string;
+        details?: undefined;
+        mediaItem?: undefined;
+    }>;
+    requiredAuth: "googlePhotosToken";
+    scope: "write";
+} | {
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        googlePhotosToken: string;
+        mediaItemIds: string[];
+    }, any>;
+    requiredAuth: "googlePhotosToken";
+    scope: "read";
+} | {
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        googlePhotosToken: string;
+        pageToken?: string | undefined;
+        pageSize?: number | undefined;
+    }, any>;
+    requiredAuth: "googlePhotosToken";
+    scope: "read";
+} | {
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        googlePhotosToken: string;
+        pageToken?: string | undefined;
+        pageSize?: number | undefined;
+        albumId?: string | undefined;
+        filters?: Record<string, any> | undefined;
+        orderBy?: string | undefined;
+    }, any>;
+    requiredAuth: "googlePhotosToken";
+    scope: "read";
+} | {
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        description: string;
+        googlePhotosToken: string;
+        mediaItemId: string;
+    }, any>;
+    requiredAuth: "googlePhotosToken";
+    scope: "write";
+} | {
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        googlePhotosToken: string;
+        mediaItemId: string;
+    }, {
+        error: string;
+        details: any;
+        file?: undefined;
+        message?: undefined;
+    } | {
+        error: string;
+        details?: undefined;
+        file?: undefined;
+        message?: undefined;
+    } | {
+        file: {
+            name: string;
+            mimetype: string;
+            contentBase64: string;
+            byteSize: number;
+        };
+        error?: undefined;
+        details?: undefined;
+        message?: undefined;
+    } | {
+        error: string;
+        message: string;
+        details?: undefined;
+        file?: undefined;
+    }>;
+    requiredAuth: "googlePhotosToken";
+    scope: "read";
+})[];
+//# sourceMappingURL=index.d.ts.map

package/dist/toolkits/google-photos/tools/index.js

@@ -0,0 +1,22 @@
+// @ts-nocheck
+import { addEnrichment, batchAddMediaItems, createAlbum, getAlbum, listAlbums, updateAlbum } from './albums.js';
+import { batchCreateMediaItems, uploadMedia, } from './uploads.js';
+import { batchGetMediaItems, downloadMediaItem, listMediaItems, searchMediaItems, updateMediaItem } from './media.js';
+export { addEnrichment, batchAddMediaItems, createAlbum, getAlbum, listAlbums, updateAlbum, batchCreateMediaItems, uploadMedia, batchGetMediaItems, downloadMediaItem, listMediaItems, searchMediaItems, updateMediaItem, };
+const auth = 'googlePhotosToken';
+export const googlePhotosTools = [
+    { name: 'googlePhotosCreateAlbum', description: 'Creates an album with a title.', tool: createAlbum, requiredAuth: auth, scope: 'write' },
+    { name: 'googlePhotosGetAlbum', description: 'Gets an album by ID.', tool: getAlbum, requiredAuth: auth, scope: 'read' },
+    { name: 'googlePhotosListAlbums', description: 'Lists albums in the Albums tab.', tool: listAlbums, requiredAuth: auth, scope: 'read' },
+    { name: 'googlePhotosUpdateAlbum', description: 'Updates an app-created album title and/or cover photo.', tool: updateAlbum, requiredAuth: auth, scope: 'write' },
+    { name: 'googlePhotosAddEnrichment', description: 'Adds a text, location, or map enrichment at an album position.', tool: addEnrichment, requiredAuth: auth, scope: 'write' },
+    { name: 'googlePhotosBatchAddMediaItems', description: 'Adds up to 50 app-created items to an app-created album.', tool: batchAddMediaItems, requiredAuth: auth, scope: 'write' },
+    { name: 'googlePhotosBatchCreateMediaItems', description: 'Uploads up to 50 files from URLs and creates media items.', tool: batchCreateMediaItems, requiredAuth: auth, scope: 'write' },
+    { name: 'googlePhotosUploadMedia', description: 'Uploads one file from a URL and creates the media item.', tool: uploadMedia, requiredAuth: auth, scope: 'write' },
+    { name: 'googlePhotosBatchGetMediaItems', description: 'Gets up to 50 media items by ID.', tool: batchGetMediaItems, requiredAuth: auth, scope: 'read' },
+    { name: 'googlePhotosListMediaItems', description: 'Lists app-created media items (full library needs Picker API).', tool: listMediaItems, requiredAuth: auth, scope: 'read' },
+    { name: 'googlePhotosSearchMediaItems', description: 'Searches app-created media by album, date, content, or type.', tool: searchMediaItems, requiredAuth: auth, scope: 'read' },
+    { name: 'googlePhotosUpdateMediaItem', description: 'Updates a media item description.', tool: updateMediaItem, requiredAuth: auth, scope: 'write' },
+    { name: 'googlePhotosDownloadMediaItem', description: 'Downloads media item bytes (base64).', tool: downloadMediaItem, requiredAuth: auth, scope: 'read' },
+];
+//# sourceMappingURL=index.js.map

package/dist/toolkits/google-photos/tools/media.d.ts

@@ -0,0 +1,52 @@
+export declare const batchGetMediaItems: import("ai").Tool<{
+    googlePhotosToken: string;
+    mediaItemIds: string[];
+}, any>;
+export declare const listMediaItems: import("ai").Tool<{
+    googlePhotosToken: string;
+    pageToken?: string | undefined;
+    pageSize?: number | undefined;
+}, any>;
+export declare const searchMediaItems: import("ai").Tool<{
+    googlePhotosToken: string;
+    pageToken?: string | undefined;
+    pageSize?: number | undefined;
+    albumId?: string | undefined;
+    filters?: Record<string, any> | undefined;
+    orderBy?: string | undefined;
+}, any>;
+export declare const updateMediaItem: import("ai").Tool<{
+    description: string;
+    googlePhotosToken: string;
+    mediaItemId: string;
+}, any>;
+export declare const downloadMediaItem: import("ai").Tool<{
+    googlePhotosToken: string;
+    mediaItemId: string;
+}, {
+    error: string;
+    details: any;
+    file?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    details?: undefined;
+    file?: undefined;
+    message?: undefined;
+} | {
+    file: {
+        name: string;
+        mimetype: string;
+        contentBase64: string;
+        byteSize: number;
+    };
+    error?: undefined;
+    details?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    message: string;
+    details?: undefined;
+    file?: undefined;
+}>;
+//# sourceMappingURL=media.d.ts.map

package/dist/toolkits/google-photos/tools/media.js

@@ -0,0 +1,142 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { googlePhotosTokenField, photosRequest } from './client.js';
+export const batchGetMediaItems = tool({
+    description: 'Gets up to 50 media items by ID (no duplicates). Failed items return a status entry.',
+    inputSchema: z.object({
+        googlePhotosToken: googlePhotosTokenField,
+        mediaItemIds: z.array(z.string()).min(1).max(50).describe('Media item IDs, no duplicates'),
+    }),
+    execute: async ({ googlePhotosToken, mediaItemIds }) => {
+        try {
+            if (new Set(mediaItemIds).size !== mediaItemIds.length)
+                return { error: 'mediaItemIds must not contain duplicates' };
+            const result = await photosRequest(googlePhotosToken, '/mediaItems:batchGet', {
+                query: { mediaItemIds },
+            });
+            if (!result.ok)
+                return { error: 'Failed to batch get media items', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return { error: 'Error batch getting media items', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+export const listMediaItems = tool({
+    description: 'Lists app-created media items (post-March-2025 API returns only your app uploads — camera/other-app photos need the Picker API).',
+    inputSchema: z.object({
+        googlePhotosToken: googlePhotosTokenField,
+        pageSize: z.number().min(1).max(100).optional().describe('Items per page (default 25, max 100)'),
+        pageToken: z.string().optional(),
+    }),
+    execute: async ({ googlePhotosToken, pageSize, pageToken }) => {
+        try {
+            const result = await photosRequest(googlePhotosToken, '/mediaItems', {
+                query: { pageSize, pageToken },
+            });
+            if (!result.ok)
+                return { error: 'Failed to list media items', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return { error: 'Error listing media items', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+export const searchMediaItems = tool({
+    description: 'Searches app-created media by album, date/content/feature/media-type filters, and ordering. Only one of albumId or filters should drive the query.',
+    inputSchema: z.object({
+        googlePhotosToken: googlePhotosTokenField,
+        albumId: z.string().optional().describe('Album to search within'),
+        filters: z.record(z.any()).optional().describe('Filters: dateFilter, contentFilter, mediaTypeFilter, featureFilter, includeArchivedMedia, excludeNonAppCreatedData'),
+        orderBy: z.string().optional().describe("Sort, e.g. 'MediaMetadata.creation_time desc'"),
+        pageSize: z.number().min(1).max(100).optional().describe('Items per page (default 25, max 100)'),
+        pageToken: z.string().optional(),
+    }),
+    execute: async ({ googlePhotosToken, albumId, filters, orderBy, pageSize, pageToken }) => {
+        try {
+            const body = {};
+            if (albumId)
+                body.albumId = albumId;
+            if (filters)
+                body.filters = filters;
+            if (orderBy)
+                body.orderBy = orderBy;
+            if (pageSize !== undefined)
+                body.pageSize = pageSize;
+            if (pageToken)
+                body.pageToken = pageToken;
+            const result = await photosRequest(googlePhotosToken, '/mediaItems:search', {
+                method: 'POST',
+                body,
+            });
+            if (!result.ok)
+                return { error: 'Failed to search media items', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return { error: 'Error searching media items', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+export const updateMediaItem = tool({
+    description: 'Updates an app-created media item description (max 1000 chars).',
+    inputSchema: z.object({
+        googlePhotosToken: googlePhotosTokenField,
+        mediaItemId: z.string().describe('Media item ID to update'),
+        description: z.string().max(1000).describe('New description'),
+    }),
+    execute: async ({ googlePhotosToken, mediaItemId, description }) => {
+        try {
+            const result = await photosRequest(googlePhotosToken, `/mediaItems/${mediaItemId}`, {
+                method: 'PATCH',
+                query: { updateMask: 'description' },
+                body: { description },
+            });
+            if (!result.ok)
+                return { error: 'Failed to update media item', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return { error: 'Error updating media item', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+export const downloadMediaItem = tool({
+    description: 'Downloads a media item bytes (base64) via its baseUrl. Use baseUrl sizing params before download if you need a specific size.',
+    inputSchema: z.object({
+        googlePhotosToken: googlePhotosTokenField,
+        mediaItemId: z.string().describe('Media item ID to download'),
+    }),
+    execute: async ({ googlePhotosToken, mediaItemId }) => {
+        try {
+            const meta = await photosRequest(googlePhotosToken, `/mediaItems/${mediaItemId}`);
+            if (!meta.ok)
+                return { error: 'Failed to get media item', details: meta.error };
+            const item = meta.data;
+            if (!item.baseUrl)
+                return { error: 'Media item has no downloadable baseUrl' };
+            const downloadUrl = `${item.baseUrl}=d`;
+            const response = await fetch(downloadUrl, {
+                headers: { Authorization: `Bearer ${googlePhotosToken}` },
+            });
+            if (!response.ok)
+                return { error: `Download failed (HTTP ${response.status})` };
+            const bytes = Buffer.from(await response.arrayBuffer());
+            return {
+                file: {
+                    name: item.filename ?? `${mediaItemId}`,
+                    mimetype: response.headers.get('content-type') ?? item.mimeType ?? 'application/octet-stream',
+                    contentBase64: bytes.toString('base64'),
+                    byteSize: bytes.length,
+                },
+            };
+        }
+        catch (error) {
+            return { error: 'Error downloading media item', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+//# sourceMappingURL=media.js.map

package/dist/toolkits/google-photos/tools/uploads.d.ts

@@ -0,0 +1,58 @@
+export declare const batchCreateMediaItems: import("ai").Tool<{
+    googlePhotosToken: string;
+    albumId?: string | undefined;
+    albumPosition?: Record<string, any> | undefined;
+    urls?: string[] | undefined;
+    mediaFiles?: {
+        description?: string | undefined;
+        fileName?: string | undefined;
+        url?: string | undefined;
+    }[] | undefined;
+}, {
+    error: string;
+    details?: undefined;
+    newMediaItemResults?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    details: any;
+    newMediaItemResults?: undefined;
+    message?: undefined;
+} | {
+    newMediaItemResults: Record<string, unknown>[];
+    error?: undefined;
+    details?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    message: string;
+    details?: undefined;
+    newMediaItemResults?: undefined;
+}>;
+export declare const uploadMedia: import("ai").Tool<{
+    googlePhotosToken: string;
+    description?: string | undefined;
+    fileName?: string | undefined;
+    url?: string | undefined;
+}, {
+    error: string;
+    details?: undefined;
+    mediaItem?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    details: any;
+    mediaItem?: undefined;
+    message?: undefined;
+} | {
+    mediaItem: {};
+    error?: undefined;
+    details?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    message: string;
+    details?: undefined;
+    mediaItem?: undefined;
+}>;
+//# sourceMappingURL=uploads.d.ts.map

package/dist/toolkits/google-photos/tools/uploads.js

@@ -0,0 +1,107 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { fetchUrlBytes, fileNameFromUrl, googlePhotosTokenField, photosRequest, uploadBytes, } from './client.js';
+async function uploadOne(googlePhotosToken, input) {
+    const { bytes, contentType } = await fetchUrlBytes(input.url);
+    const uploadToken = await uploadBytes(googlePhotosToken, input.fileName, bytes, contentType);
+    return { description: input.description, simpleMediaItem: { fileName: input.fileName, uploadToken } };
+}
+export const batchCreateMediaItems = tool({
+    description: 'Uploads up to 50 files from public URLs and creates media items (optionally into an album at a position). s3key file refs are not resolvable — provide public URLs instead.',
+    inputSchema: z.object({
+        googlePhotosToken: googlePhotosTokenField,
+        urls: z.array(z.string()).optional().describe('Public file URLs (names extracted automatically)'),
+        mediaFiles: z.array(z.object({
+            url: z.string().optional().describe('Public file URL'),
+            fileName: z.string().optional().describe("File name with extension (required with url), e.g. 'photo.jpg'"),
+            description: z.string().max(1000).optional().describe('Item description'),
+        })).optional().describe('Files with explicit names/descriptions (max 50 total with urls)'),
+        albumId: z.string().optional().describe('Album for the new items (library-only if omitted)'),
+        albumPosition: z.record(z.any()).optional().describe('Position in the album'),
+    }),
+    execute: async ({ googlePhotosToken, urls, mediaFiles, albumId, albumPosition }) => {
+        try {
+            const inputs = [
+                ...(urls ?? []).map((url, i) => ({
+                    url,
+                    fileName: fileNameFromUrl(url, `photo-${i + 1}.jpg`),
+                    description: '',
+                })),
+                ...(mediaFiles ?? []).map((m) => ({
+                    url: m.url ?? '',
+                    fileName: m.fileName ?? (m.url ? fileNameFromUrl(m.url, 'photo.jpg') : 'photo.jpg'),
+                    description: m.description ?? '',
+                })),
+            ];
+            if (inputs.length === 0)
+                return { error: 'Provide urls and/or mediaFiles with public URLs' };
+            if (inputs.length > 50)
+                return { error: 'Maximum 50 items per request' };
+            const missing = inputs.filter((i) => !i.url);
+            if (missing.length > 0)
+                return { error: 'Every media file needs a public url (s3key refs are not resolvable)' };
+            const newMediaItems = [];
+            const results = [];
+            for (const input of inputs) {
+                try {
+                    newMediaItems.push(await uploadOne(googlePhotosToken, input));
+                }
+                catch (error) {
+                    results.push({ status: { message: error instanceof Error ? error.message : 'Upload failed' } });
+                }
+            }
+            if (newMediaItems.length > 0) {
+                const body = { newMediaItems };
+                if (albumId)
+                    body.albumId = albumId;
+                if (albumPosition)
+                    body.albumPosition = albumPosition;
+                const created = await photosRequest(googlePhotosToken, '/mediaItems:batchCreate', {
+                    method: 'POST',
+                    body,
+                });
+                if (!created.ok)
+                    return { error: 'Failed to create media items', details: created.error };
+                const data = created.data;
+                results.push(...(data.newMediaItemResults ?? []));
+            }
+            return { newMediaItemResults: results };
+        }
+        catch (error) {
+            return { error: 'Error batch creating media items', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+export const uploadMedia = tool({
+    description: 'Uploads one file (images ≤200MB, videos ≤20GB) from a public URL and creates the media item. s3key file refs are not resolvable.',
+    inputSchema: z.object({
+        googlePhotosToken: googlePhotosTokenField,
+        url: z.string().optional().describe('Public file URL (JPEG/PNG/GIF/HEIC/MP4/MOV/...)'),
+        fileName: z.string().optional().describe("File name with extension (required with url), e.g. 'photo.jpg'"),
+        description: z.string().max(1000).optional().describe('Item description'),
+    }),
+    execute: async ({ googlePhotosToken, url, fileName, description }) => {
+        try {
+            if (!url)
+                return { error: 'Provide a public url (s3key refs are not resolvable)' };
+            const name = fileName ?? fileNameFromUrl(url, 'photo.jpg');
+            const newMediaItems = [await uploadOne(googlePhotosToken, { url, fileName: name, description: description ?? '' })];
+            const created = await photosRequest(googlePhotosToken, '/mediaItems:batchCreate', {
+                method: 'POST',
+                body: { newMediaItems },
+            });
+            if (!created.ok)
+                return { error: 'Failed to create media item', details: created.error };
+            const data = created.data;
+            const first = data.newMediaItemResults?.[0];
+            if (!first?.mediaItem)
+                return { error: 'Failed to create media item', details: first?.status ?? created.data };
+            return { mediaItem: first.mediaItem };
+        }
+        catch (error) {
+            return { error: 'Error uploading media', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+//# sourceMappingURL=uploads.js.map

package/dist/toolkits/google-tasks/tools/index.d.ts

@@ -156,9 +156,9 @@ export declare const googleTasksTools: ({
         status?: "completed" | "needsAction" | undefined;
         completed?: string | undefined;
         deleted?: boolean | undefined;
+        etag?: string | undefined;
         notes?: string | undefined;
         due?: string | undefined;
-        etag?: string | undefined;
     }, any>;
     requiredAuth: "googleTasksToken";
     scope: "write";

package/dist/toolkits/google-tasks/tools/update-task-full.d.ts

@@ -7,8 +7,8 @@ export declare const updateTaskFull: import("ai").Tool<{
     status?: "completed" | "needsAction" | undefined;
     completed?: string | undefined;
     deleted?: boolean | undefined;
+    etag?: string | undefined;
     notes?: string | undefined;
     due?: string | undefined;
-    etag?: string | undefined;
 }, any>;
 //# sourceMappingURL=update-task-full.d.ts.map

package/dist/toolkits/groww/tools/index.d.ts

@@ -340,13 +340,13 @@ export declare const growwTools: ({
     description: string;
     tool: import("ai").Tool<{
         limit?: number | undefined;
+        offset?: number | undefined;
         trading_symbol?: string | undefined;
         exchange?: string | undefined;
         segment?: string | undefined;
         groww_symbol?: string | undefined;
         underlying_symbol?: string | undefined;
         instrument_type?: string | undefined;
-        offset?: number | undefined;
     }, {
         error: string;
         statusCode: number;